AURIX TC397 Timer PWM 之 GPT12 CCU6

最新推荐文章于 2024-04-13 15:40:06 发布
最新推荐文章于 2024-04-13 15:40:06 发布
阅读量6.1k 收藏 61
点赞数 10
分类专栏： Infineon AURIX TC397 文章标签： CCU6 GPT12 AURIX TC397
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weifengdq/article/details/109455944
版权

目录

GPT12_Timer_Interrupt

GPT12模块的定时器T3产生500ms中断翻转LED:

  • GPT12(The General Purpose Timer Unit)包含两个GPT块(GPT1和GPT2), 每个块都有几个16-bit定时器
  • GPT1块包含核心定时器T3和两个辅助定时器T2,T4
  • GPT1的所有定时器可以四种模式之一运行: 定时器模式, 门控定时器模式, 计数器模式 或者 增量接口模式.
  • 下面的例子中, T3配置为定时器模式, 向下计数, 发生下溢事件时, T2的值会传输到T3, 就不用在中断中手动重装了
  • GPT12模块基本频率 Fgpt = 100MHz
  • Reload_Value = Fgpt / (Gpt1BlockPrescalerTimerInputPrescalerf) = 100MHz / (16642Hz) = 48828
#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "Ifx_Types.h"
#include "IfxGpt12.h"
#include "IfxPort.h"

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

#define ISR_PRIORITY_GPT12_TIMER    6                       /* Define the GPT12 Timer interrupt priority            */
#define ISR_PROVIDER_GPT12_TIMER    IfxSrc_Tos_cpu0         /* Interrupt provider                                   */
#define RELOAD_VALUE                48828u                  /* Reload value to have an interrupt each 500ms         */
#define LED                         &MODULE_P13, 0          /* LED which toggles in the Interrupt Service Routine   */

/* Macro defining the Interrupt Service Routine */
IFX_INTERRUPT(interruptGpt12, 0, ISR_PRIORITY_GPT12_TIMER);

/* Interrupt Service Routine of the GPT12 */
void interruptGpt12(void)
{
    IfxPort_togglePin(LED);                                                         /* Toggle LED state             */
}

void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    
    /* Initialize the LED */
    IfxPort_setPinModeOutput(LED, IfxPort_OutputMode_pushPull, IfxPort_OutputIdx_general);

    //initGpt12Timer
    /* Initialize the GPT12 module */
    IfxGpt12_enableModule(&MODULE_GPT120);                                          /* Enable the GPT12 module      */
    IfxGpt12_setGpt1BlockPrescaler(&MODULE_GPT120, IfxGpt12_Gpt1BlockPrescaler_16); /* Set GPT1 block prescaler     */

    /* Initialize the Timer T3 */
    IfxGpt12_T3_setMode(&MODULE_GPT120, IfxGpt12_Mode_timer);                       /* Set T3 to timer mode         */
    IfxGpt12_T3_setTimerDirection(&MODULE_GPT120, IfxGpt12_TimerDirection_down);    /* Set T3 count direction       */
    IfxGpt12_T3_setTimerPrescaler(&MODULE_GPT120, IfxGpt12_TimerInputPrescaler_64); /* Set T3 input prescaler       */
    IfxGpt12_T3_setTimerValue(&MODULE_GPT120, RELOAD_VALUE);                        /* Set T3 start value           */

    /* Initialize the Timer T2 */
    IfxGpt12_T2_setMode(&MODULE_GPT120, IfxGpt12_Mode_reload);                      /* Set T2 to reload mode        */
    IfxGpt12_T2_setReloadInputMode(&MODULE_GPT120, IfxGpt12_ReloadInputMode_bothEdgesTxOTL); /* Set reload trigger  */
    IfxGpt12_T2_setTimerValue(&MODULE_GPT120, RELOAD_VALUE);                        /* Set T2 reload value          */

    /* Initialize the interrupt */
    volatile Ifx_SRC_SRCR *src = IfxGpt12_T3_getSrc(&MODULE_GPT120);                /* Get the interrupt address    */
    IfxSrc_init(src, ISR_PROVIDER_GPT12_TIMER, ISR_PRIORITY_GPT12_TIMER);           /* Initialize service request   */
    IfxSrc_enable(src);                                                             /* Enable GPT12 interrupt       */

    IfxGpt12_T3_run(&MODULE_GPT120, IfxGpt12_TimerRun_start);                       /* Start the timer              */

    while(1)
    {
    }
}

GPT12_Timer_Concatenation

GPT12模块的2个16-bit定时器可以级联(concatenation)成一个32bit定时器:

  • GPT2块包含两个定时器: 核心定时器T6和辅助定时器T5
  • GPT2的2个定时器可以三种模式之一运行: 定时器模式, 门控定时器模式, 计数器模式.
  • 一个附加的捕获/重载寄存器(Capture/Reload register, CAPREL)
  • 下面的例子中T5是计数器模式, T6是定时器模式
  • LED每86秒翻转一次, GPT12基本频率100MHz, GPT2预分配设置为2, 定时器T6的频率为100MHz/2=50MHz => 20ns, 32位定时器最大值4294967295*20ns ≈ 86s

Cpu0_Main.c代码如下:

#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "Ifx_Types.h"
#include "IfxGpt12.h"

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

#define ISR_PRIORITY_GPT12_T5_INT   10                      /* Define the GPT12 Timer 5 interrupt priority          */
#define ISR_PRIORITY_GPT12_T6_INT   11                      /* Define the GPT12 Timer 6 interrupt priority          */
#define SHIFT_BY_16                 16                      /* Define a shift value                                 */
#define LED                         &MODULE_P13,0           /* LED which toggles in the Interrupt Service Routine   */

uint32 g_timerValue32Bit = 0x00000000;

/* Macro to define Interrupt Service Routine */
IFX_INTERRUPT(GPT12_T5_Int0_Handler, 0, ISR_PRIORITY_GPT12_T5_INT);

/* Interrupt Service Routine of timer T5 gets triggered when the concatenation of both 16-bit timers has an overflow */
void GPT12_T5_Int0_Handler(void)
{
    IfxPort_setPinState(LED, IfxPort_State_toggled);    /* Toggle LED */
}

/* Macro to define Interrupt Service Routine */
IFX_INTERRUPT(GPT12_T6_Int0_Handler, 0, ISR_PRIORITY_GPT12_T6_INT);

/* Interrupt Service Routine of timer T6 gets triggered when the 16 bit timer T6 has an overflow */
void GPT12_T6_Int0_Handler(void)
{
    uint32 timerValueLOW = (uint32)IfxGpt12_T6_getTimerValue(&MODULE_GPT120);     /* Get counter value of timer T6 */
    uint32 timerValueHIGH = (uint32)IfxGpt12_T5_getTimerValue(&MODULE_GPT120);    /* Get counter value of timer T5 */

    /* Concatenation of both 16-bit timers values to one 32 bit timer by adding the shifted value of timer T5
     * to the value of timer T6.
     */
    g_timerValue32Bit = (timerValueHIGH << SHIFT_BY_16) + timerValueLOW;
}

