A very successful tool for model-driven engineering of embedded systems is finite-state machines whose transitions are labeled with expressions of a common-sense logic. The deployment of models to different platforms and different programming languages makes it more imperative to confirm that the models are correct. However, systems are usually composed of concurrent behaviours, which complicates the potential use of model-checking technology. We structure models composed of several finite-state machines into a vector whose execution is a round-robin sequential off-line schedule. This enables model-checking of the requirements. We illustrate this with two case studies widely discussed in the literature. The models can be executed on diverse platforms, and we utilise the same interpreter to generate the corresponding Kripke structure suitable for verification with tools such as NuSMV.

The paper presents a robotic system design methodology based on the concept of an embodied agent decomposed into communicating subsystems, whose activities are specified in terms of FSMs invoking behaviours parameterised by transition functions and terminal conditions. In the implementation phase, this specification is transformed into a system composed of a whiteboard providing communication means and logically labelled FSMs (LLFSMs) defining the system behaviour. These concepts are used to generate the code of the robot controller. The inclusion of inter-subsystem communication model completes the resulting system design with respect to our previous work that did not account for this model. Thus communication plays a central role in this presentation. The design methodology is exemplified with a rudimentary table tennis ball-collecting robot. The presented methodology and the implementation tools are suitable and beneficial for application to the design of other robotic systems.

We propose vectors of finite-state machines whose transitions are labeled by formulas of a common-sense logic as the modelling tool for embedded systems software. We have previously shown that this methodology is very efficient in producing succinct and clear models (e.g., in contrast to plain finite-state machines, Petri nets, or Behavior Trees). We show that we can capture requirements precisely and that we can simulate and validate the models. We can, therefore, directly apply Model-Driven Engineering and deploy the models into software for diverse platforms with full traceability of requirements. Moreover, the sequential semantics of our vector of finite-state machines enables model-checking, formally establishing the correctness of the model. Finally, our approach facilitates systematic Failure Modes and Effects Analysis (FMEA) for diverse target platforms. We demonstrate the effectiveness of our methodology with several examples widely discussed in the software engineering literature and compare this with other approaches, showing that we can prove more properties, and that some claims about verification in such approaches have been exaggerated or are incomplete. Index Terms-Software testing, verification and validation, formal methods in software engineering, software requirements engineering. model-driven engineering.

We present gusimplewhiteboard, a software architecture analogous to ROS:services and ROS:messages, that enables the construction and extremely efficient inter-process relaying of message-types as C++11 objects, All gusimplewhiteboard objects reside in shared memory. Moreover, our principle is to use idempotent message communication, in direct contrast to previously released platforms for roboticmodule communication, that are based on an event-driven subscriber model that queues and multi-threads. We combine this with compiled, time-triggered, logic-labeled finite state machines (llfsms) the are executed concurrently, but scheduled sequentially, in an extremely efficient manner, removing all race conditions and requirements for explicit synchronisation. Together, these tools enable effective robotic behaviour design, where arrangements of llfsms can be organised as hierarchies of machines and submachines, enabling composition of very complex systems. They have proven to be very powerful for Model-Driven Development, capable of simulation, validation, and formal verification.

No abstract