const ioport_pin_cfg_t g_bsp_pin_cfg_data[] = {
    ......
    {.pin = BSP_IO_PORT_03_PIN_04,
    .pin_cfg = ((uint32_t) IOPORT_CFG_PERIPHERAL_PIN 
              | (uint32_t) IOPORT_PERIPHERAL_GPT1)
    },
};

const timer_cfg_t g_timer0_gpt7_cfg =
{
    .mode                = TIMER_MODE_PERIODIC,
    /* Actual period: 0.00065536 seconds. Actual duty: 50%. */
        .period_counts = (uint32_t) 0x10000, 
        .duty_cycle_counts = 0x8000, 
        .source_div = (timer_source_div_t)0,
    .channel             = 7,
    .p_callback          = gpt7_input_capture_callback,
    /** If NULL then do not add & */
#if defined(NULL)
    .p_context           = NULL,
#else
    .p_context           = &NULL,
#endif
    .p_extend            = &g_timer0_gpt7_extend,
    .cycle_end_ipl       = (9),
#if defined(VECTOR_NUMBER_GPT7_COUNTER_OVERFLOW)
    .cycle_end_irq       = VECTOR_NUMBER_GPT7_COUNTER_OVERFLOW,
#else
    .cycle_end_irq       = FSP_INVALID_VECTOR,
#endif
};

R_GPT_Open(timer_ctrl_t * const p_ctrl, timer_cfg_t const * const p_cfg);

R_GPT_Start(timer_ctrl_t * const p_ctrl);

R_GPT_Stop(timer_ctrl_t * const p_ctrl);

void gpt7_input_capture_callback(timer_callback_args_t * p_args)
{
    switch(p_args->event)
    {
       /* 捕获到上升沿 -- 有可能是 A 或者 C (A') 位置 */
       case TIMER_EVENT_CAPTURE_A:

       break;
       /* 捕获到下降沿 -- 是 B 位置 */
       case TIMER_EVENT_CAPTURE_B:

       break;
       /* 定时器计数溢出事件 */
       case TIMER_EVENT_CYCLE_END:

       break;
    }
}

#ifndef _GPT_INPUT_CAPTURE_H
#define _GPT_INPUT_CAPTURE_H
#include "hal_data.h"

void gpt7_InputCapture_Init(void);

void printf_PWM_Info(void);

#endif

#include "gpt_input.h"

timer_info_t gptInfo; 
uint32_t periodCnt;  //定时器一个周期计数值 

void gpt7_InputCapture_Init(void)
{
    //初始化 GPT7 输入捕获模块
    R_GPT_Open(&g_timer0_gpt7_ctrl, &g_timer0_gpt7_cfg);

    //获取GPT7周期的计数次数
    R_GPT_InfoGet(&g_timer0_gpt7_ctrl, &gptInfo);
    periodCnt = gptInfo.period_counts;

    //使能输入捕获
      R_GPT_Enable(&g_timer0_gpt7_ctrl);

    //启动 GPT 定时器
    R_GPT_Start(&g_timer0_gpt7_ctrl);
}

//测量PWM参数
uint32_t pwm_period;      //PWM周期
uint32_t pwm_freq;        //PWM频率
uint32_t pwm_high_time;   //PWM高电平的时间
uint32_t pwm_duty;        //PWM占空比

//过程记录数据
uint32_t a_time;  // A 上升沿捕获的时间
uint32_t b_time;  // B 下降沿捕获的时间
uint32_t a1_time; // 下次A上升沿捕获的时间
uint32_t overflowCnts=0;     //计数器溢出次数
uint8_t  one_period_flag=0;  //是否完成一个完整周期的测量

//GPT7 输入捕获中断函数 
void gpt7_input_capture_callback(timer_callback_args_t * p_args)
{

    switch(p_args->event)
    {
        // 捕获到上升沿, A 或者 A1 位置
        case TIMER_EVENT_CAPTURE_A:
            //A 开始对某个周期进行测量
            if (0 == one_period_flag)
            {
                a_time = p_args->capture; //记录捕获的时间 A
                overflowCnts = 0;         //初始化计数器溢出次数
                one_period_flag = 1;      //表示即将完成对某个周期的测量
            }
            //A1 再次检测到上升沿, A--B--A1表示测到一个周期结束
                        else if (1 == one_period_flag)
            {
                            //记录捕获的时间 A1
              a1_time = p_args->capture + overflowCnts * periodCnt; 

              //计算 PWM 周期
              pwm_period = a1_time - a_time;

              //清零所有标志位
              overflowCnts = 0;
                            //标志位清0,重新进入下一轮的测量
              one_period_flag = 0;         
            }
         break;

        //捕获到下降沿, B 位置, A到B是高电平时间
        case TIMER_EVENT_CAPTURE_B:
            //在检测到A后才检测B
            if (1 == one_period_flag)
            {
                            //记录B捕获的时间 
              b_time = p_args->capture + overflowCnts * periodCnt; 

                            //计算高电平时间
              pwm_high_time = b_time - a_time;  
            }
            break;

        //定时器计数溢出, 表示过了一个周期的时间
        case TIMER_EVENT_CYCLE_END:
            // 输入捕获期间计数器溢出，则记录溢出次数+1
            overflowCnts++;
            break;

        default:
            break;
    }
}

//打印测试数据
void printf_PWM_Info(void)
{
    //计算PWM频率
    pwm_freq = gptInfo.clock_frequency / pwm_period;

    //计算PWM占空比
    pwm_duty = pwm_high_time * 100 / pwm_period;

    //打印数据
    printf("\r\n High=%d, Period=%d \r\n", pwm_high_time, pwm_period);
  printf("Frequency = %dHz, Duty_Cycle = %d%%\r\n", pwm_freq, pwm_duty);

  pwm_period = 0;
    pwm_high_time = 0;
    pwm_freq = 0; 
}

void hal_entry(void)
{
    /* TODO: add your own code here */

    led_Init(); // led 初始化
  uart0_Init();
    gpt_PWM_Init();
    gpt7_InputCapture_Init();

    printf("start GPT Input Capture test\r\n");

    while(1)
    {
        LED1_TOGGLE();
        R_BSP_SoftwareDelay(1, BSP_DELAY_UNITS_SECONDS); //延时1秒

        //打印数据
        printf_PWM_Info();
    }


#if BSP_TZ_SECURE_BUILD
    /* Enter non-secure code */
    R_BSP_NonSecureEnter();
#endif
}