Academic literature on the topic 'Embedded system,scripting language,software engineering,system architecture'

In the past decade, much work has been done on integrating different lake models using general frameworks to overcome model incompatibilities. However, a framework may not be flexible enough to support applications in different fields. To overcome this problem, we used Python to integrate three lake models into a Phytoplankton Prediction System for Lake Taihu (Taihu PPS). The system predicts the short-term (1–4 days) distribution of phytoplankton biomass in this large eutrophic lake in China. The object-oriented scripting language Python is used as the so-called ‘glue language’ (a programming language used for connecting software components). The distinguishing features of Python include rich extension libraries for spatial and temporal modelling, modular software architecture, free licensing and a high performance resulting in short execution time. These features facilitate efficient integration of the three models into Taihu PPS. Advanced tools (e.g. tools for statistics, 3D visualization and model calibration) could be developed in the future with the aid of the continuously updated Python libraries. Taihu PPS simulated phytoplankton biomass well and has already been applied to support decision making.

<span>Computer aided software engineering (CASE) uses the unified modelling language UML to produce executable code to visualize software architectural blueprint systems. UML is a standard software modeling language for specifying, constructing, documenting and visualizing the artifacts of produced software-intensive systems. However, UML lacks virtual collaboration regardless of their geographical location. The present work developed a prototype of web-based CASE tool that enables UML modes to manage software projects as a virtual collaboration tool. The present methodology starts with the specification of a set of UML triplets; then, the tool generates the visual models automatically with high quality SVG graphs. The system eliminates the manual diagram requirements based on the UML possibility and supported by three diagrams that involves class and use cases. The independent scripting language was PHP7 and MYSQL 8.0 which was used to save the system data.</span>

Application models are commonly used in the development of information systems. Recent trends have introduced techniques by which models can be directly transformed into execution code and thus become a single source for application design. Inherently, it has been challenging for software developers to become proficient in designing entire systems due to the complex chain of model transformations and the further refinements required to the code generated from the models. We propose an architectural framework for building the distributed information system applications in which the application models are directly interpreted during execution. This approach shortens the evaluation cycles and provides faster feedback to developers. Our framework is based on a holistic application model represented as a graph structure complemented with a procedural action scripting language that can express more complex software behavior. We present the implementation details of this framework architecture in a mobile cloud environment and evaluate its benefits in eleven projects for different customers in the retail, supply-chain management and merchandising domain involving 300 active application users. Our approach allowed engaging end-users in the software development process in the phase of specifying executable application models. It succeeded in shortening the requirements engineering process and automating the configuration and deployment process. Moreover, it benefited from the automatic synchronization of application updates for all active versions at the customer sites.

The rapid growth of software-based functionalities has made automotive Electronic Control Units (ECUs) significantly complex. Factors affecting the software complexity of components embedded in an ECU depend not only on their interface and interaction properties, but also on the structural constraints characterized by a component’s functional semantics and timing constraints described by AUTomotive Open System ARchitecture (AUTOSAR) languages. Traditional constraint complexity measures are not adequate for the components in embedded software systems as they do not yet sufficiently provide a measure of the complexity due to timing constraints which are important for quantifying the dynamic behavior of components at run-time. This paper presents a method for measuring the constraint complexity of components in automotive embedded software systems at the specification level. It first enables system designers to define non-deterministic constraints on the event chains associated with components using the AUTOSAR-based Modeling and Analysis of Real-Time and Embedded systems (MARTE)-UML and Timing Augmented Description Language (TADL). Then, system analysts use Unified Modeling Language (UML)-compliant Object Constraint Language (OCL) and its Real-time extension (RT-OCL) to specify the structural and timing constraints on events and event chains and estimate the constraint complexity of components using a measure we have developed. A preliminary version of the method was presented in M. Garg and R. Lai, Measuring the constraint complexity of automotive embedded software systems, in Proc. Int. Conf. Data and Software Engineering, 2014, pp. 1–6. To demonstrate the usefulness of our method, we have applied it to an automotive Anti-lock Brake System (ABS).

