Real-Time Workshop Embedded Coder 4

Transcription

1 Real-Time Workshop Embedded Coder 4 Generate production code for embedded systems Real-Time Workshop Embedded Coder generates C code from Simulink and Stateflow models that has the clarity and efficiency of professional handwritten code. The generated code is exceptionally compact and fast essential requirements for embedded systems, on-target rapid prototyping boards, microprocessors used in mass production, and real-time simulators. Full support is provided for the integration of legacy applications, functions, and data. You can use Real-Time Workshop Embedded Coder to specify, deploy, and verify production-quality software. The generated code is ANSI/ISO C-compliant, enabling it to run on any microprocessor or real-time operating system (RTOS). Embedded target products (available separately) extend Real- Time Workshop Embedded Coder with target-specific support packages. KEY FEATURES Generates ANSI/ISO C code and executables from Simulink and Stateflow models with memory usage, execution speed, and readability comparable to handwritten code Extends Real-Time Workshop and Stateflow Coder with the optimizations and code configuration features essential for production deployment Supports all Simulink data objects and data dictionary capabilities, including user-defined storage classes, types, and aliases Provides an intuitive graphical user interface for creating custom data Concisely partitions multirate code for efficient scheduling with or without an RTOS Includes extensible module packaging features Provides a rich set of commenting capabilities to trace code to models and requirements Verifies code by automatically importing it into Simulink for software-in-the-loop testing Fault-Tolerant Fuel Control System - Fixed Point fuel rate controller engine gas dynamics Generates code documentation that is integrated with the Simulink Model Explorer and hyperlinked to the model nominal speed High engine throttle speed command 0 throttle sensor throttle engine speed engine speed throttle angle o2_out MAP Produces a user-defined main program detailing how to deploy the code in a target environment Speed (rad./sec.) 0 speed sensor fuel rate double fuel air/fuel ratio EGO fixpt to 12 EGO sensor double MAP 0 MAP sensor double to fixpt Metered Fuel air/fuel mixture ratio makes it easy to generate, document, review, and test code for complex systems. fuel rate sfunction throttle engine speed fuel rate EGO MAP

2 Working with Real-Time Workshop Embedded Coder provides intrinsic code generation support for Simulink and Stateflow, including continuous-time, discrete-time, and eventbased models. You interact with Real-Time Workshop Embedded Coder and configure code generation settings using the Simulink Model Explorer. From the Model Explorer, you can: Generate code for your Simulink models or subsystems Select a Real-Time Workshop Embedded Coder target Configure the target for code generation Selecting Targets uses target template files to translate your Simulink and Stateflow model into production-quality C code. The target templates specify the environment in which your generated code will run. The Embedded Real-Time Target included with Real-Time Workshop Embedded Coder generates ANSI/ISO C and can be configured for floating-point and fixed-point code. You can also extend Embedded Real-Time Target for use in specific applications. Embedded target products (available separately) provide ready-to-run, target-specific microprocessor and RTOS support packages. Manage multiple configuration sets The Model Advisor in Simulink checks your model configuration and offers advice on how to optimize or tune a configuration set based on your stated goals or style. You can generate code for any microprocessor by specifying integer word sizes and other required target characteristics or by choosing from a list of targets with predefined settings.

3 Defining and Managing Custom Data uses the following data specification and data dictionary capabilities in Simulink when generating code: Simulink data objects Provide predefined storage classes, including const, volatile, exported global, imported global, #define, structure, bitfield (bit packed structure), and get/set access methods Module packaging data objects Provide preconfigured attributes for advanced data objects typically used in mass production, such as memory segments to calibrate or tune lookup tables User data types Let you create abstract types for complex data As a result, you can precisely control how model data appears in the generated code, interface with legacy data of any complexity, and augment or replace Simulink built-in types. The following tools help you design and implement a data dictionary: Custom Storage Class Designer Lets you graphically create custom definitions and declarations to import data structures into the generated code, export data, conserve memory, or automatically generate data exchange standards, such as ASAM/ASAP2 Simulink Data Object Wizard Analyzes Simulink and Stateflow diagrams and autopopulates the workspace with appropriate data objects In addition, Real-Time Workshop Embedded Coder gives you access to ASAP2 data exchange files in Simulink, enabling you to export model data with arbitrarily complex data definitions using the ASAP2 standard. You can modify the built-in facilities to produce other data exchange mechanisms. The Model Explorer enables you to create, edit, and view your data dictionary in Simulink. The Custom Storage Class Designer enables you to graphically design and view arbitrarily complex data types.

