TI TMS320F28379D Microcontroller for Power Electronics

Import the TI example project into Code Composer Studio, then compile, download, and run it to verify the microcontroller kit; learn CCS and C2000 package installation.

Download and install Code Composer Studio, TI's integrated development environment for writing, compiling, and downloading code to microcontrollers, and learn platform options, drivers, and workspace setup on Windows 11.

Explore the Code Composer Studio IDE for the TMS320F28379D microcontroller. Learn to navigate the start screen and core menus, and to clean, build, and debug C projects with GCC.

Install the C2000Ware sdk in Code Composer Studio by creating a dummy project for the F28379D and selecting a driver lib or bitfield option, then download the package.

Download the data sheet, the technical reference manual, and the kit manuals for the launchxl f28379d development kit to understand ratings, peripherals, and pin mappings.

Learn how Code Composer Studio manages CCS projects within a workspace, including creating, organizing, and moving project folders, and how to add or remove them without deleting from disk.

Explain why Visual Studio Code is needed for TI C2000 projects, focusing on header files, include directories, and the driver lib versus bit field approaches.

Install Visual Studio Code and explore project structure for the F2837XD microcontroller, comparing it with Code Composer Studio, and browse driver lib header files and bitfield definitions.

Import sample projects in Code Composer Studio, load driver lib and bitfield CPU1 examples, including LED blinky and timed LED blink, then build to produce the .out executable.

Program the LAUNCHXL-F28379D using driver lib and bit field projects, download the dot out file to CPU one via Code Composer Studio, and verify LEDs blink as expected.

Explore the four key CCS project file types, dot c, dot h, dot asm, and dot cmd, and how they interact with the compiler to define code and memory layout.

Achieve safe hardware setup for TI TMS320F28379D by installing Code Composer Studio and Visual Studio Code, compiling and flashing a light-emitting diode project, and following de-energize guidelines to avoid damage.

Learn to configure gpio pins as digital outputs, drive them high or low, and use LEDs on a breadboard to visualize microcontroller control.

Explore the TI TMS320F28379D microcontroller architecture, including dual CPU design, shared memory, and essential peripherals like GPIO, ADC, and PWM for power electronics applications.

Explore the gpio module on the ti tms320f28379d, detailing 169 pins across ports a to f, multiplexers, direction and data registers, core select, and cpu1 cpu2 control for pwm.

Configure gpio pins by selecting digital outputs, mapping ports with GPA mux and GPB mux registers, and assigning control to CPU1 then CPU2; plan pin functions early for PWM.

Configure gpio pins as digital outputs, then use set, clear, and toggle registers to change pin levels, while the data register reads pin states and requires care when writing.

Compare driver lib and bitfield project options for the f28379d in code composer studio 20, highlighting register mapping, api style, and dual cpu trade-offs.

Discover how registers in RAM with fixed addresses configure peripherals; reading or writing a memory location reconfigures the peripheral, using 32-bit or 16-bit access helpers and headers non-biased cmd.

Compare two ti example projects on the f28379d kit, exploring driver lib and bitfield approaches, and learn how device init, system clock, and gpio setup drive led blinking.

Explore project properties, dependencies, variables, and include options in a C2000 based microcontroller project, learn about predefined symbols, dual headers, and debug mode versus bios mode.

Learn to implement a dual-cpu gpio project by initializing the system and configuring three gpio pins—cpu1 controls gpio 22 and 97, cpu2 controls gpio 52—using detailed mux and direction settings.

Configure gpio 52 as a digital output and transfer control to CPU two via GPB select three; drive gpio 22 and 97 with set data registers in a loop.

This lecture shows driving gpio 52 from cpu2 after cpu1 configures clocks, using driver lib wrappers to set pin level in a loop, with push-pull vs open-drain and pad config.

Compare using driver lib gpio functions with writing your own specialized code. Learn to access gpio registers via hardware registers, base addresses, and 32-bit vs 16-bit memory maps.

Connect LEDs to GPIO pins with a series resistor, honoring polarity (anode to high potential, cathode to low), and never drive directly to ground.