The ever-increasing complexity of cyber-physical systems is driving the need for assurance of critical infrastructure and embedded systems. However, traditional methods to secure cyber-physical systems—e.g., using cyber best practices, adapting mechanisms from information technology systems, and penetration testing followed by patching—are becoming ineffective. This paper describes, in detail, Verification Evidence and Resilient Design In anticipation of Cybersecurity Threats (VERDICT), a language and framework to address cyber resiliency. When we use the term resiliency, we mean hardening a system such that it anticipates and withstands attacks. VERDICT analyzes a system in the face of cyber threats and recommends design improvements that can be applied early in the system engineering process. This is done in two steps: (1) Analyzing at the system architectural level, with respect to cyber and safety requirements and (2) by analyzing at the component behavioral level, with respect to a set of cyber-resiliency properties. The framework consists of three parts: (1) Model-Based Architectural Analysis and Synthesis (MBAAS); (2) Assurance Case Fragments Generation (ACFG); and (3) Cyber Resiliency Verifier (CRV). The VERDICT language is an Architecture Analysis and Design Language (AADL) annex for modeling the safety and security aspects of a system’s architecture. MBAAS performs probabilistic analyses, suggests defenses to mitigate attacks, and generates attack-defense trees and fault trees as evidence of resiliency and safety. It can also synthesize optimal defense solutions—with respect to implementation costs. In addition, ACFG assembles MBAAS evidence into goal structuring notation for certification purposes. CRV analyzes behavioral aspects of the system (i.e., the design model)—modeled using the Assume-Guarantee Reasoning Environment (AGREE) annex and checked against cyber resiliency properties using the Kind 2 model checker. When a property is proved or disproved, a minimal set of vital system components responsible for the proof/disproof are identified. CRV also provides rich and localized diagnostics so the user can quickly identify problems and fix the design model. This paper describes the VERDICT language and each part of the framework in detail and includes a case study to demonstrate the effectiveness of VERDICT—in this case, a delivery drone.

In the process of customizing of CAD system for parametric product design, the modeling technology of product knowledge, the KBE (Knowledge Based Engineering) application architecture and technologies was studied. This paper proposed the classification standard for product knowledge base upon the methods of defining and representing ontological knowledge and procedural knowledge. Depending on the logic of product knowledge model, the function architecture of KBE software package embedded in CAD system has been constructed. Some practical technologies have been illustrated, like the visual interactive 3D annotation user interface base upon engineering semantic symbol, which can actualize the acquisition, representation, and ratiocination of knowledge. Using NXTM Open C and KF (Knowledge Fusion) as program language, all the methods for knowledge manipulation can be carried into execution in CAD system.

The worldwide spreading of Internet, in combination with the development of new low power and low cost embedded devices, has enabled the so-called Internet of Things vision. Wireless Sensor Networks represent an invaluable resource for realizing such scenario, inside which new and innovative applications could be developed. However, the low availability of resources and the reduced processing capacity of the target embedded platforms make the development of the next-generation applications very challenging. This paper proposes an innovative system architecture, called STarch, able to simplify the development of new applications and protocols for resource-constrained objects. It is meant to follow the software engineering principles and to support a wide range of applications, making both the programming easier and the code portable over multiple hardware platforms. STarch simplifies the network configuration process, through the use of an automatic mechanism based on the XML language and it runs properly on different operating systems, including FreeRTOS and Contiki. The feasibility of the proposed architecture has been proved by using a test bed approach, while an extensive performance analysis have been carried out in order to demonstrate its effectiveness in terms of memory requirements and processing delays.

This paper presents results and experiences coming from 10 years of development and use of XVR, a flexible, general-purpose framework for virtual reality (VR) development. The resulting architecture, that comes under the form of a self-sufficient integrated development environment (IDE) organized around a dedicated scripting language and a virtual machine, is able to accommodate a wide range of applications needs, ranging from simple Web3D applications to motion-based simulators or complex cluster-based immersive visualization systems. Within the framework a common, archetypical structure is used for any application, showing how inhomogeneous needs and technologies can be effectively covered by using a single, rather simple, system organization. We also show how the framework flexibility allows for innovative development techniques such as multiple frameworks coexisting within a single, tightly integrated, VR application.