4 /* Data with custom storage class ConstVolatile extern const volatile real_t O2limit; extern const volatile real_t pressurelimit; extern const volatile real_t rpmlimit; extern const volatile real_t templimit; /* Struct data typedef struct sensors_tag { real_t temp; real_t pressure; real_t O2; real_t rpm; sensors_struct; /* Bitfield data typedef struct alarms_tag { unsigned int tempalarm:1; unsigned int pressurealarm:1; unsigned int O2alarm:1; unsigned int rpmalarm:1; alarms_bitfield; /* Model step function void cscdemo_step(void) { /* RelationalOperator: <Root>/Relational Operator incorporates: * Constant: <Root>/Constant * Inport: <Root>/In1 alarms.tempalarm = (templimit >= sensors.temp); /* RelationalOperator: <Root>/Relational Operator1 incorporates: * Constant: <Root>/Constant1 * Inport: <Root>/In2 alarms.pressurealarm = (pressurelimit <= sensors.pressure); /* RelationalOperator: <Root>/Relational Operator2 incorporates: * Constant: <Root>/Constant2 * Inport: <Root>/In3 alarms.o2alarm = (O2limit <= sensors.o2); /* RelationalOperator: <Root>/Relational Operator3 incorporates: * Constant: <Root>/Constant3 * Inport: <Root>/In4 alarms.rpmalarm = (rpmlimit >= sensors.rpm); Model and code demonstrating the predefined custom storage classes provided with Real-Time Workshop Embedded Coder. Executing Code in a Real-Time Production Environment provides a complete, optimized framework for incorporating generated code into your real-time execution environment. The generated code is target-independent and can be executed with or without an RTOS and in single, multitasking, or asynchronous mode. Generating a Main Program An extensible main program is generated based on information you provide for deploying the code in your real-time environment. This program lets you generate and build a complete customized executable from your model. Grouping Rates generates single-rate or multirate code using periodic sample times specified in the model. For multirate, multitasking models, it employs a strategy called rate grouping that generates separate functions for the base rate task and for each sub-rate task in the model.

5 /* Model step function void ecdemo1_step(parameters *rtp, BlockIO *rtb, D_Work *rtdwork, PrevZCSigStates *rtprevzc, real32_t rtu_input, real32_t *rty_output) { /* local block i/o variables uint8_t rtb_sum_out; uint8_t rtb_switch_out; boolean_t rtb_equal_to_count; /* Sum: <Root>/Sum incorporates: * Constant: <Root>/INC * UnitDelay: <Root>/X rtb_sum_out = 1U + (rtdwork->x); /* RelationalOperator: <Root>/RelOpt incorporates: * Constant: <Root>/LIMIT rtb_equal_to_count = (rtb_sum_out!= rtp->limit); /* SubSystem: <Root>/Computation if ((rtb_equal_to_count &&!rtprevzc->computation_zce)) { /* Rounding: <S1>/trunc incorporates: * Gain: <S1>/gain * Trigonometry: <S1>/sin * Abs: <S1>/abs * Inport: <Root>/input rtb->output = floorf(((sinf(fabsf(rtu_input))) * 343.0F)); rtprevzc->computation_zce = (ZCSigState) rtb_equal_to_count; /* Outport: <Root>/output (*rty_output) = rtb->output; /* Switch: <Root>/Switch incorporates: * Constant: <Root>/RESET if (rtb_equal_to_count) { rtb_switch_out = rtb_sum_out; else { rtb_switch_out = 0U; /* UnitDelay Block: <Root>/X rtdwork->x = rtb_switch_out; Optimizing and Packaging Code You can use Real-Time Workshop Embedded Coder to control function boundaries, preserve expressions, and apply optimizations on multiple blocks to further reduce code size. Data can be communicated to the generated code as global data or as function arguments. You can trace the generated code to blocks and signals in your model. optimization options enable you to: Reuse code for exporting to legacy or external environments Eliminate unnecessary initialization, termination, logging, and error-handling code Combine output/update functions to reduce code size Remove floating-point code from integeronly applications provides module packaging features that let you package the generated code to comply with specific software styles and standards. You can control the internal organization and format of each generated file and determine how global data is defined and referenced. Templates and symbols let you specify the contents and placement of comments and sections of code within the generated code files. Model configured to leverage ISO-C math extensions and a target-specific optimization, and to generate a reusable function that communicates the data via function arguments.

6 /* Model step function void slsfexpr_step(void) { /* Stateflow: <Root>/Chart incorporates: * Logic: <Root>/Logical Operator * RelationalOperator: <Root>/Relational Operator1 * RelationalOperator: <Root>/Relational Operator * Constant: <Root>/Constant * Constant: <Root>/Constant1 * Lookup: <Root>/Look-Up Table * Gain: <Root>/Gain * Lookup2D: <Root>/Look-Up Table (2-D) if(((upper >= rtu.input2) (rtu.input2 <= LOWER))) { output = rt_lookup(t1break, 11, input1 * 2.0, T1Data); else { input1 UPPER input2 LOWER input3 input4 output = rt_lookup2d_normal(t2break, 3, T2Break, 3, T2Data, input3, input4); 2 >= <= Lookup OR Lookup2D table1d c table2d Chart {y = table2d; y 1 output [c]{y = table1d; Verifying and Documenting Your Code offers several capabilities for verifying your generated code. These include: Ability to import generated code back into Simulink as an S-function for software-inthe-loop testing with a plant model User-controlled comments and descriptions to improve code readability and traceability Support for including requirements in the generated code Persistent identifier names to minimize code differences between model revisions documents the generated code in an HTML report that comprehensively describes the code modules and model configuration settings applied during code generation. The report includes a summary section and a table of generated source files, annotated with hyperlinks. When viewed in the MATLAB Help browser, these hyperlinks cause the corresponding blocks to be highlighted in the associated Simulink model, making the code easy to trace and review. Automated HTML report generation keeps documentation up to date with your code. Required Products MATLAB Simulink Real-Time Workshop Related Products Embedded Targets Products. Deploy embedded code onto specific targets Signal Processing Blockset. Design and simulate signal processing systems and devices Simulink Fixed Point. Design and simulate fixed-point systems Stateflow. Design and simulate event-driven systems Stateflow Coder. Generate C code from Stateflow charts For more information on related products, visit rtwembedded/ Platform and System Requirements For platform and system requirements, visit rtwembedded/ Code samples showing blocks folded into the switch block operation, increasing CPU throughput. Expression folding occurs for scalar and element-wise vector operations. For demos, application examples, tutorials, user stories, and pricing: Visit Contact The MathWorks directly US & Canada Benelux +31 (0) France +33 (0) Germany +49 (0) Italy +39 (011) Korea +82 (0) Spain Sweden +46 (8) Switzerland +41 (0) UK +44 (0) Visit to obtain contact information for authorized MathWorks representatives in countries throughout Asia Pacific, Latin America, the Middle East, Africa, and the rest of Europe. Tel: info@mathworks.com v03 06/ by The MathWorks, Inc. MATLAB, Simulink, Stateflow, Handle Graphics, and Real-Time Workshop are registered trademarks, and TargetBox is a trademark of The MathWorks, Inc. Other product or brand names are trademarks or registered trademarks of their respective holders.