Compile cpu1 and cpu2 projects in Code Composer Studio, fix header-related errors, add missing gpio.c, and generate the gpio bitfield cpu1.out to load onto the microcontroller.

Execute the dual-CPU project by first debugging CPU one in debug mode, then load and run CPU two, confirming GPIO pin connections and LED behavior.

Conclude the GPIO setup section by highlighting project configuration in Code Composer Studio, header files, and register access. Explain bitfield and driver library approaches and preview clocks and PLL configuration.

Explore timers and interrupts in the TI TMS320F28379D power electronics controller, learning how to configure sampling intervals, enable interrupt service routines, and toggle GPIO pins across two CPUs.

Understand why timing matters in digital power electronics, from discrete sampling to timer-driven interrupts, and how sampling interval shapes controller stability and model accuracy.

Learn how oscillators and a phase-locked loop generate the system clock for the f28379d, selecting int oscillator one or two, external xtal, or auxiliary clock for the CPU and peripherals.

Explore how interrupts enable efficient processor and peripheral communication. See how the peripheral interrupt expansion module multiplexes interrupts with priority grouping and direct or pi routed paths.

Discover how the Pi vector table fixes the interrupt sequence, routes peripheral interrupts via the Pi module to the CPU, and maps to interrupt service routines.

Configure the system clock for the TMS320F28379D by selecting the clock source and configuring the PLL, then wait for the PLL to lock for a stable 200 MHz system clock.

Configure and use six cpu timers across two cpus, enable peripheral clocks, set 32-bit period and prescaler, and handle timer interrupts via tcr bits such as rts, rtb, and tif.

Review the example project’s device initialization and clock setup, examining the PLL configuration, oscillator assumptions, and how a missing predefined symbol affects system frequency.

Review how to initialize the TMS320F28379D by calibrating the analog-to-digital converter and related system components, enabling only required peripherals, and setting the interrupt vector table.

Review the bitfield project and its init control, clock, and watchdog setups. Examine PLL configuration, oscillator selection, and pi vector table with timer interrupts and interrupt service routines.

Review the example project code for the TI tms320f28379d microcontroller, focusing on configuring the cpu timer zero registers, the period value, prescaler, and related interrupts in Code Composer Studio.

Set up two timer projects for the F28379D: configure a driver-lib cpu one and a bitfield cpu two, add include paths and clock symbols, and enable interrupt service routines.

Utilize interrupt service routines to toggle gpio pins with a dual-cpu setup; cpu1 uses timer zero and timer one to toggle pins 22 and 97, cpu2 toggles pin 52.

Configure the gpio pins for cpu one and cpu two, and enable clocks to timer zero and timer one via cpu system registers using the hardware headers.

Configure cpu timer zero and timer one from 200MHz clock by stopping timers, loading period values, enabling interrupts, and using a prescaler in free running mode to set intervals.

Register timer zero and timer one interrupts by passing their numbers and the ISR function pointers to the interrupt register, linking the vector table address to your service routines.

Configure the pi module for the timer zero interrupt in group one by setting bit seven in the IAR and IFR using the pi control registers and base address.

Configure global interrupts by enabling timer zero and timer one in the interrupt enable register and selecting int1 and int13 from the vector table. Then enable the global switch with eint so interrupts reach the processor and you can implement the ISR and start the timer.

Configure gpio pins 22, 52, and 97 as outputs, assign pin 52 to CPU two via mux and select registers, and prepare the CPU timer control for starting timers.

Implement timer zero and timer one interrupt service routines to toggle Gpio pins 22 and 97, then clear the timer flag and pi acknowledge bit.

Master timer project coding on the Texas Instruments tms320f28379d microcontroller, moving from driver lib to bitfield timing in cpu two, and configure cpu timers, pi control, and timer one interrupts.

Clean and build in Code Composer Studio, remove headers, then compile CPU one and CPU two, include the default ISR to resolve symbols, producing two .out files; one downloaded automatically.

Execute the compiled projects by loading CPU1 and CPU2 programs, observe GPIO LED toggling driven by timed delays, timers, and interrupt service routines.

