[参考译文] LAUNCHXL-F28379D：通过来自栅极驱动器(UCC21710)和 PWM 脉冲序列的 eCAP 模块测量直流总线

admin

Guru**** 2381930 points

Other Parts Discussed in Thread: UCC21710, C2000WARE, SYSCONFIG

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

https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1173156/launchxl-f28379d-measure-dc-bus-via-the-ecap-module-from-gate-driver-ucc21710-pwm-pulse-train

器件型号：LAUNCHXL-F28379D
主题中讨论的其他器件：UCC21710、 C2000WARE、 SysConfig

您好！

我们想使用来自 UCC21710生成的 PWM 脉冲序列的 eCAP 模块测量直流总线。我们需要对 eCAP 模块进行一些澄清。

首先、eCAP 能否测量400kHz PWM 脉冲序列的占空比？我问这个问题、因为查看 c2000ware 中的示例项目、我发现它正在测量几 kHz 的 PWM 脉冲序列。

我们尝试模拟同一个示例，但在较高的频率下，但随着我们增加 PWM 频率，占空比计算不断恶化。变量衍生 DT 是根据 eCAP 模块计算得出的结果。

__interrupt void INT_myECAP0_ISR(void)
{
    ecap_counter++;
    cap1_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_1);    //1st raising edge
    cap2_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_2);    //1st falling edge
    cap3_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_3);    //2nd raising edge
    cap4_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_4);    //2nd falling edge
    derivedDT = (float)(cap2_count-cap1_count)/(cap3_count-cap1_count);
    ECAP_reArm(myECAP0_BASE);
    ECAP_clearGlobalInterrupt(myECAP0_BASE);
    ECAP_clearInterrupt(myECAP0_BASE, ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP4);

}

在10kHz 时：

100kHz 时的频率

500kHz 时：

2 年多前

0 admin 2 年多前

TI__Guru**** 2381930 points

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

您好、AK、

我将看到我能否再现您看到的内容、并在明天一天结束后尽快回复您！

谢谢、

Ryan Ma

0 admin 2 年多前

TI__Guru**** 2381930 points

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

您好、AK、

我无法再现您在更高频率 PWM 下获得的占空比差异。

这是随附的用于我的设置的代码。我将其基于 C2000Ware 中 ECAP 示例2的内容。

这里还有一个屏幕截图、展示了我在500kHz 时获得的推导占空比。

//#############################################################################
//
// FILE:    ecap_capture_pwm.c
//
// TITLE:   Capture ePWM3.
//
//! \addtogroup driver_example_list
//! <h1>eCAP Capture PWM Example</h1>
//!
//! This example configures ePWM3A for:
//! - Up count mode
//! - Period starts at 500 and goes up to 8000
//! - Toggle output on PRD
//!
//! eCAP1 is configured to capture the time between rising
//! and falling edge of the ePWM3A output.
//!
//! \b External \b Connections \n
//! - eCAP1 is on GPIO16
//! - ePWM3A is on GPIO4
//! - Connect GPIO4 to GPIO16.
//!
//! \b Watch \b Variables \n
//! - \b ecap1PassCount - Successful captures.
//! - \b ecap1IntCount - Interrupt counts.
//
//#############################################################################
//
// $Release Date: $
// $Copyright:
// Copyright (C) 2013-2022 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without 
// modification, are permitted provided that the following conditions 
// are met:
// 
//   Redistributions of source code must retain the above copyright 
//   notice, this list of conditions and the following disclaimer.
// 
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the 
//   documentation and/or other materials provided with the   
//   distribution.
// 
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################

//
// Included Files
//
#include "driverlib.h"
#include "device.h"

//
// Defines
//
#define PWM3_TIMER_MIN     100U
#define PWM3_TIMER_MAX     8000U
#define EPWM_TIMER_UP      1U
#define EPWM_TIMER_DOWN    0U

//
// Globals
//
uint32_t ecap1IntCount;
uint32_t ecap1PassCount;
uint32_t epwm3TimerDirection;
volatile uint16_t cap1Count;
volatile uint16_t cap2Count;
volatile uint16_t cap3Count;
volatile uint16_t cap4Count;
volatile uint16_t epwm3PeriodCount;
float derivedDT;
//
// Function Prototypes
//
void error(void);
void initECAP(void);
void initEPWM(void);
__interrupt void ecap1ISR(void);

