5.3.1 BLE and CAN-FD Transparent UART

Recommended Reading

1. Getting Started with Application Building Blocks – See Building Block Examples from Related Links.

2. Getting Started with Peripheral Building Blocks – See Peripheral Devices from Related Links.

3. See BLE Connection from Related Links.
4. See BLE Transparent UART from Related Links.
5. BLE Software Specification – See MPLAB® Harmony Wireless BLE in Reference Documentation from Related Links.

Hardware Requirement

SDK Setup

Refer to Getting Started with Software Development from Related Links.

Software Requirement

1. To install Tera Term tool, refer to the Tera Term web page in Reference Documentation from Related Links.

2. CAN Bus Analyzer FD Tool Driver and Wireshark Extcap:
   • APGDT006-driver-Oct2023.zip
   • APGDT006-wireshark-extcap-Mar2024.zip v4.2.6 64-bit
3. Wireshark - v4.2.6 64-bit - See Wireshark in Reference Documentation from Related Links.
4. CAN_fifo_buffer_test.py
5. CAN-FD_standard_extended_id_test.py
6. install_v1.zip

Smart phone App

Programming the Precompiled Hex File or Application Example

Using MPLAB® X IPE:

1. Import and program the precompiled hex file: <Harmony Content Path>\wireless_apps_pic32_bz6\apps\ble\peripheral_applications\can_peripheral_trp_uart\precompiled_hex.
2. For detailed steps, refer to Programming a Device in MPLAB® IPE in Reference Documentation from Related Links.

Using MPLAB® X IDE:

1. Perform the following the steps mentioned in Running a Precompiled Example. For more information, refer to Running a Precompiled Application Example from Related Links.
2. Open and program the application “can_peripheral_trp_uart.X” located in “<Harmony Content Path>\wireless_apps_pic32_bz6\apps\ble\ peripheral _applications\can_peripheral_trp_uart\firmware”.
3. For more details on how to find the Harmony Content Path, refer to Installing the MCC Plugin from Related Links.

Demo Description

This demo presents three scenarios to demonstrate the flow of data:

Testing Setup

Testing

This section assumes that user has completed the setup mentioned in the Testing Setup section.

1. Scenario 1:
   This scenario presents the data flow from PIC32WM-BZ6204UE to the CAN BUS Analyzer. Users interact with TeraTerm to generate CAN/CAN-FD frames on PIC32WM-BZ6204UE.

   
   Scenario 1 (i.e., PIC32WM-BZ6204UE -> CAN Bus Analyzer):
   1. Have all boards connected as in Hardware Setup above.
   2. Open a terminal emulator like Tera Term and select the COM port@ (Speed: 115200, Data: 8-bit, Parity: none, stop bits: 1 bit, Flow control: none) .
      
      
   3. Reset PIC32WM-BZ6204UE and you will see the following menu of actions that can be performed:
      
   4. Start capturing on Wireshark
      1. Open up Wireshark.
      2. Click on the icon next to the Microchip CAN BUS Analyzer interface.
      3. Configure the following:
         1. Tick the Send Acknowledgment box then press Save.
      4. Double click on the Microchip CAN Bus Analyzer interface to start capturing data.
         
   5. In TeraTerm, press 0 then 1 then 2.
   6. If successful, TeraTerm and Wireshark would look like this.
      
      
