LoopBack

This sample demonstrates data communication using SPI in loopback mode.

SPI1 is configured as the Master, while SPI0 is configured as the Slave. The Master and Slave send data to each other for communication.

The example uses an interrupt for data receive. When the data transfer is completed, the SPI_INT_RXF interrupt is triggered for data reception.

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

On the EVB, connect P2_4(Master SCK) to P3_0(Slave SCK), P2_5(Master MOSI) to P3_1(Slave MOSI), P2_6(Master MISO) to P3_2(Slave MISO), and P2_7(Master CS) to P3_3(Slave CS).

Building and Downloading

This sample can be found in the SDK folder:

Keil

Project file: samples\peripheral\spi\loopback\proj\rtl87x2g\mdk

GCC

Project file: samples\peripheral\spi\loopback\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 spi loopback test!
```

The Slave receives the data from the Master, enters the interrupt, prints the length of the data received by the Slave, and prints the data received by the Slave and the data sent by the Master.

SPI SLAVE receieves 20 data.
slave_rx_buf[0] = 0x00000001, master_tx_buf[0] = 0x00000001
slave_rx_buf[1] = 0x00000002, master_tx_buf[1] = 0x00000002
...
slave_rx_buf[19] = 0x00000014, master_tx_buf[19] = 0x00000014

The Master receives the information sent by the Slave, enters an interrupt, prints the length of the data received by the Master, and prints the data received by the Master and the data sent by the Slave.

SPI MASTER receieves 20 data
master_rx_buf[0] = 0x00000010, slave_tx_buf[0] = 0x00000010
master_rx_buf[1] = 0x00000011, slave_tx_buf[1] = 0x00000011
...
master_rx_buf[19] = 0x00000023, slave_tx_buf[19] = 0x00000023

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

Source files are currently categorized into several groups as below.

└── Project: loopback
    └── 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_spi.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── main_ns.c
            ├── spi_flash.c          includes a wrapper implementation of functions to communicate with external flash
            └── io_spi.c

Initialization

The initialization process includes board_spi_slave_init, board_spi_master_init, driver_spi_slave_init, and driver_spi_master_init.

board_spi_slave_init contains the PAD and PINMUX settings for SPI0_SLAVE:

Config PAD: Set pin as PINMUX mode, PowerOn, internal Pull-Up.
Config PINMUX: Assign pins for SPI0_CLK_SLAVE, SPI0_SI_SLAVE, SPI0_SO_SLAVE, and SPI0_CSN_0_SLAVE functions respectively.

board_spi_master_init contains the PAD and PINMUX settings for SPI1:

Config PAD: Refer to board_spi_slave_init.
Config PINMUX: Assign pins for SPI1_CLK_MASTER, SPI1_MO_MASTER, SPI1_MI_MASTER, and SPI1_CSN_0_MASTER functions respectively.

driver_spi_slave_init contains the initialization of SPI0_SLAVE peripherals:

Enable PCC clock.
Set the transmission mode to Fullduplex.
Configure the transmission data width.
Configure the clock to high level during idle state, with data captured on the second clock edge.
Configure the receive data length threshold to SEND_LENGTH - 1.
Set the data transfer format.
Enable SPI0_SLAVE.
Configure the receive buffer full interrupt SPI_INT_RXF.
Prepare the data to be sent from the Slave and execute the SPI_SendBuffer() function to store the data into the FIFO.

RCC_PeriphClockCmd(APBPeriph_SPI_SLAVE, APBPeriph_SPI_CLOCK_SLAVE, ENABLE);
...
SPI_InitStruct.SPI_Direction   = SPI_Direction_FullDuplex;
SPI_InitStruct.SPI_DataSize    = SPI_DataSize_8b;
SPI_InitStruct.SPI_CPOL        = SPI_CPOL_High;
SPI_InitStruct.SPI_CPHA        = SPI_CPHA_2Edge;
/* SPI_Direction_EEPROM mode read data lenth. */
SPI_InitStruct.SPI_RxThresholdLevel  = SEND_LENGTH - 1;/* Flash id lenth = 3*/
/* cause SPI_INT_RXF interrupt if data length in receive FIFO  >= SPI_RxThresholdLevel + 1*/
SPI_InitStruct.SPI_FrameFormat = SPI_Frame_Motorola;

SPI_Init(SPI_SLAVE, &SPI_InitStruct);
SPI_Cmd(SPI_SLAVE, ENABLE);

SPI_INTConfig(SPI_SLAVE, SPI_INT_RXF, ENABLE);
...
for (uint32_t i = 0; i < SEND_LENGTH; i++)
{
    slave_tx_buf[i] = 0x10 + i;
}
SPI_SendBuffer(SPI_SLAVE, slave_tx_buf, SEND_LENGTH);

driver_spi_master_init contains the initialization of SPI1 peripherals:

Refer to driver_spi_slave_init for basic initialization settings.
Enable SPI MASTER.
Prepare the data to be sent by Master, execute SPI_SendBuffer() function to store the data into the FIFO.

Note

Before the master starts a communication, the slave must have the data ready in the tx FIFO.

Functional Implementation

Data is sent from the master to the slave. The slave transmits the data to the master from its FIFO after receiving the clock signal.
After the master receives data from the slave, the SPI_INT_RXF interrupt is triggered, and enters the interrupt function SPI_Handler_MASTER
1. Clear SPI_INT_RXF interrupt pending bit.
2. Execute SPI_GetRxFIFOLen() to get the length of data in FIFO.
3. Execute SPI_ReceiveData() to receive the data sent by the slave and print the data to compare whether the received and sent data are the same.

SPI_INTConfig(SPI_MASTER, SPI_INT_RXF, DISABLE);
SPI_ClearINTPendingBit(SPI_MASTER, SPI_INT_RXF);
uint32_t master_rx_len = SPI_GetRxFIFOLen(SPI_MASTER);
for (uint32_t i = 0; i < master_rx_len; i++)
{
   master_rx_buf[i] = SPI_ReceiveData(SPI_MASTER);
   ...
}
SPI_INTConfig(SPI_MASTER, SPI_INT_RXF, ENABLE);

When the Slave receives the data from the master, it triggers the SPI_INT_RXF interrupt and enters the interrupt function SPI_Handler_SLAVE
1. Clear SPI_INT_RXF interrupt pending bit.
2. Execute SPI_GetRxFIFOLen() to get the length of data in FIFO.
3. Execute SPI_ReceiveData() to receive the data sent by the slave and print the data to compare whether the received and sent data are the same.

SPI_INTConfig(SPI_MASTER, SPI_INT_RXF, DISABLE);
SPI_ClearINTPendingBit(SPI_MASTER, SPI_INT_RXF);
uint32_t master_rx_len = SPI_GetRxFIFOLen(SPI_MASTER);
for (uint32_t i = 0; i < master_rx_len; i++)
{
   master_rx_buf[i] = SPI_ReceiveData(SPI_MASTER);
   ...
}
SPI_INTConfig(SPI_MASTER, SPI_INT_RXF, ENABLE);