An architecture for adaptive real time communication with embedded devices

The virtual testbed is designed to be a cost-effective rapid development environment as well as a teaching tool for embedded systems. Teaching and development of embedded systems otherwise requires dedicated real time operating systems and costly infrastructure for hardware simulation. Writing control software for embedded systems with such a setup takes prolonged development cycles. Moreover, actual hardware may get damaged while writing the control software. On the contrary, in a virtual testbed environment, a simulator running on the host machine is used instead of the actual hardware, which then interacts with an embedded processor through serial communication. This hardware-in-the-loop setup reduces development time drastically but is reliable only if it behaves as close to real time as possible. Use of non-real time architecture like Windows NT on the host machine and the Win32 API causes an overhead in the serial communication that slows down the simulator. The problem is that the simulator is unable to cope with the communication speeds offered by the embedded processor. We propose the development of a kernel mode device driver that overcomes inefficiencies in the Win32 API. The result is faster communication between the simulator and the embedded processor. Another problem that arises with an increase in the simulator’s communication capabilities is whether the operating system can support such a dynamic and high speed interaction. To solve this problem we propose the use of efficient process and thread management and utilization of Windows NT’s support for real time execution and utilization of intelligent buffer and interrupt handling to process the high frequency requests coming from the embedded processor to the host machine. Another hurdle is the diverse nature of hardware that is being simulated: from simple features with low data volume to fairly complex features with high data volume, and with the data rate ranging from very small to very high. Hence, we propose to make the simulator and the kernel mode device driver adaptive. All these strategies culminate into an architecture for adaptive real time communication with the embedded processor, giving the virtual testbed an edge over other design methodologies for embedded systems

Integrated Design Tools for Embedded Control Systems

Currently, computer-based control systems are still being implemented using the same techniques as 10 years ago. The purpose of this project is the development of a design framework, consisting of tools and libraries, which allows the designer to build high reliable heterogeneous real-time embedded systems in a very short time at a fraction of the present day costs. The ultimate focus of current research is on transformation control laws to efficient concurrent algorithms, with concerns about important non-functional real-time control systems demands, such as fault-tolerance, safety,\ud reliability, etc.\ud The approach is based on software implementation of CSP process algebra, in a modern way (pure objectoriented design in Java). Furthermore, it is intended that the tool will support the desirable system-engineering stepwise refinement design approach, relying on past research achievements ¿ the mechatronics design trajectory based on the building-blocks approach, covering all complex (mechatronics) engineering phases: physical system modeling, control law design, embedded control system implementation and real-life realization. Therefore, we expect that this project will result in an\ud adequate tool, with results applicable in a wide range of target hardware platforms, based on common (off-theshelf) distributed heterogeneous (cheap) processing units

Atomic-SDN: Is Synchronous Flooding the Solution to Software-Defined Networking in IoT?

The adoption of Software Defined Networking (SDN) within traditional networks has provided operators the ability to manage diverse resources and easily reconfigure networks as requirements change. Recent research has extended this concept to IEEE 802.15.4 low-power wireless networks, which form a key component of the Internet of Things (IoT). However, the multiple traffic patterns necessary for SDN control makes it difficult to apply this approach to these highly challenging environments. This paper presents Atomic-SDN, a highly reliable and low-latency solution for SDN in low-power wireless. Atomic-SDN introduces a novel Synchronous Flooding (SF) architecture capable of dynamically configuring SF protocols to satisfy complex SDN control requirements, and draws from the authors' previous experiences in the IEEE EWSN Dependability Competition: where SF solutions have consistently outperformed other entries. Using this approach, Atomic-SDN presents considerable performance gains over other SDN implementations for low-power IoT networks. We evaluate Atomic-SDN through simulation and experimentation, and show how utilizing SF techniques provides latency and reliability guarantees to SDN control operations as the local mesh scales. We compare Atomic-SDN against other SDN implementations based on the IEEE 802.15.4 network stack, and establish that Atomic-SDN improves SDN control by orders-of-magnitude across latency, reliability, and energy-efficiency metrics

Model based code generation for distributed embedded systems

Embedded systems are becoming increasingly complex and more distributed. Cost and quality requirements necessitate reuse of the functional software components for multiple deployment architectures. An important step is the allocation of software components to hardware. During this process the differences between the hardware and application software architectures must be reconciled. In this paper we discuss an architecture driven approach involving model-based techniques to resolve these differences and integrate hardware and software components. The system architecture serves as the underpinning based on which distributed real-time components can be generated. Generation of various embedded system architectures using the same functional architecture is discussed. The approach leverages the following technologies – IME (Integrated Modeling Environment), the SAE AADL (Architecture Analysis and Design Language), and Ocarina. The approach is illustrated using the electronic throttle control system as a case study

Developing a distributed electronic health-record store for India

The DIGHT project is addressing the problem of building a scalable and highly available information store for the Electronic Health Records (EHRs) of the over one billion citizens of India

Demo Abstract: Augmenting Reality with IP-based Sensor Networks

We demonstrate low-power IP-based sensor networks by showing a system that interacts with the sensor network using a RESTful web service interface. The sensor data is displayed with overlaid 3D graphics on top of a live camera feed, so-called augmented reality. The augmented reality application is built with off-the-shelf components with no sensor network-specific code. The IP-based sensor network runs the Contiki operating system