GPIO Latch

This sample uses ENH_TIM0 to implement the functionality of triggering the latch state of GPIO and recording the latch count.

P2_4 is set as a GPIO output pin with its voltage constantly flipping over time.

P2_2 is set as a GPIO input pin and also set as the count trigger pin for ENHTIM.

Connect pin P2_2 to pin P2_4. When there is a rising edge voltage change on pin P2_2, it triggers a count. After three consecutive changes, it triggers an ENHTIM interrupt, and within the interrupt function, it prints the counter value at the time of the three triggers.

Requirements

The sample supports the following development kits:

Development Kits

Hardware Platforms

Board Name

RTL87x2G HDK

RTL87x2G EVB

For more requirements, please refer to Quick Start.

Wiring

Connect P2_4 to P2_2.

Building and Downloading

This sample can be found in the SDK folder:

Project file: samples\peripheral\enhtimer\latch_gpio\proj\rtl87x2g\mdk

Project file: samples\peripheral\enhtimer\latch_gpio\proj\rtl87x2g\gcc

To build and run the sample, follow the steps listed below:

  1. Open sample project file.

  2. To build the target, follow the steps listed on the Generating App Image in Quick Start.

  3. After a successful compilation, the app bin app_MP_xxx.bin will be generated in the directory mdk\bin or gcc\bin.

  4. To download app bin into EVB board, follow the steps listed on the MP Tool Download in Quick Start.

  5. Press reset button on EVB board and it will start running.

Experimental Verification

  1. When the EVB starts, observe the following log within the Debug Analyzer.

    Start latch_gpio test!

  2. After connecting the P2_2 and P2_4 pins, the counter value at the time of each GPIO triggering latch will be continuously printed on the Debug Analyzer.

Here should be the count value latched by the GPIO trigger

The count value latched by the GPIO trigger

Code Overview

This chapter will be introduced according to the following several parts:

  1. Source Code Directory .

  2. Peripheral initialization will be introduced in chapter Initialization.

  3. Functional implementation after initialization will be introduced in chapter Functional Implementation.

Source Code Directory

  1. Project Directory: sdk\samples\peripheral\enhtimer\latch_gpio\proj

  2. Source Code Directory: sdk\samples\peripheral\enhtimer\latch_gpio\src

Source files are currently categorized into several groups as below.

└── Project: input_interrupt
    └── secure_only_app
        └── Device                   includes startup code
            ├── startup_rtl.c
            └── system_rtl.c
        ├── CMSIS                    includes CMSIS header files
        ├── CMSE Library             Non-secure callable lib
        ├── Lib                      includes all binary symbol files that user application is built on
            └── rtl87x2g_io.lib
        ├── Peripheral               includes all peripheral drivers and module code used by the application
            ├── rtl_rcc.c
            ├── rtl_pinmux.c
            └── rtl_enh_tim.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── main_ns.c
            └── io_latch_gpio.c

Initialization

The initialization process includes board_gpio_init, driver_gpio_init and driver_enhance_timer_init.

board_gpio_init contains the PAD and PINMUX settings.

  1. Configure PAD: Set PIN as PINMUX mode, PowerOn, internal Pull-Up.

  2. Configure PINMUX: Multiplex the pin to GPIO function.

driver_gpio_init contains the initialization of GPIO peripherals.

  1. Enable PCC clock.

  2. Set GPIO_Pin to P2_4.

  3. Set GPIO_Dir to GPIO output mode.

RCC_PeriphClockCmd(APBPeriph_GPIOA, APBPeriph_GPIOA_CLOCK, ENABLE);
...
GPIO_InitStruct.GPIO_Pin  = GPIO_PIN_OUTPUT;
GPIO_InitStruct.GPIO_Dir  = GPIO_DIR_OUT;

driver_enhance_timer_init contains the initialization of ENHTIM peripherals.

  1. Enable PCC clock.

  2. Set ENHTIM_ClockDiv to ENHTIM_CLOCK_DIVIDER_1, which means one division mode.

  3. Set ENHTIM_Mode to ENHTIM_MODE_FreeRun, which means the timer operates in free-running mode.

  4. Set ENHTIM_LatchCountEn[0] to ENABLE, which enables the GPIO triggering latch function.

  5. Set ENHTIM_LatchCountTrigger[0] to TRIGGER_RISING_EDGE, which means the latch is triggered on the rising edge.

  6. Set ENHTIM_LatchCountThd to 3, which sets the trigger interrupt FIFO threshold to 3.

  7. Set ENHTIM_LatchTriggerPad to INPUT_PIN.

  8. Set ENHTIM_TimerGPIOTriggerEn to ENABLE, which enables the GPIO-triggered timing function.

  9. Configure the ENHTIM interrupt, enable the ENHTIM timer interrupt, enable the FIFO threshold interrupt, and enable the ENHTIM peripheral.