The paper discusses whether (and how) to teach assembly coding as opposed to (or in conjunction with) higher programming languages as part of a modern electrical engineering curriculum. We describe the example of a very simple cooperative embedded real-time operating system, first programmed in C and then in assembler. A few lines of C language code are compared with the slightly longer assembly code equivalent, and the advantages and drawbacks are discussed. The example affords students a much deeper understanding of computer architecture and operating systems. The course is linked to other courses in the curriculum, which all use the same hardware and software platform; this lowers prices, reduces overheads and encourages students to reuse parts of a written code in subsequent courses. A student learns that badly written and poorly documented code is very difficult to reuse.

Recent studies show the impact of genetic algorithms (GA) in the design of evolutionary finite impulse response (FIR) filters. Studies have shown hardware and software method of GA implementation for design. Hardware method improves speed due to parallelism, pipelining and the absence of the function calls compared to software implementation. But area constraint was the main issue of hardware implementation. Therefore, this paper illustrates a hardware–software co-design concept to implement an Adaptive GA processor (AGAP) for FIR filter design. The architecture of AGAP uses adaptive crossover and mutation probabilities to speed up the convergence of the GA process. The AGAP architecture was implemented using Verilog Hardware Description Language (HDL) and instantiated as a custom intellectual property (IP) core to the soft-core MicroBlaze processor of Spartan 6 (XC6SLX45-3CSG324I) FPGA. The MicroBlaze processor controls the AGAP IP core and other interfaces using Embedded C programs. The experiment demonstrated a significant 134% improvement in speed over hardware implementation but with a marginal increase in area. The complete evaluation and evolution of the filter coefficients were executed on a single FPGA. The system on chip (SoC) concept enables a robust and flexible system.

La tesi descrive il lavoro svolto presso l'azienda Datalogic Automation S.r.l. nell'ambito di un progetto di estensione di un sistema di lettura di codici a barre già realizzato su firmware. L'obiettivo è rendere più flessibile la configurazione del sistema attraverso una sua estensione mediante script engine, al fine di esprimere ed estendere le possibilità di configurazione ad oggi disponibili ed evitare modifiche nel codice applicativo. Dopo aver descritto gli strumenti utilizzati ed illustrato esempi di casi reali che sollevano il problema, vengono esaminati i motivi per cui un linguaggio di scripting può essere la soluzione cercata, facendo un confronto con altre alternative. Vengono poi presentati i linguaggi scelti in questo progetto, le loro caratteristiche e la descrizione dei loro interpreti. Si procede con l'analisi architetturale del sistema, studiando la struttura delle entità coinvolte e i loro meccanismi di interazione e sottolineando i cambiamenti introdotti dall'integrazione di uno script engine. A questo, segue la descrizione dell'implementazione di un dimostratore delle funzionalità dello script engine, con una certa enfasi sugli aspetti di estendibilità che lo caratterizzano. Vengono poi illustrate le fasi di integrazione del componente nel sistema principale con i relativi test, fino a presentare il codice degli script che risolvono gli esempi di casi reali. Infine, vengono fatte alcune considerazioni sull'uso dello script engine nel prodotto finale e dei rischi che ne possono derivare. Seguono delle proposte di estensione sia delle funzionalità dello script engine, tramite inclusione di librerie esterne, sia del suo scopo, ipotizzando un refactoring che coinvolga tutto il sistema. Il fine è quello di utilizzare il linguaggio di scripting come strumento di espressione dell'interazione tra i suoi componenti.