Conclude by detailing system clock setup and pll, interrupts and the Pi module, vector table, and timer configurations on two cpus with driver lib and bitfield approaches.

Explore the enhanced pulse width modulation module of the TI TMS320F28379D, building on timer and interrupt lessons to generate open-loop gating signals and flexible pwm strategies.

Explore the ePWM module overview, including 12 enhanced pwm modules and dev config registers; learn how time-based, counter-compare, and deadband submodules generate pwm signals.

Prepare the ePWM module by selecting the controlling CPU, enabling its clock, and setting the PWM clock division, then synchronize time bases across modules for coordinated gating.

Explore the time-based submodule for PWM, counting up, down, or up-down to generate sawtooth and triangular carrier waveforms with a shadow-loaded 16-bit period and no interrupts.

Explore how the counter comparison submodule uses the time base timer to generate compare signals at Cmpa and CMP, feeding the action qualifier for gating.

The action qualifier submodule generates gating signals for pins A and B by merging time-based and counter-compare inputs, enabling independent, complementary, or identical PWM across 24 pins.

Configure a basic ePWM project using the time-based, counter-compare, and action-qualifier submodules to drive PWM1-2 with CPU1 and PWM4-5 with CPU2, generating sawtooth and triangular waveforms.

Configure the bitfield project for the c2000 F28379D by adding header directories and include options, and define dual-header symbols to ensure proper clock settings.

Initialize the system, configure clocks, assign PWM modules to cpu one, stop counters, set PWM clock below 100 mhz, enable clocks, start counters, and enter the loop.

Begin coding the basic ePWM project by initializing the system and configuring clock and dev config registers, deriving a 100 MHz pwm clock and assigning modules to CPUs.

Assign module five to cpu two, enable clocks to modules one and two via peripheral clock control and cpu sis registers, then enable tb clock sync for pwm counting.

Configure the TI TMS320F28379D ePWM module by setting the time-based, counter-compare, and action-qualifier submodules, and adjust the time-based period and counter mode for up and up-down operation.

Configure the two ePWM time bases to generate 10 kHz and 5 kHz signals using up count and up-down count modes, loading 16-bit period values.

Configure the counter-compare submodule for ePWM using CMPA (and optionally CMPB) to compare the time base counter with the duty ratio or modulation signal; enable shadow mode.

Configure the action qualifier submodule to generate gating pulses for IPM1 and IPM2, detailing A and B outputs, zero and compare events, and up/down counting logic.

Configure gpio pins as pwm outputs by applying gpio muxing and setting group mux and mux registers for gpio0 to gpio3, then start the timer counters for pwm1 and pwm2.

Configure ePWM time bases for IPMs via cpu registers. Reset time base sync before counting to start independent PWM timers; note deadband, event triggers, and trip zones.

Enable pwm modules four and five on cpu two, set their clocks, and configure the hardware registers using driver lib bitfields, while preserving other register bits.

Configure EP4 and EP5 time-base registers to produce a 15 kHz sawtooth and 4 kHz triangular waveform, using 16-bit loads for tbctl and period registers.

Configure the counter compare control register to enable shadow mode and load from the shadow register at the PWM cycle start, with a 0.6 duty ratio for a 3332 period.

Configure the action qualify sub module using the driver lib function. Initialize and update actor A and actor B settings for ep four and ep five—sawtooth and triangular waveforms.

Configure gpio pins six to nine for ePWM four and five. Set them as ep function pins and start timers by ORing 040100 into the cpu system register.

Compile the basic ePWM projects on CPU one, resolve unresolved symbols by adding the missing gpio.c source, and build the driver library for download to the TI TMS320F28379D.

Execute the basic ePWM projects on a TI microcontroller kit and observe gating pulses with an oscilloscope, using a breadboard, ground reference, and jumper cables for pins p0–p3 and p6–p9.

Explore the event trigger and interrupt submodule to generate interrupts and trigger the ADC module by signaling start of conversion (SOC), and tailor interrupt timing with prescale and compare options.

