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.

[参考译文] TMS320F28075:如何从 T1事件中微调 AQ 模块中的 EPWM 占空比?

Guru**** 657930 points
Other Parts Discussed in Thread: C2000WARE, SYSCONFIG
请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1297203/tms320f28075-how-to-fine-tune-the-epwm-duty-in-aq-module-from-t1-event

器件型号:TMS320F28075
主题中讨论的其他器件:C2000WARESysConfig

大家好!

在我们的设计中、EPWMCLK 为60MHz、并且我们有100KHz ePWM 频率输出。
我将使用 T1事件来减小 AQ 模块中的 EPWM 占空比。 T1事件来自 CMPSS→CTRIPH→X-BAR→ePWM DC 模块→DCAEVT1。

我已禁用 SYNC 模式。
我可以减小 ePWM 占空比、但我始终得到16ns 的阶跃来降低占空比。
例如,我已经用100ns 加宽减小了 PWM 占空比,然后我将 T1信号移动到前面的4ns,我仍然得到100ns 加宽。 它不能缩减到宽度等于96 ns。
如果我将比较信号提前16ns、我可以获得一个84ns 的 PWM+。 是否有可能改进它?

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    我认为这个问题也是在另一个主题中提出的: e2e.ti.com/.../tms320f28075-cmpss---latched-filter-output-drives-ctrip\。 我将继续、关闭该旧主题并在此处继续支持。 请看一下那里的回答、如果您有任何后续问题、请告诉我。  您是否能够共享 ePWM 或 HRPWM 配置?

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的 Allison:

    请检查 下面的配置。

    我添加了 HRPWM5并将其连接到 CMPIN4P。 然后我可以得到一个 T1事件、路径为 CMPSS→CTRIPH (ASYNC)→X-BAR→ePWM 直流模块→DCAEVT1 (未与 TBCLK 同步)。
    我将 CMPAHR 设置为0xF000以获得宽度为100ns 的 PWM 输出。 然后、我将 CMPAHR 设置为0xD000、以将 T1提前4ns 置于高电平。 但 PWM+宽度仍为100ns。

    /**
     * These arguments were used when this file was generated. They will be automatically applied on subsequent loads
     * via the GUI or CLI. Run CLI with '--help' for additional information on how to override these arguments.
     * @cliArgs --device "F2807x" --package "F2807x_176PTP" --part "F2807x_176PTP" --product "C2000WARE@4.01.00.00"
     * @versions {"tool":"1.18.0+3266"}
     */
    
    /**
     * Import the modules used in this configuration.
     */
    const cmpss       = scripting.addModule("/driverlib/cmpss.js", {}, false);
    const cmpss1      = cmpss.addInstance();
    const cputimer    = scripting.addModule("/driverlib/cputimer.js", {}, false);
    const cputimer1   = cputimer.addInstance();
    const epwm        = scripting.addModule("/driverlib/epwm.js");
    const epwm1       = epwm.addInstance();
    const epwm2       = epwm.addInstance();
    const epwm3       = epwm.addInstance();
    const epwm4       = epwm.addInstance();
    const epwmxbar    = scripting.addModule("/driverlib/epwmxbar.js", {}, false);
    const epwmxbar1   = epwmxbar.addInstance();
    const epwmxbar2   = epwmxbar.addInstance();
    const gpio        = scripting.addModule("/driverlib/gpio.js", {}, false);
    const gpio1       = gpio.addInstance();
    const gpio2       = gpio.addInstance();
    const gpio3       = gpio.addInstance();
    const gpio4       = gpio.addInstance();
    const gpio5       = gpio.addInstance();
    const gpio6       = gpio.addInstance();
    const gpio7       = gpio.addInstance();
    const gpio8       = gpio.addInstance();
    const gpio9       = gpio.addInstance();
    const gpio10      = gpio.addInstance();
    const gpio11      = gpio.addInstance();
    const gpio12      = gpio.addInstance();
    const gpio13      = gpio.addInstance();
    const gpio14      = gpio.addInstance();
    const gpio15      = gpio.addInstance();
    const gpio16      = gpio.addInstance();
    const gpio17      = gpio.addInstance();
    const gpio18      = gpio.addInstance();
    const gpio19      = gpio.addInstance();
    const gpio20      = gpio.addInstance();
    const gpio21      = gpio.addInstance();
    const gpio22      = gpio.addInstance();
    const gpio23      = gpio.addInstance();
    const gpio24      = gpio.addInstance();
    const gpio25      = gpio.addInstance();
    const gpio26      = gpio.addInstance();
    const gpio27      = gpio.addInstance();
    const gpio28      = gpio.addInstance();
    const gpio29      = gpio.addInstance();
    const gpio30      = gpio.addInstance();
    const gpio31      = gpio.addInstance();
    const gpio32      = gpio.addInstance();
    const gpio33      = gpio.addInstance();
    const gpio34      = gpio.addInstance();
    const gpio35      = gpio.addInstance();
    const gpio36      = gpio.addInstance();
    const gpio37      = gpio.addInstance();
    const gpio38      = gpio.addInstance();
    const gpio39      = gpio.addInstance();
    const gpio40      = gpio.addInstance();
    const gpio41      = gpio.addInstance();
    const gpio42      = gpio.addInstance();
    const gpio43      = gpio.addInstance();
    const gpio44      = gpio.addInstance();
    const outputxbar  = scripting.addModule("/driverlib/outputxbar.js", {}, false);
    const outputxbar1 = outputxbar.addInstance();
    const outputxbar2 = outputxbar.addInstance();
    const sync        = scripting.addModule("/driverlib/sync.js");
    
    /**
     * Write custom configuration values to the imported modules.
     */
    cmpss1.$name          = "DCHG_CS1_CMPSS4P";
    cmpss1.cmpssBase      = "CMPSS4_BASE";
    cmpss1.hysteresisVal  = "1";
    cmpss1.dacValLoad     = "CMPSS_DACVAL_PWMSYNC";
    cmpss1.enableModule   = true;
    cmpss1.dacValLow      = 124;
    cmpss1.dacValHigh     = 2019;
    cmpss1.latchResetHigh = true;
    
    cputimer1.$name                    = "myCPUTIMER0";
    cputimer1.enableInterrupt          = true;
    cputimer1.startTimer               = true;
    cputimer1.registerInterrupts       = true;
    cputimer1.timerPeriod              = 120000;
    cputimer1.timerInt.enableInterrupt = true;
    
    epwm1.epwmCounterCompare_cmpC                                       = 181;
    epwm1.epwmCounterCompare_cmpD                                       = 300;
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode               = true;
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                          = "EPWM_DC_TRIP_TRIPIN4";
    epwm1.epwmDeadband_outputSwapOutA                                   = true;
    epwm1.epwmDeadband_outputSwapOutB                                   = true;
    epwm1.epwmDeadband_controlShadowMode                                = true;
    epwm1.epwmEventTrigger_enableInterrupt                              = true;
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerSource                     = "EPWM_SOC_TBCTR_U_CMPC";
    epwm1.epwmTimebase_emulationMode                                    = "EPWM_EMULATION_FREE_RUN";
    epwm1.epwmTimebase_hsClockDiv                                       = "EPWM_HSCLOCK_DIVIDER_1";
    epwm1.epwmTimebase_counterMode                                      = "EPWM_COUNTER_MODE_UP";
    epwm1.epwmTimebase_syncOutPulseMode                                 = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode               = true;
    epwm1.epwmDeadband_polarityFED                                      = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm1.epwmDeadband_enableRED                                        = true;
    epwm1.epwmDeadband_enableFED                                        = true;
    epwm1.epwmDeadband_redShadowMode                                    = true;
    epwm1.epwmDeadband_fedShadowMode                                    = true;
    epwm1.$name                                                         = "myEPWM6";
    epwm1.useInterfacePins                                              = ["EPWM#A"];
    epwm1.copyUse                                                       = true;
    epwm1.copyFrom                                                      = "myEPWM7";
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEnable                     = true;
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar             = "1";
    epwm1.epwmEventTrigger_interruptSource                              = "EPWM_INT_TBCTR_U_CMPD";
    epwm1.epwmEventTrigger_interruptEventCount                          = "1";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents               = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents               = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO         = "EPWM_AQ_OUTPUT_HIGH";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA      = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                          = "EPWM_DC_TRIP_TRIPIN9";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                          = "EPWM_DC_TRIP_TRIPIN4";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                          = "EPWM_DC_TRIP_TRIPIN9";
    epwm1.epwmCounterCompare_cmpB                                       = 599;
    epwm1.epwmDeadband_delayFED                                         = 600;
    epwm1.epwmDeadband_delayRED                                         = 18;
    epwm1.epwmTimebase_period                                           = 599;
    epwm1.hrpwm_edgeModeA                                               = "HRPWM_MEP_CTRL_RISING_EDGE";
    epwm1.hrpwm_edgeModeB                                               = "HRPWM_MEP_CTRL_FALLING_EDGE";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_gld                      = true;
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_1_eventSync = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSync = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.hrpwm_enable                                                  = true;
    epwm1.epwmDigitalCompare_dcFilterInput                              = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm1.epwmDigitalCompare_EPWM_TZ_DC_OUTPUT_A1                       = "EPWM_TZ_EVENT_DCXH_HIGH";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP           = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_1_eventSync = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSync = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.epwmCounterCompare_cmpA                                       = 30;
    epwm1.epwm.$assign                                                  = "EPWM6";
    epwm1.epwm.epwmaPin.$assign                                         = "GPIO10";
    epwm1.epwm.epwmbPin.$assign                                         = "GPIO11";
    
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm2.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm2.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm2.useInterfacePins                                                = ["EPWM#A"];
    epwm2.$name                                                           = "myEPWM7";
    epwm2.epwmCounterCompare_cmpC                                         = 181;
    epwm2.epwmDeadband_controlShadowMode                                  = true;
    epwm2.epwmCounterCompare_cmpD                                         = 300;
    epwm2.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm2.epwmDeadband_enableRED                                          = true;
    epwm2.epwmDeadband_enableFED                                          = true;
    epwm2.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm2.epwmDeadband_outputSwapOutB                                     = true;
    epwm2.epwmDeadband_outputSwapOutA                                     = true;
    epwm2.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm2.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm2.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm2.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm2.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm2.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm2.epwmDeadband_fedShadowMode                                      = true;
    epwm2.epwmDeadband_redShadowMode                                      = true;
    epwm2.copyUse                                                         = true;
    epwm2.copyFrom                                                        = "myEPWM6";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN5";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN5";
    epwm2.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN10";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN10";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm2.epwmCounterCompare_cmpB                                         = 599;
    epwm2.epwmDeadband_delayFED                                           = 600;
    epwm2.epwmDeadband_delayRED                                           = 18;
    epwm2.epwmTimebase_period                                             = 599;
    epwm2.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_EDGE";
    epwm2.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_FALLING_EDGE";
    epwm2.epwmCounterCompare_cmpALink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm2.epwmCounterCompare_cmpBLink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm2.epwmTimebase_phaseEnable                                        = true;
    epwm2.epwmTimebase_phaseShift                                         = 100;
    epwm2.epwm.$assign                                                    = "EPWM7";
    epwm2.epwm.epwmaPin.$assign                                           = "GPIO12";
    epwm2.epwm.epwmbPin.$assign                                           = "GPIO13";
    
    epwm3.$name                                                           = "myEPWM1";
    epwm3.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm3.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm3.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm3.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm3.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm3.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm3.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm3.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm3.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm3.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm3.epwmCounterCompare_cmpC                                         = 181;
    epwm3.epwmCounterCompare_cmpD                                         = 300;
    epwm3.copyUse                                                         = true;
    epwm3.copyFrom                                                        = "myEPWM6";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm3.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm3.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm3.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm3.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm3.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm3.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm3.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm3.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm3.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm3.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm3.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm3.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm3.epwmDeadband_enableRED                                          = true;
    epwm3.epwmDeadband_delayRED                                           = 18;
    epwm3.epwmDeadband_enableFED                                          = true;
    epwm3.epwmDeadband_outputSwapOutA                                     = true;
    epwm3.epwmDeadband_controlShadowMode                                  = true;
    epwm3.epwmDeadband_redShadowMode                                      = true;
    epwm3.epwmDeadband_fedShadowMode                                      = true;
    epwm3.hrpwm_enable                                                    = true;
    epwm3.hrpwm_enableCalculator                                          = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm3.epwmTimebase_period                                             = 599;
    epwm3.useInterfacePins                                                = ["EPWM#A","EPWM#B"];
    epwm3.epwmCounterCompare_cmpA                                         = 300;
    epwm3.hrpwm_DBredHR                                                   = 12;
    epwm3.hrpwm_DBfedHR                                                   = 12;
    epwm3.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_EDGE";
    epwm3.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_FALLING_EDGE";
    epwm3.hrpwm_epwmclk                                                   = 60;
    epwm3.epwmDeadband_deadbandCounterClockRate                           = "EPWM_DB_COUNTER_CLOCK_HALF_CYCLE";
    epwm3.epwmCounterCompare_cmpB                                         = 599;
    epwm3.epwmDeadband_delayFED                                           = 30;
    epwm3.epwmDeadband_outputSwapOutB                                     = true;
    epwm3.epwmDigitalCompare_blankingWindowOffset                         = 57;
    epwm3.epwm.epwmaPin.$assign                                           = "GPIO0";
    epwm3.epwm.epwmbPin.$assign                                           = "GPIO1";
    
    epwm4.$name                                                           = "myEPWM5";
    epwm4.copyUse                                                         = true;
    epwm4.copyFrom                                                        = "myEPWM7";
    epwm4.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm4.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm4.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm4.epwmCounterCompare_cmpB                                         = 599;
    epwm4.epwmCounterCompare_cmpC                                         = 181;
    epwm4.epwmCounterCompare_cmpD                                         = 300;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB        = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm4.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm4.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm4.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm4.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm4.epwmDeadband_enableFED                                          = true;
    epwm4.epwmDeadband_delayFED                                           = 600;
    epwm4.epwmDeadband_outputSwapOutA                                     = true;
    epwm4.epwmDeadband_outputSwapOutB                                     = true;
    epwm4.epwmDeadband_redShadowMode                                      = true;
    epwm4.epwmDeadband_fedShadowMode                                      = true;
    epwm4.useInterfacePins                                                = ["EPWM#A"];
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN12";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN8";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN12";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN8";
    epwm4.epwmTimebase_phaseEnable                                        = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm4.epwmDeadband_enableRED                                          = true;
    epwm4.epwmDeadband_delayRED                                           = 18;
    epwm4.epwmDeadband_controlShadowMode                                  = true;
    epwm4.epwmTimebase_period                                             = 599;
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm4.epwmDigitalCompare_EPWM_TZ_DC_OUTPUT_A1                         = "EPWM_TZ_EVENT_DCXH_HIGH";
    epwm4.hrpwm_enable                                                    = true;
    epwm4.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_AND_FALLING_EDGE";
    epwm4.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_RISING_AND_FALLING_EDGE";
    epwm4.epwmTimebase_phaseShift                                         = 545;
    epwm4.epwmCounterCompare_cmpA                                         = 500;
    
    epwmxbar1.muxesUsed = ["XBAR_MUX07"];
    epwmxbar1.$name     = "DCHG_CS1_CMPSS4L_TRIP4";
    
    epwmxbar2.tripInput = "XBAR_TRIP9";
    epwmxbar2.muxesUsed = ["XBAR_MUX06"];
    epwmxbar2.$name     = "DCHG_CS1_CMPSS4H_TRIP9";
    
    gpio1.direction       = "GPIO_DIR_MODE_OUT";
    gpio1.$name           = "tFLASH_SPI_EN";
    gpio1.gpioPin.$assign = "GPIO99";
    
    gpio2.direction       = "GPIO_DIR_MODE_OUT";
    gpio2.$name           = "CFET_HOP";
    gpio2.gpioPin.$assign = "GPIO26";
    
    gpio3.direction       = "GPIO_DIR_MODE_OUT";
    gpio3.$name           = "DFET_HOP";
    gpio3.gpioPin.$assign = "GPIO27";
    
    gpio4.$name           = "MCU_SELF_TEST";
    gpio4.gpioPin.$assign = "GPIO30";
    
    gpio5.$name           = "FAN_PWR_LATCH";
    gpio5.gpioPin.$assign = "GPIO29";
    
    gpio6.$name           = "tAFE_ALARM1";
    gpio6.gpioPin.$assign = "GPIO31";
    
    gpio7.$name           = "tVPC_Check";
    gpio7.gpioPin.$assign = "GPIO32";
    
    gpio8.direction       = "GPIO_DIR_MODE_OUT";
    gpio8.$name           = "EE_WP";
    gpio8.gpioPin.$assign = "GPIO33";
    
    gpio9.$name           = "t2nd_DET";
    gpio9.gpioPin.$assign = "GPIO37";
    
    gpio10.$name           = "tCFuse_DET";
    gpio10.gpioPin.$assign = "GPIO38";
    
    gpio11.direction       = "GPIO_DIR_MODE_OUT";
    gpio11.$name           = "tFuse_Check_BATT";
    gpio11.gpioPin.$assign = "GPIO39";
    
    gpio12.$name           = "AFE_SHDN";
    gpio12.direction       = "GPIO_DIR_MODE_OUT";
    gpio12.gpioPin.$assign = "GPIO41";
    
    gpio13.$name           = "VPC_SW";
    gpio13.direction       = "GPIO_DIR_MODE_OUT";
    gpio13.gpioPin.$assign = "GPIO49";
    
    gpio14.$name           = "tPOR_LED";
    gpio14.direction       = "GPIO_DIR_MODE_OUT";
    gpio14.gpioPin.$assign = "GPIO50";
    
    gpio15.$name           = "TH_SW";
    gpio15.direction       = "GPIO_DIR_MODE_OUT";
    gpio15.gpioPin.$assign = "GPIO51";
    
    gpio16.$name           = "PF_FUSE";
    gpio16.direction       = "GPIO_DIR_MODE_OUT";
    gpio16.gpioPin.$assign = "GPIO53";
    
    gpio17.$name           = "FUSE_DET_BUS";
    gpio17.gpioPin.$assign = "GPIO54";
    
    gpio18.$name           = "Protect_HIP";
    gpio18.gpioPin.$assign = "GPIO55";
    
    gpio19.$name           = "BMS_OVP_HIP";
    gpio19.gpioPin.$assign = "GPIO56";
    
    gpio20.$name           = "BMS_UVP_HIP";
    gpio20.gpioPin.$assign = "GPIO57";
    
    gpio21.$name           = "BMS_OCP_HIP";
    gpio21.gpioPin.$assign = "GPIO58";
    
    gpio22.$name           = "BMS_SCP_HIP";
    gpio22.gpioPin.$assign = "GPIO59";
    
    gpio23.$name           = "BUS_OVP_HIP";
    gpio23.gpioPin.$assign = "GPIO60";
    
    gpio24.$name           = "BUS_UVP_HIP";
    gpio24.gpioPin.$assign = "GPIO61";
    
    gpio25.$name           = "BUS_OCP_HIP";
    gpio25.gpioPin.$assign = "GPIO64";
    
    gpio26.$name           = "BUS_SCP_HIP";
    gpio26.gpioPin.$assign = "GPIO65";
    
    gpio27.direction       = "GPIO_DIR_MODE_OUT";
    gpio27.$name           = "UNLOCK_UVP_HOP";
    gpio27.gpioPin.$assign = "GPIO66";
    
    gpio28.$name           = "UNLOCK_SYS_HOP";
    gpio28.direction       = "GPIO_DIR_MODE_OUT";
    gpio28.gpioPin.$assign = "GPIO44";
    
    gpio29.$name             = "PWM_EN_LOP";
    gpio29.direction         = "GPIO_DIR_MODE_OUT";
    gpio29.writeInitialValue = true;
    gpio29.initialValue      = 1;
    gpio29.gpioPin.$assign   = "GPIO45";
    
    gpio30.direction       = "GPIO_DIR_MODE_OUT";
    gpio30.$name           = "SYS_DCDC_EN";
    gpio30.gpioPin.$assign = "GPIO133";
    
    gpio31.$name           = "tRTC_INT";
    gpio31.gpioPin.$assign = "GPIO46";
    
    gpio32.$name           = "MCU_Boot_1_Reserved";
    gpio32.gpioPin.$assign = "GPIO72";
    
    gpio33.$name           = "tShortpin_DET";
    gpio33.gpioPin.$assign = "GPIO80";
    
    gpio34.$name           = "MCU_Boot_0_Reserved";
    gpio34.gpioPin.$assign = "GPIO84";
    
    gpio35.direction       = "GPIO_DIR_MODE_OUT";
    gpio35.$name           = "BKPWM_EN_HOP";
    gpio35.masterCore      = "GPIO_CORE_CPU1_CLA1";
    gpio35.gpioPin.$assign = "GPIO85";
    
    gpio36.direction         = "GPIO_DIR_MODE_OUT";
    gpio36.writeInitialValue = true;
    gpio36.masterCore        = "GPIO_CORE_CPU1_CLA1";
    gpio36.$name             = "C2000_Update_Ready";
    gpio36.gpioPin.$assign   = "GPIO88";
    
    gpio37.direction       = "GPIO_DIR_MODE_OUT";
    gpio37.$name           = "C2000_PRE";
    gpio37.gpioPin.$assign = "GPIO89";
    
    gpio38.direction       = "GPIO_DIR_MODE_OUT";
    gpio38.$name           = "C2000_SW";
    gpio38.gpioPin.$assign = "GPIO90";
    
    gpio39.$name             = "PRE_CHG_HOP";
    gpio39.direction         = "GPIO_DIR_MODE_OUT";
    gpio39.writeInitialValue = true;
    gpio39.gpioPin.$assign   = "GPIO21";
    
    gpio40.$name           = "AUX_LATCH_HOP";
    gpio40.direction       = "GPIO_DIR_MODE_OUT";
    gpio40.gpioPin.$assign = "GPIO28";
    
    gpio41.$name           = "IDLE_or_RUN";
    gpio41.gpioPin.$assign = "GPIO7";
    
    gpio42.$name           = "Buck_or_Boost";
    gpio42.gpioPin.$assign = "GPIO92";
    
    gpio43.direction       = "GPIO_DIR_MODE_OUT";
    gpio43.$name           = "debug_pin";
    gpio43.gpioPin.$assign = "GPIO93";
    
    gpio44.$name           = "debug_pin_164";
    gpio44.direction       = "GPIO_DIR_MODE_OUT";
    gpio44.masterCore      = "GPIO_CORE_CPU1_CLA1";
    gpio44.gpioPin.$assign = "GPIO4";
    
    outputxbar1.$name                            = "myOUTPUTXBAR0";
    outputxbar1.muxesUsed                        = ["XBAR_MUX06"];
    outputxbar1.outputxbar.$assign               = "OUTPUTXBAR1";
    outputxbar1.outputxbar.outputxbarPin.$assign = "GPIO24";
    
    outputxbar2.$name                            = "myOUTPUTXBAR1";
    outputxbar2.muxesUsed                        = ["XBAR_MUX07"];
    outputxbar2.outputxbar.$assign               = "OUTPUTXBAR2";
    outputxbar2.outputxbar.outputxbarPin.$assign = "GPIO25";
    
    sync.syncOutLock       = true;
    sync.epwm7SyncInSource = "SYSCTL_SYNC_IN_SRC_EPWM4SYNCOUT";
    
    /**
     * Pinmux solution for unlocked pins/peripherals. This ensures that minor changes to the automatic solver in a future
     * version of the tool will not impact the pinmux you originally saw.  These lines can be completely deleted in order to
     * re-solve from scratch.
     */
    epwm3.epwm.$suggestSolution          = "EPWM1";
    epwm4.epwm.$suggestSolution          = "EPWM2";
    epwm4.epwm.epwmaPin.$suggestSolution = "GPIO2";
    epwm4.epwm.epwmbPin.$suggestSolution = "GPIO3";
    

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    感谢您分享您的配置。 有几个澄清问题:您能否说明一下您在示波器截图中具体提到的 ePWM 以及该问题? (epwm1、epwm2、epwm3或 epwm4?)。 "T1"是否映射到 TRIPIN9? 此外、您在哪里尝试将信号设置为异步与同步? 信号路径上有多个不同的位置可用于同步/不同步信号(看起来只有 epwm1直流事件1和2被指定为未同步)。  

    需要注意的一点是、DCAEVTx.FORCE 信号在3TBLCK 周期内不会锁存   、如器件 TRM 第14.11.4.1节"数字比较事件"中所述(对于60MHz EPWMCLK、每个 TBCLK 周期应为16ns)。  

    另外、我可能会误解 CMPAHR 在此方面的作用-我认为 跳闸输入信号提前4ns、以尝试让 EPWM 信号更早地变为低电平、从而缩短该周期的占空比4ns。 您是想更改 CMPA 值并使用 CMPAHR 来缩短整个 PWM 而不是仅仅一个周期的占空比吗? 或者、能否详细解释一下这种应用是什么? 对不起所有的问题-只是想确保我完全了解情况。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的  Allison:

    PWM 为 PWM6。

    T1事件来自 HRPWM5 A → CMPIN4P→CTRIPH (ASYNC)→X-BAR→TRIPIN9→ePWM 直流模块→DCAEVT1。  

    3、将信号设置为异步时、即 COMPCTL[CTRIPHSEL=0、DCACTL[EVT1FRCSYNCSEL ]=1、 DCACTL[EVT2FRCSYNCSEL ]= 1、DCBCTL[EVT1FRCSYNCSEL ]=1、DCBCTL[EVT2FRCSYNCSEL ]= 1。

    4. DCAEVTx.FORCE 信号大于3TBLCK 周期。 请检查 PWM5的计数器比较 A (CMPA)是否为500。  

    在我们的设计中、CMPIN4P 的输入信号是过流信号。如果该信号太高、我们需要减小 PWM 占空比。 在我的配置中、HRPWM5用于  过流信号的仿真。 我可以调整 PWM5的 CMPAHR 寄存器、 向前移动4ns。

    我知道我可以设置 PWM6的 CMPAHR 寄存器来更改 PWM 占空比。  但我们将触发 通过 HW 实现 PWM 占空比降低。  因此、如果 T1变为高电平、我们希望减小 AQ 模块的 PWM 占空比。   

    我确信 T1是 异步信号。 因此、我想知道我们是否可以有更多的分辨率来降低 PWM 占空比、而不是每步16.67ns。

     

     

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    非常感谢您的讲解-它对理解您的设置非常有帮助。  

    现在、您将 DCAEVT1 用作 T1源来触发动作限定器。 我可能反而建议以下内容: 在数字比较子模块中、您可以使用 DCxH 高电平作为数字比较输出2A (而不是像现在那样使用1A)的条件。 然后、在跳闸区域子模块中、您可以将 DCEVT2用作逐周期(CBC)跳闸的源、并将 TZA 事件设置为"低电压"状态。 这将比您当前的动作限定符更短的信号路径。 这是否 适合您的应用?

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的  Allison:

    感谢您的答复。

    是的、它正在工作、但我们将在 TZ 模型中遇到新问题。 我来详细解释一下。

    在当前设计中、TZA 和 TZA 均设置 为0x10。 (10:强制 EPWMxA/B 进入低电平状态)。

    如果发生紧急事件、将触发一次性(OSHT)跳闸事件、并可立即关闭 PWM6 A/B 的输出。

    在这种情况下、如果我们按照您的解决方案进行设置。 我们将得到这样的波形。 PWM6A 没有输出。 这不符合我们的设计。 这就是为什么我想知道我们是否可以从 AQ 模块中微调 PWM 占空比。 或者 ,你可以分享其他 解决方案来解决新的问题?

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、  

    您是否正在尝试仅将 ePWM 的占空比缩短一个周期、然后让原始 ePWM 信号/占空比返回? 或者尝试将占空比更新为永久更短以响应 T1? 我看到您提到使用一次性跳闸、是否也尝试过使用逐周期?

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的  Allison:

     为了响应 T1 CBC、我要将占空比更新为更短。

    根据您的建议, 将 DCEVT2作为逐周期(CBC)跳闸的来源,并将 TZA 事件设置为"低电压"状态。  因此可以 缩短 EPWM6B 的工作时间。   

    但我们仍然有一些问题。

    问题1、 如果 我 将 TZB 设置为 0x10。 TZA 至 0x11。  它仅适用于 PWM6B。   

    问题2、如果我将 TZB 设置为0x10。 TZA 至0x01。 我们可以立即缩短占空比、但死区会丢失。   

    问题3、我们有其他事件可触发一次性跳闸以永久关闭 PWMA/B、因此我们需要将 TZA 和 TZB 设置 为0x10。  

     

    请检查 下面的2个快照。 第1个是正常 PWM 信号。  第二个是 问题2的快照。

     

      

    此致、

    洪瑞安

     

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    问题1, 如果 我 将 TZB 设置为 0x10。 TZA 至 0x11。  它仅适用于 PWM6B。   [/报价]

    在这种情况下、TZA 设置为0x11、表示在发生 T1时"不执行任何操作"。 TZA 控制 EPWMxA 上的操作、因此如果设置了相应的操作、则不会对 A 执行任何操作(EPWM6B 仍变为低电平、因为您的 TZB 设置为0x10、表示 T1出现时"变为低电平")。

    问题2,如果我将 TZB 设置为0x10。 TZA 至0x01。 我们可以立即缩短占空比、但死区丢失

    这里的问题是死区子模块位于 ePWM 模块中的跳闸区子模块之前。 因此在信号路径中、首先应用死区、但跳闸区中的任何操作都将覆盖应用的死区。 因此您将丢失一部分 EPWM6A 死区、因为它被跳闸区域的动作切断。  

    我们还有其他事件可触发一次性跳闸以永久关闭 PWMA/B,因此我们需要将 TZA 和 TZB 设置 为0x10。

    哪些情况下需要使用 TZA 进行一次性旅行?  除了跳闸区域之外、是否还有其他方法可以用于 永久关闭 EPWMA/B、以便我们不需要将 TZA 设置为0x10? 也许这可以是一种动作限定器软件强制、甚至可以使用 GPIO 多路复用器来禁用 ePWM。

     研究的一个途径 是位于数字比较子模块中的谷底开关功能( 有关说明、请参阅器件 TRM 第14.11.4.3节"谷底开关")、该功能可能会延迟 ePWM 开关。 其中还有一个名为 epwm_ex6_valley_switching 的 C2000Ware 软件示例。 在这里、您仍然无法使用 TZA、因为谷底开关在数字比较子模块中、仍位于跳闸区之前、 但这可能值得您针对相关应用进行研究。

    另一种可能的替代方法是将 TZA 保留为0x11 (在 T1上"不执行任何操作")、但让 T1为 EPWM6A 发布 CMPA 值更新、从而缩短占空比。 这样、EPWM6A 死区仍然可以实现、并且不会被跳闸区切断、但之后占空比会缩短。 但这只有在特定情况下才有意义(例如、在您将来的应用中、您 是否知道 T1何时发生以及/或 您是否希望在 T1之后实现精确的占空比? 或者这是否完全取决于是否随机发生 T1? 在这里、我们还将不得不检查实施中是否存在一定的延迟)。  

    我会告诉您、我是否考虑了解决问题2的其他方法、但请告诉我、这些方法是否对您有任何可能性。  

    此致、

    艾里森

    [/quote]
  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的 Allison:

    另一个事件是过流保护。 当系统过载(CMPINxP > DACLVALA、并且 CTRIPL 为高电平)时、可以通过 TZ 模块立即关闭 PWM6A/B。 在这种情况下、TZA 和 TZB 应设置为0x10。

    还有其他保护功能、例如由软件触发的过压和过热保护。 在这种情况下、我们可以在一次性(OSHT)跳闸事件之前将 TZA 和 TZB 设置为0x10以关闭 PWM6A/B。

    这就是问题出现的原因:如何从 T1事件中微调 AQ 模块中的 EPWM 占空比。 如果这有可能、我们也可以包含死区和 OSHT TZ 功能。

    此致、

    洪瑞安

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    TZA 和 TZB 应设置为0x10

    我明白了、 如果其他跳闸操作必须将 TZA 和 TZB 设置为变为低电平、那么我们无法将跳闸区域用于缩短占空比。 如果我们像以前一样返回使用 AQ 模块、您是否曾尝试过通过增大 EPWMCLK 频率来减小时钟周期、看看这是否会用 T1改变占空比调整的分辨率? 例如、您使用的是100MHz ePWM 频率、而不是60MHz 频率。  

    此外、您是否为 ePWM 实现了 HRPWM 功能? 我看到您已经为 EPWM6A/B 启用了单个边沿的 HR 和 MEP 控制、但没有为 EPWM6启用任何其他 HR 设置的实现、因此需要确认这一点。  

    我知道您只是使用 HRPWM5来模拟故障事件 T1 -您是否期望 应用中在固定频率下发生非仿真 T1? 如果您尝试在 T1之后调整占空比、您能否更新 CMPA 动作限定器来响应 T1以缩短占空比? 或者、这根本不是您要针对的、并且您想要 由 T1引起的 EPWM6A/B 时间相关的响应?

    我将在明天尝试测试几个案例,并告诉你任何发现。  

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、  

    仍在 设置我的测试、因此请允许直至明天结束、以便我再提供一次更新。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、  

    您之前附加的 SysConfig 设置是否是生成 PWM 以便我查看 AQ 问题所需的唯一代码? 或者、您或许能够附加您的项目以供我查看吗? 我将尝试尽可能详细地重新创建您的设置。  

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的  Allison:

    是的、 我分享的 SysConfig 设置 是2周期限、供您查看 AQ 问题。 我在这里选中的方式与此相同。  

    请检查 SysConfig 中的以下项目。

    /**
     * These arguments were used when this file was generated. They will be automatically applied on subsequent loads
     * via the GUI or CLI. Run CLI with '--help' for additional information on how to override these arguments.
     * @cliArgs --device "F2807x" --package "F2807x_176PTP" --part "F2807x_176PTP" --product "C2000WARE@4.01.00.00"
     * @versions {"tool":"1.17.0+3128"}
     */
    
    /**
     * Import the modules used in this configuration.
     */
    const adc       = scripting.addModule("/driverlib/adc.js", {}, false);
    const adc1      = adc.addInstance();
    const adc2      = adc.addInstance();
    const adc3      = adc.addInstance();
    const can       = scripting.addModule("/driverlib/can.js", {}, false);
    const can1      = can.addInstance();
    const cmpss     = scripting.addModule("/driverlib/cmpss.js", {}, false);
    const cmpss1    = cmpss.addInstance();
    const cmpss2    = cmpss.addInstance();
    const cmpss3    = cmpss.addInstance();
    const cmpss4    = cmpss.addInstance();
    const cputimer  = scripting.addModule("/driverlib/cputimer.js", {}, false);
    const cputimer1 = cputimer.addInstance();
    const cputimer2 = cputimer.addInstance();
    const epwm      = scripting.addModule("/driverlib/epwm.js");
    const epwm1     = epwm.addInstance();
    const epwm2     = epwm.addInstance();
    const epwm3     = epwm.addInstance();
    const epwm4     = epwm.addInstance();
    const epwm5     = epwm.addInstance();
    const epwm6     = epwm.addInstance();
    const epwm7     = epwm.addInstance();
    const epwmxbar  = scripting.addModule("/driverlib/epwmxbar.js", {}, false);
    const epwmxbar1 = epwmxbar.addInstance();
    const epwmxbar2 = epwmxbar.addInstance();
    const epwmxbar3 = epwmxbar.addInstance();
    const epwmxbar4 = epwmxbar.addInstance();
    const epwmxbar5 = epwmxbar.addInstance();
    const epwmxbar6 = epwmxbar.addInstance();
    const epwmxbar7 = epwmxbar.addInstance();
    const epwmxbar8 = epwmxbar.addInstance();
    const gpio      = scripting.addModule("/driverlib/gpio.js", {}, false);
    const gpio1     = gpio.addInstance();
    const gpio2     = gpio.addInstance();
    const gpio3     = gpio.addInstance();
    const gpio4     = gpio.addInstance();
    const gpio5     = gpio.addInstance();
    const gpio6     = gpio.addInstance();
    const gpio7     = gpio.addInstance();
    const gpio8     = gpio.addInstance();
    const gpio9     = gpio.addInstance();
    const gpio10    = gpio.addInstance();
    const gpio11    = gpio.addInstance();
    const gpio12    = gpio.addInstance();
    const gpio13    = gpio.addInstance();
    const gpio14    = gpio.addInstance();
    const gpio15    = gpio.addInstance();
    const gpio16    = gpio.addInstance();
    const gpio17    = gpio.addInstance();
    const gpio18    = gpio.addInstance();
    const gpio19    = gpio.addInstance();
    const gpio20    = gpio.addInstance();
    const gpio21    = gpio.addInstance();
    const gpio22    = gpio.addInstance();
    const gpio23    = gpio.addInstance();
    const gpio24    = gpio.addInstance();
    const gpio25    = gpio.addInstance();
    const gpio26    = gpio.addInstance();
    const gpio27    = gpio.addInstance();
    const gpio28    = gpio.addInstance();
    const gpio29    = gpio.addInstance();
    const gpio30    = gpio.addInstance();
    const gpio31    = gpio.addInstance();
    const gpio32    = gpio.addInstance();
    const gpio33    = gpio.addInstance();
    const gpio34    = gpio.addInstance();
    const gpio35    = gpio.addInstance();
    const gpio36    = gpio.addInstance();
    const gpio37    = gpio.addInstance();
    const gpio38    = gpio.addInstance();
    const gpio39    = gpio.addInstance();
    const gpio40    = gpio.addInstance();
    const gpio41    = gpio.addInstance();
    const gpio42    = gpio.addInstance();
    const i2c       = scripting.addModule("/driverlib/i2c.js", {}, false);
    const i2c1      = i2c.addInstance();
    const i2c2      = i2c.addInstance();
    const sci       = scripting.addModule("/driverlib/sci.js", {}, false);
    const sci1      = sci.addInstance();
    const spi       = scripting.addModule("/driverlib/spi.js", {}, false);
    const spi1      = spi.addInstance();
    const sync      = scripting.addModule("/driverlib/sync.js");
    
    /**
     * Write custom configuration values to the imported modules.
     */
    adc1.$name               = "myADC0";
    adc1.soc5Channel         = "ADC_CH_ADCIN3";
    adc1.interruptPulseMode  = "ADC_PULSE_END_OF_CONV";
    adc1.registerInterrupts  = ["1"];
    adc1.useInterrupts       = false;
    adc1.adcClockPrescaler   = "ADC_CLK_DIV_2_0";
    adc1.soc0SampleWindow    = 36;
    adc1.soc1SampleWindow    = 36;
    adc1.soc2SampleWindow    = 36;
    adc1.soc3Channel         = "ADC_CH_ADCIN5";
    adc1.soc3SampleWindow    = 36;
    adc1.soc4Channel         = "ADC_CH_ADCIN2";
    adc1.soc4SampleWindow    = 36;
    adc1.soc5SampleWindow    = 36;
    adc1.soc6Channel         = "ADC_CH_ADCIN4";
    adc1.soc6SampleWindow    = 36;
    adc1.soc7SampleWindow    = 36;
    adc1.soc8SampleWindow    = 36;
    adc1.soc9SampleWindow    = 36;
    adc1.socHighPriorityMode = "ADC_PRI_THRU_SOC7_HIPRI";
    adc1.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER10","ADC_SOC_NUMBER11","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3","ADC_SOC_NUMBER4","ADC_SOC_NUMBER5","ADC_SOC_NUMBER6","ADC_SOC_NUMBER7","ADC_SOC_NUMBER8","ADC_SOC_NUMBER9"];
    adc1.soc0Channel         = "ADC_CH_ADCIN4";
    adc1.soc0Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc1Channel         = "ADC_CH_ADCIN1";
    adc1.soc1Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc2Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc3Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc4Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc5Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc6Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc7Channel         = "ADC_CH_ADCIN1";
    adc1.soc7Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc8Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc9Channel         = "ADC_CH_ADCIN5";
    adc1.soc9Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc10Channel        = "ADC_CH_ADCIN2";
    adc1.soc10Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc10SampleWindow   = 36;
    adc1.soc11Channel        = "ADC_CH_ADCIN3";
    adc1.soc11Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc11SampleWindow   = 36;
    
    adc2.$name               = "myADC1";
    adc2.adcBase             = "ADCB_BASE";
    adc2.adcClockPrescaler   = "ADC_CLK_DIV_2_0";
    adc2.soc0SampleWindow    = 36;
    adc2.soc1SampleWindow    = 36;
    adc2.soc2SampleWindow    = 36;
    adc2.soc3SampleWindow    = 36;
    adc2.soc4Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc4SampleWindow    = 36;
    adc2.soc5SampleWindow    = 36;
    adc2.soc6Channel         = "ADC_CH_ADCIN3";
    adc2.soc5Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc6SampleWindow    = 36;
    adc2.socHighPriorityMode = "ADC_PRI_THRU_SOC3_HIPRI";
    adc2.useInterrupts       = false;
    adc2.soc0Channel         = "ADC_CH_ADCIN3";
    adc2.soc1Channel         = "ADC_CH_ADCIN1";
    adc2.soc0Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc1Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc2Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc3Channel         = "ADC_CH_ADCIN2";
    adc2.soc3Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc4Channel         = "ADC_CH_ADCIN14";
    adc2.soc5Channel         = "ADC_CH_ADCIN15";
    adc2.soc6Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER10","ADC_SOC_NUMBER11","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3","ADC_SOC_NUMBER4","ADC_SOC_NUMBER5","ADC_SOC_NUMBER6","ADC_SOC_NUMBER7","ADC_SOC_NUMBER8","ADC_SOC_NUMBER9"];
    adc2.soc7Channel         = "ADC_CH_ADCIN1";
    adc2.soc7Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc7SampleWindow    = 36;
    adc2.soc8Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc8SampleWindow    = 36;
    adc2.soc9Channel         = "ADC_CH_ADCIN2";
    adc2.soc9Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc9SampleWindow    = 36;
    adc2.soc10Channel        = "ADC_CH_ADCIN14";
    adc2.soc10Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc10SampleWindow   = 36;
    adc2.soc11Channel        = "ADC_CH_ADCIN15";
    adc2.soc11SampleWindow   = 36;
    adc2.soc11Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    
    adc3.$name               = "myADC2";
    adc3.adcBase             = "ADCD_BASE";
    adc3.soc0Channel         = "ADC_CH_ADCIN1";
    adc3.soc0SampleWindow    = 36;
    adc3.soc1SampleWindow    = 36;
    adc3.soc2SampleWindow    = 36;
    adc3.soc3SampleWindow    = 36;
    adc3.soc4SampleWindow    = 36;
    adc3.soc5SampleWindow    = 36;
    adc3.soc6SampleWindow    = 36;
    adc3.soc7SampleWindow    = 36;
    adc3.adcClockPrescaler   = "ADC_CLK_DIV_2_0";
    adc3.soc4Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.useInterrupts       = false;
    adc3.soc0Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc1Channel         = "ADC_CH_ADCIN2";
    adc3.soc1Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc2Channel         = "ADC_CH_ADCIN4";
    adc3.soc2Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc3Channel         = "ADC_CH_ADCIN1";
    adc3.soc3Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc4Channel         = "ADC_CH_ADCIN3";
    adc3.soc5Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.soc6Channel         = "ADC_CH_ADCIN2";
    adc3.soc6Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.soc7Channel         = "ADC_CH_ADCIN4";
    adc3.soc7Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3","ADC_SOC_NUMBER4","ADC_SOC_NUMBER5","ADC_SOC_NUMBER6","ADC_SOC_NUMBER7","ADC_SOC_NUMBER8","ADC_SOC_NUMBER9"];
    adc3.socHighPriorityMode = "ADC_PRI_THRU_SOC9_HIPRI";
    adc3.soc8Channel         = "ADC_CH_ADCIN1";
    adc3.soc8Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.soc8SampleWindow    = 36;
    adc3.soc9Channel         = "ADC_CH_ADCIN3";
    adc3.soc9SampleWindow    = 36;
    adc3.soc9Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    
    can1.$name                    = "myCAN0";
    can1.enableInterrupt          = true;
    can1.registerInterrupts       = true;
    can1.interruptLine            = ["CAN_GLOBAL_INT_CANINT0"];
    can1.interruptFlags           = ["CAN_INT_ERROR","CAN_INT_IE0","CAN_INT_STATUS"];
    can1.can.$assign              = "CANA";
    can1.can.canrxPin.$assign     = "GPIO62";
    can1.can.cantxPin.$assign     = "GPIO63";
    can1.can0Int.interruptHandler = "CAN_RxISR";
    can1.can0Int.enableInterrupt  = true;
    can1.can1Int.interruptHandler = "CAN_TxISR";
    
    cmpss1.$name          = "DCHG_CS1_CMPSS4P";
    cmpss1.cmpssBase      = "CMPSS4_BASE";
    cmpss1.hysteresisVal  = "1";
    cmpss1.dacValLoad     = "CMPSS_DACVAL_PWMSYNC";
    cmpss1.dacValLow      = 124;
    cmpss1.lowCTRIP       = "CMPSS_TRIP_SYNC_COMP";
    cmpss1.lowCompAsynch  = true;
    cmpss1.lowCompInvert  = true;
    cmpss1.highCompAsynch = true;
    cmpss1.highCTRIP      = "CMPSS_TRIP_SYNC_COMP";
    cmpss1.dacValHigh     = 1000;
    
    cmpss2.$name          = "DCHG_CS2_CMPSS3P";
    cmpss2.cmpssBase      = "CMPSS3_BASE";
    cmpss2.highCompAsynch = true;
    cmpss2.dacValHigh     = 1000;
    cmpss2.lowCompInvert  = true;
    cmpss2.lowCompAsynch  = true;
    cmpss2.dacValLow      = 124;
    cmpss2.hysteresisVal  = "1";
    
    cmpss3.cmpssBase      = "CMPSS5_BASE";
    cmpss3.$name          = "DCHG_CS3_CMPSS5P";
    cmpss3.highCompAsynch = true;
    cmpss3.dacValHigh     = 1000;
    cmpss3.lowCompInvert  = true;
    cmpss3.lowCompAsynch  = true;
    cmpss3.dacValLow      = 124;
    cmpss3.hysteresisVal  = "1";
    
    cmpss4.cmpssBase      = "CMPSS6_BASE";
    cmpss4.$name          = "DCHG_CH4_CMPSS6P";
    cmpss4.highCompAsynch = true;
    cmpss4.dacValHigh     = 1000;
    cmpss4.lowCompInvert  = true;
    cmpss4.lowCompAsynch  = true;
    cmpss4.dacValLow      = 124;
    cmpss4.hysteresisVal  = "1";
    
    cputimer1.$name                    = "myCPUTIMER0";
    cputimer1.enableInterrupt          = true;
    cputimer1.startTimer               = true;
    cputimer1.registerInterrupts       = true;
    cputimer1.timerPeriod              = 120000;
    cputimer1.timerInt.enableInterrupt = true;
    
    cputimer2.$name                    = "myCPUTIMER1";
    cputimer2.startTimer               = true;
    cputimer2.registerInterrupts       = true;
    cputimer2.enableInterrupt          = true;
    cputimer2.cputimerBase             = "CPUTIMER1_BASE";
    cputimer2.timerPeriod              = 1200;
    cputimer2.timerInt.enableInterrupt = true;
    
    epwm1.epwmTimebase_period                                             = 600;
    epwm1.epwmCounterCompare_cmpC                                         = 181;
    epwm1.epwmCounterCompare_cmpD                                         = 300;
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm1.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm1.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm1.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm1.epwmDeadband_outputSwapOutA                                     = true;
    epwm1.epwmDeadband_outputSwapOutB                                     = true;
    epwm1.epwmDeadband_controlShadowMode                                  = true;
    epwm1.epwmEventTrigger_enableInterrupt                                = true;
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerSource                       = "EPWM_SOC_TBCTR_U_CMPC";
    epwm1.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm1.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm1.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm1.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm1.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm1.epwmDeadband_enableRED                                          = true;
    epwm1.epwmDeadband_delayRED                                           = 12;
    epwm1.epwmDeadband_enableFED                                          = true;
    epwm1.epwmDeadband_delayFED                                           = 12;
    epwm1.epwmDeadband_redShadowMode                                      = true;
    epwm1.epwmDeadband_fedShadowMode                                      = true;
    epwm1.$name                                                           = "myEPWM6";
    epwm1.useInterfacePins                                                = ["EPWM#A"];
    epwm1.copyUse                                                         = true;
    epwm1.copyFrom                                                        = "myEPWM7";
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEnable                       = true;
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar               = "1";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm1.epwmEventTrigger_interruptSource                                = "EPWM_INT_TBCTR_U_CMPD";
    epwm1.epwmEventTrigger_interruptEventCount                            = "1";
    epwm1.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm1.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm1.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_HIGH";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm1.epwmTimebase_phaseEnable                                        = true;
    epwm1.epwmCounterCompare_cmpA                                         = 360;
    epwm1.epwm.$assign                                                    = "EPWM6";
    epwm1.epwm.epwmaPin.$assign                                           = "GPIO10";
    epwm1.epwm.epwmbPin.$assign                                           = "GPIO11";
    
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm2.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm2.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm2.epwmTimebase_period                                             = 600;
    epwm2.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm2.useInterfacePins                                                = ["EPWM#A"];
    epwm2.$name                                                           = "myEPWM7";
    epwm2.epwmCounterCompare_cmpC                                         = 181;
    epwm2.epwmDeadband_controlShadowMode                                  = true;
    epwm2.epwmCounterCompare_cmpD                                         = 300;
    epwm2.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm2.epwmDeadband_enableRED                                          = true;
    epwm2.epwmDeadband_enableFED                                          = true;
    epwm2.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm2.epwmDeadband_outputSwapOutB                                     = true;
    epwm2.epwmDeadband_outputSwapOutA                                     = true;
    epwm2.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm2.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm2.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm2.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm2.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm2.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm2.epwmDeadband_delayRED                                           = 12;
    epwm2.epwmDeadband_delayFED                                           = 12;
    epwm2.epwmDeadband_fedShadowMode                                      = true;
    epwm2.epwmDeadband_redShadowMode                                      = true;
    epwm2.copyUse                                                         = true;
    epwm2.copyFrom                                                        = "myEPWM6";
    epwm2.epwmTimebase_phaseEnable                                        = true;
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm2.epwmTimebase_phaseShift                                         = 150;
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_HIGH";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN5";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN5";
    epwm2.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN10";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN10";
    epwm2.epwmCounterCompare_cmpA                                         = 360;
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmCounterCompare_cmpALink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm2.epwm.$assign                                                    = "EPWM7";
    epwm2.epwm.epwmaPin.$assign                                           = "GPIO12";
    epwm2.epwm.epwmbPin.$assign                                           = "GPIO13";
    
    epwm3.epwmTimebase_emulationMode                               = "EPWM_EMULATION_FREE_RUN";
    epwm3.epwmTimebase_hsClockDiv                                  = "EPWM_HSCLOCK_DIVIDER_1";
    epwm3.epwmTimebase_counterMode                                 = "EPWM_COUNTER_MODE_UP";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode          = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_HIGH";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA = "EPWM_AQ_OUTPUT_LOW";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode          = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_LOW";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA = "EPWM_AQ_OUTPUT_HIGH";
    epwm3.useInterfacePins                                         = ["EPWM#A"];
    epwm3.$name                                                    = "myEPWM11";
    epwm3.copyFrom                                                 = "myEPWM7";
    epwm3.epwmTimebase_period                                      = 2400;
    epwm3.epwmCounterCompare_cmpA                                  = 1200;
    epwm3.useCase                                                  = "CUSTOM";
    epwm3.epwm.$assign                                             = "EPWM11";
    epwm3.epwm.epwmaPin.$assign                                    = "GPIO20";
    
    epwm4.epwmTimebase_phaseEnable                                        = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm4.epwmDeadband_controlShadowMode                                  = true;
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm4.epwmDeadband_enableRED                                          = true;
    epwm4.epwmDeadband_enableFED                                          = true;
    epwm4.useInterfacePins                                                = ["EPWM#A"];
    epwm4.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm4.epwmTimebase_period                                             = 600;
    epwm4.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm4.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm4.copyUse                                                         = true;
    epwm4.copyFrom                                                        = "myEPWM7";
    epwm4.epwmCounterCompare_cmpC                                         = 181;
    epwm4.epwmCounterCompare_cmpD                                         = 300;
    epwm4.epwmDeadband_outputSwapOutA                                     = true;
    epwm4.epwmDeadband_outputSwapOutB                                     = true;
    epwm4.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm4.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm4.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm4.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm4.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm4.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm4.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm4.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm4.epwmDeadband_delayRED                                           = 12;
    epwm4.epwmDeadband_delayFED                                           = 12;
    epwm4.epwmDeadband_redShadowMode                                      = true;
    epwm4.epwmDeadband_fedShadowMode                                      = true;
    epwm4.$name                                                           = "myEPWM9";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm4.epwmTimebase_phaseShift                                         = 450;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN8";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN8";
    epwm4.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN12";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN12";
    epwm4.epwmCounterCompare_cmpA                                         = 360;
    epwm4.epwmCounterCompare_cmpALink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_HIGH";
    epwm4.epwm.$assign                                                    = "EPWM9";
    epwm4.epwm.epwmaPin.$assign                                           = "GPIO16";
    epwm4.epwm.epwmbPin.$assign                                           = "GPIO17";
    
    epwm5.$name                                                    = "myEPWM1";
    epwm5.useCase                                                  = "CUSTOM";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_HIGH";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA = "EPWM_AQ_OUTPUT_LOW";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                    = "EPWM_TZ_ACTION_LOW";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                    = "EPWM_TZ_ACTION_LOW";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTimebase_counterMode                                 = "EPWM_COUNTER_MODE_UP";
    epwm5.epwmTimebase_syncOutPulseMode                            = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm5.epwmTimebase_hsClockDiv                                  = "EPWM_HSCLOCK_DIVIDER_1";
    epwm5.epwmTimebase_emulationMode                               = "EPWM_EMULATION_FREE_RUN";
    epwm5.epwmTimebase_period                                      = 600;
    epwm5.epwmCounterCompare_cmpA                                  = 600;
    epwm5.epwmCounterCompare_cmpC                                  = 181;
    epwm5.epwmCounterCompare_cmpD                                  = 300;
    epwm5.useInterfacePins                                         = ["EPWM#A"];
    
    epwm6.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm6.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm6.epwmTimebase_period                                             = 600;
    epwm6.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm6.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm6.epwmCounterCompare_cmpC                                         = 181;
    epwm6.epwmCounterCompare_cmpD                                         = 300;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm6.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm6.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm6.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm6.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm6.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm6.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm6.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm6.epwmDeadband_enableRED                                          = true;
    epwm6.epwmDeadband_delayRED                                           = 12;
    epwm6.epwmDeadband_enableFED                                          = true;
    epwm6.epwmDeadband_delayFED                                           = 12;
    epwm6.epwmDeadband_outputSwapOutA                                     = true;
    epwm6.epwmDeadband_outputSwapOutB                                     = true;
    epwm6.epwmDeadband_controlShadowMode                                  = true;
    epwm6.epwmDeadband_redShadowMode                                      = true;
    epwm6.epwmDeadband_fedShadowMode                                      = true;
    epwm6.epwmEventTrigger_enableInterrupt                                = true;
    epwm6.epwmEventTrigger_interruptSource                                = "EPWM_INT_TBCTR_U_CMPD";
    epwm6.epwmEventTrigger_interruptEventCount                            = "1";
    epwm6.epwmEventTrigger_EPWM_SOC_A_triggerEnable                       = true;
    epwm6.epwmEventTrigger_EPWM_SOC_A_triggerSource                       = "EPWM_SOC_TBCTR_U_CMPC";
    epwm6.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar               = "1";
    epwm6.useInterfacePins                                                = ["EPWM#A"];
    epwm6.copyUse                                                         = true;
    epwm6.copyFrom                                                        = "myEPWM6";
    epwm6.$name                                                           = "myEPWM8";
    epwm6.epwmTimebase_phaseEnable                                        = true;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm6.epwmTimebase_phaseShift                                         = 300;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_onetimeSwForceAction       = "EPWM_AQ_OUTPUT_HIGH";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm6.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN7";
    epwm6.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN7";
    epwm6.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm6.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN11";
    epwm6.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN11";
    epwm6.epwmCounterCompare_cmpA                                         = 360;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_HIGH";
    epwm6.epwmCounterCompare_cmpALink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm6.epwm.$assign                                                    = "EPWM8";
    epwm6.epwm.epwmaPin.$assign                                           = "GPIO14";
    epwm6.epwm.epwmbPin.$assign                                           = "GPIO15";
    
    epwm7.$name                    = "myEPWM2";
    epwm7.epwmTimebase_period      = 6000;
    epwm7.epwmTimebase_counterMode = "EPWM_COUNTER_MODE_UP";
    epwm7.epwmCounterCompare_cmpA  = 6000;
    epwm7.epwm.$assign             = "EPWM2";
    
    epwmxbar1.muxesUsed = ["XBAR_MUX07"];
    epwmxbar1.$name     = "DCHG_CS1_CMPSS4L_TRIP4";
    
    epwmxbar2.muxesUsed = ["XBAR_MUX05"];
    epwmxbar2.tripInput = "XBAR_TRIP5";
    epwmxbar2.$name     = "DCHG_CS2_CMPSS3L_TRIP5";
    
    epwmxbar3.muxesUsed = ["XBAR_MUX09"];
    epwmxbar3.tripInput = "XBAR_TRIP7";
    epwmxbar3.$name     = "DCHG_CS3_CMPSS5L_TRIP7";
    
    epwmxbar4.muxesUsed = ["XBAR_MUX11"];
    epwmxbar4.tripInput = "XBAR_TRIP8";
    epwmxbar4.$name     = "DCHG_CS4_CMPSS6L_TRIP8";
    
    epwmxbar5.tripInput = "XBAR_TRIP9";
    epwmxbar5.muxesUsed = ["XBAR_MUX06"];
    epwmxbar5.$name     = "DCHG_CS1_CMPSS4H_TRIP9";
    
    epwmxbar6.tripInput = "XBAR_TRIP10";
    epwmxbar6.$name     = "DCHG_CS2_CMPSS3H_TRIP10";
    epwmxbar6.muxesUsed = ["XBAR_MUX04"];
    
    epwmxbar7.tripInput = "XBAR_TRIP11";
    epwmxbar7.muxesUsed = ["XBAR_MUX08"];
    epwmxbar7.$name     = "DCHG_CS3_CMPSS5H_TRIP11";
    
    epwmxbar8.$name     = "DCHG_CS4_CMPSS6H_TRIP12";
    epwmxbar8.tripInput = "XBAR_TRIP12";
    epwmxbar8.muxesUsed = ["XBAR_MUX10"];
    
    gpio1.direction       = "GPIO_DIR_MODE_OUT";
    gpio1.$name           = "tFLASH_SPI_EN";
    gpio1.gpioPin.$assign = "GPIO99";
    
    gpio2.direction       = "GPIO_DIR_MODE_OUT";
    gpio2.$name           = "tFLASH_HOLD";
    gpio2.gpioPin.$assign = "GPIO8";
    
    gpio3.direction       = "GPIO_DIR_MODE_OUT";
    gpio3.$name           = "tFLASH_WP";
    gpio3.gpioPin.$assign = "GPIO9";
    
    gpio4.direction       = "GPIO_DIR_MODE_OUT";
    gpio4.$name           = "CFET_HOP";
    gpio4.gpioPin.$assign = "GPIO26";
    
    gpio5.direction       = "GPIO_DIR_MODE_OUT";
    gpio5.$name           = "DFET_HOP";
    gpio5.gpioPin.$assign = "GPIO27";
    
    gpio6.$name           = "MCU_SELF_TEST";
    gpio6.gpioPin.$assign = "GPIO30";
    
    gpio7.$name           = "FAN_PWR_LATCH";
    gpio7.gpioPin.$assign = "GPIO29";
    
    gpio8.$name           = "tAFE_ALARM1";
    gpio8.gpioPin.$assign = "GPIO31";
    
    gpio9.$name           = "tVPC_Check";
    gpio9.gpioPin.$assign = "GPIO32";
    
    gpio10.direction       = "GPIO_DIR_MODE_OUT";
    gpio10.$name           = "EE_WP";
    gpio10.gpioPin.$assign = "GPIO33";
    
    gpio11.$name           = "t2nd_DET";
    gpio11.gpioPin.$assign = "GPIO37";
    
    gpio12.$name           = "tCFuse_DET";
    gpio12.gpioPin.$assign = "GPIO38";
    
    gpio13.direction       = "GPIO_DIR_MODE_OUT";
    gpio13.$name           = "tFuse_Check_BATT";
    gpio13.gpioPin.$assign = "GPIO39";
    
    gpio14.$name           = "AFE_SHDN";
    gpio14.direction       = "GPIO_DIR_MODE_OUT";
    gpio14.gpioPin.$assign = "GPIO41";
    
    gpio15.$name           = "VPC_SW";
    gpio15.direction       = "GPIO_DIR_MODE_OUT";
    gpio15.gpioPin.$assign = "GPIO49";
    
    gpio16.$name           = "tPOR_LED";
    gpio16.direction       = "GPIO_DIR_MODE_OUT";
    gpio16.gpioPin.$assign = "GPIO50";
    
    gpio17.$name           = "TH_SW";
    gpio17.direction       = "GPIO_DIR_MODE_OUT";
    gpio17.gpioPin.$assign = "GPIO51";
    
    gpio18.$name           = "PF_FUSE";
    gpio18.direction       = "GPIO_DIR_MODE_OUT";
    gpio18.gpioPin.$assign = "GPIO53";
    
    gpio19.$name           = "FUSE_DET_BUS";
    gpio19.gpioPin.$assign = "GPIO54";
    
    gpio20.$name           = "Protect_HIP";
    gpio20.gpioPin.$assign = "GPIO55";
    
    gpio21.$name           = "BMS_OVP_HIP";
    gpio21.gpioPin.$assign = "GPIO56";
    
    gpio22.$name           = "BMS_UVP_HIP";
    gpio22.gpioPin.$assign = "GPIO57";
    
    gpio23.$name           = "BMS_OCP_HIP";
    gpio23.gpioPin.$assign = "GPIO58";
    
    gpio24.$name           = "BMS_SCP_HIP";
    gpio24.gpioPin.$assign = "GPIO59";
    
    gpio25.$name           = "BUS_OVP_HIP";
    gpio25.gpioPin.$assign = "GPIO60";
    
    gpio26.$name           = "BUS_UVP_HIP";
    gpio26.gpioPin.$assign = "GPIO61";
    
    gpio27.$name           = "BUS_OCP_HIP";
    gpio27.gpioPin.$assign = "GPIO64";
    
    gpio28.$name           = "BUS_SCP_HIP";
    gpio28.gpioPin.$assign = "GPIO65";
    
    gpio29.direction       = "GPIO_DIR_MODE_OUT";
    gpio29.$name           = "UNLOCK_UVP_HOP";
    gpio29.gpioPin.$assign = "GPIO66";
    
    gpio30.$name           = "UNLOCK_SYS_HOP";
    gpio30.direction       = "GPIO_DIR_MODE_OUT";
    gpio30.gpioPin.$assign = "GPIO44";
    
    gpio31.$name           = "PWM_EN_LOP";
    gpio31.gpioPin.$assign = "GPIO45";
    
    gpio32.direction       = "GPIO_DIR_MODE_OUT";
    gpio32.$name           = "SYS_DCDC_EN";
    gpio32.gpioPin.$assign = "GPIO133";
    
    gpio33.$name           = "tRTC_INT";
    gpio33.gpioPin.$assign = "GPIO46";
    
    gpio34.$name           = "MCU_Boot_1_Reserved";
    gpio34.gpioPin.$assign = "GPIO72";
    
    gpio35.$name           = "tShortpin_DET";
    gpio35.gpioPin.$assign = "GPIO80";
    
    gpio36.$name           = "MCU_Boot_0_Reserved";
    gpio36.gpioPin.$assign = "GPIO84";
    
    gpio37.direction       = "GPIO_DIR_MODE_OUT";
    gpio37.$name           = "BKPWM_EN_HOP";
    gpio37.gpioPin.$assign = "GPIO85";
    
    gpio38.direction         = "GPIO_DIR_MODE_OUT";
    gpio38.writeInitialValue = true;
    gpio38.masterCore        = "GPIO_CORE_CPU1_CLA1";
    gpio38.$name             = "C2000_Update_Ready";
    gpio38.gpioPin.$assign   = "GPIO88";
    
    gpio39.direction       = "GPIO_DIR_MODE_OUT";
    gpio39.$name           = "C2000_PRE";
    gpio39.gpioPin.$assign = "GPIO89";
    
    gpio40.direction       = "GPIO_DIR_MODE_OUT";
    gpio40.$name           = "C2000_SW";
    gpio40.gpioPin.$assign = "GPIO90";
    
    gpio41.$name           = "PRE_CHG_HOP";
    gpio41.gpioPin.$assign = "GPIO21";
    
    gpio42.$name           = "AUX_LATCH_HOP";
    gpio42.direction       = "GPIO_DIR_MODE_OUT";
    gpio42.gpioPin.$assign = "GPIO28";
    
    i2c1.$name              = "myI2C0";
    i2c1.i2c.$assign        = "I2CB";
    i2c1.i2c.sdaPin.$assign = "GPIO34";
    i2c1.i2c.sclPin.$assign = "GPIO35";
    
    i2c2.$name              = "myI2C1";
    i2c2.i2c.sdaPin.$assign = "GPIO42";
    i2c2.i2c.sclPin.$assign = "GPIO43";
    
    sci1.$name                    = "mySCI0";
    sci1.baudRates                = 19200;
    sci1.parity                   = "SCI_CONFIG_PAR_EVEN";
    sci1.registerInterrupts       = true;
    sci1.enabledErrorInterrupts   = ["SCI_INT_FE","SCI_INT_OE","SCI_INT_PE","SCI_INT_RXERR"];
    sci1.enabledFIFOInterrupts    = ["SCI_INT_RXFF","SCI_INT_TXFF"];
    sci1.txFifo                   = "SCI_FIFO_TX8";
    sci1.rxFifo                   = "SCI_FIFO_RX1";
    sci1.sci.$assign              = "SCIB";
    sci1.sci.scirxdPin.$assign    = "GPIO71";
    sci1.sci.scitxdPin.$assign    = "GPIO70";
    sci1.sciRXInt.enableInterrupt = true;
    sci1.sciTXInt.enableInterrupt = true;
    
    spi1.$name                  = "mySPI0";
    spi1.bitRate                = 1000000;
    spi1.mode                   = "SPI_MODE_MASTER";
    spi1.useInterrupts          = false;
    spi1.spi.$assign            = "SPIB";
    spi1.spi.spisimoPin.$assign = "GPIO24";
    spi1.spi.spisomiPin.$assign = "GPIO25";
    spi1.spi.spiclkPin.$assign  = "GPIO22";
    spi1.spi.spistePin.$assign  = "GPIO23";
    
    sync.syncOutLock = true;
    
    /**
     * Pinmux solution for unlocked pins/peripherals. This ensures that minor changes to the automatic solver in a future
     * version of the tool will not impact the pinmux you originally saw.  These lines can be completely deleted in order to
     * re-solve from scratch.
     */
    epwm5.epwm.$suggestSolution          = "EPWM1";
    epwm5.epwm.epwmaPin.$suggestSolution = "GPIO0";
    epwm7.epwm.epwmaPin.$suggestSolution = "GPIO2";
    epwm7.epwm.epwmbPin.$suggestSolution = "GPIO3";
    i2c2.i2c.$suggestSolution            = "I2CA";
    

    此致、

    洪瑞安

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    感谢您的回复和耐心等待。 我的主要困惑是您如何在 HRPWM5A 中进行路由的方法、因为我在您发送的旧.syscfg 中没有看到任何使用 CMPIN4P 或模拟输入的实例。 您发送的最新信息提供了更多的背景信息、不过、谢谢。 我 仍想澄清一点:您是否正在使用一个跳线将 HRPWM5A 直接路由到 ADCIN14/CMPIN4P 引脚?  

    我还想问一下您正在尝试开发哪种类型的拓扑? 也许我们可以在这里利用其他相关的参考设计。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。
    您是否使用跳线将 HRPWM5A 直接路由到 ADCIN14/CMPIN4P 引脚?  [/报价]

    是的、我正在使用跳线 将 HRPWM5A 直接路由到 ADCIN14/CMPIN4P 引脚。

    我还想问您要开发哪种拓扑? [/报价]

    它是 降压-升压直流/直流转换器。

    [/quote]
  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    感谢您的澄清。 我仍在致力于 生成此 文件的简化版本、因此需要更多时间查看所有配置以了解这一点、因为与您发送的第一个文件相比、有一些内容发生了变化。 您似乎没有在您最近附加的.syscfg 中使用 HR 设置、是这样吗? 询问、因为我在第一个案例中看到了一些适用于您的 HRPWM 的人力资源实施方案-您用于模拟的 HRPWM 是否仍应包含在内?

    只是为了让你知道我的意图-我正在尝试弄清楚在实现 AQ 更改时为什么你看到大于3 TBCLK 时间。 行动条件判断器模块似乎只能根据 EPWMCLK 采取行动 、这将解释您看到的边沿的16ns 分辨率(16ns 是您的60MHz EPWMCLK 的周期)。 但我还要就此事向其他人征求一些意见。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的 Allison:

    很抱歉、我困惑、因为我几天前就禁用了 HWPWM 来进行一些测试。 请检查下面的最新版本。


    /**
     * These arguments were used when this file was generated. They will be automatically applied on subsequent loads
     * via the GUI or CLI. Run CLI with '--help' for additional information on how to override these arguments.
     * @cliArgs --device "F2807x" --package "F2807x_176PTP" --part "F2807x_176PTP" --product "C2000WARE@4.01.00.00"
     * @versions {"tool":"1.18.0+3266"}
     */
    
    /**
     * Import the modules used in this configuration.
     */
    const adc         = scripting.addModule("/driverlib/adc.js", {}, false);
    const adc1        = adc.addInstance();
    const adc2        = adc.addInstance();
    const adc3        = adc.addInstance();
    const cmpss       = scripting.addModule("/driverlib/cmpss.js", {}, false);
    const cmpss1      = cmpss.addInstance();
    const cmpss2      = cmpss.addInstance();
    const cmpss3      = cmpss.addInstance();
    const cmpss4      = cmpss.addInstance();
    const cputimer    = scripting.addModule("/driverlib/cputimer.js", {}, false);
    const cputimer1   = cputimer.addInstance();
    const epwm        = scripting.addModule("/driverlib/epwm.js");
    const epwm1       = epwm.addInstance();
    const epwm2       = epwm.addInstance();
    const epwm3       = epwm.addInstance();
    const epwm4       = epwm.addInstance();
    const epwm5       = epwm.addInstance();
    const epwm6       = epwm.addInstance();
    const epwm7       = epwm.addInstance();
    const epwmxbar    = scripting.addModule("/driverlib/epwmxbar.js", {}, false);
    const epwmxbar1   = epwmxbar.addInstance();
    const epwmxbar2   = epwmxbar.addInstance();
    const epwmxbar3   = epwmxbar.addInstance();
    const epwmxbar4   = epwmxbar.addInstance();
    const epwmxbar5   = epwmxbar.addInstance();
    const epwmxbar6   = epwmxbar.addInstance();
    const epwmxbar7   = epwmxbar.addInstance();
    const epwmxbar8   = epwmxbar.addInstance();
    const gpio        = scripting.addModule("/driverlib/gpio.js", {}, false);
    const gpio1       = gpio.addInstance();
    const gpio2       = gpio.addInstance();
    const gpio3       = gpio.addInstance();
    const gpio4       = gpio.addInstance();
    const gpio5       = gpio.addInstance();
    const gpio6       = gpio.addInstance();
    const gpio7       = gpio.addInstance();
    const gpio8       = gpio.addInstance();
    const gpio9       = gpio.addInstance();
    const gpio10      = gpio.addInstance();
    const gpio11      = gpio.addInstance();
    const gpio12      = gpio.addInstance();
    const gpio13      = gpio.addInstance();
    const gpio14      = gpio.addInstance();
    const gpio15      = gpio.addInstance();
    const gpio16      = gpio.addInstance();
    const gpio17      = gpio.addInstance();
    const gpio18      = gpio.addInstance();
    const gpio19      = gpio.addInstance();
    const gpio20      = gpio.addInstance();
    const gpio21      = gpio.addInstance();
    const gpio22      = gpio.addInstance();
    const gpio23      = gpio.addInstance();
    const gpio24      = gpio.addInstance();
    const gpio25      = gpio.addInstance();
    const gpio26      = gpio.addInstance();
    const gpio27      = gpio.addInstance();
    const gpio28      = gpio.addInstance();
    const gpio29      = gpio.addInstance();
    const gpio30      = gpio.addInstance();
    const gpio31      = gpio.addInstance();
    const gpio32      = gpio.addInstance();
    const gpio33      = gpio.addInstance();
    const gpio34      = gpio.addInstance();
    const gpio35      = gpio.addInstance();
    const gpio36      = gpio.addInstance();
    const gpio37      = gpio.addInstance();
    const gpio38      = gpio.addInstance();
    const gpio39      = gpio.addInstance();
    const gpio40      = gpio.addInstance();
    const gpio41      = gpio.addInstance();
    const gpio42      = gpio.addInstance();
    const gpio43      = gpio.addInstance();
    const gpio44      = gpio.addInstance();
    const i2c         = scripting.addModule("/driverlib/i2c.js", {}, false);
    const i2c1        = i2c.addInstance();
    const i2c2        = i2c.addInstance();
    const outputxbar  = scripting.addModule("/driverlib/outputxbar.js", {}, false);
    const outputxbar1 = outputxbar.addInstance();
    const outputxbar2 = outputxbar.addInstance();
    const sci         = scripting.addModule("/driverlib/sci.js", {}, false);
    const sci1        = sci.addInstance();
    const sync        = scripting.addModule("/driverlib/sync.js");
    
    /**
     * Write custom configuration values to the imported modules.
     */
    adc1.$name               = "myADC0";
    adc1.soc5Channel         = "ADC_CH_ADCIN3";
    adc1.interruptPulseMode  = "ADC_PULSE_END_OF_CONV";
    adc1.registerInterrupts  = ["1"];
    adc1.useInterrupts       = false;
    adc1.adcClockPrescaler   = "ADC_CLK_DIV_2_0";
    adc1.soc0SampleWindow    = 36;
    adc1.soc1SampleWindow    = 36;
    adc1.soc2SampleWindow    = 36;
    adc1.soc3Channel         = "ADC_CH_ADCIN5";
    adc1.soc3SampleWindow    = 36;
    adc1.soc4Channel         = "ADC_CH_ADCIN2";
    adc1.soc4SampleWindow    = 36;
    adc1.soc5SampleWindow    = 36;
    adc1.soc6Channel         = "ADC_CH_ADCIN4";
    adc1.soc6SampleWindow    = 36;
    adc1.soc7SampleWindow    = 36;
    adc1.soc8SampleWindow    = 36;
    adc1.soc9SampleWindow    = 36;
    adc1.socHighPriorityMode = "ADC_PRI_THRU_SOC7_HIPRI";
    adc1.soc0Channel         = "ADC_CH_ADCIN4";
    adc1.soc0Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc1Channel         = "ADC_CH_ADCIN1";
    adc1.soc1Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc2Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc3Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc4Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc5Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc1.soc6Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc7Channel         = "ADC_CH_ADCIN1";
    adc1.soc7Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc8Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc9Channel         = "ADC_CH_ADCIN5";
    adc1.soc9Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc10Channel        = "ADC_CH_ADCIN2";
    adc1.soc10Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc10SampleWindow   = 36;
    adc1.soc11Channel        = "ADC_CH_ADCIN3";
    adc1.soc11Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc1.soc11SampleWindow   = 36;
    adc1.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER10","ADC_SOC_NUMBER11","ADC_SOC_NUMBER3","ADC_SOC_NUMBER4","ADC_SOC_NUMBER5","ADC_SOC_NUMBER6","ADC_SOC_NUMBER9"];
    
    adc2.$name               = "myADC1";
    adc2.adcBase             = "ADCB_BASE";
    adc2.adcClockPrescaler   = "ADC_CLK_DIV_2_0";
    adc2.soc0SampleWindow    = 36;
    adc2.soc1SampleWindow    = 36;
    adc2.soc2SampleWindow    = 36;
    adc2.soc3SampleWindow    = 36;
    adc2.soc4Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc4SampleWindow    = 36;
    adc2.soc5SampleWindow    = 36;
    adc2.soc6Channel         = "ADC_CH_ADCIN3";
    adc2.soc5Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc6SampleWindow    = 36;
    adc2.socHighPriorityMode = "ADC_PRI_THRU_SOC3_HIPRI";
    adc2.useInterrupts       = false;
    adc2.soc0Channel         = "ADC_CH_ADCIN3";
    adc2.soc1Channel         = "ADC_CH_ADCIN1";
    adc2.soc0Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc1Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc2Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc3Channel         = "ADC_CH_ADCIN2";
    adc2.soc3Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc2.soc4Channel         = "ADC_CH_ADCIN14";
    adc2.soc5Channel         = "ADC_CH_ADCIN15";
    adc2.soc6Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc7Channel         = "ADC_CH_ADCIN1";
    adc2.soc7Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc7SampleWindow    = 36;
    adc2.soc8Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc8SampleWindow    = 36;
    adc2.soc9Channel         = "ADC_CH_ADCIN2";
    adc2.soc9Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc9SampleWindow    = 36;
    adc2.soc10Channel        = "ADC_CH_ADCIN14";
    adc2.soc10Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.soc10SampleWindow   = 36;
    adc2.soc11Channel        = "ADC_CH_ADCIN15";
    adc2.soc11SampleWindow   = 36;
    adc2.soc11Trigger        = "ADC_TRIGGER_EPWM8_SOCA";
    adc2.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER10","ADC_SOC_NUMBER11","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3","ADC_SOC_NUMBER4","ADC_SOC_NUMBER5","ADC_SOC_NUMBER6","ADC_SOC_NUMBER8","ADC_SOC_NUMBER9"];
    
    adc3.$name               = "myADC2";
    adc3.adcBase             = "ADCD_BASE";
    adc3.soc0Channel         = "ADC_CH_ADCIN1";
    adc3.soc0SampleWindow    = 36;
    adc3.soc1SampleWindow    = 36;
    adc3.soc2SampleWindow    = 36;
    adc3.soc3SampleWindow    = 36;
    adc3.soc4SampleWindow    = 36;
    adc3.soc5SampleWindow    = 36;
    adc3.soc6SampleWindow    = 36;
    adc3.soc7SampleWindow    = 36;
    adc3.adcClockPrescaler   = "ADC_CLK_DIV_2_0";
    adc3.soc4Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.useInterrupts       = false;
    adc3.soc0Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc1Channel         = "ADC_CH_ADCIN2";
    adc3.soc1Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc2Channel         = "ADC_CH_ADCIN4";
    adc3.soc2Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc3Channel         = "ADC_CH_ADCIN1";
    adc3.soc3Trigger         = "ADC_TRIGGER_EPWM6_SOCA";
    adc3.soc4Channel         = "ADC_CH_ADCIN3";
    adc3.soc5Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.soc6Channel         = "ADC_CH_ADCIN2";
    adc3.soc6Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.soc7Channel         = "ADC_CH_ADCIN4";
    adc3.soc7Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3","ADC_SOC_NUMBER4","ADC_SOC_NUMBER5","ADC_SOC_NUMBER6","ADC_SOC_NUMBER7","ADC_SOC_NUMBER8","ADC_SOC_NUMBER9"];
    adc3.socHighPriorityMode = "ADC_PRI_THRU_SOC9_HIPRI";
    adc3.soc8Channel         = "ADC_CH_ADCIN1";
    adc3.soc8Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    adc3.soc8SampleWindow    = 36;
    adc3.soc9Channel         = "ADC_CH_ADCIN3";
    adc3.soc9SampleWindow    = 36;
    adc3.soc9Trigger         = "ADC_TRIGGER_EPWM8_SOCA";
    
    cmpss1.$name          = "DCHG_CS1_CMPSS4P";
    cmpss1.cmpssBase      = "CMPSS4_BASE";
    cmpss1.hysteresisVal  = "1";
    cmpss1.dacValLoad     = "CMPSS_DACVAL_PWMSYNC";
    cmpss1.enableModule   = true;
    cmpss1.dacValLow      = 124;
    cmpss1.dacValHigh     = 2019;
    cmpss1.latchResetHigh = true;
    
    cmpss2.$name         = "DCHG_CS2_CMPSS3P";
    cmpss2.cmpssBase     = "CMPSS3_BASE";
    cmpss2.lowCompInvert = true;
    cmpss2.hysteresisVal = "1";
    cmpss2.enableModule  = true;
    cmpss2.dacValLoad    = "CMPSS_DACVAL_PWMSYNC";
    cmpss2.highCTRIP     = "CMPSS_TRIP_SYNC_COMP";
    cmpss2.lowCTRIP      = "CMPSS_TRIP_SYNC_COMP";
    cmpss2.dacValLow     = 124;
    cmpss2.dacValHigh    = 2019;
    
    cmpss3.cmpssBase     = "CMPSS5_BASE";
    cmpss3.$name         = "DCHG_CS3_CMPSS5P";
    cmpss3.lowCompInvert = true;
    cmpss3.hysteresisVal = "1";
    cmpss3.enableModule  = true;
    cmpss3.dacValLoad    = "CMPSS_DACVAL_PWMSYNC";
    cmpss3.highCTRIP     = "CMPSS_TRIP_SYNC_COMP";
    cmpss3.lowCTRIP      = "CMPSS_TRIP_SYNC_COMP";
    cmpss3.dacValLow     = 124;
    cmpss3.dacValHigh    = 2019;
    
    cmpss4.cmpssBase     = "CMPSS6_BASE";
    cmpss4.lowCompInvert = true;
    cmpss4.hysteresisVal = "1";
    cmpss4.enableModule  = true;
    cmpss4.dacValLoad    = "CMPSS_DACVAL_PWMSYNC";
    cmpss4.$name         = "DCHG_CS4_CMPSS6P";
    cmpss4.lowCTRIP      = "CMPSS_TRIP_SYNC_COMP";
    cmpss4.highCTRIP     = "CMPSS_TRIP_SYNC_COMP";
    cmpss4.dacValLow     = 124;
    cmpss4.dacValHigh    = 2019;
    
    cputimer1.$name                    = "myCPUTIMER0";
    cputimer1.enableInterrupt          = true;
    cputimer1.startTimer               = true;
    cputimer1.registerInterrupts       = true;
    cputimer1.timerPeriod              = 120000;
    cputimer1.timerInt.enableInterrupt = true;
    
    epwm1.epwmCounterCompare_cmpC                                         = 181;
    epwm1.epwmCounterCompare_cmpD                                         = 300;
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm1.epwmDeadband_outputSwapOutA                                     = true;
    epwm1.epwmDeadband_outputSwapOutB                                     = true;
    epwm1.epwmDeadband_controlShadowMode                                  = true;
    epwm1.epwmEventTrigger_enableInterrupt                                = true;
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerSource                       = "EPWM_SOC_TBCTR_U_CMPC";
    epwm1.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm1.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm1.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm1.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm1.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm1.epwmDeadband_enableRED                                          = true;
    epwm1.epwmDeadband_enableFED                                          = true;
    epwm1.epwmDeadband_redShadowMode                                      = true;
    epwm1.epwmDeadband_fedShadowMode                                      = true;
    epwm1.$name                                                           = "myEPWM6";
    epwm1.useInterfacePins                                                = ["EPWM#A"];
    epwm1.copyUse                                                         = true;
    epwm1.copyFrom                                                        = "myEPWM7";
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEnable                       = true;
    epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar               = "1";
    epwm1.epwmEventTrigger_interruptSource                                = "EPWM_INT_TBCTR_U_CMPD";
    epwm1.epwmEventTrigger_interruptEventCount                            = "1";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm1.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm1.epwmCounterCompare_cmpB                                         = 599;
    epwm1.epwmDeadband_delayFED                                           = 600;
    epwm1.epwmDeadband_delayRED                                           = 18;
    epwm1.epwmTimebase_period                                             = 599;
    epwm1.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_EDGE";
    epwm1.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_FALLING_EDGE";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_gld                        = true;
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_1_eventSync   = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSync   = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.hrpwm_enable                                                    = true;
    epwm1.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm1.epwmDigitalCompare_EPWM_TZ_DC_OUTPUT_A1                         = "EPWM_TZ_EVENT_DCXH_HIGH";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_1_eventSync   = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSync   = "EPWM_DC_EVENT_INPUT_NOT_SYNCED";
    epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm1.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm1.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm1.epwmDigitalCompare_blankingWindowLength                         = 24;
    epwm1.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm1.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_DISABLE";
    epwm1.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm1.epwmCounterCompare_cmpA                                         = 200;
    epwm1.epwmDigitalCompare_EPWM_TZ_DC_OUTPUT_A2                         = "EPWM_TZ_EVENT_DCXH_HIGH";
    epwm1.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm1.epwm.$assign                                                    = "EPWM6";
    epwm1.epwm.epwmaPin.$assign                                           = "GPIO10";
    epwm1.epwm.epwmbPin.$assign                                           = "GPIO11";
    
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm2.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm2.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm2.useInterfacePins                                                = ["EPWM#A"];
    epwm2.$name                                                           = "myEPWM7";
    epwm2.epwmCounterCompare_cmpC                                         = 181;
    epwm2.epwmDeadband_controlShadowMode                                  = true;
    epwm2.epwmCounterCompare_cmpD                                         = 300;
    epwm2.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm2.epwmDeadband_enableRED                                          = true;
    epwm2.epwmDeadband_enableFED                                          = true;
    epwm2.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm2.epwmDeadband_outputSwapOutB                                     = true;
    epwm2.epwmDeadband_outputSwapOutA                                     = true;
    epwm2.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm2.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm2.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm2.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm2.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm2.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm2.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm2.epwmDeadband_fedShadowMode                                      = true;
    epwm2.epwmDeadband_redShadowMode                                      = true;
    epwm2.copyUse                                                         = true;
    epwm2.copyFrom                                                        = "myEPWM6";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN5";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN5";
    epwm2.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN10";
    epwm2.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN10";
    epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm2.epwmCounterCompare_cmpB                                         = 599;
    epwm2.epwmDeadband_delayFED                                           = 600;
    epwm2.epwmDeadband_delayRED                                           = 18;
    epwm2.epwmTimebase_period                                             = 599;
    epwm2.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_EDGE";
    epwm2.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_FALLING_EDGE";
    epwm2.epwmCounterCompare_cmpALink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm2.epwmCounterCompare_cmpBLink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm2.epwmTimebase_phaseEnable                                        = true;
    epwm2.epwmTimebase_phaseShift                                         = 100;
    epwm2.epwm.$assign                                                    = "EPWM7";
    epwm2.epwm.epwmaPin.$assign                                           = "GPIO12";
    epwm2.epwm.epwmbPin.$assign                                           = "GPIO13";
    
    epwm3.epwmTimebase_emulationMode                               = "EPWM_EMULATION_FREE_RUN";
    epwm3.epwmTimebase_hsClockDiv                                  = "EPWM_HSCLOCK_DIVIDER_1";
    epwm3.epwmTimebase_counterMode                                 = "EPWM_COUNTER_MODE_UP";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode          = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_HIGH";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA = "EPWM_AQ_OUTPUT_LOW";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode          = true;
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_LOW";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA = "EPWM_AQ_OUTPUT_HIGH";
    epwm3.useInterfacePins                                         = ["EPWM#A"];
    epwm3.$name                                                    = "myEPWM11";
    epwm3.copyFrom                                                 = "myEPWM7";
    epwm3.epwmTimebase_period                                      = 2400;
    epwm3.epwmCounterCompare_cmpA                                  = 1200;
    epwm3.useCase                                                  = "CUSTOM";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP      = "EPWM_AQ_OUTPUT_HIGH";
    epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP      = "EPWM_AQ_OUTPUT_LOW";
    epwm3.epwm.$assign                                             = "EPWM11";
    epwm3.epwm.epwmaPin.$assign                                    = "GPIO20";
    
    epwm4.$name                                                           = "myEPWM1";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm4.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm4.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm4.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm4.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm4.epwmCounterCompare_cmpC                                         = 181;
    epwm4.epwmCounterCompare_cmpD                                         = 300;
    epwm4.copyUse                                                         = true;
    epwm4.copyFrom                                                        = "myEPWM6";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm4.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm4.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN9";
    epwm4.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN4";
    epwm4.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm4.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm4.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm4.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm4.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm4.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm4.epwmDeadband_enableRED                                          = true;
    epwm4.epwmDeadband_delayRED                                           = 18;
    epwm4.epwmDeadband_enableFED                                          = true;
    epwm4.epwmDeadband_outputSwapOutA                                     = true;
    epwm4.epwmDeadband_controlShadowMode                                  = true;
    epwm4.epwmDeadband_redShadowMode                                      = true;
    epwm4.epwmDeadband_fedShadowMode                                      = true;
    epwm4.hrpwm_enable                                                    = true;
    epwm4.hrpwm_enableCalculator                                          = true;
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm4.epwmTimebase_period                                             = 599;
    epwm4.useInterfacePins                                                = ["EPWM#A","EPWM#B"];
    epwm4.epwmCounterCompare_cmpA                                         = 300;
    epwm4.hrpwm_DBredHR                                                   = 12;
    epwm4.hrpwm_DBfedHR                                                   = 12;
    epwm4.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_EDGE";
    epwm4.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_FALLING_EDGE";
    epwm4.hrpwm_epwmclk                                                   = 60;
    epwm4.epwmDeadband_deadbandCounterClockRate                           = "EPWM_DB_COUNTER_CLOCK_HALF_CYCLE";
    epwm4.epwmCounterCompare_cmpB                                         = 599;
    epwm4.epwmDeadband_delayFED                                           = 30;
    epwm4.epwmDeadband_outputSwapOutB                                     = true;
    epwm4.epwmDigitalCompare_blankingWindowOffset                         = 57;
    epwm4.epwm.epwmaPin.$assign                                           = "GPIO0";
    epwm4.epwm.epwmbPin.$assign                                           = "GPIO1";
    
    epwm5.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm5.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm5.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm5.epwmTimebase_syncOutPulseMode                                   = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm5.epwmCounterCompare_cmpC                                         = 181;
    epwm5.epwmCounterCompare_cmpD                                         = 300;
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm5.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm5.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm5.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm5.epwmDigitalCompare_useBlankingWindow                            = true;
    epwm5.epwmDigitalCompare_blankingWindowEvent                          = "EPWM_DC_WINDOW_START_TBCTR_ZERO";
    epwm5.epwmDigitalCompare_blankingWindowOffset                         = 576;
    epwm5.epwmDigitalCompare_blankingWindowLength                         = 84;
    epwm5.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm5.epwmDeadband_enableRED                                          = true;
    epwm5.epwmDeadband_enableFED                                          = true;
    epwm5.epwmDeadband_outputSwapOutA                                     = true;
    epwm5.epwmDeadband_outputSwapOutB                                     = true;
    epwm5.epwmDeadband_controlShadowMode                                  = true;
    epwm5.epwmDeadband_redShadowMode                                      = true;
    epwm5.epwmDeadband_fedShadowMode                                      = true;
    epwm5.epwmEventTrigger_enableInterrupt                                = true;
    epwm5.epwmEventTrigger_interruptSource                                = "EPWM_INT_TBCTR_U_CMPD";
    epwm5.epwmEventTrigger_interruptEventCount                            = "1";
    epwm5.epwmEventTrigger_EPWM_SOC_A_triggerEnable                       = true;
    epwm5.epwmEventTrigger_EPWM_SOC_A_triggerSource                       = "EPWM_SOC_TBCTR_U_CMPC";
    epwm5.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar               = "1";
    epwm5.useInterfacePins                                                = ["EPWM#A"];
    epwm5.copyUse                                                         = true;
    epwm5.copyFrom                                                        = "myEPWM6";
    epwm5.$name                                                           = "myEPWM8";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_onetimeSwForceAction       = "EPWM_AQ_OUTPUT_HIGH";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm5.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN7";
    epwm5.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN7";
    epwm5.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm5.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN11";
    epwm5.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN11";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_HIGH";
    epwm5.epwmCounterCompare_cmpALink                                     = "EPWM_LINK_WITH_EPWM_6";
    epwm5.epwmCounterCompare_cmpB                                         = 599;
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPB        = "EPWM_AQ_OUTPUT_HIGH";
    epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB        = "EPWM_AQ_OUTPUT_LOW";
    epwm5.epwmDeadband_delayFED                                           = 600;
    epwm5.epwmDigitalCompare_EPWM_TZ_DC_OUTPUT_A2                         = "EPWM_TZ_EVENT_DCXL_HIGH";
    epwm5.epwmDeadband_delayRED                                           = 18;
    epwm5.epwmTimebase_period                                             = 599;
    epwm5.epwmTimebase_phaseEnable                                        = true;
    epwm5.epwmTimebase_phaseShift                                         = 150;
    epwm5.epwm.$assign                                                    = "EPWM8";
    epwm5.epwm.epwmaPin.$assign                                           = "GPIO14";
    epwm5.epwm.epwmbPin.$assign                                           = "GPIO15";
    
    epwm6.$name                                                    = "myEPWM2";
    epwm6.epwmTimebase_period                                      = 6000;
    epwm6.epwmTimebase_counterMode                                 = "EPWM_COUNTER_MODE_UP";
    epwm6.epwmCounterCompare_cmpA                                  = 3000;
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_HIGH";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA = "EPWM_AQ_OUTPUT_LOW";
    epwm6.epwmTimebase_hsClockDiv                                  = "EPWM_HSCLOCK_DIVIDER_1";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO    = "EPWM_AQ_OUTPUT_HIGH";
    epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB = "EPWM_AQ_OUTPUT_LOW";
    epwm6.epwmTimebase_syncOutPulseMode                            = "EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO";
    epwm6.epwmTimebase_emulationMode                               = "EPWM_EMULATION_FREE_RUN";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                    = "EPWM_TZ_ACTION_LOW";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                    = "EPWM_TZ_ACTION_LOW";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                = "EPWM_TZ_ACTION_DISABLE";
    epwm6.epwmCounterCompare_cmpB                                  = 2349;
    epwm6.epwm.$assign                                             = "EPWM2";
    
    epwm7.$name                                                           = "myEPWM5";
    epwm7.copyUse                                                         = true;
    epwm7.copyFrom                                                        = "myEPWM7";
    epwm7.epwmTimebase_emulationMode                                      = "EPWM_EMULATION_FREE_RUN";
    epwm7.epwmTimebase_hsClockDiv                                         = "EPWM_HSCLOCK_DIVIDER_1";
    epwm7.epwmTimebase_counterMode                                        = "EPWM_COUNTER_MODE_UP";
    epwm7.epwmCounterCompare_cmpB                                         = 599;
    epwm7.epwmCounterCompare_cmpC                                         = 181;
    epwm7.epwmCounterCompare_cmpD                                         = 300;
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_A_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_HIGH";
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA        = "EPWM_AQ_OUTPUT_LOW";
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_LOW";
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_B_shadowMode                 = true;
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_B_usedEvents                 = ["EPWM_AQ_OUTPUT_ON_T1_COUNT_UP"];
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_ZERO           = "EPWM_AQ_OUTPUT_LOW";
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB        = "EPWM_AQ_OUTPUT_LOW";
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_T1_COUNT_UP             = "EPWM_AQ_OUTPUT_HIGH";
    epwm7.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm7.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCAEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm7.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT1                       = "EPWM_TZ_ACTION_DISABLE";
    epwm7.epwmTripZone_EPWM_TZ_ACTION_EVENT_DCBEVT2                       = "EPWM_TZ_ACTION_DISABLE";
    epwm7.epwmTripZone_cbcSource                                          = ["EPWM_TZ_SIGNAL_DCAEVT2"];
    epwm7.epwmDigitalCompare_EPWM_DC_MODULE_A_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm7.epwmDigitalCompare_EPWM_DC_MODULE_B_EPWM_DC_EVENT_2_eventSource = "EPWM_DC_EVENT_SOURCE_FILT_SIGNAL";
    epwm7.epwmDigitalCompare_dcFilterInput                                = "EPWM_DC_WINDOW_SOURCE_DCAEVT2";
    epwm7.epwmDeadband_polarityFED                                        = "EPWM_DB_POLARITY_ACTIVE_LOW";
    epwm7.epwmDeadband_enableFED                                          = true;
    epwm7.epwmDeadband_delayFED                                           = 600;
    epwm7.epwmDeadband_outputSwapOutA                                     = true;
    epwm7.epwmDeadband_outputSwapOutB                                     = true;
    epwm7.epwmDeadband_redShadowMode                                      = true;
    epwm7.epwmDeadband_fedShadowMode                                      = true;
    epwm7.useInterfacePins                                                = ["EPWM#A"];
    epwm7.epwmDigitalCompare_EPWM_DC_TYPE_DCAH                            = "EPWM_DC_TRIP_TRIPIN12";
    epwm7.epwmDigitalCompare_EPWM_DC_TYPE_DCAL                            = "EPWM_DC_TRIP_TRIPIN8";
    epwm7.epwmDigitalCompare_EPWM_DC_TYPE_DCBH                            = "EPWM_DC_TRIP_TRIPIN12";
    epwm7.epwmDigitalCompare_EPWM_DC_TYPE_DCBL                            = "EPWM_DC_TRIP_TRIPIN8";
    epwm7.epwmTimebase_phaseEnable                                        = true;
    epwm7.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode                 = true;
    epwm7.epwmDeadband_enableRED                                          = true;
    epwm7.epwmDeadband_delayRED                                           = 18;
    epwm7.epwmDeadband_controlShadowMode                                  = true;
    epwm7.epwmTimebase_period                                             = 599;
    epwm7.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZA                           = "EPWM_TZ_ACTION_LOW";
    epwm7.epwmTripZone_EPWM_TZ_ACTION_EVENT_TZB                           = "EPWM_TZ_ACTION_LOW";
    epwm7.epwmDigitalCompare_EPWM_TZ_DC_OUTPUT_A1                         = "EPWM_TZ_EVENT_DCXH_HIGH";
    epwm7.hrpwm_enable                                                    = true;
    epwm7.hrpwm_edgeModeA                                                 = "HRPWM_MEP_CTRL_RISING_AND_FALLING_EDGE";
    epwm7.hrpwm_edgeModeB                                                 = "HRPWM_MEP_CTRL_RISING_AND_FALLING_EDGE";
    epwm7.epwmCounterCompare_cmpA                                         = 540;
    epwm7.epwmTimebase_phaseShift                                         = 560;
    epwm7.epwm.$assign                                                    = "EPWM5";
    epwm7.epwm.epwmaPin.$assign                                           = "GPIO8";
    epwm7.epwm.epwmbPin.$assign                                           = "GPIO9";
    
    epwmxbar1.muxesUsed = ["XBAR_MUX07"];
    epwmxbar1.$name     = "DCHG_CS1_CMPSS4L_TRIP4";
    
    epwmxbar2.muxesUsed = ["XBAR_MUX05"];
    epwmxbar2.tripInput = "XBAR_TRIP5";
    epwmxbar2.$name     = "DCHG_CS2_CMPSS3L_TRIP5";
    
    epwmxbar3.muxesUsed = ["XBAR_MUX09"];
    epwmxbar3.tripInput = "XBAR_TRIP7";
    epwmxbar3.$name     = "DCHG_CS3_CMPSS5L_TRIP7";
    
    epwmxbar4.muxesUsed = ["XBAR_MUX11"];
    epwmxbar4.tripInput = "XBAR_TRIP8";
    epwmxbar4.$name     = "DCHG_CS4_CMPSS6L_TRIP8";
    
    epwmxbar5.tripInput = "XBAR_TRIP9";
    epwmxbar5.muxesUsed = ["XBAR_MUX06"];
    epwmxbar5.$name     = "DCHG_CS1_CMPSS4H_TRIP9";
    
    epwmxbar6.tripInput = "XBAR_TRIP10";
    epwmxbar6.$name     = "DCHG_CS2_CMPSS3H_TRIP10";
    epwmxbar6.muxesUsed = ["XBAR_MUX04"];
    
    epwmxbar7.tripInput = "XBAR_TRIP11";
    epwmxbar7.muxesUsed = ["XBAR_MUX08"];
    epwmxbar7.$name     = "DCHG_CS3_CMPSS5H_TRIP11";
    
    epwmxbar8.$name     = "DCHG_CS4_CMPSS6H_TRIP12";
    epwmxbar8.tripInput = "XBAR_TRIP12";
    epwmxbar8.muxesUsed = ["XBAR_MUX10"];
    
    gpio1.direction       = "GPIO_DIR_MODE_OUT";
    gpio1.$name           = "tFLASH_SPI_EN";
    gpio1.gpioPin.$assign = "GPIO99";
    
    gpio2.direction       = "GPIO_DIR_MODE_OUT";
    gpio2.$name           = "CFET_HOP";
    gpio2.gpioPin.$assign = "GPIO26";
    
    gpio3.direction       = "GPIO_DIR_MODE_OUT";
    gpio3.$name           = "DFET_HOP";
    gpio3.gpioPin.$assign = "GPIO27";
    
    gpio4.$name           = "MCU_SELF_TEST";
    gpio4.gpioPin.$assign = "GPIO30";
    
    gpio5.$name           = "FAN_PWR_LATCH";
    gpio5.gpioPin.$assign = "GPIO29";
    
    gpio6.$name           = "tAFE_ALARM1";
    gpio6.gpioPin.$assign = "GPIO31";
    
    gpio7.$name           = "tVPC_Check";
    gpio7.gpioPin.$assign = "GPIO32";
    
    gpio8.direction       = "GPIO_DIR_MODE_OUT";
    gpio8.$name           = "EE_WP";
    gpio8.gpioPin.$assign = "GPIO33";
    
    gpio9.$name           = "t2nd_DET";
    gpio9.gpioPin.$assign = "GPIO37";
    
    gpio10.$name           = "tCFuse_DET";
    gpio10.gpioPin.$assign = "GPIO38";
    
    gpio11.direction       = "GPIO_DIR_MODE_OUT";
    gpio11.$name           = "tFuse_Check_BATT";
    gpio11.gpioPin.$assign = "GPIO39";
    
    gpio12.$name           = "AFE_SHDN";
    gpio12.direction       = "GPIO_DIR_MODE_OUT";
    gpio12.gpioPin.$assign = "GPIO41";
    
    gpio13.$name           = "VPC_SW";
    gpio13.direction       = "GPIO_DIR_MODE_OUT";
    gpio13.gpioPin.$assign = "GPIO49";
    
    gpio14.$name           = "tPOR_LED";
    gpio14.direction       = "GPIO_DIR_MODE_OUT";
    gpio14.gpioPin.$assign = "GPIO50";
    
    gpio15.$name           = "TH_SW";
    gpio15.direction       = "GPIO_DIR_MODE_OUT";
    gpio15.gpioPin.$assign = "GPIO51";
    
    gpio16.$name           = "PF_FUSE";
    gpio16.direction       = "GPIO_DIR_MODE_OUT";
    gpio16.gpioPin.$assign = "GPIO53";
    
    gpio17.$name           = "FUSE_DET_BUS";
    gpio17.gpioPin.$assign = "GPIO54";
    
    gpio18.$name           = "Protect_HIP";
    gpio18.gpioPin.$assign = "GPIO55";
    
    gpio19.$name           = "BMS_OVP_HIP";
    gpio19.gpioPin.$assign = "GPIO56";
    
    gpio20.$name           = "BMS_UVP_HIP";
    gpio20.gpioPin.$assign = "GPIO57";
    
    gpio21.$name           = "BMS_OCP_HIP";
    gpio21.gpioPin.$assign = "GPIO58";
    
    gpio22.$name           = "BMS_SCP_HIP";
    gpio22.gpioPin.$assign = "GPIO59";
    
    gpio23.$name           = "BUS_OVP_HIP";
    gpio23.gpioPin.$assign = "GPIO60";
    
    gpio24.$name           = "BUS_UVP_HIP";
    gpio24.gpioPin.$assign = "GPIO61";
    
    gpio25.$name           = "BUS_OCP_HIP";
    gpio25.gpioPin.$assign = "GPIO64";
    
    gpio26.$name           = "BUS_SCP_HIP";
    gpio26.gpioPin.$assign = "GPIO65";
    
    gpio27.direction       = "GPIO_DIR_MODE_OUT";
    gpio27.$name           = "UNLOCK_UVP_HOP";
    gpio27.gpioPin.$assign = "GPIO66";
    
    gpio28.$name           = "UNLOCK_SYS_HOP";
    gpio28.direction       = "GPIO_DIR_MODE_OUT";
    gpio28.gpioPin.$assign = "GPIO44";
    
    gpio29.$name             = "PWM_EN_LOP";
    gpio29.direction         = "GPIO_DIR_MODE_OUT";
    gpio29.writeInitialValue = true;
    gpio29.initialValue      = 1;
    gpio29.gpioPin.$assign   = "GPIO45";
    
    gpio30.direction       = "GPIO_DIR_MODE_OUT";
    gpio30.$name           = "SYS_DCDC_EN";
    gpio30.gpioPin.$assign = "GPIO133";
    
    gpio31.$name           = "tRTC_INT";
    gpio31.gpioPin.$assign = "GPIO46";
    
    gpio32.$name           = "MCU_Boot_1_Reserved";
    gpio32.gpioPin.$assign = "GPIO72";
    
    gpio33.$name           = "tShortpin_DET";
    gpio33.gpioPin.$assign = "GPIO80";
    
    gpio34.$name           = "MCU_Boot_0_Reserved";
    gpio34.gpioPin.$assign = "GPIO84";
    
    gpio35.direction       = "GPIO_DIR_MODE_OUT";
    gpio35.$name           = "BKPWM_EN_HOP";
    gpio35.masterCore      = "GPIO_CORE_CPU1_CLA1";
    gpio35.gpioPin.$assign = "GPIO85";
    
    gpio36.direction         = "GPIO_DIR_MODE_OUT";
    gpio36.writeInitialValue = true;
    gpio36.masterCore        = "GPIO_CORE_CPU1_CLA1";
    gpio36.$name             = "C2000_Update_Ready";
    gpio36.gpioPin.$assign   = "GPIO88";
    
    gpio37.direction       = "GPIO_DIR_MODE_OUT";
    gpio37.$name           = "C2000_PRE";
    gpio37.gpioPin.$assign = "GPIO89";
    
    gpio38.direction       = "GPIO_DIR_MODE_OUT";
    gpio38.$name           = "C2000_SW";
    gpio38.gpioPin.$assign = "GPIO90";
    
    gpio39.$name             = "PRE_CHG_HOP";
    gpio39.direction         = "GPIO_DIR_MODE_OUT";
    gpio39.writeInitialValue = true;
    gpio39.gpioPin.$assign   = "GPIO21";
    
    gpio40.$name           = "AUX_LATCH_HOP";
    gpio40.direction       = "GPIO_DIR_MODE_OUT";
    gpio40.gpioPin.$assign = "GPIO28";
    
    gpio41.$name           = "IDLE_or_RUN";
    gpio41.gpioPin.$assign = "GPIO7";
    
    gpio42.$name           = "Buck_or_Boost";
    gpio42.gpioPin.$assign = "GPIO92";
    
    gpio43.direction       = "GPIO_DIR_MODE_OUT";
    gpio43.$name           = "debug_pin";
    gpio43.gpioPin.$assign = "GPIO93";
    
    gpio44.$name           = "debug_pin_164";
    gpio44.direction       = "GPIO_DIR_MODE_OUT";
    gpio44.masterCore      = "GPIO_CORE_CPU1_CLA1";
    gpio44.gpioPin.$assign = "GPIO4";
    
    i2c1.$name              = "myI2C0";
    i2c1.i2c.$assign        = "I2CB";
    i2c1.i2c.sdaPin.$assign = "GPIO34";
    i2c1.i2c.sclPin.$assign = "GPIO35";
    
    i2c2.$name              = "myI2C1";
    i2c2.i2c.sdaPin.$assign = "GPIO42";
    i2c2.i2c.sclPin.$assign = "GPIO43";
    
    outputxbar1.$name                            = "myOUTPUTXBAR0";
    outputxbar1.muxesUsed                        = ["XBAR_MUX06"];
    outputxbar1.outputxbar.$assign               = "OUTPUTXBAR1";
    outputxbar1.outputxbar.outputxbarPin.$assign = "GPIO24";
    
    outputxbar2.$name                            = "myOUTPUTXBAR1";
    outputxbar2.muxesUsed                        = ["XBAR_MUX07"];
    outputxbar2.outputxbar.$assign               = "OUTPUTXBAR2";
    outputxbar2.outputxbar.outputxbarPin.$assign = "GPIO25";
    
    sci1.$name                    = "mySCI0";
    sci1.baudRates                = 19200;
    sci1.parity                   = "SCI_CONFIG_PAR_EVEN";
    sci1.registerInterrupts       = true;
    sci1.enabledErrorInterrupts   = ["SCI_INT_FE","SCI_INT_OE","SCI_INT_PE","SCI_INT_RXERR"];
    sci1.enabledFIFOInterrupts    = ["SCI_INT_RXFF","SCI_INT_TXFF"];
    sci1.txFifo                   = "SCI_FIFO_TX8";
    sci1.rxFifo                   = "SCI_FIFO_RX1";
    sci1.sci.$assign              = "SCIB";
    sci1.sci.scirxdPin.$assign    = "GPIO71";
    sci1.sci.scitxdPin.$assign    = "GPIO70";
    sci1.sciRXInt.enableInterrupt = true;
    sci1.sciTXInt.enableInterrupt = true;
    
    sync.syncOutLock       = true;
    sync.epwm7SyncInSource = "SYSCTL_SYNC_IN_SRC_EPWM4SYNCOUT";
    
    /**
     * Pinmux solution for unlocked pins/peripherals. This ensures that minor changes to the automatic solver in a future
     * version of the tool will not impact the pinmux you originally saw.  These lines can be completely deleted in order to
     * re-solve from scratch.
     */
    epwm4.epwm.$suggestSolution          = "EPWM1";
    epwm6.epwm.epwmaPin.$suggestSolution = "GPIO2";
    epwm6.epwm.epwmbPin.$suggestSolution = "GPIO3";
    i2c2.i2c.$suggestSolution            = "I2CA";
    

    此致、

    洪瑞安

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、不需要担心、感谢您额外提供了新的 SysConfig。 您能否确认、在该.syscfg 中您查看的是"myEPWM6"的行为、而您尝试用于行程的 HRPWM 是"myEPWM1"。 那个文件中有7个 ePWM 实例、并且名称一直在变化、所以我要确定我在查看与这个线程相关的2个实例。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的 Allison:

    1. myEPWM6是指 PWM6 (GPIO10和11)、这是我几天前分享的波形。

    2、T1事件来自 HRPWM5 A (myEPWM5 , GPIO8  ) → CMPIN4P →CTRIPH(ASYNC )→X-BAR→ TRIPIN9 →ePWM DC 模块→DCAEVT1。

    此致、

    洪瑞安  

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    HRPWM5 A (myEPWM5,GPIO8  )

    可能它是以某种方式重命名的、因为在您发送的最后一个.syscfg 中没有"myEPWM5"、因此那里有点混乱。

    我们还更新了到目前为止工作的内容:我们的程序有2个 EPWM (EPWM1和 EPWM2)、可表示您的2个 PWM 信号。  我们已移除了其他模块、因为这些模块在这里不是必需的、并且具有任何额外的 ePWM 设置。 由此、我们一直在测试能否获得您需要的4ns 分辨率、但到目前为止却无法实现。 目前来看、这似乎是 动作限定器模块的逻辑限制。

    我们的 EPWM2具有 HR 功能、用作 EPWM1的 T1。 我们可以看到 EPWM2上的细微边沿调整、但 EPWM1只能以更大的分辨率进行响应。 我们需要做更多测试来了解跳转为何如此之大、但 我们明天还要尝试的另一个步骤是在 EPWM1上实施 HR 功能、以查看这是否允许根据 EPWM2的变化进行更精细的边沿调整。 请注意、最简单的情况是、现在我们只是使用 CMPAHR 来调整 EPWM2的边沿。  

    同时、您能否告诉我们您设置了哪些分频器来获得60MHz EPWMCLK、以及您是否还有任何其他结果? 我明天将向您提供两个使用 HRPWM 功能的 EPWM 的最新成果。 再次感谢您的耐心等待。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、  

    更新内容、我们仍在对两种 HR 配置进行测试。 我们目前的设置中出现了一些额外的延迟、因此我们仍在研究如何降低延迟。 (至于我之前问的 EPWMCLK 问题、我将假设您从 SYSCLK 120MHz 中采用通常为2的分频器来获得60MHz)。  在我们能够从 HRx2设置收集结果之后、我将再次提供更新。

    此致、

    艾里森

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    尊敬的  Allison:

     

    请检查 下面的 EPWMCLK 设置。

    此致、

    洪瑞安

     

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您好、Ryan、

    我在这里收集了一些其他专业知识的输入、但遗憾的是、ePWM AQ 模块无法支持比 EPWMCLK 周期更精细的粒度(HR 级别)。 动作限定符子模块中有一个逻辑 需要计时、因此动作必须相应发生。 跳闸区域 是实现您正在尝试执行的操作的最佳方法、但我知道这与您需要将两个通道驱动为低电平的其他跳闸相冲突。

    我意识到这是您的应用的一个很大限制、因此我还要借此机会询问您是否能够更加具体地解释为什么需要用这个特定的用例驱动 EPWMA/B 高和低、从而对具有如此高分辨率的外部信号做出反应 (我知道您之前解释了一些上下文、但我想更好地了解系统的重要性)。 我之所以提出 这个问题、是因为如果这里有足够大的需求、我们总有可能尝试在未来的设计中添加这一特性。  

    再次感谢您的耐心和愿意完成这项工作。 如果您对 SysConfig 中 EPWM/HRPWM 模块的可用性还有任何其他反馈、敬请告知-我们将始终在努力提高其易用性。

    此致、

    艾里森