void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    
    /* Initialize LED port pin */
    IfxPort_setPinMode(LED, IfxPort_Mode_outputPushPullGeneral);

    //init_GPT12_module
    /* Enable GPT12 module */
    IfxGpt12_enableModule(&MODULE_GPT120);
    /* Select 2 as prescaler for the GPT2 module -> fastest clock frequency */
    IfxGpt12_setGpt2BlockPrescaler(&MODULE_GPT120, IfxGpt12_Gpt2BlockPrescaler_2);
    /* Set the core timer T6 in timer mode */
    IfxGpt12_T6_setMode(&MODULE_GPT120, IfxGpt12_Mode_timer);
    /* Set the auxiliary timer T5 in counter mode */
    IfxGpt12_T5_setMode(&MODULE_GPT120, IfxGpt12_Mode_counter);
    /* Select the rising and falling edges of Output Toggle Latch of timer T6 */
    IfxGpt12_T5_setCounterInputMode(&MODULE_GPT120, IfxGpt12_CounterInputMode_bothEdgesTxOTL);
    /* Turn remote control on; Timer T5 is controlled by overflow of timer T6 */
    IfxGpt12_T5_setRemoteControl(&MODULE_GPT120, IfxGpt12_TimerRemoteControl_on);

    /* Service request configuration */
    /* Get source pointer of timer T5, initialize and enable */
    volatile Ifx_SRC_SRCR *src = IfxGpt12_T5_getSrc(&MODULE_GPT120);
    IfxSrc_init(src, IfxSrc_Tos_cpu0, ISR_PRIORITY_GPT12_T5_INT);
    IfxSrc_enable(src);
    /* Get source pointer of timer T6, initialize and enable */
    src = IfxGpt12_T6_getSrc(&MODULE_GPT120);
    IfxSrc_init(src, IfxSrc_Tos_cpu0, ISR_PRIORITY_GPT12_T6_INT);
    IfxSrc_enable(src);

    /* Start timer T6 */
    IfxGpt12_T6_run(&MODULE_GPT120, IfxGpt12_TimerRun_start);


    while(1)
    {
    }
}

GPT12_PWM_Generation

参考GPT12_PWM_Generation_1 for KIT_AURIX_TC397_TFT.

用GPT12产生固定频率的PWM和自定义的占空比:

  • GPT1的T3配置为向下计数的定时器模式, 一旦T3下溢出, T3OTL(T3 Output Toggle Latch)翻转, T2(dutyDownTime)和T4(dutyUpTime)的值传递给T3(哪个传递取决于T3OTL的值), T3的中断中翻转LED
  • 得到GPT12的基本频率Fgpt: IfxGpt12_getModuleFrequency(), 100MHz
  • 定时器频率 Ftimer = Fgpt / (GPT1_BLOCK_PRESCALER × TimerInputPrescaler) = 100MHz/(32x32) = 97656.25Hz
  • dutyUpTime = Ftimer x DutyCycle / f = 97656.25Hz * 0.85 / 2 = 41.5
  • dutyDownTime = Ftimer x (1 - DutyCycle) / f

Cpu0_Main.c代码:

#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "Ifx_Types.h"
#include "IfxGpt12.h"
#include "IfxPort.h"

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

#define ISR_PRIORITY_GPT12_TIMER    6                       /* Define the GPT12 Timer interrupt priority            */
#define ISR_PROVIDER_GPT12_TIMER    IfxSrc_Tos_cpu0         /* Interrupt provider                                   */
#define PWM_FREQUENCY               2.0f                    /* Frequency of the PWM signal in Hz                    */
#define PWM_DUTY_CYCLE              85                      /* Duty cycle of the PWM signal in percentage           */
#define LED                         &MODULE_P13, 0          /* LED which toggles in the Interrupt Service Routine   */
#define GPT1_BLOCK_PRESCALER        32                      /* GPT1 block prescaler value                           */
#define TIMER_T3_INPUT_PRESCALER    32                      /* Timer input prescaler value                          */

/* Macro to define Interrupt Service Routine */
IFX_INTERRUPT(interruptGpt12, 0, ISR_PRIORITY_GPT12_TIMER);

/* Interrupt Service Routine of the GPT12 */
void interruptGpt12(void)
{
    /* Toggle the state of the LED */
    IfxPort_togglePin(LED);
}

void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    
    /* Initialize the LED */
    IfxPort_setPinModeOutput(LED, IfxPort_OutputMode_pushPull, IfxPort_OutputIdx_general);

    //initGpt12PWM
    /* Enable the GPT12 module */
    IfxGpt12_enableModule(&MODULE_GPT120);
    /* Set GPT1 block prescaler to divide the module frequency */
    IfxGpt12_setGpt1BlockPrescaler(&MODULE_GPT120, IfxGpt12_Gpt1BlockPrescaler_32);
    /* Set the GPT12 timer T3 in timer mode */
    IfxGpt12_T3_setMode(&MODULE_GPT120, IfxGpt12_Mode_timer);
    /* Set the Timer T3 direction   */
    IfxGpt12_T3_setTimerDirection(&MODULE_GPT120, IfxGpt12_TimerDirection_down);
    /* Set timer T3 input prescaler to divide the timer frequency */
    IfxGpt12_T3_setTimerPrescaler(&MODULE_GPT120, IfxGpt12_TimerInputPrescaler_32);

    /* Calculate dutyUpTime and dutyDownTime for reloading timer T3 */
    float32 moduleFreq = IfxGpt12_getModuleFrequency(&MODULE_GPT120);
    float32 fTimer = (moduleFreq / (GPT1_BLOCK_PRESCALER * TIMER_T3_INPUT_PRESCALER));
    uint16 dutyUpTime = (fTimer * (PWM_DUTY_CYCLE / 100.0f)) / PWM_FREQUENCY;
    uint16 dutyDownTime = (fTimer * (1 - (PWM_DUTY_CYCLE / 100.0f))) / PWM_FREQUENCY;

    /* Set timer T3 value */
    IfxGpt12_T3_setTimerValue(&MODULE_GPT120, dutyDownTime);

    /* Timer T2: reloads the value dutyDownTime in timer T3 */
    /* Set the timer T2 in reload mode */
    IfxGpt12_T2_setMode(&MODULE_GPT120, IfxGpt12_Mode_reload);
    /* Set the T2 input parameter: Negative transition (falling edge) of T3 toggle latch T3OTL */
    IfxGpt12_T2_setReloadInputMode(&MODULE_GPT120, IfxGpt12_ReloadInputMode_fallingEdgeTxOTL);
    /* Set timer T2 value (the value that is reloaded in T3 on negative transition) */
    IfxGpt12_T2_setTimerValue(&MODULE_GPT120, dutyDownTime);

    /* Timer T4: reloads the value dutyUpTime in timer T3 */
    /* Set timer T4 in reload mode */
    IfxGpt12_T4_setMode(&MODULE_GPT120, IfxGpt12_Mode_reload);
    /* Set the T4 input parameter: Positive transition (rising edge) of T3 toggle latch T3OTL */
    IfxGpt12_T4_setReloadInputMode(&MODULE_GPT120, IfxGpt12_ReloadInputMode_risingEdgeTxOTL);
    /* Set timer T4 value (the value that is reloaded in T3 on positive transition) */
    IfxGpt12_T4_setTimerValue(&MODULE_GPT120, dutyUpTime);

    /* Configure the GPT12 interrupt */
    volatile Ifx_SRC_SRCR *src = IfxGpt12_T3_getSrc(&MODULE_GPT120);            /* Get interrupt address            */
    IfxSrc_init(src, ISR_PROVIDER_GPT12_TIMER, ISR_PRIORITY_GPT12_TIMER);       /* Initialize the service request   */
    IfxSrc_enable(src);                                                         /* Enable GPT12 interrupt           */

    IfxGpt12_T3_run(&MODULE_GPT120, IfxGpt12_TimerRun_start);                   /* Start the timer T3               */

    while(1)
    {
    }
}