RCC_PeriphClockCmd(APBPeriph_ENHTIMER, APBPeriph_ENHTIMER_CLOCK, ENABLE);
...
ENHTIM_InitStruct.ENHTIM_ClockDiv             = ENHTIM_CLOCK_DIVIDER_1;
ENHTIM_InitStruct.ENHTIM_Mode                 = ENHTIM_MODE_FreeRun;
ENHTIM_InitStruct.ENHTIM_LatchCountEn[0]      = ENABLE;
ENHTIM_InitStruct.ENHTIM_LatchCountTrigger[0] = ENHTIM_LATCH_TRIGGER_RISING_EDGE;
ENHTIM_InitStruct.ENHTIM_LatchCountThd        = 3;
ENHTIM_InitStruct.ENHTIM_LatchTriggerPad      = INPUT_PIN;

/*  Enable ENHTIM IRQ  */
NVIC_InitTypeDef NVIC_InitStruct;
NVIC_InitStruct.NVIC_IRQChannel = ENHTIMER_IRQn;
NVIC_InitStruct.NVIC_IRQChannelPriority = 3;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStruct);

ENHTIM_ClearINTPendingBit(ENHTIMER_NUM, ENHTIM_INT_TIM);
ENHTIM_INTConfig(ENHTIMER_NUM, ENHTIM_INT_TIM, ENABLE);

ENHTIM_ClearINTPendingBit(ENHTIMER_NUM, ENHTIM_INT_LATCH_CNT_FIFO_FULL);
ENHTIM_INTConfig(ENHTIMER_NUM, ENHTIM_INT_LATCH_CNT_FIFO_FULL, ENABLE);

ENHTIM_ClearINTPendingBit(ENHTIMER_NUM, ENHTIM_INT_LATCH_CNT_FIFO_THD);
ENHTIM_INTConfig(ENHTIMER_NUM, ENHTIM_INT_LATCH_CNT_FIFO_THD, ENABLE);

ENHTIM_Cmd(ENHTIMER_NUM, ENABLE);

Functional Implementation

When the rising edge trigger count of the GPIO input pin reaches the set threshold of the FIFO, it triggers an RNHTIM interrupt and enters the interrupt handler function Enhanced_Timer0_Handler.

  1. Check if the interrupt status bit is ENHTIM_INT_LATCH_CNT_FIFO_THD, disable the interrupt.

  2. Execute ENHTIM_GetLatchCountFIFOLength() to get the number of data in the FIFO.

  3. Execute ENHTIM_ReadLatchCountFIFO() to get the count value and print the value data.

  4. Clear the interrupt flag and enable the interrupt.

void Enhanced_Timer0_Handler()
{
    ...
    if (ENHTIM_GetINTStatus(ENH_TIM0, ENHTIM_INT_LATCH_CNT_FIFO_THD))
    {
        APP_PRINT_INFO0("ENH_TIM0 ENHTIM_INT_LATCH_CNT2_FIFO_THD\r\n");
        ENHTIM_INTConfig(ENHTIMER_NUM, ENHTIM_INT_LATCH_CNT_FIFO_THD, DISABLE);
        uint8_t length = ENHTIM_GetLatchCountFIFOLength(ENH_TIM0);
        uint32_t data[4] = {0};
        ENHTIM_ReadLatchCountFIFO(ENH_TIM0, data, length);
        /* Only for debugging, removed in actual application. */
        APP_PRINT_INFO1("ENH_TIM0 fifo length = %d\r\n", length);
        for (uint8_t i = 0; i < length; i++)
        {
            /* Only for debugging, removed in actual application. */
            APP_PRINT_INFO2("ENH_TIM0 data[%d] = 0x%x\r\n", i, data[i]);
        }

        ENHTIM_ClearINTPendingBit(ENH_TIM0, ENHTIM_INT_LATCH_CNT_FIFO_THD);
        ENHTIM_INTConfig(ENH_TIM0, ENHTIM_INT_LATCH_CNT_FIFO_THD, ENABLE);
    }
}