Model-Based Code Generation

2013 ◽  
pp. 21-42 ◽  
Author(s):  
Chris Raistrick
Keyword(s):  
Code Generation ◽  
Model Based

scholarly journals A Model-Based Design Floating-Point Accumulator. Case of Study: FPGA Implementation of a Support Vector Machine Kernel Function

Sensors ◽  
2020 ◽  
Vol 20 (5) ◽  
pp. 1362 ◽  
Author(s):  
Marco Bassoli ◽  
Valentina Bianchi ◽  
Ilaria De Munari
Keyword(s):  
Support Vector Machine ◽  
Kernel Function ◽  
Code Generation ◽  
Wearable Sensors ◽  
Machine Learning Algorithms ◽  
Floating Point ◽  
Polynomial Kernel ◽  
Support Vector ◽  
Practical Case ◽  
Model Based

Recent research in wearable sensors have led to the development of an advanced platform capable of embedding complex algorithms such as machine learning algorithms, which are known to usually be resource-demanding. To address the need for high computational power, one solution is to design custom hardware platforms dedicated to the specific application by exploiting, for example, Field Programmable Gate Array (FPGA). Recently, model-based techniques and automatic code generation have been introduced in FPGA design. In this paper, a new model-based floating-point accumulation circuit is presented. The architecture is based on the state-of-the-art delayed buffering algorithm. This circuit was conceived to be exploited in order to compute the kernel function of a support vector machine. The implementation of the proposed model was carried out in Simulink, and simulation results showed that it had better performance in terms of speed and occupied area when compared to other solutions. To better evaluate its figure, a practical case of a polynomial kernel function was considered. Simulink and VHDL post-implementation timing simulations and measurements on FPGA confirmed the good results of the stand-alone accumulator.

scholarly journals A Model-Based Design of Distributed Automation Systems for the Smart Grid: Implementation and Validation

Energies ◽  
2020 ◽  
Vol 13 (14) ◽  
pp. 3560 ◽  
Author(s):  
Davide Della Giustina ◽  
Amelia Alvarez de Sotomayor ◽  
Alessio Dedè ◽  
Francisco Ramos
Keyword(s):  
Code Generation ◽  
Smart Grids ◽  
Fault Location ◽  
Distribution Networks ◽  
Target System ◽  
Implementation Phase ◽  
Medium Voltage ◽  
Model Based ◽  
Automation Systems ◽  
Protection Devices

The paper aims at describing a model-based approach to design automation logics for fault location and supply restoration in medium voltage distribution networks. The application of automation functions along medium voltage feeders and, in particular, the installation of protection devices in secondary substations mandates the design and the implementation of complex logics to coordinate the operations of this hardware in case of fault occurrences. This synchronization is realized with the exchange of IEC 61850 GOOSE messages, but the correct usage of this information must be implemented in each protection device through dedicated logics, which are not in the common out-of-the-box system configurations. To support the introduction and the design of these logics, an automata-based approach has been proposed and successfully demonstrated in a real environment in the European research project IDE4L. This formal methodology has been introduced to simplify the design phase and to standardize the logics implemented in the protection prototypes realized in the project. The same models have also been used in the implementation phase with a semi-automatic code generation procedure, considering as a target system the software programmable logic controllers (soft-PLCs), available on the protection devices. Based on the test results and the short time to set up the test bench, this approach proved to be a reliable and effective way to implement complex medium voltage (MV) automation logics such those needed in modern smart grids.

Model-Based Development

2011 ◽  
pp. 289-312 ◽  
Author(s):  
Juan D. Lara ◽  
Esther Guerra ◽  
Hans Vangheluwe
Keyword(s):  
Programming Languages ◽  
Graphical Models ◽  
Code Generation ◽  
Simulation Analysis ◽  
Model Simulation ◽  
General Purpose ◽  
Test Case ◽  
Model Driven ◽  
Model Based ◽  
Design Activities

Since the beginning of computer science more than 50 years ago, software engineers have sought techniques resulting in higher levels of quality and productivity. Some of these efforts have concentrated in increasing the level of abstraction in programming languages (from assembler to structured languages to object-oriented languages). In the last few years, we have witnessed an increasing focus on development based on high-level, graphical models. They are used not only as a means to documentthe analysis and design activities, but also as the actual “implementation” of the application, as well as for automatic analysis, code, and test case generation. The notations used to describe the models can be standard and general purpose (for example, UML) or tightly customized for the application domain. Code generation for the full application is only accomplished for specific, well-understood application domains. A key initiative in this direction is OMG’s Model-Driven Architecture (MDA), where models are progressively transformed until executable code is obtained. In this chapter, we give an overview of these technologies and propose ideas following this line (concerning metamodeling and the use of visual languages for the specification of model transformation, model simulation, analysis and code generation), and examine the impact of model-based techniques in the development process.

AN EVALUATION OF MODEL-BASED SOFTWARE SYNTHESIS FROM SIMULINK MODELS FOR EMBEDDED VIDEO APPLICATIONS