//
// Main
//
void main(void)
{
    //
    // Initialize device clock and peripherals
    //
    Device_init();

    //
    // Disable pin locks and enable internal pullups.
    //
    Device_initGPIO();

    //
    // Initialize PIE and clear PIE registers. Disables CPU interrupts.
    //
    Interrupt_initModule();

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    //
    Interrupt_initVectorTable();

    //
    // Configure GPIO4/5 as ePWM3A/3B
    //
    GPIO_setPadConfig(4, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_4_EPWM3A);
    GPIO_setPadConfig(5, GPIO_PIN_TYPE_STD);
    GPIO_setPinConfig(GPIO_5_EPWM3B);

    //
    // Configure GPIO 16 as eCAP input
    //
    XBAR_setInputPin(XBAR_INPUT7, 16);
    GPIO_setPinConfig(GPIO_16_GPIO16);
    GPIO_setDirectionMode(16, GPIO_DIR_MODE_IN);
    GPIO_setQualificationMode(16, GPIO_QUAL_ASYNC);

    //
    // Interrupts that are used in this example are re-mapped to ISR functions
    // found within this file.
    //
    Interrupt_register(INT_ECAP1, &ecap1ISR);

    //
    // Configure ePWM and eCAP
    //
    initEPWM();
    initECAP();

    //
    // Initialize counters:
    //
    cap2Count = 0U;
    cap3Count = 0U;
    cap4Count = 0U;
    ecap1IntCount = 0U;
    ecap1PassCount = 0U;
    epwm3PeriodCount = 0U;

    //
    // Enable interrupts required for this example
    //
    Interrupt_enable(INT_ECAP1);

    //
    // Enable Global Interrupt (INTM) and Real time interrupt (DBGM)
    //
    EINT;
    ERTM;

    //
    // Loop forever. Suspend or place breakpoints to observe the buffers.
    //
    for(;;)
    {
       NOP;
    }
}

//
// initEPWM - Configure ePWM
//
void initEPWM()
{
    //
    // Disable sync(Freeze clock to PWM as well)
    //
    SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);

    //
    // Configure ePWM
    //       Counter runs in up-count mode.
    //       Action qualifier will toggle output on period match
    //
    EPWM_setTimeBaseCounterMode(EPWM3_BASE, EPWM_COUNTER_MODE_UP);
    EPWM_setTimeBasePeriod(EPWM3_BASE, PWM3_TIMER_MIN);
    EPWM_setPhaseShift(EPWM3_BASE, 0U);
    EPWM_setCounterCompareShadowLoadMode(EPWM3_BASE,
                                         EPWM_COUNTER_COMPARE_A,
                                         EPWM_COMP_LOAD_ON_CNTR_ZERO);

    EPWM_setCounterCompareValue(EPWM3_BASE, EPWM_COUNTER_COMPARE_A,
                                PWM3_TIMER_MIN >> 1);
    EPWM_setActionQualifierAction(EPWM3_BASE,
                                  EPWM_AQ_OUTPUT_A,
                                  EPWM_AQ_OUTPUT_HIGH,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_ZERO);
    EPWM_setActionQualifierAction(EPWM3_BASE,
                                  EPWM_AQ_OUTPUT_A,
                                  EPWM_AQ_OUTPUT_LOW,
                                  EPWM_AQ_OUTPUT_ON_TIMEBASE_UP_CMPA);
    EPWM_setClockPrescaler(EPWM3_BASE,
                           EPWM_CLOCK_DIVIDER_1,
                           EPWM_HSCLOCK_DIVIDER_2);

    epwm3TimerDirection = EPWM_TIMER_UP;

    //
    // Enable sync and clock to PWM
    //
    SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
}

//
// initECAP - Configure eCAP
//
void initECAP()
{
    //
    // Disable ,clear all capture flags and interrupts
    //
    ECAP_disableInterrupt(ECAP1_BASE,
                          (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                           ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                           ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                           ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                           ECAP_ISR_SOURCE_COUNTER_COMPARE));
    ECAP_clearInterrupt(ECAP1_BASE,
                        (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                         ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                         ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                         ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                         ECAP_ISR_SOURCE_COUNTER_COMPARE));

    //
    // Disable CAP1-CAP4 register loads
    //
    ECAP_disableTimeStampCapture(ECAP1_BASE);

    //
    // Configure eCAP
    //    Enable capture mode.
    //    One shot mode, stop capture at event 4.
    //    Set polarity of the events to rising, falling, rising, falling edge.
    //    Set capture in time difference mode.
    //    Select input from XBAR7.
    //    Enable eCAP module.
    //    Enable interrupt.
    //
    ECAP_stopCounter(ECAP1_BASE);
    ECAP_enableCaptureMode(ECAP1_BASE);

    ECAP_setCaptureMode(ECAP1_BASE, ECAP_ONE_SHOT_CAPTURE_MODE, ECAP_EVENT_4);

    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_1, ECAP_EVNT_RISING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_2, ECAP_EVNT_FALLING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_3, ECAP_EVNT_RISING_EDGE);
    ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_4, ECAP_EVNT_FALLING_EDGE);

    ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_4);

    XBAR_setInputPin(XBAR_INPUT7, 16);

    ECAP_enableLoadCounter(ECAP1_BASE);
    ECAP_setSyncOutMode(ECAP1_BASE, ECAP_SYNC_OUT_SYNCI);
    ECAP_startCounter(ECAP1_BASE);
    ECAP_enableTimeStampCapture(ECAP1_BASE);
    ECAP_reArm(ECAP1_BASE);

    ECAP_enableInterrupt(ECAP1_BASE, ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
}

