Pub Date : 2021-09-08DOI: 10.1109/FDL53530.2021.9568380
Loïc Salmon, P. Pillain, Goulven Guillou, Jean-Philippe Babau
One key objective of Cyber-Physical System (CPS) simulation is to evaluate different CPS configurations regarding a certain user objective. First, simulation of CPS necessitates frameworks to handle heterogeneity of CPS components (the software and hardware system control, the behavior of the CPS itself and its physical environment). Then, to build simulators, designers use paradigms like FMI (Functional Mock-Up Interface) that proposes a data-driven generic interface facilitating the integration of heterogeneous models. However, in order to facilitate simulation configuration, an approach is required to drive modeling of parametric features and operational conditions. In this paper, we present CARES, a component-based and model-driven approach to facilitate CPS simulation. CARES is applied to evaluate an Autonomous Underwater Vehicle (AUV) navigation function by simulation. The proposed models integrate both the principles of a generic simulation (integration of Component Based Software Engineering CBSE concepts and FMI paradigm) and domain specific aspects through a component-based architecture style. From a design model, a code generator builds the structural (Java or C++) code of the simulator. The generated code relies on a given run-time library for its execution and its structure facilitates integration of domain-specific code. The experiments show the effectiveness of the approach to build simulators for evaluation of different AUV configurations.
{"title":"CARES, a framework for CPS simulation : application to autonomous underwater vehicle navigation function","authors":"Loïc Salmon, P. Pillain, Goulven Guillou, Jean-Philippe Babau","doi":"10.1109/FDL53530.2021.9568380","DOIUrl":"https://doi.org/10.1109/FDL53530.2021.9568380","url":null,"abstract":"One key objective of Cyber-Physical System (CPS) simulation is to evaluate different CPS configurations regarding a certain user objective. First, simulation of CPS necessitates frameworks to handle heterogeneity of CPS components (the software and hardware system control, the behavior of the CPS itself and its physical environment). Then, to build simulators, designers use paradigms like FMI (Functional Mock-Up Interface) that proposes a data-driven generic interface facilitating the integration of heterogeneous models. However, in order to facilitate simulation configuration, an approach is required to drive modeling of parametric features and operational conditions. In this paper, we present CARES, a component-based and model-driven approach to facilitate CPS simulation. CARES is applied to evaluate an Autonomous Underwater Vehicle (AUV) navigation function by simulation. The proposed models integrate both the principles of a generic simulation (integration of Component Based Software Engineering CBSE concepts and FMI paradigm) and domain specific aspects through a component-based architecture style. From a design model, a code generator builds the structural (Java or C++) code of the simulator. The generated code relies on a given run-time library for its execution and its structure facilitates integration of domain-specific code. The experiments show the effectiveness of the approach to build simulators for evaluation of different AUV configurations.","PeriodicalId":114039,"journal":{"name":"2021 Forum on specification & Design Languages (FDL)","volume":"18 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2021-09-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128072089","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Pub Date : 2021-09-08DOI: 10.1109/FDL53530.2021.9568371
Sebastiano Gaiardelli, Stefano Spellini, M. Lora, F. Fummi
The Industry 4.0 trend speeds up the adoption of a variety of technologies. In modern manufacturing, system data are collected both from the field through sensors and by exploiting complex simulations. Data analysis techniques became crucial to build and maintain any efficient production line, while autonomous systems and robots are the main focus of researchers and practitioners. This pervasive use of artificial intelligence derived technologies pushed humans to the border of production systems. Industry 5.0 aims at bringing the attention back to humans in production lines while magnifying their interactions with intelligent systems. This new trend will impact the design of future manufacturing infrastructures, increasing their complexity. Engineers will need modeling and developing tools able to capture this complexity. In this paper, we analyze the modeling languages and tools being used, identifying their strengths and weaknesses. Then, we propose some possible directions to provide engineers with the expressive power needed to tackle the challenges posed by Industry 5.0.
{"title":"Modeling in Industry 5.0: What Is There and What Is Missing: Special Session 1: Languages for Industry 5.0","authors":"Sebastiano Gaiardelli, Stefano Spellini, M. Lora, F. Fummi","doi":"10.1109/FDL53530.2021.9568371","DOIUrl":"https://doi.org/10.1109/FDL53530.2021.9568371","url":null,"abstract":"The Industry 4.0 trend speeds up the adoption of a variety of technologies. In modern manufacturing, system data are collected both from the field through sensors and by exploiting complex simulations. Data analysis techniques became crucial to build and maintain any efficient production line, while autonomous systems and robots are the main focus of researchers and practitioners. This pervasive use of artificial intelligence derived technologies pushed humans to the border of production systems. Industry 5.0 aims at bringing the attention back to humans in production lines while magnifying their interactions with intelligent systems. This new trend will impact the design of future manufacturing infrastructures, increasing their complexity. Engineers will need modeling and developing tools able to capture this complexity. In this paper, we analyze the modeling languages and tools being used, identifying their strengths and weaknesses. Then, we propose some possible directions to provide engineers with the expressive power needed to tackle the challenges posed by Industry 5.0.","PeriodicalId":114039,"journal":{"name":"2021 Forum on specification & Design Languages (FDL)","volume":"7 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2021-09-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122187221","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Pub Date : 2021-09-08DOI: 10.1109/FDL53530.2021.9568383
Julien Deantoni, João Cambeiro, Soroush Bateni, Shaokai Lin, Marten Lohstroh
LINGUA Franca (lf) is a polyglot coordination language designed for the composition of concurrent, time-sensitive, and potentially distributed reactive components called reactors. The LF coordination layer facilitates the use of target languages (e.g., C, C++, Python, TypeScript) to realize the program logic, where each target language requires a separate runtime implementation that must correctly implement the reactor semantics. Verifying the correctness of runtime implementations is not a trivial task, and is currently done on the basis of regression testing. To provide a more formal verification tool for existing and future target runtimes, as well as to help verify properties of LF programs, we recruit the use of GemocStudio-an Eclipse-based workbench for the development, integration, and use of heterogeneous executable modeling languages. We present an operational model for LF, realized in GEmocStudio, that is primed to interact with a rich set of analysis and verification tools. Our instrumentation provides the ability to navigate the execution of LF programs using an omniscient debugger with graphical model animation; to check assertions in particular execution runs, or exhaustively, using a model checker; and to validate or debug traces obtained from arbitrary LF runtime environments.
LINGUA Franca (lf)是一种多语言协调语言，专为称为反应器的并发、时间敏感和潜在分布式反应性组件的组合而设计。LF协调层有助于使用目标语言(如C、c++、Python、TypeScript)来实现程序逻辑，其中每种目标语言都需要单独的运行时实现，必须正确实现反应器语义。验证运行时实现的正确性不是一项微不足道的任务，目前是在回归测试的基础上完成的。为了为现有的和未来的目标运行时提供更正式的验证工具，以及帮助验证LF程序的属性，我们使用了gemocstudio——一个基于eclipse的工作台，用于开发、集成和使用异构的可执行建模语言。我们提出了一个在GEmocStudio中实现的LF操作模型，该模型已准备好与丰富的分析和验证工具集进行交互。我们的工具提供了使用无所不知的调试器和图形模型动画导航LF程序执行的能力;在特定的执行运行中检查断言，或者使用模型检查器进行彻底检查;并验证或调试从任意LF运行时环境获得的跟踪。
{"title":"Debugging and Verification Tools for Lingua Franca in Gemoc Studio","authors":"Julien Deantoni, João Cambeiro, Soroush Bateni, Shaokai Lin, Marten Lohstroh","doi":"10.1109/FDL53530.2021.9568383","DOIUrl":"https://doi.org/10.1109/FDL53530.2021.9568383","url":null,"abstract":"LINGUA Franca (lf) is a polyglot coordination language designed for the composition of concurrent, time-sensitive, and potentially distributed reactive components called reactors. The LF coordination layer facilitates the use of target languages (e.g., C, C++, Python, TypeScript) to realize the program logic, where each target language requires a separate runtime implementation that must correctly implement the reactor semantics. Verifying the correctness of runtime implementations is not a trivial task, and is currently done on the basis of regression testing. To provide a more formal verification tool for existing and future target runtimes, as well as to help verify properties of LF programs, we recruit the use of GemocStudio-an Eclipse-based workbench for the development, integration, and use of heterogeneous executable modeling languages. We present an operational model for LF, realized in GEmocStudio, that is primed to interact with a rich set of analysis and verification tools. Our instrumentation provides the ability to navigate the execution of LF programs using an omniscient debugger with graphical model animation; to check assertions in particular execution runs, or exhaustively, using a model checker; and to validate or debug traces obtained from arbitrary LF runtime environments.","PeriodicalId":114039,"journal":{"name":"2021 Forum on specification & Design Languages (FDL)","volume":"52 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2021-09-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121166311","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Pub Date : 2021-09-08DOI: 10.1109/FDL53530.2021.9568379
Nicola Dall'Ora, Sadia Azam, Enrico Fraccaroli, André Alberts, F. Fummi
There are plentiful successors of SPICE language for describing transistor-level designs. For most of them, the semantic matches those of SPICE, and only the syntax is changed. Others instead provide more default models or analysis tools. Consequently, a commercial tool is usually required for simulating, analyzing, and especially manipulating these languages. This article proposes a framework that relies on the shared semantic for reading, writing, or manipulating transistor-level designs. The ultimate goal of the framework is: reading an input design written in a specific syntax and then allowing to write the same design in another syntax. First, the input description is parsed by a language-specific front-end which turns it into an in-memory abstract syntax tree that follows the common semantic. Then, the in-memory description can be subject to different user-defined manipulations built on top of a series of API or visitor/listener classes. Finally, the description goes through the desired back-end, transforming the in-memory description into the target transistor-level language. As a use-case for the proposed framework, we chose the process of analog fault injection. This activity requires adding, removing, or replacing nodes, components, or even entire sub-circuits. Therefore, the framework is completely written in C++, and its APIs are also interfaced with python. The entire framework is open-source and available on GitHub.
{"title":"A Common Manipulation Framework for Transistor-Level Languages","authors":"Nicola Dall'Ora, Sadia Azam, Enrico Fraccaroli, André Alberts, F. Fummi","doi":"10.1109/FDL53530.2021.9568379","DOIUrl":"https://doi.org/10.1109/FDL53530.2021.9568379","url":null,"abstract":"There are plentiful successors of SPICE language for describing transistor-level designs. For most of them, the semantic matches those of SPICE, and only the syntax is changed. Others instead provide more default models or analysis tools. Consequently, a commercial tool is usually required for simulating, analyzing, and especially manipulating these languages. This article proposes a framework that relies on the shared semantic for reading, writing, or manipulating transistor-level designs. The ultimate goal of the framework is: reading an input design written in a specific syntax and then allowing to write the same design in another syntax. First, the input description is parsed by a language-specific front-end which turns it into an in-memory abstract syntax tree that follows the common semantic. Then, the in-memory description can be subject to different user-defined manipulations built on top of a series of API or visitor/listener classes. Finally, the description goes through the desired back-end, transforming the in-memory description into the target transistor-level language. As a use-case for the proposed framework, we chose the process of analog fault injection. This activity requires adding, removing, or replacing nodes, components, or even entire sub-circuits. Therefore, the framework is completely written in C++, and its APIs are also interfaced with python. The entire framework is open-source and available on GitHub.","PeriodicalId":114039,"journal":{"name":"2021 Forum on specification & Design Languages (FDL)","volume":"159 ","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2021-09-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114091603","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Pub Date : 2021-09-08DOI: 10.1109/FDL53530.2021.9568372
Geri Skenderi, Alessia Bozzini, Luigi Capogrosso, Enrico Carlo Agrillo, G. Perbellini, F. Fummi, M. Cristani
This paper presents DOHMO, an embedded computer vision system where multiple sensors, including intelligent cameras, are connected to actuators that regulate illumination and doors. The system aims at assisting elderly and impaired people in co-housing scenarios, in accordance with privacy design principles. The paper provides details of two core elements of the system: The first one is the BOX-IO controller, a fully scalable and customizable hardware and software IoT ecosystem that can collect, control, and monitor data, operational flows and business scenarios, whether indoor or outdoor. The second one is the embedded 3DEverywhere intelligent camera, a device composed of an embedded system that receives input data provided by a 3D/2D camera, analyzes it, and returns the metadata of this analysis. We illustrate how they can be connected and how simple decision mechanisms can be implemented in such a framework. In particular, illumination can be triggered on and off by the detected presence of people, overcoming the limitations of typical sensors, while doors can be opened or closed based on person trajectories in an intelligent manner. To substantiate the proposed system, numerous experiments are performed in a lab and a co-housina scenario.
{"title":"DOHMO: Embedded Computer Vision in Co-Housing Scenarios","authors":"Geri Skenderi, Alessia Bozzini, Luigi Capogrosso, Enrico Carlo Agrillo, G. Perbellini, F. Fummi, M. Cristani","doi":"10.1109/FDL53530.2021.9568372","DOIUrl":"https://doi.org/10.1109/FDL53530.2021.9568372","url":null,"abstract":"This paper presents DOHMO, an embedded computer vision system where multiple sensors, including intelligent cameras, are connected to actuators that regulate illumination and doors. The system aims at assisting elderly and impaired people in co-housing scenarios, in accordance with privacy design principles. The paper provides details of two core elements of the system: The first one is the BOX-IO controller, a fully scalable and customizable hardware and software IoT ecosystem that can collect, control, and monitor data, operational flows and business scenarios, whether indoor or outdoor. The second one is the embedded 3DEverywhere intelligent camera, a device composed of an embedded system that receives input data provided by a 3D/2D camera, analyzes it, and returns the metadata of this analysis. We illustrate how they can be connected and how simple decision mechanisms can be implemented in such a framework. In particular, illumination can be triggered on and off by the detected presence of people, overcoming the limitations of typical sensors, while doors can be opened or closed based on person trajectories in an intelligent manner. To substantiate the proposed system, numerous experiments are performed in a lab and a co-housina scenario.","PeriodicalId":114039,"journal":{"name":"2021 Forum on specification & Design Languages (FDL)","volume":"79 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2021-09-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122526153","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Pub Date : 2021-09-08DOI: 10.1109/FDL53530.2021.9568376
Francesco Lumpp, M. Panato, F. Fummi, N. Bombieri
Programming modern Robots' missions and behavior has become a very challenging task. The always increasing level of autonomy of such platforms requires the integration of multi-domain software applications to implement artificial intelligence, cognition, and human-robot/robot-robot interaction applications. In addition, to satisfy both functional and nonfunctional requirements such as reliability and energy efficiency, robotic SW applications have to be properly developed to take advantage of heterogeneous (Edge-Fog-Cloud) architectures. In this context, containerization and orchestration are becoming a standard practice as they allow for better information flow among different network levels as well as increased modularity in the use of software components. Nevertheless, the adoption of such a practice along the design flow, from simulation to the deployment of complex robotic applications by addressing the de-facto development standards (i.e., robotic operating system - ROS - compliancy for robotic applications) is still an open problem. We present a design methodology based on Docker and Kubernetes that enables containerization and orchestration of ROS-based robotic SW applications for heterogeneous and hierarchical HW architectures. The design methodology allows for (i) integration and verification of multi-domain components since early in the design flow, (ii) task-to-container mapping techniques to guarantee minimum overhead in terms of performance and memory footprint, and (iii) multi-domain verification of functional and non-functional constraints before deployment. We present the results obtained in a real case of study, in which the design methodology has been applied to program the mission of a Robotnik RB-Kairos mobile robot in an industrial agile production chain. The source code of the mobile robot is publicly available on GitHub.
{"title":"A Container-based Design Methodology for Robotic Applications on Kubernetes Edge-Cloud architectures","authors":"Francesco Lumpp, M. Panato, F. Fummi, N. Bombieri","doi":"10.1109/FDL53530.2021.9568376","DOIUrl":"https://doi.org/10.1109/FDL53530.2021.9568376","url":null,"abstract":"Programming modern Robots' missions and behavior has become a very challenging task. The always increasing level of autonomy of such platforms requires the integration of multi-domain software applications to implement artificial intelligence, cognition, and human-robot/robot-robot interaction applications. In addition, to satisfy both functional and nonfunctional requirements such as reliability and energy efficiency, robotic SW applications have to be properly developed to take advantage of heterogeneous (Edge-Fog-Cloud) architectures. In this context, containerization and orchestration are becoming a standard practice as they allow for better information flow among different network levels as well as increased modularity in the use of software components. Nevertheless, the adoption of such a practice along the design flow, from simulation to the deployment of complex robotic applications by addressing the de-facto development standards (i.e., robotic operating system - ROS - compliancy for robotic applications) is still an open problem. We present a design methodology based on Docker and Kubernetes that enables containerization and orchestration of ROS-based robotic SW applications for heterogeneous and hierarchical HW architectures. The design methodology allows for (i) integration and verification of multi-domain components since early in the design flow, (ii) task-to-container mapping techniques to guarantee minimum overhead in terms of performance and memory footprint, and (iii) multi-domain verification of functional and non-functional constraints before deployment. We present the results obtained in a real case of study, in which the design methodology has been applied to program the mission of a Robotnik RB-Kairos mobile robot in an industrial agile production chain. The source code of the mobile robot is publicly available on GitHub.","PeriodicalId":114039,"journal":{"name":"2021 Forum on specification & Design Languages (FDL)","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2021-09-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130514221","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：