Configure the event trigger and interrupt sub-module to toggle gpio 22 and 52 using two cpu modules, and initialize and enable the interrupt service routine for pwm cycle interrupts.

Add and initialize pi control and pi vector files, clear iar and ifr, and configure the event trigger to generate an interrupt at the start of every pwm cycle.

Register the pwm interrupt by placing the epwm1 isr address in the pi vector table and declare it as an interrupt service routine, then enable group 3 and global interrupts.

Configure gpio pins 22 and 52 as outputs by adjusting mux and direction registers. Implement an interrupt service routine to toggle gpio 22 in sync with the pwm event trigger.

Program CPU two by duplicating CPU one steps for driver lib, and enable PWM five interrupts by setting int select to three for start and middle of PWM cycle.

Configure cpu and global interrupts, register the pwm five interrupt, and define the pwm five isr, then enable group three interrupts via the pi control registers.

Write pwm five interrupt service routine and transfer gpio 52 control from cpu1 to cpu2 by setting port b core select register three to two, then acknowledge pwm group three.

Compile the bitfield and driver lib projects by performing clean builds, verify error-free results, and prepare for the next lecture's execution and performance checks.

Execute the event trigger project by comparing gate pulses with gpio signals to verify interrupt service routines and generated interrupts on the microcontroller.

Explore the deadband sub-module in the EPW module to generate safe, complementary gating pulses and prevent shoot-through, using rising edge delay and inversion options to shape outputs.

Configure the deadband module in the pwm project by wiring the action qualifier outputs to the rising edge delay generator and the falling edge delay generator, enabling both delays.

Set the dead-band read register to apply rising and falling edge delays using the 50 MHz PWM clock, producing two- and five-microsecond delays for complementary gate pulses.

Copy the dead-band configuration from cpu one to cpu two, write the Dbcp register via reg h, and adjust in mode, load mode, and active elb for correct inversion.

Compile and build the CPU one bitfield and driver lib submodules, then observe the deadband between gating signals in the gating waveforms and prepare for the next lecture.

Explore how to implement and verify dead-band in gate pulses across multiple IPMs using the tms320f28379d microcontroller, measuring two- and five-microsecond deadbands to prevent shoot-through.

Configure the trip-zone submodule to accept fault feedback via GPIOs and map inputs with the xbar module. Use one-shot or cycle-by-cycle trips to block gating pulses and generate interrupts.

Configure the trip zone submodule to use Gpio 97 as trip zone input 1, route via input x bar, and enable a one-shot interrupt with outputs forced low.

Configure pwm trip-zone interrupts by setting the interrupt vector table and trip service routines, enable the two group two interrupts, and implement flag clearing in the trip-zone clear register.

Configure gpu 97 as trip zone input 1 by setting the input one select in the input x bar crossbar registers, then copy to cpu two with driver lib.

Copy configurations to the cpu two project, integrate the trip-zone and event trigger submodules, update interrupt service routines for ipm4 and ipm5, and enable group two pwm interrupts.

Configure the trip zone interrupts and map the interrupt service routines for pwm five ts and ipm five ts, then enable them in the pi vector table group two.

Resolve a copy-paste error in the trip zone control register and initialize trip zone flags to prevent spurious interrupts, clearing IFR flags in PI and EP modules before timer start.

Compile and build the cpu one bitfield project and the driver lib, verify clean builds, generate dot out files, and prepare for code execution in the next lecture.

Execute the trip zone project by wiring gpio 97 to 3.3V to disable the active-low input, then ground gpio 97 to block gate signals on PWM and epm2.

Conclude the enhanced pulse width modulation module by reviewing submodules—timer, interrupts, deadband, and trip zone—and their role in power electronics projects, with a preview of the analog to digital converter.

Master the adc module to convert analog measurements—grid current and voltages, and converter currents—into digital signals for closed-loop control, with interrupt and timer-based sampling.

Explore the f28379d adc modules A through D, their 16 input pins and 0–3.3 v range via reference configurator, 12- or 16-bit results, soc/eoc flow, and the post-processing module.