//
// eCAP 1 ISR
//
__interrupt void ecap1ISR(void)
{
    //
    // Get the capture counts. Each capture should be 4x the ePWM count
    // because of the ePWM clock dividers.
    //
    uint32_t tb_ctr_ecap = ECAP_getTimeBaseCounter(ECAP1_BASE);
    cap1Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_1);    //1st raising edge
    cap2Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_2);    //1st falling edge
    cap3Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_3);    //2nd raising edge
    cap4Count = ECAP_getEventTimeStamp(ECAP1_BASE, ECAP_EVENT_4);    //2nd falling edge
    derivedDT = (float)(cap2Count-cap1Count)/(cap3Count-cap1Count);

    //
    // Compare the period value with the captured count
    //
    epwm3PeriodCount = EPWM_getTimeBasePeriod(EPWM3_BASE);

    ecap1IntCount++;

    //
    // Keep track of the ePWM direction and adjust period accordingly to
    // generate a variable frequency PWM.
    //

    //
    // Count correct captures
    //
    ecap1PassCount++;

    //
    // Clear interrupt flags for more interrupts.
    //
    ECAP_clearInterrupt(ECAP1_BASE,ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
    ECAP_clearGlobalInterrupt(ECAP1_BASE);

    //
    // Start eCAP
    //
    ECAP_reArm(ECAP1_BASE);

    //
    // Acknowledge the group interrupt for more interrupts.
    //
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP4);
}

//
// error - Error function
//
void error()
{
    ESTOP0;
}

如果您仍遇到任何问题、请告诉我！

最棒的

Ryan Ma

0 admin 2 年多前

TI__Guru**** 2381930 points

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

您好、Ryan、

你是否尝试在飞行中改变占空比，对我来说，它一直在波动。

如果没有太多问题、请尝试以下设置并检查：

PWM 生成基于 C2000WARE 中位于(\C2000Ware_4_01_00_00\driverlib\f2837xd\examples\cpu1\ePWM)的示例"ePWM_ex11_configure_signal"。

可以动态更改结构"pwmSignal"、我将 GPIO0和 GPIO61连接在一起、GPIO0生成 PWM (使用 PWM1A)、并将 GPIO61配置为 eCAP。只需在 main 中调用 ePWM_configureSignal (base、&pwmSignal)即可更新 PWM 值。

/*
 * ecap_test.c
 *
 *  Created on: 18-Nov-2022
 *      Author: AK
 *
 *  Connect GPIO0 to GPIO 61
 */
#include "ecap_test.h"

uint32_t pwm_counter = 0;
uint32_t ecap_counter = 0;
uint32_t cap1_count = 0;
uint32_t cap2_count = 0;
uint32_t cap3_count = 0;
uint32_t cap4_count = 0;

float32_t derivedDT = 0.0;

EPWM_SignalParams pwmSignal = {
                               50000,                       //!< Desired Signal Frequency(in Hz)
                               0.5f,                        //!< Desired ePWMxA Signal Duty
                               0.5f,                        //!< Desired ePWMxB Signal Duty
                               true,                        //!< Invert ePWMxB Signal if true
                               DEVICE_SYSCLK_FREQ,          //!< SYSCLK Frequency(in Hz)
                               SYSCTL_EPWMCLK_DIV_2,        //!< EPWM Clock Divider
                               EPWM_COUNTER_MODE_UP_DOWN,   //!< Time Base Counter Mode
                               EPWM_CLOCK_DIVIDER_1,        //!< Time Base Counter Clock Divider
                               EPWM_HSCLOCK_DIVIDER_1       //!< Time Base Counter HS Clock Divider
};
//__interrupt void pwmISR(void)
//{
//    pwm_counter++;
//    EPWM_clearEventTriggerInterruptFlag(EPWM1_BASE);
//    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP3);
//}
__interrupt void INT_myECAP0_ISR(void)
{
    ecap_counter++;
    cap1_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_1);    //1st raising edge
    cap2_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_2);    //1st falling edge
    cap3_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_3);    //2nd raising edge
    cap4_count = ECAP_getEventTimeStamp(myECAP0_BASE, ECAP_EVENT_4);    //2nd falling edge
    derivedDT = (float)(cap2_count-cap1_count)/(cap3_count-cap1_count);
    ECAP_reArm(myECAP0_BASE);
    ECAP_clearGlobalInterrupt(myECAP0_BASE);
    ECAP_clearInterrupt(myECAP0_BASE, ECAP_ISR_SOURCE_CAPTURE_EVENT_4);
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP4);

}

void HAL_setupECAP()
{
    // GPIO61->ECAP1
    GPIO_setMasterCore(61, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_61_GPIO61);
    GPIO_setPadConfig(61, GPIO_PIN_TYPE_PULLUP);
    GPIO_setQualificationMode(61, GPIO_QUAL_ASYNC);
}