Avec la construction des robots de plus en plus complexes, la croissance des architectures logicielles robotiques et l’explosion de la diversité toujours plus grande des applications et misions des robots, la conception, le développement et l’intégration des entités logicielles des systèmes robotiques, constituent une problématique majeure de la communauté robotique. En effet, les architectures logicielles robotiques et les plateformes de développement logiciel pour la robotique sont nombreuses, et sont dépendantes du type de robot (robot de service, collaboratif, agricole, médical, etc.) et de son mode d'utilisation (en cage, d’extérieur, en milieu occupé, etc.). L’effort de maintenance de ces plateformes et leur coût de développement sont donc considérables.Les roboticiens se posent donc une question fondamentale : comment réduire les coûts de développement des systèmes logiciels robotiques, tout en augmentant leur qualité et en préservant la spécificité et l’indépendance de chaque système robotique? Cette question induit plusieurs autres : d’une part, comment décrire et encapsuler les diverses fonctions que doit assurer le robot, sous la forme d’un ensemble d’entités logicielles en interaction? Et d’autre part, comment conférer à ces entités logicielles, des propriétés de modularité, portabilité, réutilisabilité, interopérabilité, etc.?A notre avis, l’une des solutions les plus probables et prometteuses à cette question consiste à élever le niveau d’abstraction dans la définition des entités logicielles qui composent les systèmes robotiques. Pour ce faire, nous nous tournons vers l’ingénierie dirigée par les modèles, et plus particulièrement la conception des DSML (Domain Specific Modeling Language).Dans cette thèse, nous réalisons dans un premier temps, une étude comparative des langages de modélisation et de méthodes utilisés dans le développement des systèmes embarqués temps réel en général. L’objectif de ce premier travail étant de voir s’il en existe qui puissent permettre de répondre aux questions susmentionnées des roboticiens. Cette étude, non seulement nous montre que ces approches ne sont pas adaptées à la définition des architectures logicielles robotiques, mais elle aboutit surtout à unFramework, que nous proposons et qui aide à choisir la (les) méthode(s) et/ou le(s) langage(s) de modélisation le(s) plus adapté(s) aux besoins du concepteur. Par la suite, nous proposons un DSML baptisé RsaML (Robotic Software Architecture Modeling Language), pour la définition des architectures logicielles robotiques avec prise en compte de propriétés temps réel. Pour ce faire, un méta-modèle est proposé à partir des concepts que les roboticiens ont l’habitude d’utiliser pour la définition de leurs applications. Il constitue la syntaxe abstraite du langage. Les propriétés temps réel sont identifiées à leur tour et incluses dans les concepts concernés. Des règles sémantiques du domaine de la robotique sont ensuite définies sous forme de contraintes OCL, puis intégrées au méta-modèle, pour permettre que des vérifications de propriétés non fonctionnelles et temps réel soient effectuées sur les modèles construits. Le Framework de modélisation EMF d’Eclipse a été utilisé pour mettre en oeuvre un éditeur qui supporte le langage RsaML.La suite des travaux réalisés dans cette thèse a consisté à définir des transformations de modèles, puis à les utiliser pour implémenter des générateurs. Ces derniers permettent à partir d’un modèle RsaML construit, d’une part, de produire sa documentation et, d’autre part, de produire du code source en langage C. Ces contributions sont validées à travers un cas d’étude décrivant un scénario basé sur le robot Khepera III
With the construction of increasingly complex robots, the growth of robotic software architectures and the explosion of ever greater diversity of applications and robots missions, the design, development and integration of software entities of robotic systems, constitute a major problem for the robotics community. Indeed, robotic software architectures and software development platforms for robotics are numerous, and are dependent on the type of robot (service robot, collaborative, agricultural, medical, etc.) and its usage mode (In cage, outdoor, environment with obstacles, etc.).The maintenance effort of these platforms and their development cost are therefore considerable.Roboticists are therefore asking themselves a fundamental question: how to reduce the development costs of robotic software systems, while increasing their quality and preserving the specificity and independence of each robotic system? This question induces several others: on the one hand, how to describe and encapsulate the various functions that the robot must provide, in the form of a set of interactive software entities? And on the other hand, how to give these software entities, properties of modularity, portability, reusability, interoperability etc.?In our opinion, one of the most likely and promising solutions to this question, is to raise the level of abstraction in defining the software entities that make up robotic systems. To do this, we turn to model-driven engineering, specifically the design of Domain Specific Modeling Language (DSML).In this thesis, we first realize a comparative study of modeling languages and methods used in the development of embedded real time systems in general. The objective of this first work is to see if there are some that can make it possible to answer the aforementioned questions of the roboticists. This study not only shows that these approaches are not adapted to the definition of robotic software architectures, but mainly results in a framework, which we propose and which helps to choose the method (s) and / or the modeling language (s) best suited to the needs of the designer. Subsequently, we propose a DSML called Robotic Software Architecture Modeling Language (RsaML), for the definition of robotic software architectures with real-time properties. To do this, a meta-model is proposed from the concepts that roboticists are used to in defining their applications. It constitutes the abstract syntax of the language. Real-time properties are identified and included in the relevant concepts. Semantic rules in the field of robotics are then defined as OCL constraints and then integrated into the meta-model, to allow non-functional and realtime property checks to be performed on the constructed models.Eclipse Modeling Framework has been used to implement an editor that supports the RsaML language. The rest of the work done in this thesis involved defining model transformations and then using them to implement generators. These generators make it possible from a RsaML model built, to produce its documentation and source code in C language. These contributions are validated through a case study describing a scenario based on the Khepera III robot