GPT12_PWM_Capture

参考 GPT12_PWM_Capture_1 for KIT_AURIX_TC397_TFT

  • GPT1的定时器T2和T4可以用作核心定时器T3的捕获或重载寄存器
  • 本例中T2(捕获模式)捕获T3(定时器模式)的值
  • T3是16bit定时器, 最大值65535, GPT12基本频率100MHz, GPT1预分配4, T3频率100MHz/4=25MHz, 40ns +1, 溢出时间65535*40≈0.0026s => 381Hz
  • 总增量可以通过比较T2当前值和一个PWM周期前的值(1000为例)来获得, 50Hz PWM周期0.2s, 0.2s内, T3计数0.02s/40ns=500000次, 溢出7次, T2记录的PWM一个周期前的值为1000, T2当前值42255, 总增量为 (65535-1000)+(7-1)*65535+42255 = 500000, PWM频率为25MHz/500000=50Hz
  • 本例中软件模拟PWM产生
  • 用杜邦线连接P00.7(GPT1 T2 输入)和P00.8(PWM信号)

在这里插入图片描述

在这里插入图片描述

Cpu0_Main.c代码如下:

#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "IfxGpt12.h"
#include "Bsp.h"

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

#define ISR_PRIORITY_GPT12_T2_INT   10              /* Define the GPT12 Timer 2 interrupt priority                  */
#define ISR_PRIORITY_GPT12_T3_INT   11              /* Define the GPT12 Timer 2 interrupt priority                  */
#define MAX_VAL_16_BIT              0xFFFF          /* Used for calculation of timer value with overflows           */

#define PWM_PIN                     &MODULE_P00,8   /* Pin which is used to generate a simple PWM signal            */
#define PWM_DUTY                    0.5             /* Duty cycle of generated PWM signal, value between 0 and 1    */
#define FACTOR_SEC_TO_USEC          1000000         /* Factor to convert seconds to microseconds                    */

float32 g_generatedPwmFreqHz    = 50.0; /* Global variable for frequency of generated PWM signal                    */
float32 g_measuredPwmFreqHz     = 0.0;  /* Global variable for frequency calculation of PWM signal                  */
uint32  g_cntOverflow           = 0;    /* Global counter variable for the timer overflow between two edges         */
uint32  g_previousCntVal        = 0;    /* Global variable which stores the timer value of the previous interrupt   */

/* Macro to define the Interrupt Service Routine */
IFX_INTERRUPT(GPT12_T2_Int0_Handler, 0, ISR_PRIORITY_GPT12_T2_INT);

/* Interrupt Service Routine of timer T2, gets triggered by rising edge on input pin of timer T2 */
void GPT12_T2_Int0_Handler(void)
{
    uint32 currentCntVal = IfxGpt12_T2_getTimerValue(&MODULE_GPT120); /* Get timer value of timer T2 */
    uint32 finalCntVal = 0; /* Variable to calculate final timer counter value */

    if(g_cntOverflow == 0)
    {
        /* If no overflow detected */
        finalCntVal = currentCntVal - g_previousCntVal; /* Total counter value calculation */
    }
    else
    {
        /* One or more overflows detected */
        /* Add to the current counter value, the amount of counter ticks which passed before the first overflow,
         * plus 65525 (0xFFFF) for each additional overflow since the previous rising edge.
         */
        finalCntVal = (uint32)(currentCntVal + (MAX_VAL_16_BIT - g_previousCntVal) + ((g_cntOverflow - 1) * MAX_VAL_16_BIT));
    }

    /* Calculation of the PWM frequency by dividing the frequency of timer T3 through the final total counter value */
    g_measuredPwmFreqHz = IfxGpt12_T3_getFrequency(&MODULE_GPT120) / finalCntVal;

    g_previousCntVal = currentCntVal;    /* Set g_previousCntVal to currentCntVal for the next calculation */
    g_cntOverflow = 0;                   /* Reset overflow flag */
}

/* Macro to define the Interrupt Service Routine. */
IFX_INTERRUPT(GPT12_T3_Int0_Handler, 0, ISR_PRIORITY_GPT12_T3_INT);

/* Interrupt Service Routine of timer T3, gets triggered after T3 timer overflow */
void GPT12_T3_Int0_Handler(void)
{
    g_cntOverflow++; /* Increase overflow counter */
}