void pwm_init(uint32_t base)
{
    // GPIO0->EPWM1A->UH_M1
    GPIO_setMasterCore(0, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_0_EPWM1A);
    GPIO_setPadConfig(0, GPIO_PIN_TYPE_STD);

    // GPIO1->EPWM1B->UL_M1
    GPIO_setMasterCore(1, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_1_EPWM1B);
    GPIO_setPadConfig(1, GPIO_PIN_TYPE_STD);

    EPWM_configureSignal(base, &pwmSignal);
    EPWM_setSyncOutPulseMode(base, EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
    SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
    //Interrupt_enable(INT_EPWM1);
}
void pwm_update_duty(uint32_t base)
{
    switch (rec_data)
    {
    case 232:   //up arrow
    {
        pwmSignal.dutyValA += 0.05f;
        pwmSignal.dutyValB += 0.05f;
        rec_data = 0;
    }
        break;
    case 244:   //down arrow
    {
        pwmSignal.dutyValA -= 0.05f;
        pwmSignal.dutyValB -= 0.05f;
        rec_data = 0;
    }
        break;
    default:
        break;
    }
    if (pwmSignal.dutyValA > 1.0f)
    {
        pwmSignal.dutyValA = 0.99f;
    }
    else if (pwmSignal.dutyValA < 0)
    {
        pwmSignal.dutyValA = 0;
    }
    if (pwmSignal.dutyValB > 1.0f)
    {
        pwmSignal.dutyValB = 0.99f;
    }
    else if (pwmSignal.dutyValB < 0)
    {
        pwmSignal.dutyValB = 0;
    }

    EPWM_configureSignal(base, &pwmSignal);
}

//void HAL_setupMotorPWMs()
//{
//    float32_t switchingFreqKHz = 100.0;
//    uint16_t halfPeriod = 0;
//    EALLOW;
//    // GPIO0->EPWM1A->UH_M1
//    GPIO_setMasterCore(0, GPIO_CORE_CPU1);
//    GPIO_setPinConfig(GPIO_0_EPWM1A);
//    GPIO_setPadConfig(0, GPIO_PIN_TYPE_STD);
//
//    // GPIO1->EPWM1B->UL_M1
//    GPIO_setMasterCore(1, GPIO_CORE_CPU1);
//    GPIO_setPinConfig(GPIO_1_EPWM1B);
//    GPIO_setPadConfig(1, GPIO_PIN_TYPE_STD);
//
//    SysCtl_disablePeripheral(SYSCTL_PERIPH_CLK_TBCLKSYNC);
//
//    // Time Base SubModule Registers
//    // set Immediate load
//    EPWM_setPeriodLoadMode(EPWM1_BASE, EPWM_PERIOD_DIRECT_LOAD);
//    EPWM_setTimeBasePeriod(EPWM1_BASE, 0);
//    EPWM_setPhaseShift(EPWM1_BASE, 0);
//    EPWM_setTimeBaseCounter(EPWM1_BASE, 0);
//    EPWM_setTimeBaseCounterMode(EPWM1_BASE, EPWM_COUNTER_MODE_UP_DOWN);
//
//    EPWM_setClockPrescaler(EPWM1_BASE, EPWM_CLOCK_DIVIDER_1,
//                           EPWM_HSCLOCK_DIVIDER_1);
//
//    // Counter Compare Submodule Registers
//    // set duty 0% initially
//    EPWM_setCounterCompareValue(EPWM1_BASE, EPWM_COUNTER_COMPARE_A, 0);
//    EPWM_setCounterCompareShadowLoadMode(EPWM1_BASE, EPWM_COUNTER_COMPARE_A,
//                                         EPWM_COMP_LOAD_ON_CNTR_ZERO);
//
//    // Action Qualifier SubModule Registers
//    EPWM_setActionQualifierActionComplete(
//            EPWM1_BASE,
//            EPWM_AQ_OUTPUT_A,
//            (EPWM_ActionQualifierEventAction) (EPWM_AQ_OUTPUT_LOW_UP_CMPA
//                    | EPWM_AQ_OUTPUT_HIGH_DOWN_CMPA));
//
//    // Active high complementary PWMs - Set up the deadband
//    EPWM_setRisingEdgeDeadBandDelayInput(EPWM1_BASE, EPWM_DB_INPUT_EPWMA);
//    EPWM_setFallingEdgeDeadBandDelayInput(EPWM1_BASE, EPWM_DB_INPUT_EPWMA);
//
//    EPWM_setDeadBandDelayMode(EPWM1_BASE, EPWM_DB_RED, true);
//    EPWM_setDeadBandDelayMode(EPWM1_BASE, EPWM_DB_FED, true);
//    EPWM_setDeadBandDelayPolarity(EPWM1_BASE, EPWM_DB_RED,
//                                  EPWM_DB_POLARITY_ACTIVE_HIGH);
//    EPWM_setDeadBandDelayPolarity(EPWM1_BASE, EPWM_DB_FED,
//                                  EPWM_DB_POLARITY_ACTIVE_LOW);
//    /*
//     * INFO: PWM Dead Time
//     * Change this to change the pwm dead time.
//     */
//    EPWM_setRisingEdgeDelayCount(EPWM1_BASE, 50);
//    EPWM_setFallingEdgeDelayCount(EPWM1_BASE, 50);
//
//    EPWM_enablePhaseShiftLoad(EPWM1_BASE);
//
//    EPWM_setCountModeAfterSync(EPWM1_BASE, EPWM_COUNT_MODE_UP_AFTER_SYNC);
//    // configure sync
//    EPWM_setSyncOutPulseMode(EPWM1_BASE, EPWM_SYNC_OUT_PULSE_ON_EPWMxSYNCIN);
//
//    //EPWM1->EWPM4
//    SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM4,
//                              SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
//
/////-----------------------///
//        halfPeriod = ((((DEVICE_SYSCLK_FREQ / 1000000U)/2.0)/switchingFreqKHz)*1000) / 2;     // 100MHz EPWMCLK
//        EPWM_disablePhaseShiftLoad(EPWM1_BASE);
//
//        // sync "down-stream"
//        EPWM_setSyncOutPulseMode(EPWM1_BASE,
//                                 EPWM_SYNC_OUT_PULSE_ON_COUNTER_ZERO);
//
//        EPWM_setPhaseShift(EPWM1_BASE, 0);
////        EPWM_setPhaseShift(obj->pwmHandle[1], 2);
////        EPWM_setPhaseShift(obj->pwmHandle[2], 4);
//
//        EPWM_setTimeBasePeriod(EPWM1_BASE, halfPeriod);
////        EPWM_setTimeBasePeriod(obj->pwmHandle[1], halfPeriod);
////        EPWM_setTimeBasePeriod(obj->pwmHandle[2], halfPeriod);
//
/////-----------------------///
//
//    // Setting up link from EPWM to ADC
//    // EPWM1/EPWM4 - Inverter currents at sampling frequency
//    //               (@ PRD or @ (PRD&ZRO) )
//    // Select SOC from counter at ctr = prd
//    EPWM_setADCTriggerSource(EPWM1_BASE, EPWM_SOC_A,
//                             EPWM_SOC_TBCTR_ZERO);
//
//    // Generate pulse on 1st event
//    EPWM_setADCTriggerEventPrescale(EPWM1_BASE, EPWM_SOC_A, 1);
//
//    // Enable SOC on A group
//    EPWM_enableADCTrigger(EPWM1_BASE, EPWM_SOC_A);
//
//    EPWM_setInterruptSource(EPWM1_BASE, EPWM_INT_TBCTR_ZERO);
//    // Enable Interrupt Generation from the PWM module
//    EPWM_enableInterrupt(EPWM1_BASE);
//
//    // This needs to be 1 for the INTFRC to work
//    EPWM_setInterruptEventCount(EPWM1_BASE, 1);
//
//    // Clear ePWM Interrupt flag
//    EPWM_clearEventTriggerInterruptFlag(EPWM1_BASE);
//    EPWM_clearTripZoneFlag(EPWM1_BASE,
//                           (EPWM_TZ_FLAG_OST | EPWM_TZ_FLAG_DCAEVT1));
//
//    Interrupt_register(INT_EPWM1, &pwmISR);
//
//    Interrupt_enable(INT_EPWM1);
//    return;
//}

/*
 * ecap_test.h
 *
 *  Created on: 18-Nov-2022
 *      Author: AK
 */

#ifndef ECAP_TEST_H_
#define ECAP_TEST_H_

#include "driverlib.h"
#include "device.h"
#include "board.h"
#include "serial_driver.h"
extern __interrupt void INT_myECAP0_ISR();
//extern __interrupt void pwmISR();

extern void HAL_setupECAP();
extern void pwm_init(uint32_t);
extern void pwm_update_duty(uint32_t);
//extern void HAL_setupMotorPWMs();



#endif /* ECAP_TEST_H_ */

0 admin 2 年多前

TI__Guru**** 2381930 points

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

您好、AK、

感谢您提供您的代码、我将查看此内容并在一天结束前回复。

0 admin 2 年多前

TI__Guru**** 2381930 points

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

您好、AK、

因此、我一直在"Registers"选项卡(在 CCS 中)中更改 PWM 频率、以查看是否看到任何更改。

这是 PWM 处于50kHz 时的情况：

200KHz 时的 PWM：

500KHz 时的 PWM ：

1MHz 时的 PWM：

我仍然从上面屏幕截图中的 eCAP 计算中获得合理的占空比。

您是否正在将 eCAP 同步到 ePWM？您能否为我提供您的 ECAP 初始化代码？这里是 eCAP 代码的初始化、我确保禁用加载计数器、因为我没有与 ePWM 同步：

//
// Disable ,clear all capture flags and interrupts
//
ECAP_disableInterrupt(ECAP1_BASE,
                      (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                       ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                       ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                       ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                       ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                       ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                       ECAP_ISR_SOURCE_COUNTER_COMPARE));
ECAP_clearInterrupt(ECAP1_BASE,
                    (ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
                     ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
                     ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
                     ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
                     ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
                     ECAP_ISR_SOURCE_COUNTER_PERIOD   |
                     ECAP_ISR_SOURCE_COUNTER_COMPARE));

//
// Disable CAP1-CAP4 register loads
//
ECAP_disableTimeStampCapture(ECAP1_BASE);

//
// Configure eCAP
//    Enable capture mode.
//    One shot mode, stop capture at event 4.
//    Set polarity of the events to rising, falling, rising, falling edge.
//    Set capture in time difference mode.
//    Select input from XBAR7.
//    Enable eCAP module.
//    Enable interrupt.
//
ECAP_stopCounter(ECAP1_BASE);
ECAP_enableCaptureMode(ECAP1_BASE);

ECAP_setCaptureMode(ECAP1_BASE, ECAP_ONE_SHOT_CAPTURE_MODE, ECAP_EVENT_4);

ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_1, ECAP_EVNT_RISING_EDGE);
ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_2, ECAP_EVNT_FALLING_EDGE);
ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_3, ECAP_EVNT_RISING_EDGE);
ECAP_setEventPolarity(ECAP1_BASE, ECAP_EVENT_4, ECAP_EVNT_FALLING_EDGE);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_1);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_2);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_3);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_4);