Self-assessment is one of the crucial activities within e-learning environments that provide learners with feedback regarding their level of accumulated knowledge. From this point of view, the authors think that guidance of learners in self-assessment activity must be an important goal of e-learning environment developers. The scope of the chapter is to present a recommender software system that runs along the e-learning platform. The recommender software system improves the effectiveness of self-assessment activities. The activities performed by learners represent the input data and the machine learning algorithms are used within the business logic of the recommender software system that runs along the e-learning platform. The output of the recommender software system is represented by advice given to learners in order to improve the effectiveness of self-assessment process. The methodology for obtaining improvement of self-assessment is based on embedding knowledge management into the business logic of the e-learning platform. Naive Bayes Classifier is used as machine learning algorithm for obtaining the resources (e.g., questions, chapters, and concepts) that need to be further accessed by learners. The analysis is accomplished for disciplines that are well structured according to a concept map. The input data set for the recommender software system is represented by student activities that are monitored within Tesys e-learning platform. This platform has been designed and implemented within Multimedia Applications Development Research Center at Software Engineering Department, University of Craiova. Monitoring student activities is accomplished through various techniques like creating log files or adding records into a table from a database. The logging facilities are embedded in the business logic of the e-learning platform. The e-learning platform is based on a software development framework that uses only open source software. The software architecture of the e-learning platform is based on MVC (model-view-controller) model that ensures the independence between the model (represented by MySQL database), the controller (represented by the business logic of the platform implemented in Java) and the view (represented by WebMacro which is a 100% Java open-source template language).

A significant part of a Manufacturing Automation course is devoted to CNC machine tools, their architecture, and the part programming languages (APT, ISO G-code and so on). Nevertheless, it is not trivial to provide the students with a complete understanding of the relationships between the machine dynamics, the path planning strategy, and the control systems. For this reason, a short laboratory course has been developed aimed at the programming of a simplified CNC software with the following functionalities: to parse a part program written in a subset of the ISO G-code; to process the instruction blocks and to generate trapezoidal velocity profiles; to convert the velocity profiles reference trajectory; to interpolate the reference trajectory at the servo loop control frequency. In order to shorten the development time, the following choices have been made. The parser only implements a small subset of the ISO G-code, which is point-to-point positioning (G00), linear interpolation (G01) and full stop (M30). The velocity profiles are calculated as acceleration-limited trapezoidal profiles with zero-feed velocity boundary conditions. Finally, the system is developed in Ruby, which is an object-oriented scripting language, easy to learn and well suited for rapid prototyping of complex software systems. This is why the project has been named RNC (Ruby Numerical Control). At the course start, the overall system architecture is explained and is translated in the set of Ruby classes that have to be developed, and classes interfaces are mandatorily determined. During the laboratory activity, students work in teams, and each team is encouraged to work separately on the development of each Ruby class. At the end of the development phase, the students can interface the RNC they wrote with a machine tool simulator (developed separately) and use the whole software system to test the accuracy of the tool-tip trajectories as a function of the system parameters (servo loop gains, motors torque, masses and dynamic performance of the virtual machine tool). Moreover, thanks to the object-based architecture of RNC and to the common, pre-determined class interfaces, the students can then swap and mix different implementations of the above reported functionalities, as well as enhanced versions provided by the teacher. With respect to other similar Mathlab/Simulink based solutions, the presented laboratory activity brings a more detailed insight into a CNC software still limiting the code complexity thanks to the Ruby language and it is only based on open-source tools.