void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    
    //init_GPT12_module
    /* Enable GPT12 module */
    IfxGpt12_enableModule(&MODULE_GPT120);
    /* Select 4 as prescaler for the GPT1 module -> fastest clock frequency for best accuracy */
    IfxGpt12_setGpt1BlockPrescaler(&MODULE_GPT120, IfxGpt12_Gpt1BlockPrescaler_4);
    /* Set core timer T3 in timer mode */
    IfxGpt12_T3_setMode(&MODULE_GPT120, IfxGpt12_Mode_timer);
    /* Set auxiliary timer T2 in capture mode */
    IfxGpt12_T2_setMode(&MODULE_GPT120, IfxGpt12_Mode_capture);
    /* Select input pin A of timer T2 which is P00.7 (the James Bond pin) */
    IfxGpt12_T2_setInput(&MODULE_GPT120, IfxGpt12_Input_A);
    /* Select rising edge as capture event */
    IfxGpt12_T2_setCaptureInputMode(&MODULE_GPT120, IfxGpt12_CaptureInputMode_risingEdgeTxIN);

    /* Service request configuration */
    /* Get source pointer of timer T2, initialize and enable */
    volatile Ifx_SRC_SRCR *src = IfxGpt12_T2_getSrc(&MODULE_GPT120);
    IfxSrc_init(src, IfxSrc_Tos_cpu0, ISR_PRIORITY_GPT12_T2_INT);
    IfxSrc_enable(src);
    /* Get source pointer of timer T3, initialize and enable */
    src = IfxGpt12_T3_getSrc(&MODULE_GPT120);
    IfxSrc_init(src, IfxSrc_Tos_cpu0, ISR_PRIORITY_GPT12_T3_INT);
    IfxSrc_enable(src);

    /* Initialize time constants */
    initTime();
    /* Initialize PWM_PIN port pin */
    IfxPort_setPinMode(PWM_PIN, IfxPort_Mode_outputPushPullGeneral);

    /* Start timer T3*/
    IfxGpt12_T3_run(&MODULE_GPT120, IfxGpt12_TimerRun_start);

    while(1)
    {
        /* Calculate the total time between two rising edges for the specific frequency */
        sint32 targetWaitTime_us = (1 / g_generatedPwmFreqHz) * FACTOR_SEC_TO_USEC * TimeConst_1us;
        /* Set the pin high to trigger an interrupt */
        IfxPort_setPinState(PWM_PIN, IfxPort_State_high);
        /* Wait for an amount of CPU ticks that represent the calculated microseconds considering the duty cycle */
        wait(PWM_DUTY * targetWaitTime_us);
        /* Set pin state to low */
        IfxPort_setPinState(PWM_PIN, IfxPort_State_low);
        /* Wait for an amount of CPU ticks that represent the calculated microseconds considering the duty cycle */
        wait((1 - PWM_DUTY) * targetWaitTime_us);
    }
}

CCU6_Interrupt

参考 CCU6_Interrupt_1 for KIT_AURIX_TC397_TFT

CCU6每500ms中断一次, 翻转LED:

  • CCU6是一个高分辨率的16-bit捕获和比较单元, 主要用于AC驱动控制, 有定时器T12(3个捕获/比较通道)和定时器T13(1个比较通道), 本例中用T12
  • CCU6可以在计数到预定义的周期值时产生中断
  • 定时器模式下, 默认的时钟频率Fcc6为100MHz, 可以以2的倍数分频, 最多32768分频, 对应3051.75Hz
  • 中断频率fISR = (CCU6 clock frequency) / (period + 1), 其中period的值储存在16-bit寄存器中, 最大值65535
  • fISR=10Hz为例, period=65535, 算出CCU6频率655360Hz, 最接近100MHz/256=390625Hz, 用这个值重新计算period≈39061, fISR=390625/39062≈10Hz
  • 下面的例子fISR=2Hz

Cpu0_Main.c代码如下:

#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "IfxPort.h"
#include "IfxCcu6_Timer.h"

#define ISR_PRIORITY_CCU6_INT1  40                                          /* Priority for interrupt ISR           */
#define CCU6_TIMER_FREQ         97656                                       /* Timer module frequency in Hz         */
#define CCU6_ISR_FREQ           2                                           /* ISR frequency in Hz                  */
#define CCU6_TIMER_PERIOD       (CCU6_TIMER_FREQ / CCU6_ISR_FREQ) - 1       /* Timer module period in ticks         */

#define LED1                    &MODULE_P13,0                               /* LED D107  */

/* CCU6 */
#define CCU6                    &MODULE_CCU60                               /* CCU6 will be used in this example    */

IfxCcu6_Timer g_timer;                                                      /* Timer structure                      */
uint8 g_counter = 0;                                                        /* Variable to keep count of ISR calls  */

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

IFX_INTERRUPT(isrCCU6Timer, 0, ISR_PRIORITY_CCU6_INT1);

void isrCCU6Timer(void)
{
    IfxPort_togglePin(LED1);
}

void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    
    IfxPort_setPinMode(LED1, IfxPort_Mode_outputPushPullGeneral);
    IfxPort_setPinState(LED1, IfxPort_State_high);

    //initCCU6
    IfxCcu6_Timer_Config timerConfig;                   /* Structure for timer configuration                        */
    IfxCcu6_Timer_initModuleConfig(&timerConfig, CCU6); /* Initialize the timer module structure with default values*/
    /* The Serial Peripheral Bus has a default Frequency of Fcc6 = 100000000 Hz = 100 MHz
     * Possible frequencies for the CCU6 timer are:
     *       - 100000000 Hz = 100 MHz   (Fcc6)
     *       - 50000000 Hz  = 50 MHz    (Fcc6/2)
     *       - 25000000 Hz  = 25 MHz    (Fcc6/4)
     *       - 12500000 Hz  = 12.5 MHz  (Fcc6/8)
     *       - 6250000 Hz   = 6.25 MHz  (Fcc6/16)
     *       - 3125000 Hz   ~ 3 MHz     (Fcc6/32)
     *       - 1562500 Hz   ~ 1.5 MHz   (Fcc6/64)
     *       - 781250 Hz    ~ 780 KHz   (Fcc6/128)
     *       - 390625 Hz    ~ 390 KHz   (Fcc6/256)
     *       - 195312.5 Hz  ~ 200 KHz   (Fcc6/512)
     *       - 97656.25 Hz  ~ 100 KHz   (Fcc6/1024)
     *       - 48828.12 Hz  ~ 50 KHz    (Fcc6/2048)
     *       - 24414.06 Hz  ~ 25 KHz    (Fcc6/4096)
     *       - 12207.03 Hz  ~ 12.5 KHz  (Fcc6/8192)
     *       - 6103.51 Hz   ~ 6 KHz     (Fcc6/16384)
     *       - 3051.75 Hz   ~ 3 KHz     (Fcc6/32768)
     */
    timerConfig.base.t12Frequency = CCU6_TIMER_FREQ;                /* Configure the frequency of the timer module */
    timerConfig.base.t12Period = CCU6_TIMER_PERIOD;                 /* Configure the period of the timer (16-bit)  */
    timerConfig.timer = IfxCcu6_TimerId_t12;                        /* Select the timer to be started              */
    timerConfig.interrupt1.source = IfxCcu6_InterruptSource_t12PeriodMatch; /* Set interrupt source                */
    timerConfig.interrupt1.priority = ISR_PRIORITY_CCU6_INT1;       /* Set the priority of the ISR                 */
    timerConfig.interrupt1.typeOfService = IfxSrc_Tos_cpu0;         /* Set the type of service for the interrupt   */
    timerConfig.trigger.t13InSyncWithT12 = FALSE;                   /* Configure timers synchronization            */
    IfxCcu6_Timer_initModule(&g_timer, &timerConfig);               /* Initialize the CCU6 module                  */

    IfxCcu6_Timer_start(&g_timer);                                  /* Start the timer                             */


    while(1)
    {
    }
}

