Enhance Timer Timeout

This sample uses ENH_TIM0 to implement a one-second timer function.

In order to facilitate the observation of the phenomenon, connect P0_0 to LED0.

When the timer reaches the set time, an interrupt is triggered, and in the interrupt handler function, P0_0 (LED0) is toggled to achieve a blinking effect for LED0 every second.

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 P0_0 to LED0 on the EVB.

The LED driver circuit is shown below.

Here should be a picture of the LED driver circuit — LED Driver Circuit Diagram

Building and Downloading

This sample can be found in the SDK folder:

Keil

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

GCC

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

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

Open sample project file.
To build the target, follow the steps listed on the Generating App Image in Quick Start.
After a successful compilation, the app bin app_MP_xxx.bin will be generated in the directory mdk\bin or gcc\bin.
To download app bin into EVB board, follow the steps listed on the MP Tool Download in Quick Start.
Press reset button on EVB board and it will start running.

Experimental Verification

When the EVB starts, observe the following log within the Debug Analyzer
```
Start enhtim interrupt test!
```
Once P0_0 is connected to LED0, LED0 will blink every 1 second.

Code Overview

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

Source Code Directory.
Peripheral initialization will be introduced in chapter Initialization.
Functional implementation after initialization will be introduced in chapter Functional Implementation.

Source Code Directory

Project Directory: sdk\samples\peripheral\enhtimer\enhtim_interrupt\proj
Source Code Directory: sdk\samples\peripheral\enhtimer\enhtim_interrupt\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_gpio.c
            ├── rtl_nvic.c
            └── rtl_enh_tim.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── main_ns.c
            └── io_enhtim_interrupt.c

Initialization

The initialization process includes board_gpio_init, driver_gpio_init, and driver_enhtim_init.

board_gpio_init contains the PAD and PINMUX settings.

Configure PAD: Set PIN as PINMUX mode, PowerOn, internal Pull-Up.
Configure PINMUX: Multiplex the pin to GPIO function.

driver_gpio_init contains the initialization of GPIO peripherals.

Enable PCC clock.
Set GPIO_Pin to P0_0.
Set GPIO_Dir to GPIO output mode.

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

driver_enhtim_init contains the initialization of ENHTIM peripherals.

Enable PCC clock.
Set ENHTIM_ClockDiv to ENHTIM_CLOCK_DIVIDER_1, which means one division mode.
Set ENHTIM_PWMOutputEn to DISABLE, which means disable the PWM function of ENHTIM.
Set ENHTIM_MaxCount to ENHTIM_PERIOD, which means set the period of ENHTIM.
Set ENHTIM_Mode to ENHTIM_MODE_PWM_MANUAL, which means user-defined manual mode.
Configure ENHTIM interrupt; enable ENHTIM timer interrupt; enable ENHTIM peripheral.

RCC_PeriphClockCmd(APBPeriph_ENHTIMER, APBPeriph_ENHTIMER_CLOCK, ENABLE);
...
ENHTIM_InitStruct.ENHTIM_ClockDiv               = ENHTIM_CLOCK_DIVIDER_1;
ENHTIM_InitStruct.ENHTIM_PWMOutputEn            = DISABLE;
ENHTIM_InitStruct.ENHTIM_MaxCount               = ENHTIM_PERIOD;
ENHTIM_InitStruct.ENHTIM_Mode                   = ENHTIM_MODE_PWM_MANUAL;
ENHTIM_Init(ENHTIMER_NUM, &ENHTIM_InitStruct);

/*  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_Cmd(ENHTIMER_NUM, ENABLE);

Functional Implementation

When the timer of ENH_TIM0 reaches its specified timing, it triggers an interrupt, and the program enters the interrupt handling function Enhanced_Timer0_Handler.

Clear the interrupt flag of ENH_TIM0 and disable ENH_TIM0.
Check the current state of the LED, and toggle the level of LED0.

void Enhanced_Timer0_Handler()
{
    ENHTIM_ClearINTPendingBit(ENHTIMER_NUM, ENHTIM_INT_TIM);
    ENHTIM_Cmd(ENHTIMER_NUM, DISABLE);
    if (!LED_Status)
    {
        GPIO_WriteBit(GPIO_PORT, GPIO_PIN, (BitAction)(1));
        LED_Status = 1;
    }
    else
    {
        GPIO_WriteBit(GPIO_PORT, GPIO_PIN, (BitAction)(0));
        LED_Status = 0;
    }
    //Add user code here
    ENHTIM_Cmd(ENHTIMER_NUM, ENABLE);
}