Configure and share the adc module between cpu1 and cpu2 on the F28379D, enable the peripheral clock, and calibrate using library functions for 12- or 16-bit, single-ended or differential operation.

Configure the adc module to start conversions using multiple SoC sources. Use CPU timers, software triggers, GPIO, and end-of-conversion signals to control sampling instances.

Configure start-of-conversion routing to multiple channels, assign SoC signals to ADC pins, and set up 16 SoC control registers with channel, trigger, and acquisition window settings for round-robin, priority-based sampling.

Configure SoC sources and channel assignments to drive ADC conversion, then follow the round-robin sampling with priority options and end-of-conversion signals updating per-SoC result registers.

Explore end of conversion signals and how to trigger and handle ADC interrupts across multiple modules, reading results from ADC result registers and coordinating module completion for fast, parallel conversions.

Generate analog signals using a GPIO-driven source with RC shaping to create a triangular waveform within 0–3.3 V, using saturation circuits and resistor-capacitor networks to protect ADC modules.

Set up an adc project in Code Composer Studio, assign cpu1 to adc module a and cpu2 to module c, configure a0/a1 and c3/c5 pins, plan two-input gpio mock signals.

Plan and implement mock analog signals using GPIO pins to feed RC filters, generate 50 Hz rectangular waveforms, and set up dual ADC module triggers on TI TMS320F28379D.

Configure the system to generate analog signals, set up timer 1, enable clocks and interrupts, and use timer/gpio code to produce a 50 Hz waveform on gpio 22 and 52.

Review the adc project - part 4 by validating the 200 MHz system clock, pi control setup, timer one configuration, and verifying triangular waveforms on the oscilloscope.

Compile and fix the adc project by resolving missing includes and linking errors in the bitfield build, adding the f28x project and F2 text project, then proceed to CPU two.

Execute a mock analog signal generator on the TI TMS320F28379D using an RC circuit with a 2.2 kΩ resistor to generate triangular waveforms with 2.2 μF and 3.3 μF capacitors.

Configure adc triggering via pwm, using ep1 and ep4 for adc a and c, copy timer/pwm setup from project, enable clocks, stop counters, and use start-of-conversion triggers instead of interrupts.

During this coding session, copy driver library for PWM4 and enable clocks. Start the timer, configure IPM4 (ignoring IPM5), set a 15kHz sawtooth, and prep for ADC interrupts later.

Review the bitfield PWM setup, including clocking, CPU assignment, and time-base start. Configure the event trigger, SOC pulse, and dead band to produce a synchronized PWM signal.

Configure adc project on the tms320f28379d by enabling soc signals to the adc module, setting pwm to a fifteen kilohertz sawtooth with shadow mode, cmp, and deadband, then start timer.

Compile the adc projects for cpu1 and cpu2 using ePWMs as trigger sources, perform clean builds, and verify pwm signals on the oscilloscope before configuring the adc module.

Assign adc module a to cpu1 and adc module c to cpu2; configure adc clock, power up, set mode and resolution with calibration; configure channels and interrupts for round-robin conversions.

Assign adc A to cpu1 and adc c to cpu2, then enable the adc A clock and set the adc prescale to achieve a 50 mhz adc clock.

Power up the adc core by setting the adc power down bit, then configure mode, resolution, and signal mode with adc_set_mode, ensuring proper enable sequencing, calibration, and register configurations.

Configure adc module a channels a0 and a1 in single-ended 12-bit mode. Use soc zero/one controls and a pwm trigger with 500 ns sample-and-hold to capture 10 kHz pwm.

Learn how to correctly configure ADC register bitfields in Code Composer Studio, choosing decimal values for 9-bit fields. Understand unsigned 16/32-bit types and prepare for interrupt setup.

Configure a0 and a1 to listen to the soc signal in a round-robin sequence. Enable adc interrupt one to fire when eoc0 and eoc1 complete.

Map the adc a1 interrupt to the pi vector table and define its ISR. Enable adc a1 in pi ier1 group one and activate the iar global level.

Explore the ADC continuous mode flag, interrupt service routine design, and how clearing the ADC int one flag controls EOC-driven interrupts, with guidance against continuous mode for easier debugging.

