DIGITAL SAFETY MANAGER: IOT SERVICE TO ASSURE THE SAFE BEHAVIOUR OF MACHINES AND CONTROLS IN THE DIGITAL INDUSTRY

10.6036/10243 ◽  
2022 ◽  
Vol 97 (1) ◽  
pp. 18-22
Author(s):  
MIREN ILLARRAMENDI REZABAL ◽  
ASIER IRIARTE ◽  
AITOR ARRIETA AGUERRI, ◽  
GOIURIA SAGARDUI MENDIETA ◽  
FELIX LARRINAGA BARRENECHEA
Keyword(s):  
System Level ◽  
Software Systems ◽  
Software Components ◽  
State Machines ◽  
Time Model ◽  
Software Models ◽  
Check System ◽  
Internal Information ◽  
Run Time ◽  
Research Challenge

The digital industry requires increasingly complex and reliable software systems. They need to control and make critical decisions at runtime. As a consequence, the verification and validation of these systems has become a major research challenge. At design and development time, model testing techniques are used while run-time verification aims at verifying that a system satisfies a given property. The latter technique complements the former. The solution presented in this paper targets embedded systems whose software components are designed by state machines defined by Unified Modelling Language (UML). The CRESCO (C++ REflective State-Machines based observable software COmponents) platform generates software components that provide internal information at runtime and the verifier uses this information to check system-level reliability/safety contracts. The verifier detects when a system contract is violated and initiates a safeState process to prevent dangerous scenarios. These contracts are defined by internal information from the software components that make up the system. Thus, as demonstrated in the tested experiment, the robustness of the system is increased. All software components (controllers), such as the verifier, have been deployed as services (producers/consumers) of the Arrowhead IoT platform: the controllers are deployed on local Arrowhead platforms (Edge) and the verifier (Safety Manager) is deployed on an Arrowhead platform (Cloud) that will consume controllers on the Edge and ensure the proper functioning of the plant controllers. Keywords: run-time monitoring, robustness, software components, contracts, software models, state machines

Model-driven engineering and run-time model-usage in service robotics

2012 ◽  
Vol 47 (3) ◽  
pp. 73-82 ◽  
Author(s):  
Andreas Steck ◽  
Alex Lotz ◽  
Christian Schlegel
Keyword(s):  
Model Driven Engineering ◽  
Service Robotics ◽  
Time Model ◽  
Model Driven ◽  
Run Time

scholarly journals Fragment-oriented programming: a framework to design and implement software product line domain components

DYNA ◽  
2018 ◽  
Vol 85 (207) ◽  
pp. 74-83 ◽  
Author(s):  
Daniel Correa ◽  
Raúl Mazo ◽  
Gloria Lucia Giraldo Goméz
Keyword(s):  
Software Product Line ◽  
Preliminary Evidence ◽  
Product Line ◽  
Software Systems ◽  
Software Components ◽  
Product Lines ◽  
Reusable Software ◽  
Software Products ◽  
Manual Intervention ◽  
Software Product

Software product lines facilitate the industrialization of software development. The main goal is to create a set of reusable software components for the rapid production of a software systems family. Many authors have proposed different approaches to design and implement the components of a product line. However, the construction and integration of these components continue to be a complex and time-consuming process. This paper introduces Fragment-oriented programming (FragOP), a framework to design and implement software product line domain components, and derive software products. FragOP is based on: (i) domain components, (ii) fragmentations points and (iii)fragments. FragOP was implemented in the VariaMos tool and using it we created a clothing stores software product line. We derivedfive different products, integrating automatically thousands of lines of code. On average, only three lines of code were manually modified;which provided preliminary evidence that using FragOP reduces manual intervention when integrating domain components.

scholarly journals Composition, Separation of Roles and Model-Driven Approaches as Enabler of a Robotics Software Ecosystem

2020 ◽  
pp. 53-108
Author(s):  
Christian Schlegel ◽  
Alex Lotz ◽  
Matthias Lutz ◽  
Dennis Stampfer
Keyword(s):  
Complex Systems ◽  
Open Source ◽  
Building Block ◽  
Building Blocks ◽  
Software Systems ◽  
Software Components ◽  
Separation Of Concerns ◽  
Software Ecosystem ◽  
Model Driven ◽  
Successful Approach

