This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

[FAQ] Sticky: MathWorks Solutions for C2000 MCU’s

Other Parts Discussed in Thread: TMS320F28335, CONTROLSUITE, TMS320F28035, TMDSDOCK28379D, LAUNCHXL-F28379D, TMS320F28379D, TMS320F28379S

Save design time and get into production faster with C2000 MCU’s with MathWorks solutions.

To begin you use MATLAB® and Simulink® to create and simulate your algorithms. Next you use Embedded Coder® to generate production code of your algorithms. Embedded Coder support for Texas Instruments C2000 includes:

        • Automated build and execution
        • Block libraries for on-chip and on-board peripherals such as ADC, digital I/O, ePWM, SPI, I2C, and more
        • Real-time parameter tuning and logging using external mode
        • Processor optimized code including DMC and IQMath libraries
        • Ability to perform processor-in-the-loop (PIL) tests with execution profiling
        • Examples for motor control and power conversion that run on TI C2000 hardware

You can also generate code that runs on the Control Law Accelerator (CLA), a co-processor available on select TI Delfino and Piccolo processors.

For multicore systems, you can use SoC Blockset with C2000 Support for SoC Blockset to build your system architecture using processor, inter-processor communication, interrupt and I/O models, and simulate the architecture together with the algorithms. This allows you to partition algorithms between multiple cores to achieve design modularity and improve performance, and to account for issues like ADC-PWM synchronization and latency.


From within MATLAB you can access hardware support for Embedded Coder via the Add-On Explorer from the MATLAB toolstrip.


Search for C2000, and select to download and install free C2000 library blocks. You insert and configure the blocks, which include IO and various functions, in your Simulink model. Then you use Embedded Coder to generate production code of your algorithm and run it directly on your TI C2000 MCU. The library blocks include documentation, example models, and support C2000 Piccolo, Delfino, and Concerto families.

Note: Using Embedded Coder requires additional MathWorks software: MATLAB®, Simulink®, MATLAB Coder™, and Simulink Coder™.

You can also just generate production code of your algorithms which can be imported and integrated into an existing Code Composer Studio project.

--- ---

Here is more info including how-to videos and examples you can run with TI hardware kits:


    • Details and Examples:

      • C2000 Hardware Support webpages:

      • Delfino: F2833x, F2837xS, F2837xD, C2834x

      • Piccolo: F2802x, F2803x, F2805x, F2806x, F2807x, F28004x

      • Concerto: F28M35x, F28M36x (C28x + ARM Cortex M3)

      • Legacy: C280x, C281x, C2833x, F281x, F280x

      • C2000-Based Examples