CCU6_PWM_Generation

参考 CCU6_PWM_Generation_1

用CCU6生成三个中心对齐的PWM信号, 频率固定, 占空比不同:

  • 用CCU6的T12和它的3个比较模块产生20kHz PWM信号, 占空比分别为25%, 50%, 75%, 三个信号中心对齐, 定时器必须被配置为向上和向下计数, 输出引脚P02.1, P02.3, P02.5, 可以用示波器测量
  • 初始化阶段, 使用函数IfxCpu_disableInterrupts()暂时禁止中断, 避免未配置外设的抢占, 初始化完成后用IfxCpu_restoreInterrupts()重新使能中断
  • 目标找到比较值Vcmp, 以产生周期50ms, 占空比50%的PWM信号: CCU6基本频率Fcc6=100MHz, PWM频率20kHz, 每周期需要P=100MHz/20kHz=5000ticks, 25%占空比需要1250ticks, 比较值Vcmp=P-dutycycle=5000-1250=3750

在这里插入图片描述

#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "IfxCcu6_PwmHl.h"

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

#define CCU6_BASE_FREQUENCY     100000000                                   /* CCU6 base frequency, in Hertz        */
#define PWM_FREQUENCY           20000                                       /* PWM signal frequency, in Hertz       */
#define PWM_PERIOD              (CCU6_BASE_FREQUENCY / PWM_FREQUENCY)       /* PWM signal period, in ticks          */

#define NUMBER_OF_CHANNELS      3

#define CHANNEL1_DUTY_CYCLE     25                                          /* PWM Signal 1 Duty cycle, in percent  */
#define CHANNEL2_DUTY_CYCLE     50                                          /* PWM Signal 2 Duty cycle, in percent  */
#define CHANNEL3_DUTY_CYCLE     75                                          /* PWM Signal 3 Duty cycle, in percent  */

#define CHANNEL1_COMPARE_VALUE  ((PWM_PERIOD / 100) * (100 - CHANNEL1_DUTY_CYCLE))
#define CHANNEL2_COMPARE_VALUE  ((PWM_PERIOD / 100) * (100 - CHANNEL2_DUTY_CYCLE))
#define CHANNEL3_COMPARE_VALUE  ((PWM_PERIOD / 100) * (100 - CHANNEL3_DUTY_CYCLE))

IfxCcu6_TimerWithTrigger g_timer;
IfxCcu6_PwmHl g_driver;

void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    

    //initCCU6
    boolean interruptState = IfxCpu_disableInterrupts();            /* Disable global interrupts                    */

    /* Timer configuration: timer used as counter */
    IfxCcu6_TimerWithTrigger_Config timerConf;
    IfxCcu6_TimerWithTrigger_initConfig(&timerConf, &MODULE_CCU60); /* Initialize the timer configuration with
                                                                     * default values                               */
    /* User timer configuration */
    timerConf.base.frequency = PWM_FREQUENCY;                       /* Set the desired frequency for the PWM signal */
    timerConf.base.countDir = IfxStdIf_Timer_CountDir_upAndDown;    /* Configure the timer to count up and down, in
                                                                     * order to generate center-aligned PWM signals */
    /* Initialize the timer driver */
    IfxCcu6_TimerWithTrigger_init(&g_timer, &timerConf);

    /* PWM High/Low driver configuration */
    IfxCcu6_PwmHl_Config pwmHlConf;
    IfxCcu6_PwmHl_initConfig(&pwmHlConf);                           /* Initialize the PwmHl configuration with
                                                                     * default values                               */
    /* User PWM High/Low driver configuration */
    pwmHlConf.timer = &g_timer;                                     /* Use the already configured timer             */
    pwmHlConf.base.channelCount = NUMBER_OF_CHANNELS;               /* Configure the driver to use use all three
                                                                     * compare modules available in T12             */
    /* Assign output pins */
    pwmHlConf.cc0 = &IfxCcu60_CC60_P02_0_OUT;
    pwmHlConf.cc1 = &IfxCcu60_CC61_P02_2_OUT;
    pwmHlConf.cc2 = &IfxCcu60_CC62_P02_4_OUT;
    pwmHlConf.cout0 = &IfxCcu60_COUT60_P02_1_OUT;
    pwmHlConf.cout1 = &IfxCcu60_COUT61_P02_3_OUT;
    pwmHlConf.cout2 = &IfxCcu60_COUT62_P02_5_OUT;

    /* Initialize the PwmHl driver */
    IfxCcu6_PwmHl_init(&g_driver, &pwmHlConf);

    /* Instruct the driver to generate center aligned PWM signals */
    IfxCcu6_PwmHl_setMode(&g_driver, Ifx_Pwm_Mode_centerAligned);

    /* Set the duty cycles for the three channels */
    Ifx_TimerValue cmpValues[NUMBER_OF_CHANNELS];
    cmpValues[0] = CHANNEL1_COMPARE_VALUE;                          /* Set the compare value for channel 1          */
    cmpValues[1] = CHANNEL2_COMPARE_VALUE;                          /* Set the compare value for channel 2          */
    cmpValues[2] = CHANNEL3_COMPARE_VALUE;                          /* Set the compare value for channel 3          */

    g_driver.update(&g_driver, cmpValues);                          /* Apply the compare values                     */

    /* Update the timer.
     * This instruction enables the shadow transfer of the compare values, copying the compare values to the
     * compare registers */
    IfxCcu6_TimerWithTrigger_applyUpdate(g_driver.timer);

    /* Restore interrupts to their initial state */
    IfxCpu_restoreInterrupts(interruptState);

    //startPWMGeneration
    IfxCcu6_TimerWithTrigger_run(&g_timer);

    while(1)
    {
    }
}

官方的测试结果:

在这里插入图片描述

CCU6_PWM_Capture

参考 CCU6_PWM_Capture_1 for KIT_AURIX_TC397_TFT

软件模拟PWM通过P02.1引脚输出, 然后用CCU6 T12(P02.0输入, 与P02.1短接)测量频率和占空比:

  • 需要一个中断CCU6_edge_detection_isr捕获PWM, 用两个上升沿计算周期, 上升沿和下降沿计算占空比
  • 另一个中断CCU6_period_match_isr对计数器溢出计数
  • T12最大值65534(16bit-1), T12频率781250Hz => 1.28us, 在65534*1.28us≈0.084s后溢出

周期计算举例:

在这里插入图片描述

高电平时间计算举例:

在这里插入图片描述

Cpu0_Main.c代码如下:

#include "Ifx_Types.h"
#include "IfxCpu.h"
#include "IfxScuWdt.h"

#include "Ifx_Types.h"
#include "IfxCcu6_Icu.h"
#include "Bsp.h"

