Deeply Embedded Python, a virtual machine for embedded systems

Johan Lilius and Iván Porres Paltor

1           Introduction

Traditionally embedded systems have been programmed in assembler and high-level languages like C or C++, to provide optimal implementations in terms of cost and efficiency. However, if one considers the whole product cycle then it is not at all clear that only optimising for single product cost and efficiency will give the best revenue (cf.[[1]]). Indeed recently other issues such as portability, security, simplicity and the ever-shorter time-to-market requirements have become increasingly important concerns of the design cycle of an embedded system. This has sparked interest in alternative solutions.

For embedded systems where most of the added value is in the user application, while the hardware interface remains relatively stable, Java* [[2]] has been seen as an interesting alternative.  Recent articles in EDN [[3] ,[4]] discuss its use as a viable programming language for embedded systems. The articles identify a number of advantages of Java for embedded systems:

• portability,
• design reuse, and
• location independence of development

• speed,
• to much memory is needed,
• no deterministic performance, due to garbage-collection, and
• no pointers.

2         The DePython project

In the DePython  (Deeply Embeddable Python) project we have created a stripped-down version of Python  that provides a platform for implementing embedded systems in the Python language.  Specifically the DePython system provides the following advantages of Java^tm:

• absolutely free, even for commercial use (including resale),
• small footprint (<200K)
• easy maintenance of software: objects and methods can be replaced ``on-the-fly''
• reference counting garbage-collection giving more deterministic performance

2.1        The architecture of DePython

1. The Hardware abstraction layer provides an adaptation of the hardware to fit the OS.
2. The Operating system layer provides an abstraction of the hardware, together with the traditional services of an operating system.
3. The services layer: Usually the OS has to be adapted with some extra drivers, or some other functionality has to be added.
4. The final layer is the actual application.

In many cases the layers 1-3 are very stable and the user application layer is used to customise the system. An example of this are set-top boxes, where the basic delivery system is the same, but each cable TV provider requires their own user interface to the system. DePython is aimed at exactly this kind of systems, where most of the added value is in the user application layer.

The Python language is a bytecode-interpreted language that runs on the Python virtual machine. The virtual machine executes the Python programs on the target hardware. Any programming environment always includes a number of dependencies on the target system. These can be classified as follows:

• Dependencies on particular processor, such as size of address space, FPU, etc; for example: the Hitachi SH1 micro-controller does not have FPU.
• Dependencies on particular hardware, such as the I/O, for example: the board we are running DePython on has a LCD screen, small keypad and two RS-232 ports for I/O, while a SGI may have very complex graphics hardware.
• Dependencies on a particular operating system, such as threads, interrupts, file system etc; in our case the SH1 evaluation board does not have an operating system.

The Python system comes with a number of add-on modules that add functionality to the system. These are:

• The extension modules (this includes things like support for regular expressions)
• The OS modules (this includes the file system, signalling, threading),
• The hardware modules (this includes support for specific hardware graphics) and
• The command line interface.

2.2       The Hardware

2.3       Future plans

3         More information

4         People

5         References