Content Updated 2020-11-02

  • Hi Kash,

    At least in my case the hex file is directly provided by Matlab during the compilation process.

    Do you not have a Matlab license available to try it out? Install the toolbox, take one of the example programs and hit build. Maybe you even have a development board where you can actually something like a blinking led.

  • Hi Kash,

    Actually Bob is right - I do see a .hex file. But it exists in the work directory, not the filename_ert_rtw directory. But I don't see it for every model, and I'm not sure why - I'll ask around and let you know what I hear back.


  • Hi,

    Hex file is generated as part of the build process if the user is using "deploy to hardware" button.

    The file can found in the same folder where the model file present. While the generated code is inside the _ert_rtw folder, the executable binary is outside.

    If the user is looking for symbols for debugging purpose, then .out file can be handy. This generated along with Hex file.


    Venkatesh C

    • If my post answered your questions, please click on "Verified answer" button.

  • Hi Brian and Venkatesh,
    Yeah I see that Matlab generates the HEX file while I build the code. Thanks for your help and confirmation.
  • I am having problem with SCI programs with simulink and CCS, codes for both dont work

    I have tested with shipped in codes with c2000ware for SCI but dont work, used 28 and 29 pins for Rx Tx

    I having doubt about the usage of switch in launchpad, I used OFF OFF ON and ON ON ON

    The board I am using is LaunchXL F283779D

    I am attaching the screenshot for simulink models i have used and the CCS which I tested.

    I am pasting the CCS code here which is shipped in code with C2000ware

    Included Files
    #include "F28x_Project.h"
    // Globals
    Uint16 LoopCount;
    // Function Prototypes
    void scia_echoback_init(void);
    void scia_fifo_init(void);
    void scia_xmit(int a);
    void scia_msg(char *msg);
    // Main
    void main(void)
        Uint16 ReceivedChar;
        char *msg;
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the F2837xD_SysCtrl.c file.
    // Step 2. Initialize GPIO:
    // This example function is found in the F2837xD_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    // For this example, only init the pins for the SCI-A port.
    //  GPIO_SetupPinMux() - Sets the GPxMUX1/2 and GPyMUX1/2 register bits
    //  GPIO_SetupPinOptions() - Sets the direction and configuration of the GPIOS
    // These functions are found in the F2837xD_Gpio.c file.
       GPIO_SetupPinMux(28, GPIO_MUX_CPU1, 1);
       GPIO_SetupPinOptions(28, GPIO_INPUT, GPIO_PUSHPULL);
       GPIO_SetupPinMux(29, GPIO_MUX_CPU1, 1);
       GPIO_SetupPinOptions(29, GPIO_OUTPUT, GPIO_ASYNC);
    // Step 3. Clear all __interrupts and initialize PIE vector table:
    // Disable CPU __interrupts
    // Initialize PIE control registers to their default state.
    // The default state is all PIE __interrupts disabled and flags
    // are cleared.
    // This function is found in the F2837xD_PieCtrl.c file.
    // Disable CPU __interrupts and clear all CPU __interrupt flags:
       IER = 0x0000;
       IFR = 0x0000;
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    // This will populate the entire table, even if the __interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in F2837xD_DefaultIsr.c.
    // This function is found in F2837xD_PieVect.c.
    // Step 4. User specific code:
       LoopCount = 0;
       scia_fifo_init();       // Initialize the SCI FIFO
       scia_echoback_init();   // Initialize SCI for echoback
       msg = "\r\n\n\nHello World!\0";
       msg = "\r\nYou will enter a character, and the DSP will echo it back! \n\0";
           msg = "\r\nEnter a character: \0";
           // Wait for inc character
           while(SciaRegs.SCIFFRX.bit.RXFFST == 0) { } // wait for empty state
           // Get character
           ReceivedChar = SciaRegs.SCIRXBUF.all;
           // Echo character back
           msg = "  You sent: \0";
    //  scia_echoback_init - Test 1,SCIA  DLB, 8-bit word, baud rate 0x000F,
    //                       default, 1 STOP bit, no parity
    void scia_echoback_init()
        // Note: Clocks were turned on to the SCIA peripheral
        // in the InitSysCtrl() function
        SciaRegs.SCICCR.all = 0x0007;   // 1 stop bit,  No loopback
                                        // No parity,8 char bits,
                                        // async mode, idle-line protocol
        SciaRegs.SCICTL1.all = 0x0003;  // enable TX, RX, internal SCICLK,
                                        // Disable RX ERR, SLEEP, TXWAKE
        SciaRegs.SCICTL2.all = 0x0003;
        SciaRegs.SCICTL2.bit.TXINTENA = 1;
        SciaRegs.SCICTL2.bit.RXBKINTENA = 1;
        // SCIA at 9600 baud
        // @LSPCLK = 50 MHz (200 MHz SYSCLK) HBAUD = 0x02 and LBAUD = 0x8B.
        // @LSPCLK = 30 MHz (120 MHz SYSCLK) HBAUD = 0x01 and LBAUD = 0x86.
        SciaRegs.SCIHBAUD.all = 0x0002;
        SciaRegs.SCILBAUD.all = 0x008B;
        SciaRegs.SCICTL1.all = 0x0023;  // Relinquish SCI from Reset
    // scia_xmit - Transmit a character from the SCI
    void scia_xmit(int a)
        while (SciaRegs.SCIFFTX.bit.TXFFST != 0) {}
        SciaRegs.SCITXBUF.all =a;
    // scia_msg - Transmit message via SCIA
    void scia_msg(char * msg)
        int i;
        i = 0;
        while(msg[i] != '\0')
    // scia_fifo_init - Initialize the SCI FIFO
    void scia_fifo_init()
        SciaRegs.SCIFFTX.all = 0xE040;
        SciaRegs.SCIFFRX.all = 0x2044;
        SciaRegs.SCIFFCT.all = 0x0;
    // End of file

  • Vipin,
    Have you ever tried to send a simple one byte (uint8) character?
    Can you post an screen shot of the settings inside the SCI_TX block and inside the "Model Configuration Parameters"?

  • The second model is a simple constant value to the sci
    but its unit16

    I will send the screenshot of the configuration
  • I have attached the screenshots of settings

  • The afore said simulink model now sends data to the terminal, but it is always 's'

    NO other character is shown what ever ascii value sent from the constant

  • Hi,

    Please refer the following thread and the last part of conversation that talks about oscillator frequency settings and its impact on SCI_A operation. Hopefully the solution suggested in this thread is applicable here.


    Venkatesh Chilapur

  • Thanks for the reply

    It is working now, protocol selection was the problem

    I forgot to followup here sorry

  • Hi vipin,

    could you please elaborate on "protocol selection was the problem" so that we can have a learning as well.
    This will help us to bridge any gap from our side.

    Venkatesh Chilapur
  • sorry for the confusion, in this linked picture there is a option called protocol, I changed to Raw data, and now it works

    My team member suggested me to do so, earlier I was busy thats why I didnt able to type this long

  • I got my LAUNCHXL-CC2640 SimpleLink Bluetooth which runs TM4C129 MCU. When I open the Simulink (2016b) "Model configuration Parameters" there is the hardware support for "Tive TM4C123G LauchPad":

    My first question is can I use these settings for LAUNCHXL-CC2640 SimpleLink Bluetooth with TM4C129 MCU? 

    The TM4C129X and TM4C123X manual says these MCUs support CAN communication but I don't see any CAN communication settings when I select "Tive TM4C123G LauchPad":

  • Hi Kash,

    I don't think so - we don't have custom support for any of the CC2xxx devices.


  • Hi Brian,
    But the board is using TM4C129 MCU so I was hoping it'd be possible to to program the MCU through Simulink.
  • Hi Kash,

    You can look at the Energia Support Package - but that only offers basic blocks for the TM4C123G - which may work for the TM4C129.

    Generically, you can generate code from your algorithm and use CCS to program nearly any MCU. In this case, you would need to manually configure the code generation. Many MathWorks  customers do this for production, because they want their code to fit within an existing SW architecture.

    You can build your own Simulink blocks to handle some of the peripherals - many customers also do this.



  • Brian,
    Thanks for your response.
    What do you mean by generating code in Matlab? I know how to make custom Simulink blocks but at the end I should be able to generate the C code for CCS then manually configure it.
  • Hi Kash,

    MATLAB Coder generates ISO/ANSI C Code from MATLAB programs. Simulink Coder does the same for Simulink diagrams. Embedded Coder allows you to fully control and customize the code that you get.

    For example, if you have your own special arctan function, you can use a feature in Embedded Coder called code replacement to replace any arctan's in the generated code with your special version. And there are many other customization features you can use to generate code so it is suitable for your testing or production environment.

    So what I'm really saying, is that you can use Embedded Coder to generate code of your algorithm (which may be MATLAB, Simulink or both) that you can easily import into CCS and deploy to any TI MCU. But you need to configure both the code you generate, and spackle together the hooks in CCS so the code works with the needed MCU peripherals. Thin k of it like - you can use MathWorks tools to design the IP - your algorithm and export it into C code, and then use the TI development tools to import, connect to and deploy that algorithm on your MCU of choice.

    There's tons of info, videos, etc on our website about Embedded Coder.

  • Hi Brian,
    Thanks a lot for the very useful information.

  • Please tell me how to use TMU and VCU of arithmetic function on TMS320F2837XX or TMS320F28004XX with simulink.

    When is TMS320F28004XX compatible with simulink?

  • Hi Hayaoki,

    We are working hard on adding F28004X support, will have more updates in the next couple weeks.


    (edited to say F28004x)

  • Thank you for answering

    It is TMS320F28004X.
    I expect that the peripheral CLB for absolute encoder installed in this microcomputer will be available from simulink.

    How about using arithmetic unit (TMU, VCU) from simulink

    Configurable Logic Block (CLB)
    Augments Existing Peripheral Capability
    Supports Position Manager Solutions

    Best regards
  • TMS320F28004X is supported by R2017b.
    I am very grateful.

    Samples of positioning control
    We are expecting greatly that the correspondence of the absolute encoder will also increase.

    It is even more amazing that Simulink Control Designe can also autotune using EmbeddedCoder.

    Thank you very much

  • MathWorks Release R2017b is now available for download. We've made some enhancements to our C2000 Support, which is a free download but requires our Embedded Coder product.

    Here are the release notes for C2000 in R2017b:

    • SPI Block Support: New SPI Master Transfer block and changes to C28x SPI Transmit and Receive blocks


    And as Hayaoki mentions, we now launched our initial F28004x support! 

    The F28004x support is also the first MCU where MathWorks is leveraging C2000Ware, which you will need to download and install to use this MCU. We will continue adding to and updating the F28004x support over the next set of releases.

    F28004X Library


    And finally, the DC-DC Buck Converter Example for F28377S is now included in the support package (used to only be available as a separate MATLAB File Exchange download).



  • There are only two QEPs of TMS320F28377S.
    I tested the counter with QEP 2, but there is no reaction.
    QEP 3 to pull down? There is, and it reacts when using it.
    Could you check it out

    The attached file is a sample project of servo control contained in controlsuite.
    As a demonstration model, are there any plans to create?
    If you have already created it, would you please show

  • That's fantastic Brian. Thanks for the update.
  • Hi all,

    A couple of MathWorks engineers recorded a couple cool YouTube videos on a C2000-based Remote Control Racecar. It's using a F28379D LaunchPad to control the motors, and shows some nifty algorithms such as traction control and torque vectoring.

    Part 1: MATLAB and Simulink Racing Lounge: Remote Control Racecar, Part 1: Programming ECUs Using Simulink Hardware Support

    Part 2: MATLAB and Simulink Racing Lounge: Remote Control Racecar, Part 2: Integrating CAN Data into Your Simulation

    Models/ files for download: Remote Control Racecar using Simulink® and Texas Instruments C2000




  • On the Web two QEPs were confirmed in the datasheet and it was three.
    I was wrong.
    I am sorry.

    Please also correspond to CLB peripheral in TMS320F28379X, TMS320F280049X.
    Hopefully, I will wait for the next update.
  • Hi Hayaoki,

    I know we are looking at CLB support, but I'm not sure of the exact timing and priority. What do you want to do with CLB?

  • Thank you for care

    CLB is a function necessary for multi-turn absolute encoder.
    I want to develop a motor driver program with only MATLAB / simulink.
    For example, it is sad that MATLAB can not be used depending on the type of encoder.

    I want MATLAB to be able to do everything.
  • Hayaoki,

    Functionality like Position Manager will use the CLB but be enabled simply by a TI provided Library. Currently uou won't have tools to program the CLB yourself.  But we do need to discuss with The Mathworks how the use of the PM API functions would work with their tool set.  We will do that shortly.

  • Hello,

    I have successfully completed 'PID controller' using Matlab R2016a for dsp kit eZdsp TMS320F2808.

    Now want to develop 'fuzzy logic PID controller', is it possible through Matlab R2016a?

  • MathWorks just published a customer story which includes Processor-in-the-Loop (PIL) and code generation for deployment to an F28335: 

    Korea Aerospace Industries Develops Helicopter Active Vibration Control System Software to DO-178C Standards

    Also interesting to note that the customer was following DO-178C and DO-331 standards.



  • Brian/MathWorks Team,

    Antoine is having some issues with some header files that don't appear to be linked, but do not throw any compile errors. Can you help us out over here?

  • DDK

    Combine the above evaluation kits and control positioning of the motor with EtherCAT
    Do you have a schedule for sample models?

  • Hey Brian/Mathworks team,

    We are having some issues with getting some data between two devices running with different Mathworks /CCS versions.

  • Dear MathWorks team,

    I am currently working on a project that includes the TMS320F280049M.

    Since this processor is fairly new not all functions are included in the simulink support package (eCAP/CAN/I2C). Will there be an update along with MATLAB release 2018a that will include the missing functions?
    Best regards


  • Hi Patrick,

    We will add additional functions in R2018a which is due out this Spring. The list of scheduled additions are blocks for eCAP, eQEP, SPI, I2C and CLA. I cant promise all of those will make the release, but these are the set of blocks we are working on. 

    I don't know the status on CAN, I will need to ask about that. If you urgently need CAN, it would be worth a side conversation - so please feel free to connect with me via direct message in E2E and we can go from there



  • Quick Update: Release R2018a is now available, and that includes enhancements to our C2000 Support:

    Release notes are here:

    1) Improved dual-core programming for F28379D

    -          IPC Transmit and Receive Blocks: F2837xD IPC Receive / F2837xD IPC Transmit

    -          Example on how to use them: Inter-Processor Communication Using IPC Blocks

    -          And we also added a dual core / dual motor variant to our PMSM motor control example

    For dual motor control using IPC blocks, see Permanent Magnet Synchronous Motor Field-Oriented Control. In this example, c28379Dpmsmfocdual_cpu1_ert.slxand c28379Dpmsmfocdual_cpu2_ert.slx models communicate using IPC.

    2) Additional IO support for F28004x

    -          Added support for eCAP, eQEP, SPI, I2C, and CLA peripherals



  • Quick Update: Release R2018b is now available, and that includes enhancements to our C2000 Support:

    Release notes are here:

    1) Support for F28004x LaunchPad

    2) DMA support for F2837x, F2807x, and F28004x devices

    3) CAN support for F28004x devices

    4) Support for Code Composer Studio v8 and C2000Ware version 1_00_05_00



  • New customer story that uses this exact MathWorks workflow to program TI C2000 devices for a complex Energy Management System (EMS). Below I clipped out some of the most interesting bits (below the link).

    Murata Manufacturing Reduces Development Time for Energy Management System Control Software by More Than 50% with Model-Based Design

    As part of its smart home/office/factory initiative, Murata Manufacturing is developing an energy management system (EMS) that combines a solar panel, a battery controller, a grid-tied inverter, and an intelligent control system to optimize energy usage. When the solar panel produces more power than the user needs, the control system either uses the excess energy to charge the battery or feeds it back into the grid. Conversely, when the user needs more power than is being produced by the solar panel, the control system either discharges the battery or accesses power from the grid.


    Dr. Ma and his team created some plant models of the major system components, including the solar converter, battery DC-DC converter, and three-phase grid-tied inverter using Simscape Electrical™. The model was adjustable so that they could test different hardware topologies.

    After adding measurement blocks to compute the total harmonic distortion (THD) and root-mean-square (RMS) of key signals, the team ran simulations to check that these metrics were within acceptable ranges and to compare the performance of different control strategies and hardware topologies.

    Working in Simulink, the team modeled the system’s PI controller and then ran closed-loop simulations with the controller and the transfer function counterpart of the plant, using Simulink Control Design™ to tune control parameters.

    Additional closed-loop simulations were performed to assess the design’s response to abnormal situations, including blackouts and phase unbalance of the grid, as well as some grid-tied requirements, including fault ride through (FRT) and maximum power point tracking (MPPT) for solar.

    Using Stateflow®, they created state transition diagrams to model EMS startup, shutdown, and abnormal sequences as well as state transitions for the system’s various operating modes.

    To implement the control logic on the micro-controller, they converted the floating-point design to fixed point using auto-scaling and other time-saving tools in Fixed-Point Designer.

    Next, they generated C code and Code Composer Studio™ projects from the controller model with Embedded Coder®. Finally, they deployed it to Piccolo™ and Delfino™ 32-bit microcontrollers made by TI.

    The team tested the microcontroller and EMS circuitry together to verify the code with the production hardware, by running open-loop tests to perform basic checks and by verifying system closed-loop controller and state transitions.


  • Quick Update: Release R2019a is now available, and that includes enhancements to our C2000 Support:

    Release notes are here:

    1)      Example: Photovoltaic Inverter with MPPT Using Solar Explorer Kit

    2)      Example: Modify Duty Cycle of ePWM Using DMA

    3)      External Memory Interface (EMIF) Support for F2807x/F2737xS/F2837xD Processors

    1. You can use EMIF to interface supported synchronous or asynchronous off-chip memory devices. You can also use asynchronous EMIF to facilitate chip-to-chip data transfer.

    4)      Support for TI Code Composer Studio v8.2, TI C2000Ware and TI CGT 16.9.9



  • Quick News: Release R2019b is now available, and that includes enhancements to our C2000 Support. MathWorks login may be required for some of the links.

    Release notes are here:

    1)      Data logging on SD card.

    You can log data from Simulink blocks to an SD card mounted on the C2000 Hardware. The data values can be saved in three formats: Structure, Structure with time, or Array. The data is logged to a MAT file. For more information, see Log Signals on an SD Card

    2)      Partial Support for F2838x Processor - Only C28x Core.

    ADC, PWM, GPIO, SCI, and interrupts are the only F2838x blocks supported for code generation. External mode over serial and PIL simulation are also supported in F2838x blocks. For more information, see F2838x (C2838xlib)

    3)      Support for Code Composer Studio v9.1, C2000Ware and CGT 18.12.2.

    4)      Perform External Mode Simulation using XCP on Serial.

    --- ---

    There were also 2 updates provided in July 2019 (so they apply to R2019a and R2019b):

    U1)    Better Handling of Generated Files. Now uses the relative path for all the generated files to be fetched from a shared path. [July 2019 Update]

    U2)    F28004x Examples: c28004x_adcpwmasynctest_ert.slx and c28004xblink_cla.slx are now available. [July 2019 Update]



  • Update: MathWorks Release R2020a is now available, and that includes enhancements to our C2000 Support. MathWorks login may be required for some of the links.

    Release notes are here:

    1)  Additional ePWM features:

    • High resolution deadband support
    • Load mode support for deadband RED and FED registers
    • Additional load modes for period (TBPRD), CMPA, CMPB, CMPC, and CMPD registers
    • Peripheral synchronization event generation

    2)  Additional peripheral support for F2838x (C28x) and ARM Cortex M4 Core:

    • eCAP, QEP, SPI, I2C, CAN, CLA, Watchdog, External Interrupts, DMA, and SD card logging support for C28x core
    • GPIO and UART blocks are supported for ARM Cortex M4 core
    • Inter-Processor Communications (IPC), IPC Receive, and IPC Transmit blocks are supported for C28x (CPU1, CPU2) and ARM Cortex M4 core

    3)  Comparator subsystem (CMPSS) peripheral support for F2807x, F2837x, F28004, and F2838x (C28x) processors

    4)  Code Composer Studio IDE version 4 (CCSV4) is now compatible with the R2019b version

    ---- ----

    We also provided updates & bug fixes for our R2019b release:

    1)  Updated GPIO conflict check for TI Delfino C2834x hardware (October 2019, Version 19.2.1)

    • The check displays a pin conflict message if multiple blocks in a Simulink model are using the same pin

    ePWM Module

    GPIO Pins


    58 and 59


    60 and 61


    62 and 63

    2)  Corrected ODIV and SYSDIVSEL calculations for TI F2838x (C28x) hardware (October 2019, Version 19.2.1)

    • In previous releases, when you specified the value of Desired CPU Clock in MHz as less than or equal to 20, PLL output divider (ODIV) and System clock divider (SYSDIVSEL) were auto calculated incorrectly. These calculations are now corrected. The calculations were correct for values of Desired CPU Clock in MHz greater than 20.

    3)  Fixed CCSV4 compatibility issue with Embedded Coder Support Package for Texas Instruments C2000 Processors (October 2019, Version 19.2.1)

  • MathWorks has launched new product, in Release R2020a, which will be of interest to the C2000 Community:

    New Product Announcement: Motor Control Blockset

    Motor Control Blockset™ provides reference examples and blocks for developing field-oriented control algorithms for brushless motors. The examples show how to configure a controller model to generate compact and fast C code for any target microcontroller (with Embedded Coder®). You can also use the reference examples to generate algorithmic C code and driver code for specific motor control kits.

    The blockset includes Park and Clarke transforms, sliding mode and flux observers, a space-vector generator, and other components for creating speed and torque controllers. You can automatically tune controller gains based on specified bandwidth and phase margins for current and speed loops (with Simulink Control Design™).

    The blockset lets you create an accurate motor model by providing tools for collecting data directly from hardware and calculating motor parameters. You can use the parameterized motor model to test your control algorithm in closed-loop simulations.


    A couple of interesting notes about this new product, which was launched as part of MathWorks Release R2020a.

    1)  Product Overview Video (2 min)

    2)  A number of examples directly leverage C2000 microcontrollers and hardware kits.

    3)  Interesting features to explore: Motor Parameter Estimation, Motor Control Algorithms (including Field-Oriented Control), and Controller Autotuning.

    4)  Interesting links for more information:

  • Update: MathWorks Release R2020b is now available, and that includes enhancements to our C2000 Support. MathWorks login may be required for some of the links.

    1. Support of Hardware Interrupt, TCP Send/Receive and UDP Send/Receive blocks for TI F2838x (ARM Cortex-M4).
    2. Sigma Delta Filter Module (SDFM) module support for TI F2807x, F2837x, F28004x and F2838x.
    3. Updates to PIL and “Monitor and tune” (External mode) to support multiple serial modules and common user interface.
    4. Profiling support for Interrupt service routines generated from the Hardware Interrupt block.
    5. Updates to reduce compile time for generated code from model using parallel and dependency build.
    6. Addition of a getting started example and Sigma Delta Filter Module (SDFM) example for TI C2000.


    Full Release notes are here.





    John Kluza | Technical Marketing |

  • MathWorks has launched new hardware support for TI C2000 MCUs, in Release R2020b, which will be of interest to the C2000 Community: Support Package for Texas Instruments™ C2000™ Processors with SoC Blockset™

    SoC Blockset Support Package for TI C2000 Processors provides Simulink blocks and visualization tools for modeling, implementing, and verifying applications for TI C2000 MCUs. With this tool, you can model hardware and software scheduling effects on your algorithms and use the complete Model-Based-Design (MBD) workflow from simulation to implementation using the same model.


    Key Features

    Hardware component modeling, including:

    • Multicore architecture
    • Inter-Processor Communication (IPC)
    • ADC, e.g. resolution bits, acquisition time, conversion time
    • PWM, e.g. counter mode, waveform, dead time
    • ADC/PWM synchronization
    • Interrupt triggering

    Rapid-prototyping capability allows you to build, load, and execute models on TI C2000 boards. e.g. TI C2000 Delfino MCU F28379D LaunchPad development kit.

    On-device profiling allows you to see a live visualization of hardware execution information, e.g. task preemption and overrun and CPU load,  by streaming data from the hardware to Simulink Data Inspector (SDI) viewer.


    Useful links for examples and video

    John Kluza | Technical Marketing |

    # dualcore multicore dual-core dual-CPU multi-CPU

  • Update: MathWorks Release R2021a is now available, and that includes enhancements to our C2000 Support. MathWorks login may be required for some of the links.

    1. Code generation support for CAN/CAN-FD for TI F2838x and DAC for TI F28004x and F2838x.
    2. Overrun detection support for Embedded Coder Support Package for Texas Instruments C2000 Processors.
    3. Input, output and ePWM crossbar (X-BAR) configurations support for TI F2807x, F2837x, F28004x and F2838x.
    4. 64-bit floating point support for TI F2838x board.
    5. Partial support for TI F28002x Processor (ADC, ePWM, GPIO, SCI, SPI, I2C, X-BAR, and interrupts with External mode and PIL).
    6. Addition of examples for using CMPSS block and Digital DC/DC Buck Converter Using Peak Current Mode Control.
    7. Motor control examples using the Motor Control Blockset.
    8. Support for Code Composer Studio v10.1, C2000Ware, TI C28x CGT 20.2.1 and TI ARM CGT 20.2.1.

     Full Release notes are here.



    John Kluza | Technical Marketing |