2. Scenario 2:
   This scenario shows the data flow from MBD to PIC32WM-BZ6204UE to the CAN Bus Analyzer.

   
   Scenario 2 (i.e., MBD on smartphone -> PIC32WM-BZ6204UE -> CAN Bus Analyzer):
   1. Have all boards connected as in Hardware Setup above.
   2. Open a terminal emulator like Tera Term and select the COM port@ (Speed: 115200, Data: 8-bit, Parity: none, stop bits: 1 bit, Flow control: none) as in step 1.b.
   3. Open MBD on your smartphone. Navigate to BLE UART then PIC32CXBZ and search for “pic32cx-bz6.” Connect to the device and select the transparent option. From here you can enable the “Display Data” checkbox to begin viewing received data.
      
      Note: Some iOS users may not find the device “pic32cx-bz6” in the “PIC32CXBZ” page in MBD. In this case, users can select “BM70” on MBD and follow the same instructions.
   4. Follow step 1.d to setup Wireshark.
   5. Send between 1 and 8 bytes of data on MBD (e.g. “123”).
      
      1. If successful, TeraTerm and Wireshark will look like this:
         
         
         Note: When PIC32WM-BZ6204UE receives a message between 1 and 8 bytes, it will structure a standard CAN message with ID of 0x555 and will append 0x00 to any of the remaining 8 bytes.
   6. Send between 9 and 64 bytes of data on MBD (e.g. “123456789”).
      
      1. If successful, TeraTerm and Wireshark will look like this:
         
         
      Note: When PIC32WM-BZ6204UE receives a message between 9 and 64 bytes, it will structure an extended CAN-FD message with ID of 0x100000A5 and will append 0x00 to any of the remaining 64 bytes.
3. Scenario 3:
   This scenario shows the data flow from the CAN Bus Analyzer to PIC32WM-BZ6204UE to MBD.

   

   Scenario 3 (i.e., CAN Bus Analyzer -> PIC32WM-BZ6204UE -> MBD on smartphone):

   1. Follow steps 2.a through 2.c to establish a BLE connection.
   2. Do not capture data on Wireshark for the remaining steps.
   3. Run CAN_fifo_buffer_test.py located in “<Harmony Content Path>\wireless_apps_pic32_bz6\apps\ble\peripheral_applications\can_peripheral_trp_uart\tools” folder

      Note: Wireshark cannot be capturing data at the same time you use the python script to transmit data.
      1. If successful, command prompt and TeraTerm will look like this:

         

         
      2. The message will also be seen on MBD as follows:

         
      3. You can also play around with the message IDs in the script to test message capture in RX FIFO0, RX Buffer and RX FIFO1, respectively.

         

   4. Run CAN-FD_standard_extended_id_test.py located in “<Harmony Content Path>\wireless_apps_pic32_bz6\apps\ble\peripheral_applications\can_peripheral_trp_uart\tools” folder:

      1. If successful, command prompt and TeraTerm would look like this:

         

         
      2. The message will also be seen on MBD as follows:

         

      3. You can also play around with the message IDs in the script to test standard and extended ID filtering, respectively.

Developing the Application from Scratch using the MPLAB Code Configurator

1. Create a new harmony project. For more details, see Creating a New MCC Harmony Project from Related Links.

2. Import component configuration – This step helps users setup the basic components and configuration required to develop this application. The imported file is of format .mc3 and is located in the path “<Harmony Content Path>\wireless_apps_pic32_bz6\apps\ble\advanced_applications\can_peripheral_trp_uart\firmware\can_peripheral_trp_uart.X”.

3. Accept dependencies or satisfiers when prompted.
4. Verify if the Project Graph window has all the expected configuration.
   

#define configUSE_TICKLESS_IDLE 0

Verifying Advertisement, Connection and Transparent UART Profile Configuration

1. Select the BLE Stack component in the Project Graph.

   
2. Select Transparent Profile component in the Project Graph.
   

Verifying CAN1 Configuration

1. Select CAN1 component in the Project Graph.

   

Verifying SERCOM Configuration

1. Select SERCOM0 component in the Project Graph.

   

Verifying the Pin Configuration

1. Select Pin Configuration under Plugins in the Project Graph:

   
2. Verify the Pin Settings:
   
   1. RA10 and RB10 must have this configuration for ATA6571 to operate in normal mode.
      See this Pinout Diagram of the ATA6571 and mikroBUS:

      

      Pin RA10 corresponds to the CS pin on the mikroBUS which is the EN pin on ATA6571.

      Pin RB10 corresponds to the AN pin on the mikroBUS which is the STB pin on ATA6571.

      These are the operating modes of the ATA6571:

      
      

      From this schematic, we can see that AN is connected to NSTBY and INH is NC. Hence, we must set RA10 and RB10 to be high so that the ATA6571 can operate in normal mode.

Generating Code

For more details on code generation, refer to MPLAB Code Configurator (MCC) Code Generation from Related Links.

Files and Routines Automatically generated by the MCC