IFX_ALIGN(4) IfxCpu_syncEvent g_cpuSyncEvent = 0;

#define ISR_PRIORITY_CCU6_RISING_EDGE   1               /* Define the CCU6 rising edge interrupt priority           */
#define ISR_PRIORITY_CCU6_PERIOD_MATCH  2               /* Define the CCU6 period match interrupt priority          */
#define CCU6_INPUT_PIN                  IfxCcu60_CC60INA_P02_0_IN /* Select input port pin P02.0                    */

#define PWM_PIN                         &MODULE_P02,1   /* Pin used to generate a simple PWM signal                 */
#define SEC_TO_USEC                     1000000         /* Factor to convert seconds to microseconds                */
#define MAX_VAL_T12                     (0xFFFF - 1)    /* Maximum number of ticks between two overflows            */

IfxCcu6_Icu_Channel g_icuChannel;           /* CCU6 ICU channel handle                                              */
float32 g_CCU6Frequency_Hz = 0.0;           /* Global variable which stores the CCU6 capture frequency              */

float32 g_generatedPwmFreq_Hz = 5.0;        /* Frequency of the generated PWM signal                                */
float32 g_generatedPwmDutyCycle = 80.0;     /* Duty cycle in percentage of the generated PWM signal                 */
float32 g_measuredPwmFreq_Hz = 0.0;         /* Calculated frequency of the measured PWM signal                      */
float32 g_measuredPwmDutyCycle = 0.0;       /* Calculated duty cycle of the measured PWM signal                     */
uint32  g_cntOverflowPeriod = 0;            /* Counter of timer overflows between two rising edges                  */
uint32  g_cntOverflowHighLevel = 0;         /* Counter of timer overflows between a rising and a falling edge       */
uint32  g_previousCntVal = 0;               /* Global variable to store the timer value of the previous interrupt   */

IFX_INTERRUPT(CCU6_edge_detection_isr, 0, ISR_PRIORITY_CCU6_RISING_EDGE);

/* Interrupt Service Routine of the CCU6, which gets triggered by a rising edge of the input port pin of timer T12 */
void CCU6_edge_detection_isr(void)
{
    uint32  risingEdgeCntVal = 0;           /* Number of ticks between the last overflow and the rising edge        */
    uint32  fallingEdgeCntVal = 0;          /* Number of ticks between the last overflow and the falling edge       */

    /* Check on the occurrence of the rising edge */
    if (g_icuChannel.ccu6->IS.B.ICC60R)
    {
        /* Reset interrupt status flag */
        IfxCcu6_clearInterruptStatusFlag(&MODULE_CCU60, IfxCcu6_InterruptSource_cc60RisingEdge);

        /* Get the captured rising edge counter value from the counter register */
        risingEdgeCntVal = IfxCcu6_getCaptureRegisterValue(g_icuChannel.ccu6, g_icuChannel.channelId);
    }

    /* Check on the occurrence of the falling edge */
    if (g_icuChannel.ccu6->IS.B.ICC60F)
    {
        /* Reset interrupt status flag */
        IfxCcu6_clearInterruptStatusFlag(&MODULE_CCU60, IfxCcu6_InterruptSource_cc60FallingEdge);

        /* Get the captured falling edge counter value from the shadow register */
        fallingEdgeCntVal = IfxCcu6_getCaptureShadowRegisterValue(g_icuChannel.ccu6, g_icuChannel.channelId);
    }

    /* Define a variable to calculate the final timer counter value */
    uint32 finalFreqCntVal, finalDutyCycCntVal = 0;

    /* If no overflow was detected during the period measurement */
    if(g_cntOverflowPeriod == 0)
    {
        finalFreqCntVal = risingEdgeCntVal - g_previousCntVal;      /* Total counter value calculation          */
    }
    /* If one or more overflows were detected during the period measurement */
    else
    {
        /* Add to the current counter value, the amount of counter ticks which passed before the first overflow,
         * plus 65534 (0xFFFF - 1) for each additional overflow occurred between two rising edges.
         */
        finalFreqCntVal = (uint32)(risingEdgeCntVal + (MAX_VAL_T12 - g_previousCntVal) + ((g_cntOverflowPeriod - 1) * MAX_VAL_T12));
    }

    /* If no overflows were detected during signal high level time measurement */
    if(g_cntOverflowHighLevel == 0)
    {
        finalDutyCycCntVal = fallingEdgeCntVal - g_previousCntVal;
    }

    /* If one or more overflows were detected during signal high level time measurement */
    else
    {
        /* Add to the current counter value, the amount of counter ticks which passed before the first overflow,
         * plus 65534 (0xFFFF - 1) for each additional overflow occurred between the rising and the falling edge.
         */
        finalDutyCycCntVal = (uint32)(fallingEdgeCntVal + (MAX_VAL_T12 - g_previousCntVal) + ((g_cntOverflowHighLevel - 1) * MAX_VAL_T12));
    }

    /* The PWM frequency is calculated by dividing the captured frequency with the final total counter value
     *      total number of ticks * (1 / CCU6 frequency) = period of the measured signal =>
     *      => frequency of the measured signal = CCU6 frequency / total number of ticks
     */
    g_measuredPwmFreq_Hz = g_CCU6Frequency_Hz / (float32)finalFreqCntVal;

    /* The PWM duty cycle is calculated by dividing the captured signal high level time by the period */
    g_measuredPwmDutyCycle = 100 * (finalDutyCycCntVal / (float32)finalFreqCntVal);

    g_previousCntVal = risingEdgeCntVal;    /* Update g_previousCntVal for the next calculation                 */
    g_cntOverflowPeriod = 0;                /* Reset overflow counter of the period measurement                 */
    g_cntOverflowHighLevel = 0;             /* Reset overflow counter of the signal high level time measurement */
}

/* Macro to define the Interrupt Service Routine */
IFX_INTERRUPT(CCU6_period_match_isr, 0, ISR_PRIORITY_CCU6_PERIOD_MATCH);

/* Interrupt Service Routine of the CCU6, which gets triggered at each period match event for counting overflows */
void CCU6_period_match_isr(void)
{
    g_cntOverflowPeriod++;

    /* Increments high level time measurement overflows number only if the signal is still high
     * (no falling edge occurrence yet)
     */
    if(IfxCcu6_getInterruptStatusFlag(&MODULE_CCU60, IfxCcu6_InterruptSource_cc60FallingEdge) == FALSE)
    {
        g_cntOverflowHighLevel++;
    }
}