Read ADC result registers, convert 12-bit values to voltages and currents, and write a computed duty ratio to the CMP register with shadow mode after running the control algorithm.

Make volt and current global to observe them in debugger and ISR, then enable the ADC module clock and set PC CR 13 for ADC configuration in Code Composer Studio.

Explore configuring the adc module in the tms320f28379d driver, including prescale setup, enabling the module, and using the adc set mode function to select 12-bit single-ended operation.

Configure adc channels (c3 and c5) in single-ended mode by setting soc zero ctl and soc one ctl, using driver lib examples to map bit fields and set pwm trigger.

Configure adc interrupts for two channels, enable adc interrupt one after the last conversion, register the adc ISR, and enable pi group one interrupt to finalize ADC interrupt setup.

Adopt the driver lib approach to access ADC result registers, copy the global variable, and clear the int flag with 16-bit casts for sensor gain, offsets, voltages, and currents.

Walks through compiling the adc and bitfield projects, configuring clocks, timer, pwm, and 12‑bit adc, wiring interrupts, and resolves a missing adc set mode by adding adc.c.

Execute the adc project and verify readings by wiring pins a0/c3 and a1/c5, then use the debugger watch window and registers to monitor volt and current values.

Configure the ADC module to start and end conversions with precise timing, manage channels and interrupts, and run independent control loops on two CPUs using PWM and ADC modules.

Explore inter-processor communication between CPU1 and CPU2 on the F28379D, enabling data exchange and coordinated control via the IPC module with a flexible set of registers and interrupts.

Explore how the IPC module enables two CPUs to communicate via a shared message RAM. Use flag and status registers with data, address, and command registers, plus configurable interrupts.

Configure the ipc signal registers to enable two-way cpu communication, using ipc set and ipc sts with optional interrupts, acknowledge, and clear to coordinate signaling in power electronics controllers.

Explore how the IPC data registers enable two CPUs to exchange data and signals, using send com, send address, and send data with mirrored receive registers.

Learn how to set up a basic IPC module project in Code Composer Studio to enable CPU-to-CPU communication, including configuring registers, symbols, and project structure.

Define an IPC project for inter-CPU communication between a control CPU and a diagnostics CPU, exchanging duty ratio data to drive PWM and diagnostics timing.

Clean up the driver lib cpu1 code, enable the pi module and init vector table, configure pwm4 and pwm5 for sawtooth waveform and triangular waveform, and prepare for ipc interrupt.

Review ipc project cpu two code, enable timer one, and simulate diagnostics that send events and data to cpu one while adjusting pwm duty from 75% toward 50% or 10%.

Configure the cpu module gpio pins to enable pwm ports 4 and 5 via gpa mux one and gpe control settings.

Simulate flux growth on cpu two every 0.5 seconds, triggering ipc set and ipc send data events to drop the duty ratio to 50% when flux exceeds 5 or 10.

Configure IPC interrupts to handle flux events, send the new duty cycle via IPC, initialize IPC send data to prevent junk data, and prepare the interrupt service routine.

Implement an IPC interrupt service routine, acknowledge the IPC and Pi module interrupts, read the 32-bit duty ratio from CPU two, cast to 16-bit, and update the PWM duty.

Explore how to implement inter-processor communication with IPC between cpu one and cpu two, triggering duty-cycle adjustments based on flux thresholds, using interrupt service routines and IPC registers.

Run the IPC project in the debug window, connect CPU1 and CPU2, load the dot out file, and validate IPC send and receive data via the CMPA registers and flux.

Observe how the IPC module links cpu one and cpu two to exchange data and notifications, driving pwm gate pulses with varying duty ratios as flux crosses thresholds.

This lecture demonstrates coordinated control between two f28379d CPUs using the IPC module to exchange data, trigger interrupts, and adjust the duty ratio and gate pulses in real time.

Recaps how the dual-CPU TI F28379D enables coordinated control for power electronics, delivering up to 400 MHz total, multiple ADC modules and PWM outputs, and emphasizes hands-on practice and safety.