After generating the program source from the MCC interface (by clicking Generate Code), the BLE configuration source can then be found in the following project directories.

Initialization routines for OSAL, RF System, and BLE System are auto-generated by the MCC. See OSAL Libraries Help in Reference Documentation from Related Links. Initialization routine executed during program initialization can be found in the project file.C.

The BLE stack initialization routine executed during Application Initialization can be found in project files. This initialization routine is automatically generated by the MCC. This call initializes and configures the GAP, GATT, SMP, L2CAP and BLE middleware layers.

Autogenerated, Advertisement Data Format

Header Files

• ble_gap.h: This header file contains BLE GAP functions and is automatically included in the app.c file
• ble_trsps.h: This header file associated with API’s and structures related to BLE Transparent Client functions for Application User

Function Calls

MCC generates and adds the code to initialize the BLE Stack GAP, GATT, L2CAP and SMP in APP_BleStackInit() function

• APP_BleStackInit() API is called in the Applications Initial State APP_STATE_INIT in app.c is the API that will be called inside the Applications Initial State APP_STATE_INIT in app.c

User Application Development

Configure CAN1 and USART and Start Advertisement

CAN1

CAN1_MessageRAMConfigSet(Can1MessageRAM);

CAN1_RxFifoCallbackRegister(CAN_RX_FIFO_0, APP_CAN_RxFifo0Callback, APP_STATE_CAN_RECEIVE);

CAN1_RxFifoCallbackRegister(CAN_RX_FIFO_1, APP_CAN_RxFifo1Callback, APP_STATE_CAN_RECEIVE);

CAN1_RxBuffersCallbackRegister(APP_CAN_RxBufferCallback, APP_STATE_CAN_RECEIVE);

USART

SERCOM0_USART_ReadNotificationEnable(true, true);

SERCOM0_USART_ReadThresholdSet(1);

SERCOM0_USART_ReadCallbackRegister(uart_cb, (uintptr_t)NULL);

Start Advertising

BLE_GAP_SetAdvEnable(0x01, 0);

Connected and Disconnected Events

• In app_ble_handler.c "BLE_GAP_EVT_CONNECTED" event will be generated when a BLE connection is completed

Connection Handler

• Connection handle associated with the peer peripheral device needs to be saved for data exchange after a BLE connection

• p_event->eventField.evtConnect.connHandle has this information

• Start advertising upon disconnection

  

Transmit CAN/CAN-FD Message to CAN Bus Analyzer FD Tool

• Add “APP_MSG_UART_CB” to the generated APP_MsgId_T.
  

• The UART data will be captured in the uart_cb() function.

• The function responsible for transmitting CAN/CAN-FD messages is sendCANMessage().
  • The functions APP_UARTCBHandler and APP_TrspsEvtHandler() are responsible for gathering the data to be transmitted and they call sendCANMessage to structure and send the CAN message.
    

• When data is inputted into TeraTerm, the data is captured by UART. From there the data ends up in the APP_UartCBHandler(). This function creates a data buffer for either a standard CAN message, CAN-FD message, or CAN-FD extended message and calls sendCANMessage depending on the 3 options that the user chose.
  

• When the user inputs custom CAN data into MBD, the message is received by the transparent service. The BLE_TRSPS_EVT_RECEIVE_DATA event is generated upon receiving a BLE packet. This function structures a data buffer for either a standard CAN message or a CAN-FD extended message depending on the length of data inputted by the user. This CAN message is filled with user defined data in contrast to the 3 options of predefined data used in the UART callback.
  

Receive CAN/CAN-FD Messages and Send to MBD

• The CAN Rx callback functions call the print_and_tx_message() function to print the received data to the terminal and transmit the message to MBD.
  
• The print_and_tx_message() is used to queue messages to be sent over the transparent service and print the CAN data to the terminal.
  
• Add “APP_MSG_CAN_EVT” and “APP_MSG_UART_CB” to the generated APP_MsgId_T.
  
• BLE_TRSPS_SendData(); is the API to be used for sending data towards the central device.

Where to go from here

• BLE Sensor App utilizes the Transparent UART building block, see BLE Sensor from Related Links.