IR Receive

This sample demonstrates the use of the IR receive function.

The RX function is realized by using another EVB to download the IR transmit program as the sender of IR data to send IR data to the EVB.

Data reception is performed within the IR interrupt, and if the amount of data is larger than the IR FIFO, it is necessary to receive data several times in a row.

The example of IR transmit can be found in IR Transmit.

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

Use another EVB to download the IR TX program, connecting P2_5 to the transmit pin of the other EVB.

Building and Downloading

This sample can be found in the SDK folder:

Project file: samples\peripheral\ir\rx\proj\rtl87x2g\mdk

Project file: samples\peripheral\ir\rx\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

When the number of IR receive counters reaches the set threshold, it represents that the IR data is received and enters the IR interrupt to print the received data and its length. The received data is the data content defined by the IR sender.

IR_INT_RX_CNT_THR
len = xx
[io_ir]io_handle_ir_msg: IR RX data[0] = xxx
[io_ir]io_handle_ir_msg: IR RX data[1] = xxx
...

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

  • Project Directory: sdk\samples\peripheral\ir\rx\proj

  • Source Code Directory: sdk\samples\peripheral\ir\rx\src

Source files are currently categorized into several groups as below.

└── Project: rx
    └── 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_nvic.c
            └── rtl_ir.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── main_ns.c
            └── io_ir.c

Initialization

The initialization process includes board_ir_init and driver_ir_init .

board_ir_init contains the PAD and PINMUX settings.

  1. Config PAD: Set pin as PINMUX mode, PowerOn, internal Pull-None.

  2. Config PINMUX: Assign P2_5 for IRDA_RX functions.

driver_ir_init contains the initialization of the IR peripheral.

  1. Enable PCC clock.

  2. Set the IR receive frequency to 38kHz.

  3. Set IR to auto receive mode.

  4. Set the IR receive threshold to 30 to discard the latest data when the IR receive FIFO is full and filter spurious data below 50ns.

  5. Set the level type that triggers the receive counter threshold interrupt to low and IR_RxCntThr to 0x1400.

  6. Enable the IR peripheral receive function and clear the IR receive FIFO.

  7. Configure the IR receive FIFO data count greater than the set receive threshold interrupt IR_INT_RF_LEVEL and the receive level timeout interrupt IR_INT_RX_CNT_THR.

  8. Unmask the IR_INT_RF_LEVEL and IR_INT_RX_CNT_THR interrupts.

RCC_PeriphClockCmd(APBPeriph_IR, APBPeriph_IR_CLOCK, ENABLE);
...
IR_InitStruct.IR_Freq               = 38000;
IR_InitStruct.IR_Mode               = IR_MODE_RX;
IR_InitStruct.IR_RxStartMode        = IR_RX_AUTO_MODE;
IR_InitStruct.IR_RxFIFOThrLevel     = IR_RX_FIFO_THR_LEVEL;
IR_InitStruct.IR_RxFIFOFullCtrl     = IR_RX_FIFO_FULL_DISCARD_NEWEST;
IR_InitStruct.IR_RxFilterTime       = IR_RX_FILTER_TIME_50ns;
IR_InitStruct.IR_RxTriggerMode      = IR_RX_FALL_EDGE;
IR_InitStruct.IR_RxCntThrType       = IR_RX_Count_Low_Level;
IR_InitStruct.IR_RxCntThr           = 0x200;
IR_Init(&IR_InitStruct);
IR_Cmd(IR_MODE_RX, ENABLE);
IR_ClearRxFIFO();
...
IR_INTConfig(IR_INT_RF_LEVEL | IR_INT_RX_CNT_THR, ENABLE);
IR_MaskINTConfig(IR_INT_RF_LEVEL | IR_INT_RX_CNT_THR, DISABLE);

Functional Implementation

1. Sends IR data to the IR transceiver module. The IR_INT_RF_LEVEL interrupt is triggered when the number of data in the IR receive FIFO reaches the set receive threshold (set to 30 in this example). Or when the number of receive counters reaches the set threshold (0x1400 in this example), trigger the IR_INT_RX_CNT_THR interrupt and enter the interrupt handler function IR_Handler.

  1. Mask the IR_INT_TF_LEVEL and IR_INT_RX_CNT_THR interrupts.

  2. If the triggered interrupt is IR_INT_TF_LEVEL, the IR is required to receive data from the FIFO. Store the data into DataBuf and record the length of the data that has been received.

  3. If the triggered interrupt is IR_INT_RX_CNT_THR, it means that the stop condition for IR to receive data is triggered. Store the remaining data into DataBuf, record the length of data that has been received, and print the data contents.

  4. Clear the IR_INT_RX_CNT_THR interrupt pending bit.

  5. Unmask the IR_INT_RF_LEVEL and IR_INT_RX_CNT_THR interrupts.

if (int_status_rfl == SET)
{
    len = IR_GetRxDataLen();
    IR_ReceiveBuf(IR_Rx_Data.DataBuf + IR_RX_Count, len);
    IR_Rx_Data.DataLen += len;
    IR_RX_Count += len;

    IR_ClearINTPendingBit(IR_INT_RF_LEVEL_CLR);
}

/* Stop to receive IR data */
if (int_status_rxcnt == SET)
{
    DBG_DIRECT("IR_INT_RX_CNT_THR");
    /* Read remaining data */
    len = IR_GetRxDataLen();
    IR_ReceiveBuf(IR_Rx_Data.DataBuf + IR_RX_Count, len);
    IR_Rx_Data.DataLen += len;
    IR_RX_Count += len;

                DBG_DIRECT("len = %d", IR_RX_Count);

    for (uint16_t i = 0; i < IR_RX_Count; i++)
    {
        DBG_DIRECT("[io_ir]io_handle_ir_msg: IR RX data[%d] = 0x%x", i, IR_Rx_Data.DataBuf[i]);
    }
    memset(&IR_Rx_Data, 0, sizeof(IR_Rx_Data));
    IR_RX_Count = 0;

    IR_ClearINTPendingBit(IR_INT_RX_CNT_THR_CLR);
}

/* Unmask IR all interrupt */
IR_MaskINTConfig(IR_INT_RF_LEVEL | IR_INT_RX_CNT_THR, DISABLE);