XBAR_setInputPin(XBAR_INPUT7, 16);

//    ECAP_enableLoadCounter(ECAP1_BASE);
ECAP_disableLoadCounter(ECAP1_BASE);
ECAP_setSyncOutMode(ECAP1_BASE, ECAP_SYNC_OUT_SYNCI);
ECAP_startCounter(ECAP1_BASE);
ECAP_enableTimeStampCapture(ECAP1_BASE);
ECAP_reArm(ECAP1_BASE);

ECAP_enableInterrupt(ECAP1_BASE, ECAP_ISR_SOURCE_CAPTURE_EVENT_4);

需要注意的一点是、可以通过另一种方式解决占空比问题。

例如、如果我们有50kHz PWM 信号、并在向上计数模式下将 CMPA (999)设置为 TBPRD (1999)的一半。我们预计占空比为50%。

CAP1_COUNT = ECAP_getEventTimeStamp (ECAP1_BASE、ECAP_EVENT_1)；//第一个上升沿

CAP2_COUNT = ECAP_getEventTimeStamp (ECAP1_BASE、ECAP_EVENT_2)；//第一个下降沿

CAP1_COUNT 将在到达第一个上升沿时返回计数器值、而 CAP2_COUNT 将在到达下降沿时返回计数器值。

当我们启用事件1和事件2上的计数器复位时、我们应该为这两个事件获得相同的计数器。如下面的屏幕截图所示。这意味着 PWM 以相同的计数打开/关闭。这也意味着它具有50%的占空比。

ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_1);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_2);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_3);
ECAP_enableCounterResetOnEvent(ECAP1_BASE, ECAP_EVENT_4);