AbstractSuccessful engineering principles for building software systems rely on the separation of concerns for mastering complexity. However, just working on different concerns of a system in a collaborative way is not good enough for economically feasible tailored solutions. A successful approach for this is the composition of complex systems out of commodity building blocks. These come as is and can be represented as blocks with ports via data sheets. Data sheets are models and allow a proper selection and configuration as well as the prediction of the behavior of a building block in a specific context. This chapter explains how model-driven approaches can be used to support separation of roles and composition for robotics software systems. The models, open-source tools, open-source robotics software components and fully deployable robotics software systems shape a robotics software ecosystem.

A CSP-Based Approach for Managing the Dynamic Reconfiguration of Software Architecture

2021 ◽  
Vol 14 (1) ◽  
pp. 156-173
Author(s):  
Abdelfetah Saadi ◽  
Youcef Hammal ◽  
Mourad Chabane Oussalah
Keyword(s):  
Dynamic Reconfiguration ◽  
Software Components ◽  
Behavioral Consistency ◽  
Dynamic Nature ◽  
Model Concept ◽  
Software Applications ◽  
Run Time ◽  
And Behavior ◽  
Dynamic Updates ◽  
Complicated Task

Software applications are composed of a set of interconnected software components running on different machines. Most of these applications have a dynamic nature and need to reconfigure structure and behavior at run-time. The dynamic reconfiguration of software is a problem that must be dealt with. Reconfiguring this kind of applications is a complicated task and risks to take software at an undesirable situation. In this paper, the authors present a solution whose objective is to provide a complete support for reconfiguring and formally verifying consistency of dynamic updates of software before performing them. The aim is to provide highly available systems with the ability to safely modify their structure and behavior at run-time. The proposed approach is based mainly on the use of the meta-model concept for reconfiguration structural checking, and the CSP language, refinement technique, and the FDR model checking tool for the verification of reconfiguration behavioral consistency. The authors have also developed a tool prototype that validates and implements their proposals.

Run-Time Compositional Software Platform for Autonomous NXT Robots

2019 ◽  
pp. 649-662
Author(s):  
Ning Gui ◽  
Vincenzo De Florio ◽  
Chris Blondia
Keyword(s):  
Autonomous Robots ◽  
Software Systems ◽  
Robot System ◽  
Unstructured Environments ◽  
System A ◽  
Adaptive Middleware ◽  
Context Knowledge ◽  
Run Time ◽  
Compositional Software ◽  
Robotic Applications

Autonomous Robots normally perform tasks in unstructured environments, with little or no continuous human guidance. This calls for context-aware, self-adaptive software systems. This paper aims at providing a flexible adaptive middleware platform to seamlessly integrate multiple adaptation logics during the run-time. To support such an approach, a reconfigurable middleware system “ACCADA” was designed to provide compositional adaptation. During the run-time, context knowledge is used to select the most appropriate adaptation modules so as to compose an adaptive system best-matching the current exogenous and endogenous conditions. Together with a structure modeler, this allows robotic applications' structure to be autonomously (re)-constructed and (re)-configured. This paper applies this model on a Lego NXT robot system. A remote NXT model is designed to wrap and expose native NXT devices into service components that can be managed during the run-time. A dynamic UI is implemented which can be changed and customized according to system conditions. Results show that the framework changes robot adaptation behavior during the run-time.

An Ontology-Driven System for E-Learning and Knowledge Management

2010 ◽  
pp. 302-324 ◽  
Author(s):  
Gilbert Paquette
Keyword(s):  
Knowledge Management ◽  
Research Network ◽  
Software Systems ◽  
Operation System ◽  
Ontological Engineering ◽  
Modeling Tool ◽  
Graphic Model ◽  
Driven System ◽  
E Learning ◽  
Run Time

Between 2003 and 2008, within the LORNET research network (www.lornet.org), our team has been designing and developing TELOS, an innovative operation system for eLearning and knowledge management environments that is driven by a technical ontology. After presenting the underlying principles of this system, we will develop a graphic model of the resulting ontology that captures the conceptual architecture of the system. Next, we will present the main aggregation modeling tool and the way it is related to the TELOS Ontology. Finally, we will illustrate how the ontology is used to drive the system at run-time. The conclusion will discuss the contri- bution of this research to the field of ontological engineering of software systems.

Sign in / Sign up

Export Citation Format

Share Document