void core0_main(void)
{
    IfxCpu_enableInterrupts();
    
    /* !!WATCHDOG0 AND SAFETY WATCHDOG ARE DISABLED HERE!!
     * Enable the watchdogs and service them periodically if it is required
     */
    IfxScuWdt_disableCpuWatchdog(IfxScuWdt_getCpuWatchdogPassword());
    IfxScuWdt_disableSafetyWatchdog(IfxScuWdt_getSafetyWatchdogPassword());
    
    /* Wait for CPU sync event */
    IfxCpu_emitEvent(&g_cpuSyncEvent);
    IfxCpu_waitEvent(&g_cpuSyncEvent, 1);
    
    //init_CCU6_ICU, Configure the CCU6 for capturing the rising edge of a PWM signal
    IfxCcu6_Icu ccu6Handle;                                             /* CCU6 handle                              */
    IfxCcu6_Icu_Config ccu6Config;                                      /* Create a configuration structure         */

    IfxCcu6_Icu_initModuleConfig(&ccu6Config, &MODULE_CCU60);           /* Fill the structure with default values   */
    IfxCcu6_Icu_initModule(&ccu6Handle, &ccu6Config);                   /* Initialize the module                    */

    /* Store the configured captured frequency in a global variable */
    g_CCU6Frequency_Hz = ccu6Handle.captureFrequency;

    IfxCcu6_Icu_ChannelConfig ccu6ChannelConfig;                        /* Create a channel configuration structure */
    IfxCcu6_Icu_initChannelConfig(&ccu6ChannelConfig, &MODULE_CCU60);   /* Fill the structure with default values   */

    ccu6ChannelConfig.channelId = IfxCcu6_T12Channel_0;                 /* Select Timer T12 channel 0               */

    /* Select the capture mode: IfxCcu6_T12ChannelMode_doubleRegisterCaptureRisingAndFalling
     * With this particular value, the CCU6 stores the T12 value in the CC6xR register when a rising edge is detected,
     * while it stores the T12 value in the CC6xSR shadow register when a falling edge is detected.
     */
    ccu6ChannelConfig.channelMode = IfxCcu6_T12ChannelMode_doubleRegisterCaptureRisingAndFalling;

    /* Service Request 0 for interrupt at any rising or falling edge */
    ccu6ChannelConfig.interrupt1.source = IfxCcu6_InterruptSource_cc60RisingEdge; /* Select the interrupt source    */
    ccu6ChannelConfig.interrupt1.serviceRequest = IfxCcu6_ServiceRequest_0; /* Select the service request output    */
    ccu6ChannelConfig.interrupt1.priority = ISR_PRIORITY_CCU6_RISING_EDGE;  /* Configure the interrupt priority     */
    ccu6ChannelConfig.interrupt1.typeOfService = IfxSrc_Tos_cpu0;           /* Select the type of interrupt service */

    /* Service Request 1 for interrupt at T12 period match */
    ccu6ChannelConfig.interrupt2.source = IfxCcu6_InterruptSource_t12PeriodMatch; /* Select the interrupt source    */
    ccu6ChannelConfig.interrupt2.serviceRequest = IfxCcu6_ServiceRequest_1; /* Select the service request output    */
    ccu6ChannelConfig.interrupt2.priority = ISR_PRIORITY_CCU6_PERIOD_MATCH; /* Configure the interrupt priority     */
    ccu6ChannelConfig.interrupt2.typeOfService = IfxSrc_Tos_cpu0;           /* Select the type of interrupt service */

    /* Configure internal start of timer T12 controlled by the run bit T12R */
    ccu6ChannelConfig.trigger.extInputTrigger = NULL_PTR;

    /* CCU6 ICU pin configuration */
    IfxCcu6_Icu_Pins pins =
    {
        &CCU6_INPUT_PIN,            /* CC60In pin                   */
        NULL_PTR,                   /* CC61In pin not used          */
        NULL_PTR,                   /* CC62In pin not used          */
        NULL_PTR,                   /* CCPOS0In pin not used        */
        NULL_PTR,                   /* CCPOS1In pin not used        */
        NULL_PTR,                   /* CCPOS2In pin not used        */
        IfxPort_InputMode_pullUp,   /* CC6x pin input mode          */
        IfxPort_InputMode_pullUp,   /* CCPOSx pin input mode        */
        NULL_PTR,                   /* T12HR input signal not used  */
        NULL_PTR,                   /* T13HR input signal not used  */
        IfxPort_InputMode_pullUp    /* Pad driver mode              */
    };
    ccu6ChannelConfig.pins = &pins;                                     /* Set the configuration of the port pins   */

    ccu6ChannelConfig.multiInputCaptureEnabled = FALSE;                 /* Disable multiple input capture mode      */

    IfxCcu6_Icu_initChannel(&g_icuChannel, &ccu6ChannelConfig);         /* Initialize the channel                   */

    /* Start the timer T12 by setting the run bit T12R with the associated bit T12RS */
    IfxCcu6_Icu_startCapture(&g_icuChannel);

    initTime();                                                         /* Initialize the time constants            */
    IfxPort_setPinMode(PWM_PIN, IfxPort_Mode_outputPushPullGeneral);    /* Initialize the PWM_PIN port pin          */

    while(1)
    {
        /* Calculate the total time between two rising edges for the specific frequency */
        uint32 targetWaitTime_us = (1 / g_generatedPwmFreq_Hz) * SEC_TO_USEC * TimeConst_1us;

        /* Set the port pin state to high in order to trigger an interrupt */
        IfxPort_setPinState(PWM_PIN, IfxPort_State_high);
        /* Wait time while the signal is in high state */
        wait(g_generatedPwmDutyCycle * targetWaitTime_us / 100);

        /* Set pin state to low */
        IfxPort_setPinState(PWM_PIN, IfxPort_State_low);
        /* Wait time while the signal is in low state */
        wait((100 - g_generatedPwmDutyCycle) * targetWaitTime_us / 100);

    }
}

微信公众号

欢迎扫描关注我的微信公众号, 及时获取最新文章:
在这里插入图片描述

