Creating the Bootloader Example Using a CAN Physical Layer on a device with a CAN-FD Capable Peripheral

Introduction

Tools

Software

1. Microchip MPLAB® X version 5.40 or later
2. Microchip MPLAB® XC16 C compiler version 1.60 or later
3. Unified Bootloader Host Application v1.16.4 or later
4. Microchip MPLAB® Code Configurator version v4.0.1 or later (optional – for code configuration)
5. 16-bit Bootloader MCC module version 1.18.3 or later (optional – for code configuration)

Hardware

1. Explorer 16/32 Demo board
2. dsPIC33CK256MP508 Processor or other Processors with the Microchip CAN-FD module
3. A programmer/debugger of choice
4. A Peak CAN protocol analyzer/protocol generator. A PCAN-USB FD was used for development of this demo (https://www.peak-system.com/PCAN-USB-FD.365.0.html?&L=1).
5. A CAN cable
6. An MCP2542 click board (https://www.mikroe.com/mcp2542-click) or another appropriate CAN transceiver click board. It is important that this is just a transceiver and not a CAN-to-SPI/UART converter chip.
7. A micro USB cable, a USB-Type C cable, or a 9v power adapter for the Explorer 16/32 (for powering the board).

Creating the Bootloader Project

1. Open MPLAB® X and press the new project icon
2. Select the Standalone Project and press Next.



3. Enter the device name with the CAN-FD controller. For this example, "dsPIC33CK256MP508".
4. Enter the Tool that your using and press Next.



5. Select your compiler. Version 1.60 or later and press Next.



6. Name your project and select the project location and press Finish.

Adding the 16-Bit Bootloader to the project

1. Open MCC by selecting the MCC Icon and press Save when prompted to save the project



2. Select the 16-Bit Bootloader:Bootloader library by pressing the green plus sign "+".



3. Select "Protocol for communication" and select UART1. (This will be later removed from being compiled.)
4. Change Bootloader end address to 0x5000.
5. Leave Verification Scheme as Not Blank.



6. Since we will need a interrupt driven timer in the bootloader, scroll down to the Interrupt Vector Table and configure T1Interrupt as "Keep In Bootloader"



7. To generate the base Bootloader files for the project, press Generate as shown below

Configuring the system clocks to support 80 Mhz needed for our CAN configuration.

1. Goto Project Resources --> System Module to view the System Clock Settings.



2. Change the clock to 8000000 Primary Oscillator.
3. Enable the PLL.
4. Change the Feedback to 1:150.
5. If Enabled, disable the Auxillary Clock.
6. Change CAN Clock Generator to AFVCO/4 - 300Mhz.
7. Change the Requested CAN to 20 Mhz.
8. For debugging, and for this device, change the ICD to PCG3 and PGD3.

Adding CAN to the 16-Bit Bootloader project

1. Goto Device Resources, and add CAN1 by pressing the green plus sign "+" next to it.



2. Clock Freq should be 20Mhz.
3. Change Nominal Bit Rate to 125 Kbps.
4. Change Sample Point to 80%.

Step 3 - General Settings

1. Verify that Step 3 just has Enable ISO CRC selected.

Step 4 - FIFO Settings

1. Goto Step 4, and select FIFO1 from drop down box and press Add.



2. Select FIFO2 from drop down box and press Add.

Step 5 - Filter Object Settings

1. Goto Step 5, and select Filter 0 from drop down box and press Add.



2. For the Receive FIFO, change to FIFO2 and Enter 0xA1 into the Message ID.

CAN GPIO Settings

Adding Timer 1 to the project

1. Goto Device Resources, scroll down and enable Timer 1 by pressing the green plus sign "+".



2. Configure Timer 1 by setting a timer period of 1ms shown below. This will require first changing the prescaler to 1:64 and then changing the Timer Period to 1 ms.
3. Enable the Timer Interrupt by checking the Timer Interrupt Enable Box.

Adding LED and Switch to Bootloader

1. Open Pin Manager and configure GPIO RE0 as an output and GPIO RB14 as an input.

Generating the code.

Removing UART from project

Remove com_adaptor_uart.c from being compiled.

1. Open Projects and then right click on com_adaptor_uart.c and select "Exclude File(s) from Current project"



2. Open the original can/boot.X/mcc_generated_files directory and copy the following files from this directory to the "mcc_generated_files" of the new project.
• can_tp.c
• can_tp.h
• can_tp_config.h
• can_tp_phy_adaptor.c
• can_tp_phy_adaptor.h



3. Next, Open the original "can/boot.X/mcc_generated_files/boot directory" and copy the file com_adaptor_can.c in this directory to the "mcc_generated_files/boot" of the new project.
4. Add the 2 new C files to this project by going to Projects, and right clicking on "MCC Generated Files" and selecting Add Existing Existing Item.



5. Select the two C files just added



6. Repeat the above process and add the file Add the file boot.X/mcc_generated_files/boot/com_adaptor_can.c to the project as well.

Adding code for LED D3 and switch SW3

1. Add #include "../pin_manager.h" at the top of the file.
2. At the top of BOOT_DEMO_Tasks() add the following code to turn on the LED.

    void BOOT_DEMO_Tasks(void)
    {
        // Turn on LED to indicate bootloader mode.
        IO_RE0_SetHigh();

3. Add the following line of code in EnterBootloaderMode(void) towards the bottom of file. This will return the status of the button SW3

    return (IO_RB14_GetValue() == 0);    

Disable Timer1 when before running the Application

Before running the application, we need to disable any units that could affect the application. One of these items is to disable Timer 1 which is generating 1ms interrupts before running the application.
1. Add #include "../tmr1.h" at the top of boot_demo.c
2. Add the call to the function TMR1_Stop() in BOOT_DEMO_Tasks() as shown below.

Updating main.c with CAN bootloader code

1. Add the two #include statements to include can1.h and can_tp.h
2. Create the buffer named rxBuffer below and add the TMR1_Callback() function below right above main().
3. Add the two CAN_TP calls at the beginning of main().
4. Add the CAN_TP_Tasks() to the while(1) loop.

  
    #include "mcc_generated_files/system.h"
    #include "mcc_generated_files/boot/boot_demo.h"
    #include "mcc_generated_files/can1.h"
    #include "mcc_generated_files/can_tp.h"
    
    uint8_t rxBuffer[512];
    
    void TMR1_CallBack(void)
    {
      CAN_TP_Tick();
    }
    
    /*
        Main application
    */
    int main(void)
    {
        // initialize the device
        SYSTEM_Initialize();
        BOOT_DEMO_Initialize(); 
        
        CAN_TP_Initialize();
        CAN_TP_RxMessageBufferSet(rxBuffer, sizeof(rxBuffer)); 
        
        while (1)
        {
            CAN_TP_Tasks();
            // Add your application code
            BOOT_DEMO_Tasks();
        }
        return 1; 
    }

Creating the Application

1. This time, lets name the project "app" using the same device as before(dsPIC33CK256MP508).



2. Open MCC by pressing the MCC icon as before.
3. Goto the Device resources and add the 16-bit Bootloader:Application library to the project.



4. After the bootloader:Application library is loaded, the Application library will ask for the location of the bootloader project. So browse to the path of the bootloader project as shown below.




5. We will use the Delay library so goto Project Resources and under Foundation Services, add the "Delay" library

Configuring the clocks to match the bootloader

1. Goto Project Resources --> System Module to view the System Clock Settings.



2. Change the clock to 8000000 Primary Oscillator.
3. Enable the PLL.
4. Change the Feedback to 1:150.
5. If Enabled, disable the Auxillary Clock.
6. Change CAN Clock Generator to AFVCO/4 - 300Mhz.
7. Change the Requested CAN to 20 Mhz.
8. For debugging, and for this device, change the ICD to PCG3 and PGD3.

Adding LED to the Application

1. Open Pin Manager and configure GPIO RE0 as an output

Generating the Application

Adding Code to the Application

1. Open the Application main.c
2. At the top of the file, add includes the pin_manager.h and the delay.h files.
3. Create an unsigned int variable named counter.
4. Add code to blink the LED every 500 milliseconds.

Downloading the Application

Terminology

ISO 15765-2 is a transport protocol layer designed for usage with the CAN bus. The original CAN bus specifically allows for up to 8 bytes of data to be in a single frame. Larger messages need to be fragmented into smaller frames for transmission on the CAN bus. ISO 15765-2 defines a protocol for fragmenting larger messages and sending them over the CAN bus. It also incorporates flexibility in handling the data transmission through the use of flow control packets to control the frequency of when packets arrive as well allowing to pause the transmission of a message until the receiver is ready to receive the message.

Microchip’s MPLAB® Code Configurator tool. This tool helps configure and generate source code for peripherals and libraries.

The PC application used to send the firmware update and verification commands from the PC to the board to complete the firmware update.

Trademarks