Software Frameworks and Embedded Control Systems

Innovations in Systems and Software Engineering, 2019

Software for satellite control systems (SCS) domain performs a relevant role in space systems, being responsible for ensuring the functioning of the satellites, from the orbit launch to the end of their lifetime. Systems in this domain are complex and are constantly evolving due to technological advancement of satellites, the significant increase in controlled satellites, and the interoperability among space organizations. However, in order to meet such complexity and such evolution, the architectures of these systems have been usually designed in an isolated way by each organization and hence may be prone to recurrent efforts and difficulties of interoperability. In parallel to this scenario, reference architecture, a special type of software architecture that aggregates knowledge of a specific domain, has performed an important role for the success in development, standardization, and evolution of systems in several domains. Nevertheless, the usage of reference architecture has not been explored in the SCS domain. Thus, this article presents a reference architecture for satellite control systems (SCS-RA). Results achieved from usage of SCS-RA in the development of a microsatellite control system for National Institute for Space Research showed a significant reduction of effort, benefits of interoperability, scalability, and sharing of ground resources.

Gateway to the New Millennium. 18th Digital Avionics Systems Conference. Proceedings (Cat. No.99CH37033)

This paper advocates a new approach to satellite software design based on objectoriented framework technology and describes early results from a project for the European Space Agency (ESA) to design a software framework for satellite attitude and orbit control systems 1 (AOCS). Frameworks are collections of components with pre-defined cooperations among them. They make architecture (as opposed to mere code) reuse possible. The framework concept is being tested in a redesign of the AOCS software. This paper illustrates it by describing the implementation of telecommand handling, telemetry handling, and operational mode management.

Lecture Notes in Computer Science, 2001

Object-oriented frameworks are a software reuse technology that fosters reuse of entire architectures and which has made software reuse a reality in many domain areas. Like other advanced software techniques, however, framework technology has seldom been used in the embedded domain. This paper argues that its application to embedded (control) systems is technically feasible and liable to bring to them the same benefits it has already brought to other domains. The description of a prototype framework for satellite control systems corroborates the argument. It is then argued that software frameworks, when combined with other enabling technologies, have the potential to standardize various aspects of embedded software and to transform the embedded sytems market.

ARM and uVision are registered trademarks of ARM Limited.

Based on the experiences from PÅLSJÖ and PAL, a new language called FRIEND is proposed. The FRIEND language supports the implementation of flexible embedded control systems by providing mechanisms for adding and removing code on-line. Eker, J., and A. Blomdell: "A Contract-Based Language For Embedded Control Systems." In submission to the 25th IFAC/IFIP Workshop on Real-Time Programming WRTP'2000, Palma de Mallorca, Spain. Contributions FRIEND supports the implementation of flexible control systems through the use of contracts. In FRIEND, a control algorithm may be associated with a contract, which defines the expected behavior of the algorithm. The contracts allow the run-time system to distinguish between blocks that are working correctly or incorrectly. The notion of contracts in the language supports the development of systems with a high level of adaptivity and fault tolerance. Paper 4 A feedback scheduler algorithm is presented. Given that all the control tasks are associated with cost functions, it finds the optimal set of sam

2007

The work presented here is on setting up methodological support, including (prototype) tools, for the design of distributed hard real-time embedded control software for mechatronic products. The use of parallel hardware (CPUs, FPGAs) and parallel software is investigated, to exploit the inherent parallel nature of embedded systems and their control. Two core models of computation are used to describe the behavior of the total mechatronic system (plant, control, software and I/O): discrete event system (DES) and continuous time system (CTS). These models of computation are coupled via co-simulation, to be able to do consistency checking at the boundaries. This allows for integration of discipline-specific parts on the model level (during design phases) instead of on the code level (during realization and test phases). Crossview design-change influences get specific attention, to allow for relaxation of the tension between several dependability issues (like reliability and robustness), while keeping design time (and thus design costs) under control. Furthermore, the design work can be done as a stepwise refinement process. This yields a shorter design time, and a better quality product. The method is illustrated with a case using the tools being prototyped.

… PROGRESS 2000 Workshop …, 2000

Developing embedded control systems using a building-block approach at all the parts enables an efficient and fast design process. Main reasons are the real plug-and-play capabilities of the blocks. Furthermore, due the simulatability of the designs, parts of the system can already be tested before the other parts are available. We have applied an object-oriented approach for modeling all three parts of embedded control systems: compositional programming for the embedded software parts; VHDL for the specific I/O computer hardware parts; and bond graphs for the appliance (i.e. the device to be controlled). Due to the simulatability, our building-block method is suitable for a concurrent engineering design approach, and thus supporting hardware-software co-design. Currently, our research focuses on the software description part. The appliance description part has been worked on, while we just use VHDL descriptions for the computer hardware. This is the reason why the emphasis in this text is on the building blocks for the embedded software part.