weifengdq
关注
  • 10
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
Aurix TC3xx系列MCU GPT模块配置
m0_38045338的博客
03-10 770
介绍了英飞凌Aurix TC3xx系列单片机GPT模块在EB tresos中的配置方法。
TC3XX - MCAL知识点（五）：GPT12 EB-tresos配置说明与代码浅析
梦想技术家
07-11 804
通用定时器单元块GPT1和GPT2具有非常灵活的多功能定时器结构，可用于定时、事件计数、脉宽测量、脉冲产生、倍频等用途。统称为GPT12而已。它们包含了5个16位定时器，它们被分组到两个定时器块GPT1和GPT2中。每个块中的每个计时器可以在许多不同的模式下独立运行，例如门控计时器或计数器模式，或者可以与同一块的另一个计时器连接。GPT12模块时钟为FgptGPT1包含三个定时器/计数器:核心定时器T3和两个辅助定时器T2和T4。最大分辨率为fGpT/4。
AURIX-TC275 Ccu6在电机控制中的应用
sinat_28346733的博客
08-31 1131
CCU6 Timer T13
TC397 使用 EB 配置PWM波
我只是来这世间散散步
04-13 802
TC397 使用EB 配置生产PWM波
AURIX TC397 Timer PWM 基础知识
weifengdq的专栏
10-30 9580
目录Timer/PWM资源STMGTMGPT12CCU6参考微信公众号 Timer/PWM资源 TC397有下列Timer/PWM资源: 6x STM GTM 1x GPT12 1x CCU6 STM STM, System Timer, 系统定时器, 64bit计数器, 6个STM意味着6个核每个都可以有自己的时基定时器, 用于各自的RTOS GTM GTM, Generic Timer Module, 通用定时器模块, 24bit分辨率, 10ns精度, 可以用于**PWM输出, 脉冲捕获, 电
AURIX TC397 Timer PWM 之 STM GTM
weifengdq的专栏
11-02 5345
目录STM_InterruptSTM_System_TimeGTM_ATOM_PWMGTM_ATOM_InterruptGTM_TOM_PWMGTM_TIM_Capture微信公众号 STM_Interrupt 下面Cpu0_Main.c的代码, STM配置每500ms触发一次中断, 中断中翻转LED: STM是一个自由运行的64bit计数器, 先声明结构体IfxStm_CompareConfig g_STMConf;, 初始化结构体; 设置中断优先级 g_STMConf.triggerPriority
12.GPT定时器
Pintitus的博客
05-21 1117
一、GPT定时器 ​ 以前的延时，通过空指令进行延时，不准确。当修改时钟频率后，才用延时就会有很大的变动。而6ULL的GPT是一个高精度定时器装置。 ​ GPT是一个32bit的向上计数器，有两个输入捕获通道，三个输出比较通道。有一个12分频器。 ​ GPT有两种模式restart和free-run模式。restart模式：定时器的值与寄存器的某个值比较相等就会重新开始计时。它是捕获专有的。free-run模式适用于比较输出的模式。 二、寄存器 ​ CR寄存： bit[0]：模块使能 bit[1]
英飞凌AURIX TC2xx TC3xx代码例程
最新发布
05-23
内容概要：压缩包中有TC234、TC237、TC265、TC275、TC297、TC334、TC367、TC375、TC377、TC387、TC397各资源代码例程（ADC、Timer、CAN、LIN、以太网、SPI、IIC、RTC。。。。），每个例程都带有驱动库，可以独立编译...
TC26X GPT12DEMO
08-04
这个DEMO着重展示了GPT12（General Purpose Timer 12）模块的功能，该模块是英飞凌微控制器中的一个关键组件，用于实现精确的时间控制和定时任务。 英飞凌TC26X系列是高性能的32位微控制器，广泛应用于工业自动化、...
Infineon TC397 WDT驱动模块
08-29
Infineon TC397 WDT驱动模块是针对Infineon公司生产的TC397系列微控制器中的看门狗定时器（Watchdog Timer, WDT）功能进行操作和管理的软件组件。看门狗定时器在嵌入式系统中扮演着重要的角色，它能确保系统在异常或...
Timer_A之典型应用——PWM
08-28
**Timer_A PWM应用详解** Timer_A是MSP430微控制器中一个强大的定时器模块，它可以被用来实现多种功能，其中包括脉冲宽度调制（PWM）。PWM是一种模拟信号生成技术，通过改变数字信号的高电平和低电平持续时间...
霍尔传感器模式实现直流无刷电机同步整流控制
08-09
本文阐述了利用英飞凌XC866/846中包含的CCU6E模块实现硬件霍尔换相和同步整流的方案，并进行了验证。与传统的利用软件扫描霍尔输入的方案相比，CCU6E可以自动进行霍尔信号滤波、采样、比较及换相等操作，CPU占用率低，占有软件资源少，换相误差小，电机控制效率高，对于高速电机等对换相误差要求高的应用，具有很大优势。
CCU6-输入捕获／输出比较单元6.pdf
05-03
1)CCU6单元中有两个独立的计数器：T12和T13，可被用来产生脉宽调制 （PWM）信号，尤其适用于控制交流电机的应用场合。 2)CCU6支持用于块交换和多相电机的专用控制模式。 3)除了适合电机控制以外，CCU6单元还可以单独用作输入捕捉和输出比较 的应用。
Aurix培训完整实验例程
01-16
Aurix培训完整实验例程 适用TC2xx系列 同济大学英飞凌培训材料
STM32 TIMER PWM频率计算工具 20181008 修改
10-08
STM32 TIMER PWM频率计算工具 20181008
MCAL知识点（二十七）：TC275如何通过GPT12实现ABZ解码
梦想技术家
02-19 445
GPT12 - General Purpose Timer Unit (GPT12):通用定时器单元，具备较为灵活的定时器结构，可以用来做定时器、事件计数、脉冲宽度测量、产生PWM、频率调制、ABZ编码器增量测量。文章记录一下如何通过GPT12实现编码器ABZ信号的测量。注意一下使用方法，只有GPT1才具备增量接口模式。
TC275旋变软解码仿真
u013719984的博客
12-04 2564
TC275旋变软解码仿真
基于TC397的Bootloader开发过程中遇到的问题记录
dp的博客
01-11 2114
开发boot过程中的简单记录
AURIX系列之TC275学习笔记（四）：GPT2 模块
qq_45528033的博客
05-11 1718
定时器 GPT2 模块 这次简单介绍下GPT2 GPT2 模块框图 **捕捉/重载寄存器 CAPREL 可用来捕捉定时器 T5 的值， 或者重载定时器 T6。 同时， 特殊模式促进两种功能对寄存器 CAPREL的使用。 该模式允许倍频。 捕捉功能由输入引脚 CAPIN 或 GPT1 定时器的 T3 输入线 T3IN 和 T3EUD 触发。 重载功能由定时器T6 的的上溢或下溢触发。**每个定时器的当
TIM,TOM,CCU6,GTM,GPT的
09-07
在GTM模块中，包含了多个子模块，其中包括了TIM、TOM和CCU6。 TIM模块是用于进行PWM波的周期和占空比测量的。TOM模块则是用于产生PWM波的。而CCU6模块是GTM中的定时器和计数器单元，用于实现更复杂的定时和计数功能。GTM是一个通用计时模块，可以用于多种用途，包括高精度的定时和计数应用。GPT是另一个模块，代表通用定时器。它通常用于提供简单的定时功能，例如生成延时或周期性中断。除此之外，GTM还包含了其他模块，例如CMU模块用于产生多个时钟信号，以及DPLL和BRC等模块用于时钟同步和时钟源选择。总的来说，GTM是一个功能强大的计时模块，可以满足多种计时和控制需求。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [AURIX TC397 Timer PWM 基础知识](https://blog.csdn.net/weifengdq/article/details/109387875)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [Autosar MCAL-GTM之TOM](https://blog.csdn.net/weixin_49000276/article/details/128267796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值