您可能会注意到 cap1_count 是2*CMPA (CMPA 是发生上升沿的地方)，这是因为 ePWM 由 SYSCLK /2计时。 ECAP 由 SYSCLK 计时。

0 admin 2 年多前

TI__Guru**** 2381930 points

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

Ryan、您好、感谢您提供如此详细的解释

[引用 userid="531667" URL"~/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1173156/launchxl-f28379d-measure-dc-bus-via-the-ecap-module-from-gate-driver-ucc21710-pwm-pulse-train/4418989 #4418989">您是否正在将 eCAP 同步到 ePWM？您能否为我提供您的 ECAP 初始化代码？这里是我的 eCAP 代码初始化、我确保禁用加载计数器、因为我没有与 ePWM 同步：[/quot]

这是我的初始化代码、我使用 SysConfig 生成初始代码、但设置看起来与您的初始化类似。在结构中、我计划将 eCAP 与 PWM 开关频率同步。如果我错了、但同步是通过从 PWM ISR 重新布防 eCAP 模块来完成的、请纠正我的问题？

/*
 * Copyright (c) 2020 Texas Instruments Incorporated - http://www.ti.com
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "board.h"

void Board_init()
{
	EALLOW;

	PinMux_init();
	INPUTXBAR_init();
	SYNC_init();
	CPUTIMER_init();
	ECAP_init();
	GPIO_init();
	SCI_init();
	INTERRUPT_init();

	EDIS;
}

void PinMux_init()
{
	// GPIO31 -> blue_led Pinmux
	GPIO_setPinConfig(GPIO_31_GPIO31);
	//
	// SCIA -> mySCI0 Pinmux
	//
	GPIO_setPinConfig(GPIO_43_SCIRXDA);
	GPIO_setPinConfig(GPIO_42_SCITXDA);

}

void CPUTIMER_init(){
	//myCPUTIMER0 initialization 
	CPUTimer_setEmulationMode(myCPUTIMER0_BASE, CPUTIMER_EMULATIONMODE_STOPAFTERNEXTDECREMENT);
	CPUTimer_setPreScaler(myCPUTIMER0_BASE, 0U);
	CPUTimer_setPeriod(myCPUTIMER0_BASE, 30000U);
	CPUTimer_enableInterrupt(myCPUTIMER0_BASE);
	CPUTimer_stopTimer(myCPUTIMER0_BASE);

	CPUTimer_reloadTimerCounter(myCPUTIMER0_BASE);
	CPUTimer_startTimer(myCPUTIMER0_BASE);
}
void ECAP_init(){

	//myECAP0 initialization
    // Disable ,clear all capture flags and interrupts
    ECAP_disableInterrupt(myECAP0_BASE,
		(ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
		 ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
		 ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
		 ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
		 ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
		 ECAP_ISR_SOURCE_COUNTER_PERIOD   |
		 ECAP_ISR_SOURCE_COUNTER_COMPARE));
	ECAP_clearInterrupt(myECAP0_BASE,
	  	(ECAP_ISR_SOURCE_CAPTURE_EVENT_1  |
		ECAP_ISR_SOURCE_CAPTURE_EVENT_2  |
		ECAP_ISR_SOURCE_CAPTURE_EVENT_3  |
		ECAP_ISR_SOURCE_CAPTURE_EVENT_4  |
		ECAP_ISR_SOURCE_COUNTER_OVERFLOW |
		ECAP_ISR_SOURCE_COUNTER_PERIOD   |
		ECAP_ISR_SOURCE_COUNTER_COMPARE));
	// Disables time stamp capture.
	ECAP_disableTimeStampCapture(myECAP0_BASE);
	// Stops Time stamp counter.
	ECAP_stopCounter(myECAP0_BASE);
	// Sets eCAP in Capture mode.
	ECAP_enableCaptureMode(myECAP0_BASE);
	// Sets the capture mode.
	ECAP_setCaptureMode(myECAP0_BASE,ECAP_ONE_SHOT_CAPTURE_MODE,ECAP_EVENT_4);
	// Sets the Capture event prescaler.
	ECAP_setEventPrescaler(myECAP0_BASE, 0U);
	// Sets the Capture event polarity.
	ECAP_setEventPolarity(myECAP0_BASE,ECAP_EVENT_1,ECAP_EVNT_RISING_EDGE);
	ECAP_setEventPolarity(myECAP0_BASE,ECAP_EVENT_2,ECAP_EVNT_FALLING_EDGE);
	ECAP_setEventPolarity(myECAP0_BASE,ECAP_EVENT_3,ECAP_EVNT_RISING_EDGE);
	ECAP_setEventPolarity(myECAP0_BASE,ECAP_EVENT_4,ECAP_EVNT_FALLING_EDGE);
	// Configure counter reset on events 
	ECAP_disableCounterResetOnEvent(myECAP0_BASE,ECAP_EVENT_1);
	ECAP_disableCounterResetOnEvent(myECAP0_BASE,ECAP_EVENT_2);
	ECAP_disableCounterResetOnEvent(myECAP0_BASE,ECAP_EVENT_3);
	ECAP_enableCounterResetOnEvent(myECAP0_BASE,ECAP_EVENT_4);	
	// Sets a phase shift value count.
	ECAP_setPhaseShiftCount(myECAP0_BASE,0U);
	// Disable counter loading with phase shift value.
	ECAP_disableLoadCounter(myECAP0_BASE);
	// Configures Sync out signal mode.
	ECAP_setSyncOutMode(myECAP0_BASE,ECAP_SYNC_OUT_SYNCI);
	// Configures emulation mode.
	ECAP_setEmulationMode(myECAP0_BASE,ECAP_EMULATION_STOP);

	// Starts Time stamp counter for myECAP0.
	ECAP_startCounter(myECAP0_BASE);
	// Enables time stamp capture for myECAP0.
	ECAP_enableTimeStampCapture(myECAP0_BASE);
	// Re-arms the eCAP module for myECAP0.
	ECAP_reArm(myECAP0_BASE);

	// Enables interrupt source for myECAP0.
	ECAP_enableInterrupt(myECAP0_BASE,(ECAP_ISR_SOURCE_CAPTURE_EVENT_4));

}
void GPIO_init(){
		
	//blue_led initialization
	GPIO_setDirectionMode(blue_led, GPIO_DIR_MODE_OUT);
	GPIO_setPadConfig(blue_led, GPIO_PIN_TYPE_STD);
	GPIO_setMasterCore(blue_led, GPIO_CORE_CPU1);
	GPIO_setQualificationMode(blue_led, GPIO_QUAL_SYNC);
	GPIO_writePin(blue_led, 0);
}
void INPUTXBAR_init(){
	
	//myINPUTXBAR0 initialization
	XBAR_setInputPin(XBAR_INPUT7, 61);
}
void INTERRUPT_init(){
	
	// Interrupt Setings for INT_myECAP0
	Interrupt_register(INT_myECAP0, &INT_myECAP0_ISR);
	Interrupt_enable(INT_myECAP0);
	
	// Interrupt Setings for INT_mySCI0_RX
	Interrupt_register(INT_mySCI0_RX, &INT_mySCI0_RX_ISR);
	Interrupt_enable(INT_mySCI0_RX);
	
	// Interrupt Setings for INT_mySCI0_TX
	Interrupt_register(INT_mySCI0_TX, &INT_mySCI0_TX_ISR);
	Interrupt_enable(INT_mySCI0_TX);
}

void SCI_init(){
	
	//mySCI0 initialization
	SCI_clearInterruptStatus(mySCI0_BASE, SCI_INT_RXFF | SCI_INT_TXFF | SCI_INT_FE | SCI_INT_OE | SCI_INT_PE | SCI_INT_RXERR | SCI_INT_RXRDY_BRKDT | SCI_INT_TXRDY);
	SCI_clearOverflowStatus(mySCI0_BASE);

	SCI_disableFIFO(mySCI0_BASE);
	SCI_resetChannels(mySCI0_BASE);

	SCI_setConfig(mySCI0_BASE, DEVICE_LSPCLK_FREQ, mySCI0_BAUDRATE, (SCI_CONFIG_WLEN_8|SCI_CONFIG_STOP_ONE|SCI_CONFIG_PAR_NONE));
	SCI_disableLoopback(mySCI0_BASE);
	SCI_performSoftwareReset(mySCI0_BASE);
	SCI_enableInterrupt(mySCI0_BASE, SCI_INT_RXRDY_BRKDT);
	SCI_enableModule(mySCI0_BASE);
}
void SYNC_init(){
	SysCtl_setSyncOutputConfig(SYSCTL_SYNC_OUT_SRC_EPWM1SYNCOUT);
	// For EPWM1, the sync input is: SYSCTL_SYNC_IN_SRC_EXTSYNCIN1
	SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM4, SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
	SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM7, SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
	SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_EPWM10, SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
	SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_ECAP1, SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
	SysCtl_setSyncInputConfig(SYSCTL_SYNC_IN_ECAP4, SYSCTL_SYNC_IN_SRC_EPWM1SYNCOUT);
	// SOCA
	SysCtl_enableExtADCSOCSource(0);
	// SOCB
	SysCtl_enableExtADCSOCSource(0);
}

[引用 userid="531667" URL"~/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1173156/launchxl-f28379d-measure-dc-bus-via-the-ecap-module-from-gate-driver-ucc21710-pwm-pulse-train/4418989 #4418989">当我们启用计数器在事件1和事件2上复位时，我们应该得到相同的计数器。如下面的屏幕截图所示。这意味着 PWM 以相同的计数打开/关闭。这也意味着它具有50%的占空比。[/报价]

我看到、基本上我们只需等待事件1和2、然后检查两个时间计数之间的偏差以测量占空比...这里的优势是我们不需要等待所有4个事件发生？

0 admin 2 年多前

TI__Guru**** 2381930 points

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

您好、AK、

当你为 eCAP 启用负载计数器时、同步完成。如果您计划将 eCAP 用作非对称 PWM 信号、则可以启用负载计数器。但是、如果您计划使用 eCAP 来捕获占空比、请确保禁用负载计数器。

'一旦启用、eCAP 模块等待1-4 (由停止值定义)个捕捉事件、然后再冻结这两个事件
Mod4计数器和 CAP1-4寄存器的内容(时间戳)。
重新布防为另一个捕捉序列准备 eCAP 模块。此外、重新布防会清除(归零)
Mod4计数器、并允许再次加载 CAP1-4寄存器、前提是 CAPLDEN 位被置位。"

第二点、是的、您回答正确！

希望这对您有所帮助。

最棒的

Ryan Ma

0 admin 2 年多前

TI__Guru**** 2381930 points

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

谢谢 Ryan，我终于能够让它在高频下工作了。

0 admin 2 年多前

TI__Guru**** 2381930 points

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

没问题！

此致、

Ryan Ma

C2000™︎ 微控制器（参考译文帖）

C2000™︎ 微控制器（参考译文帖）(Read Only)

[参考译文] LAUNCHXL-F28379D：通过来自栅极驱动器(UCC21710)和 PWM 脉冲序列的 eCAP 模块测量直流总线