2005 ◽  
Vol 15 (02) ◽  
pp. 343-348
Author(s):  
ANDREAS DOBLANDER ◽  
DIETMAR GÖSSERINGER ◽  
BERNHARD RINNER ◽  
HELMUT SCHWABACH
Keyword(s):  
Code Generation ◽  
Ad Hoc ◽  
Resource Constraints ◽  
Digital Signal ◽  
Detection Algorithm ◽  
Visual Development ◽  
Surveillance Systems ◽  
Model Based ◽  
Pressing Time ◽  
High Level

In next generation video surveillance systems there is a trend towards embedded solutions. Digital signal processors (DSP) are often used to provide the necessary computing power. The limited resources impose significant challenges for software development. Resource constraints must be met while facing increasing application complexity and pressing time-to-market demands. Recent advances in synthesis tools for Simulink suggest a high-level approach to algorithm implementation for embedded DSP systems. The model-based visual development process of Simulink facilitates simulation as well as synthesis of target specific code. In this work the modeling and code generation capabilities of Simulink are evaluated with respect to video analysis algorithms. Different models of a motion detection algorithm are used to synthesize code. The generated code targeted at a Texas Instruments TMS320C6416 DSP is compared to a hand-optimized reference. Experiments show that an ad hoc approach to synthesize complex image processing algorithms hardly yields optimal code for DSPs. However, several optimizations can be applied to improve performance.

Harvesting Maximum Power from Mismatch Module of PV System Using PO Buck-Boost Converter

2014 ◽  
Vol 953-954 ◽  
pp. 95-98
Author(s):  
Mohd Najib Mohd Hussain ◽  
Ahmad Maliki Omar ◽  
Intan Rahayu Ibrahim
Keyword(s):  
Code Generation ◽  
Boost Converter ◽  
Maximum Power ◽  
Solar Pv ◽  
Pv System ◽  
Maximum Power Point ◽  
Development Environment ◽  
Model Based ◽  
Pv Module ◽  
Power Point

This paper presents a simulation and laboratory test of Photovoltaic (PV) module incorporated with Positive Output (PO) Buck-Boost Converter for harnessing maximum energy from the solar PV module. The main intention is to invent a system which can harvest maximum power point (MPP) energy of the PV system in string-connection. The model-based design of the controller and maximum power point tracking (MPPT) algorithm for the system were implemented using MATLAB SIMULINK software. For laboratory execution, the digital microcontroller of dsPIC30F digital signal controller (DSC) was used to control the prototype of PO buck-boost converter. The code generation via MPLAB Integrated Development Environment (IDE) from model-based design was embedded into the dsPIC30F using the SKds40A target board and PICkit 3 circuit debugger. The system was successfully simulated and verified by simulation and laboratory evaluations. A physical two PV module of PV-MF120EC3 Mitsubishi Electric is modeled in string connection to represent a mismatch module. While in laboratory process, a string-connection of 10W and 5W PV module is implemented for the mismatch module condition.

Pragmatic model transformations for refactoring in Scilab/Xcos

2016 ◽  
Vol 07 (01) ◽  
pp. 1541004 ◽  
Author(s):  
Umut Durak
Keyword(s):  
Code Generation ◽  
Model Transformation ◽  
Graphical Model ◽  
Model Development ◽  
Model Specification ◽  
Model Transformations ◽  
Modeling Tools ◽  
Model Based ◽  
Code Structure ◽  
Model Refactoring

Model-Based Development has become an industry wide standard paradigm. As an open source alternative, Scilab/Xcos is being widely employed as a hybrid dynamic systems modeling tool. With the increasing efficiency in implementation using graphical model development and code generation, the modeling and simulation community is struggling with assuring quality as well as maintainability and extendibility. Refactoring is defined as an evolutionary modernization activity where, most of the time, the structure of the artifact is changed to alter its quality characteristics, while keeping its behavior unchanged. It has been widely established as a technique for textual programming languages to improve the code structure and quality. While refactoring is also regarded as one of the key practices of model engineering, the methodologies and approaches for model refactoring are still under development. Architecture-Driven Modernization (ADM) has been introduced by the software engineering community as a model-based approach to software modernization, in which the implicit information that lies in software artifacts is extracted to models and model transformations are applied for modernization tasks. Regarding refactoring as a low level modernization task, the practices from ADM are adaptable. Accordingly, this paper proposes a model-based approach for model refactoring in order to come up with more efficient and effective model refactoring methodology that is accessible and extendable by modelers. Like other graphical modeling tools, Scilab/Xcos also possesses a formalized model specification conforming to its implicit metamodel. Rather than proposing another metamodel for knowledge extraction, this pragmatic approach proposes to conduct in place model-to-model transformations for refactoring employing the Scilab/Xcos model specification. To construct a structured model-based approach, the implicit Scilab/Xcos metamodel is explicitly presented utilizing ECORE as a meta-metamodel. Then a practical model transformation approach is established based on Scilab scripting. A Scilab toolset is provided to the modeler for in-place model-to-model transformations. Using a sample case study, it is demonstrated that proposed model transformation functions in Scilab provide a valuable refactoring tool.

Sign in / Sign up

Export Citation Format

Share Document