IR Transmit

This example demonstrates the use of the IR transmit function. Data is sent using the IR peripheral to implement the IR transmit function, and the IR transmit waveform is observed using a logic analyzer.

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 the IR transmit pin P2_5 to the logic analyzer.

Building and Downloading

This sample can be found in the SDK folder:

Keil

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

GCC

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

Observe the IR TX waveform within the logic analyzer.

Here should be a picture of the IR sending waveforms — IR Transmit Waveform

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\ir\tx\proj
Source Code Directory: sdk\samples\peripheral\ir\tx\src

Source files are currently categorized into several groups as below.

└── Project: tx
    └── 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.

Config PAD: Set pin as PINMUX mode, PowerOn, internal Pull-None.
Config PINMUX: Assign P2_5 for IRDA_TX functions.

driver_ir_init contains the initialization of IR peripheral.

Enable PCC clock.
Set the IR transmit frequency to 38 kHz.
Set the IR carrier duty cycle to 1/2.
Set the IR to transmit mode.
Set IR_TxInverse to IR_TX_DATA_NORMAL, which means the IR transmission data will not be inverted.
Set the IR transmit FIFO threshold to 2.
Configure the IR to send FIFO data count less than the set send threshold interrupt IR_INT_TF_LEVEL.

RCC_PeriphClockCmd(APBPeriph_IR, APBPeriph_IR_CLOCK, ENABLE);
...
IR_InitStruct.IR_Freq           = vFreq;
IR_InitStruct.IR_DutyCycle      = 2; /* !< 1/2 duty cycle */
IR_InitStruct.IR_Mode           = IR_MODE_TX;
IR_InitStruct.IR_TxInverse      = IR_TX_DATA_NORMAL;
IR_InitStruct.IR_TxFIFOThrLevel = IR_TX_FIFO_THR_LEVEL;
IR_Init(&IR_InitStruct);

/* Enable IR threshold interrupt. when TX FIFO offset <= threshold value, trigger interrupt*/
IR_INTConfig(IR_INT_TF_LEVEL, ENABLE);
...

Functional Implementation

Define IR send data array: carrier data is represented by the number of carriers or 0x80000000, no carrier data is represented by the number of carriers or 0x00000000.
Execute IR_SendBuf() function to start sending data into IR send FIFO; enable IR peripheral send function.
Record the number of data that have been sent.

IR_TxData.CarrierFreq = 38000;
IR_TxData.DataLen = 67 + 1; //2+64+1;
IR_TxData.DataBuf[0] =  0x80000000 | 0x156; //342 about 9ms
IR_TxData.DataBuf[1] =  0x00000000 | 0xAB; //171 about 4.5ms
...
IR_TxData.DataBuf[IR_TxData.DataLen - 1] =  0x80000000 | 0x15;
...
IR_SendBuf(IR_TxData.DataBuf, IR_TX_FIFO_SIZE, DISABLE);
IR_Cmd(IR_MODE_TX, ENABLE);

When the number of FIFO data sent by IR is less than the set sending threshold (set to 2 in this example), trigger the IR_INT_TF_LEVEL interrupt and enter the interrupt handler function IR_Handler.
1. Mask the IR_INT_TF_LEVEL interrupt.
2. If the number of data remaining to be sent is greater than the size of the sending FIFO, insert (IR_TX_FIFO_SIZE - IR_TX_FIFO_THR_LEVEL) data into the IR sending FIFO and send it to clear the IR_INT_TF_LEVEL interrupt suspend.
3. Otherwise, if the number of data remaining to be sent is greater than 0, stuff the IR transmit FIFO with the remaining data, clearing the IR_INT_TF_LEVEL interrupt pending bit.
4. Otherwise, if there is no remaining data, disable the IR_INT_TF_LEVEL interrupt and clear the IR_INT_TF_LEVEL interrupt pending bit.
5. Unmask the IR_INT_TF_LEVEL interrupt.

IR_MaskINTConfig(IR_INT_TF_LEVEL, ENABLE);
if ((IR_TxData.DataLen - IR_TX_Count) >= IR_TX_FIFO_SIZE)
{
    IR_SendBuf(IR_TxData.DataBuf + IR_TX_Count, (IR_TX_FIFO_SIZE - IR_TX_FIFO_THR_LEVEL), DISABLE);
    IR_TX_Count += (IR_TX_FIFO_SIZE - IR_TX_FIFO_THR_LEVEL);

    /* Clear threshold interrupt */
    IR_ClearINTPendingBit(IR_INT_TF_LEVEL_CLR);
}
else if ((IR_TxData.DataLen - IR_TX_Count) > 0)
{
    /* The remaining data is less than the TX FIFO length */

    /*  Configure TX threshold level to zero and trigger interrupt when TX FIFO is empty */
    IR_SetTxThreshold(0);
    IR_SendBuf(IR_TxData.DataBuf + IR_TX_Count, IR_TxData.DataLen - IR_TX_Count, DISABLE);
    IR_TX_Count += (IR_TxData.DataLen - IR_TX_Count);

    /* Clear threshold interrupt */
    IR_ClearINTPendingBit(IR_INT_TF_LEVEL_CLR);
}
else
{
    /* Tx completed */
    /* Disable IR tx empty interrupt */
    IR_INTConfig(IR_INT_TF_LEVEL, DISABLE);
    IR_TX_Count = 0;

    /* Clear threshold interrupt */
    IR_ClearINTPendingBit(IR_INT_TF_LEVEL_CLR);
}