Johannes Helander

MMLite: a highly componentized system architecture

MMLite is a modular system architecture that is suitable for a wide variety of hardware and applications. The system provides a selection of object-based components that are dynamically assembled into a full application system. Amongst these components is a namespace, which supports a new programming model, where components are automatically loaded on demand. The virtual memory manager is optional and is loaded on demand. Components can be easily replaced and reimplemented. A third party independently replaced the real-time scheduler with a different implementation. Componentization reduced the development time and led to a flexible and understandable system. MMLite is efficient, portable, and has a very small memory footprint. It runs on several microprocessors, including two VLIW processors. It is being used on processors that are embedded in a number of multimedia DirectX accelerator boards.

Deeply embedded XML communication: towards an interoperable and seamless world

Current consumer electronics devices do not interoperate and are hard to use. Devices use proprietary, device-specific and inflexible protocols. Resources across device classes, such as personal computers and home appliances cannot be taken advantage of. Even recent efforts to connect sensors into networks concentrate on new, ad-hoc protocols that segregate the low-cost devices into their own little world.If all classes of devices could speak the same language, they could talk directly to each other in ways natural to the application without artificial technical barriers. This would allow easily creating seamless applications that aggregate the capabilities of all the electronics. The interoperation adds value to all the devices.Extensible Markup Language (XML) Web Services were conceived to solve the e-business interoperation problem. After decades of failed attempts with EDI, SNA, DCOM, CORBA, and other similar technologies, XML and its communication specification SOAP has proven itself to be a viable technology. If XML is good for e-business, could it also be good for embedded systems communication?This paper argues that XML and SOAP indeed can be useful in small devices. Solutions to performance questions are available and techniques are outlined here. New unique challenges, such as heterogeneous configuration, privacy and security issues, and real-time requirements (e.g. for gaming) are identified and solutions outlined. A prototype implementation for low-cost microcontrollers is described with numbers included.

Secure Web services for low-cost devices

This paper describes how to use XML Web services and public key cryptography on small devices in consumer settings to achieve a high level of interoperation and security. This is done while maintaining the strict performance requirements that are expected from low-cost devices operating with limited energy and other resources.

Self-tuning planned actions time to make real-time SOAP real

This paper proposes a new method for programming and controlling distributed tasks. Applications declare behavior patterns that are used to automatically predict and reserve resources needed by applications in a heterogeneous distributed environment. The paper introduces a stochastic quality sampling driven scheduler and a rendezvous mechanism for matching pre-planned activities with actual payload data. The system is built around the first real-time SOAP implementation, also presented in this paper. It extends the XML Web services interoperability benefits that have proven themselves in e-business into two new areas: embedded and real-time. The paper presents an efficient implementation that runs on common microcontrollers and other computers.

Adapting Futures: Scalability for Real-World Computing

Creating robust real-time embedded software is critical in combining the physical world with computing, such as in consumer electronics or robotics. One challenge is the complexity of dealing with time together with implementation details that often end up implicitly determining the temporal behavior of the program. In this paper we suggest deconstructing a program into two separate aspects, the functional implementation and a temporal pattern, each expressed separately in a different language. This separation enables independent specification, analysis and prediction of the temporal behavior without regard to the implementation. Meanwhile the implementation is optimized for platforms with different capabilities through a scalable programming model that automatically adapts the execution to the level of concurrency a platform can support. Finally the aspects are put together to create a working system. This paper presents the use of futures and partitures to achieve predictability and performance in embedded systems. A new real-time scheduler for partiture based futures execution is introduced, along with multiple implementations, including one for an 8-bit microcontroller. The paper explains how to create, model, and execute futures and partitures.