Transmit And Receive

This sample demonstrates the data transmission and reception capabilities of the CAN peripheral.

The CAN external USB CAN FD analyzer communicates with the CAN controller by sending and receiving standard data frames, extended data frames, standard remote frames, extended remote frames, FD standard data frames, FD extended data frames, and other frame types from the PC side.

The SoC side receives the data from the PC in the CAN interrupt and transmits the same data to the PC side, which receives the data back from the SoC.

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

The EVB is connected to a TJA1051 CAN Receiver module by connecting P3_2 to CTX, P3_4 to CRX. The EVB VCC3.3V is connected to the module VCC and NC. The EVB GND is connected to the module GND and S.

The other end of the TJA1051 CAN Receiver module is connected to the PC via a USB CAN FD analyzer, by connecting module CANH to analyzer CANH and module CANL to analyzer CANL.

CAN Transceiver Introduction

The module adopts TJA1051, which is a high-speed CAN transceiver that provides differential transmission and reception functions for the CAN controller, with a transmission rate of up to 1Mbit/s. Any other CAN transceivers could be used instead.

CAN transceiver module

CAN transceiver module connection schematic

Building and Downloading

This sample can be found in the SDK folder:

Keil

Project file: samples\peripheral\can\trx\proj\rtl87x2g\mdk

GCC

Project file: samples\peripheral\can\trx\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. After IC reset, frames of each type are received on the CAN FD Tool.

2. Use the tool to send data frames to the IC.

3. On the Debug Analyzer, print the received frame data.

   [CAN] send standard remote frame
   [CAN HANDLER]  MB_1 tx done
   ...
   [CAN HANDLER]  MB_5 tx done
   [CAN]  waiting for rx...
   [CAN HANDLER] MB_0 rx done
   [CAN HANDLER] frame_type 1, frame_id = 0x100, ext_frame_id = 0x00000
   [CAN HANDLER] rx_data [0] 0x01
   ...
   [CAN HANDLER] rx_data [7] 0xef
   [CAN]  waiting for rx...
   [CAN HANDLER] MB_0 tx done
   

4. The IC sends the received data frames back to the tool, and it can see the sent and received data frames on the tool:

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\can\trx\proj

• Source Code Directory: sdk\samples\peripheral\can\trx\src

Source files are currently categorized into several groups as below.

└── Project: trx
    └── 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_can.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── main_ns.c
            └── io_can.c

Initialization

The initialization process includes can_board_init and can_driver_init.

---

can_board_init contains settings for PAD and PINMUX.

1. Configure PAD: set pins, PINMUX mode, PowerOn, internal Pull-None.

2. Configure PINMUX: assign pins to CAN_TX, CAN_RX functions respectively.

---

can_driver_init contains the initialization of the CAN peripheral.

1. Enable PCC Clock.

2. Disable CAN auto re-transmission function.

3. Set CAN bus bit sync timing. Configure CAN speed to 500 kHz.

4. Enable CAN FD. Set CAN FD bit sync timing in the data field. Configure CAN FD speed to 5 MHz. Enable can_fd_auto_ssp function.

5. Enable the CAN peripheral, enable CAN interrupts.

6. Poll the CAN bus to be on.

Note

If the program is stuck at the point of waiting for the CAN bus to be on, please check if the CAN bus is connected correctly.

RCC_PeriphClockCmd(APBPeriph_CAN, APBPeriph_CAN_CLOCK, ENABLE);
...
init_struct.CAN_AutoReTxEn = DISABLE;
init_struct.CAN_BitTiming.b.can_brp = 3;
...
init_struct.CAN_FdEn = ENABLE;
/* Here config to 5mhz. */
init_struct.CAN_FdBitTiming.b.can_fd_brp = 0;
...
CAN_Init(&init_struct);
CAN_Cmd(ENABLE);
/* CAN interrupts enable */
CAN_INTConfig((CAN_BUS_OFF_INT | CAN_WAKE_UP_INT | CAN_ERROR_INT |
               CAN_RX_INT | CAN_TX_INT), ENABLE);
...
/* polling CAN bus on status */
while (CAN_GetBusState() != CAN_BUS_STATE_ON)
...

Functional Implementation

1. Execute can_basic_tx, send a standard data frame, an extended data frame, a standard remote frame, an extended remote frame, an FD standard data frame, an FD extended data frame.

   1. Configure the message buffer to tx mode using the set transmit frame type.

   2. Enable the message buffer tx interrupt. Poll the RAM status to be idle.

CANError_TypeDef tx_error;

CANTxFrame_TypeDef tx_frame_type;

tx_frame_type.msg_buf_id = buf_id;
...
switch (frame_type)
...

CAN_MBTxINTConfig(tx_frame_type.msg_buf_id, ENABLE);
tx_error = CAN_SetMsgBufTxMode(&tx_frame_type, tx_data, data_len);

while (CAN_GetRamState() != CAN_RAM_STATE_IDLE)
...

Note

If sending several frames using the same message buffer id, make sure to wait for the previous frame to be already sent before sending the next frame.

2. After sending, execute can_basic_rx and wait for the PC to send a frame into the receive interrupt.

1. Use message buffer 12 to receive frame if FIFO mode is enabled.

2. Mask the rtr, ide, and id bit filters to receive all frames.

3. Disable Rx DMA. Disable auto reply.

4. Configure the message buffer to rx mode using the set receive frame type.

5. Enable the message buffer rx interrupt. Poll the RAM status to be idle.

  CANError_TypeDef rx_error;
  CANRxFrame_TypeDef rx_frame_type;
#if CAN_RX_FIFO_EN
  rx_frame_type.msg_buf_id = CAN_MESSAGE_FIFO_START_ID;
#else
  rx_frame_type.msg_buf_id = 0;
#endif

  rx_frame_type.extend_frame_id = 0;
  ...
  rx_error = CAN_SetMsgBufRxMode(&rx_frame_type);

  CAN_MBRxINTConfig(rx_frame_type.msg_buf_id, ENABLE);

  while (CAN_GetRamState() != CAN_RAM_STATE_IDLE)
  ...

3. When transmission is complete, reception is complete, or when an error occurs, enter interrupt handler function CAN_Handler.

   1. Read and print the received frame data sequentially from the mailbox that generated the receive completion interrupt.

   2. Execute can_basic_tx to send back the received frame type and frame data.

   3. Execute can_basic_rx and wait for the next interrupt.

...
CAN_ClearMBnRxDoneFlag(index);
CANError_TypeDef get_error;
CANMsgBufInfo_TypeDef mb_info;
get_error = CAN_GetMsgBufInfo(index, &mb_info);
...
CAN_GetRamData(mb_info.data_length, rx_data);
CANDataFrameSel_TypeDef frame_type = CAN_CheckFrameType(mb_info.rtr_bit, mb_info.ide_bit,
                                                        mb_info.edl_bit);
...
/* Send back frame here. */
can_basic_tx(0, frame_type, mb_info.standard_frame_id, \
              mb_info.extend_frame_id, rx_data, mb_info.data_length);

/* Start rx next time. */
can_basic_rx();
...