Proceedings of the 2nd International Workshop on Software Engineering for Resilient Systems - SERENCE '10, 2010

The efficient design of resilient embedded systems is hampered by the separation of engineering disciplines in current development approaches. We describe a new project entitled "Design Support and Tooling for Embedded Control Software" (DESTECS), which aims to develop a methodology and open tools platform for collaborative and multidisciplinary development of dependable embedded real-time control systems. We also present some initial results from a small co-simulation case study. The DESTECS methodology combines continuous-time and discrete-event modelling via co-simulation, allowing explicit modelling of faults and fault-tolerance mechanisms from the outset. Continuous-time models are expressed using differential equations, which we represent using the wellknown bond graph notation, supported by the 20-sim tool. We model discrete-event controllers using the Vienna Development Method (VDM), supported by the Overture tools. An open, extensible tools platform will be developed, populated with plug-ins to support static analysis, co-simulation, testing and fault analysis. Trials will be conducted on industrial case studies from several domains, including document handling, inertial measurement and personal transportation.

IEEE Transactions on Reliability - TR, 2001

Software implementation of control laws for industrial systems seem straightforward, but is not. The computer code stemming from the control laws is mostly not more than 10 to 30% of the total. A building-block approach for embedded control system development is advocated to enable a fast and efficient software design process. We have developed the CTJ library, Communicating Threads for Java¿, resulting in fundamental elements for creating building blocks to implement communication using channels. Due to the simulate-ability, our building block method is suitable for a concurrent engineering design approach. Furthermore, via a stepwise refinement process, using verification by simulation, the implementation trajectory can be done efficiently.

Innovations in Systems and Software Engineering, 2011

The widespread use of embedded systems requires the creation of industrial software technology that will make it possible to engineer systems being correct by construction. That can be achieved through the use of validated (trusted) components, verification of design models, and automatic configuration of applications from validated design models and trusted components. This design philosophy has been instrumental for developing COMDES-a component-based framework for distributed embedded control systems. A COMDES application is conceived as a network of embedded actors that are configured from instances of reusable, executable components-function blocks (FBs). System actors operate in accordance with a timed multitasking model of computation, whereby I/O signals are exchanged with the controlled plant at precisely specified time instants, resulting in the elimination of I/O jitter. The paper presents an analysis technique that can be used to validate COMDES design models in SIMULINK. It is based on a transformation of the COMDES design model

2000

In this paper, a set of 11 embedded machine contro l system pat- terns are presented. These patterns were identified during architectural as- sessments carried out at several sites of Finnish m achine industry. The pattern set is categorized according to three major characteristics of such software: distribution, real-time, and fault tolera nce. The pattern set does not yet constitute

1999

Abstract Software components for embedded reactive real-time applications must satisfy tight code size and run-time constraints. Cooperating finite state machines provide convenient intermediate format for embedded system co-synthesis, between high-level specification languages and software or hardware implementations. We propose a software generation methodology that takes advantage of a restricted class of specifications and allows for tight control over the implementation cost.

Three persistent common problems in satellite ground control software are obsolescence, lack of desired features and flexibilities, and endless software bug fixing. The obsolescence problem occurs when computer and ground equipment hardware become obsolete usually after only one third into the satellite mission lifetime. The software needs to be updated to accommodate changes on the hardware side, requiring significant work of satellite operators to test, verify, and validate these software updates. Trying to help solve these problems, an OPM model and guidelines for developing satellite ground control software have been proposed. The system makes use of a database-driven application and concepts of object-process orientation and modularity. In the new proposed framework, instead of coding each software function separately, the common base functions will be coded, and combining them in various ways will provide the different required functions. The formation and combination of these base functions will be governed by the main code, definitions, and database parameters. These design principles will make sure that the new software framework would provide satellite operators with the flexibility to create new features, and enable software developer to find bugs quicker and fix them more effectively.

Today embedded control systems are created using tools that give insufficient support for rapid prototyping and code reuse. New tools for the implementation of embedded controllers are necessary. This paper presents the experimental software framework PÅLSJÖ, and the language PAL. The PÅLSJÖ system is a rapid prototyping environment designed to support on-line system reconfigurations and code reuse. PAL is a new language, designed for implementation of control algorithms.

IFAC Proceedings Volumes, 2005

Software-related costs account for a growing share of total development costs for embedded control systems. In the control field, containment of software costs can be done either through the use of model-based tools (e.g. Matlab) or through a higher level of reuse. This paper argues that the second strategy is advantageous in the case of industrial control systems targeting niche markets where systems tend to be one-of-a-kind and where they can be organized in "families" of related applications. The paper then argues that progress in raising the level of software reuse in these fields depends on the adoption of better software adaptability techniques. The most promising such techniques are reviewed from the standpoint of control engineers.