After installation of Paulus the source code is stored in the file structure shown in Table 1 describes the contents.
project folder with all necessary Atollic Studio project files
target independent CANopen sources for Paulus
Design Tool project of Paulus with all generated files, e.g. the EDS file and documentation files
Target-specific sources of Paulus, e.g. CAN-driver, and low-level drivers and supporting services from Spansion/Fujitsu Corporation e.g startup, clock and flash-service.
target-specific flash routines
header file for the environment definition
Paulus configuration file
Fujitsu Flash service for FM3 devices
Startup files generated by Atollic Studio
example application with a CANopen slave project (s1)
checksum generator tool for Paulus
main loop of Paulus
Table 1: File structure
The initialization of the CAN controller is done in module spansion_mb9bf51x/ mb9bf51x_can.c.
In module spansion_mb9bf51x/ mb9bf51x_init.c the I/O pins for the CAN interface have to be initialized.
In module spansion_mb9bf51x/ mb9bf51x_init.c there must be the functions getBitRate() and getNodeId() available. Usually the CANopen network parameters are provided by reading jumpers or by loading from flash memory.
Paulus on the platform of Spansion MB9BF51x was developed with the Atollic TrueSTUDIO for ARM v8.1.0. The Hardware environment is a Spansion FM3 StarterKit with MB9BF516N as target CPU.
In general the initialization function initializes only the absolutely necessary peripherals like clock system, CAN controller, memory management as needed by Paulus and a timer for Heartbeat or LSS. Nevertheless, there might be situations where it makes sense that Paulus initializes other functionalities which are later used by the application as well. As an example consider the serial interface for debug messages.
CAN bit rate
The CAN bit rate is coded by the index of the CAN bit timing table according to /CiA-305/. The index of the default CAN bit rate is specified about the compiler-define BITRATE_INDEX_<bit_rate> in /spansion_mb9bf51x/bl_config.h:
#define BL_USED_BITRATE_INDEX BITRATE_INDEX_125K
The default CAN bit rate is 125 kbit/s and can be changed by LSS services. The LSS services are described in /Paulus_man/ and base on /CiA-305/. The supported CAN bit rates are depending on the clock of the CAN controller and are listed in /spansion_mb9bf51x/mb9bf51x_can.c. The value FFh for segment3 marks unsupported CAN bit rates. The clock for the activation of the CAN bit rate is generated by timer Systick with a period of 1 ms.
Timer Systick is also used for the generation of Heartbeat producer messages..
By the compiler-define DEBUG some debug output can be activated about the serial interface UART0. The compiler-define is set in file /spansion_mb9bf51xx/bl_config.h:
#define DEBUG 1
In general the initialization function will initialize only the absolutely necessary peripherals like clock system, CAN controller, memory management as needed by Paulus. Nevertheless, there might be situations where it makes sense that Paulus initializes other functionalities which are later used by the application as well. As an example consider the serial interface for debug messages.
Generating application software
The application software consists of an application header and an application program.
The application program has to be prepared for download by the following steps:
build the application program in binary format
calculate the CRC of the application program, build the application header and generate the application software to download
configure the start address of the application software in Paulus
The program paulus_cksum calculates the CRC checksum of the binary application program generates the application header and stores the application header and the application program in a new file. This file can be loaded in the device by Paulus.
Unused bytes in the application header are set to 0x00 with the MB9BF51x. The length of the application header is 256 bytes.
Example: The download file for the application program s1_download.bin is generated about Windows console:
C:\jsc\Paulus_SpansionMB9BF51x\software\tools>paulus_cksum.exe -v -C -l 256 -x 0x00008100 s1_mb9bf516.bin -O s1_download.bin
reduce Flash end to file end: 0x00006604
reduce EndAddr to the Flash end 0x00006603
address - crc: 0x00000000, start: 0x00000000, end: 0x00006603, exec 0x00008100
Flash end: 0x00006604
calc CRC from 0x00000000 to 0x00006603
size: 0x00006604, crc: 0x07c9
Writing Appl. to >s1_download.bin<:
length: 26116/0x6604, crc: 0x07c9, execadr: 0x00008100
Besides checking the CRC Paulus checks also the size of the application header. A size of 0 is invalid. An application may destroy the ’valid’ information by overwriting the size with 0. That is always possible on the Spansion MB9BF51x FLASH, because the byte content is 0xFF after erasing.
More detailed information from this tool can find in /Paulus_CRC/.
To prepare: In order to produce a usable binary file from the Intel hex file output of Atollic Studio you can use the free software tool HEX2BIN.
It is important that the start address of the application software in the flash memory and the information in the Paulus configuration in spansion_mb9bf51x/ mb9bf51x_flash.h are identical. The application software is stored as a separate program in the flash memory additionally to the bootloader program. Therefore the application software is flashed to:
#define FLASH_PROGRAM_START_ADR 0x00008000
The length of the application header is 256 byte. The program start of the application is at address (FLASH_PROGRAM_START_ADR + 256 bytes).
The shared RAM for data exchange between bootloader and application starts at address 0x20000000. The size of the shared RAM is specified in spansion_mb9bf51x/bl_interface.h by the compiler-define BL_JUMPCODE_SIZE. The shared memory is installed in spansion_mb9bf51x/bl_interface.h as follow:
The keyword for the re-start of the application program is set in byte 0-3 of jumpcode. Paulus uses the keyword “APPL” or “BOOT” to start the application program, see /Paulus_man/.
The total size of the MB9BF516N flash is 512Kb. The current implementation of Paulus occupies a memory area of 32Kb from this. Therefore 480Kb (less 0x100 byte crc header) flash memory area available for the application software.
The flash area for configuration data of Paulus is located at flash address 0x00007F00 and following. On this address and the following Paulus stores the node-ID and the CAN bit rate index during the execution of the LSS service “LSS store configuration“. The addresses are configurable in spansion_mb9bf51x/bl_interface.h:
#define FLASH_ADDRESS_NODEID 0x00007F00
#define FLASH_ADDRESS_BITRATE_INDEX 0x00007F02
/* additional need some bytes for NodeId and bitrateIndex saved in a special section */
__attribute__((section (".myRAMSection"))) UNSIGNED8 flashNodeId=0xFF; /* connected on flash address 'FLASH_ADDRESS_NODEID' */
__attribute__((section (".myRAMSection"))) UNSIGNED8 bitrateIndex=0xFF; /* connected on flash address 'FLASH_ADDRESS_BITRATE_INDEX' */
#endif /* BL_USE_LSS */
After the next re-start Paulus read this flash addresses, saved the values in a own RAM variables and uses this node-ID and this CAN bit rate index for communication. The new CAN bit rate cannot be activated by NMT-Command Reset Application. If the LSS services are not used, Paulus uses the node-ID and CAN bit rate index configured in spansion_mb9bf51x / bl_config.h.
CANopenSlave1 is an example for an application program. The directory example/ CANopenSlave1 contain the compiler project and the application-specific functions. For compilation the CANopen Library and the suitable driver package is necessary. The CANopen Library and the driver package belong not to the delivery scope of Paulus. The binary application software in example/ CANopenSlave1/bin/s1_download.bin can be used for a quick start.
The linker file of this example project is adapted on these memory requirements (flash addresses and shared RAM section).
See settings in linker file from example (fm3_flash.ld):
/* Specify the memory areas */
FLASH (rx) : ORIGIN = 0x00008100, LENGTH = 480K
RAM (xrw) : ORIGIN = 0x1FFF8000, LENGTH = 32K
SRAM1 (xrw) : ORIGIN = 0x20000000, LENGTH = 32K
MEMORY_B1 (rx) : ORIGIN = 0x60000000, LENGTH = 0K
/* placing my ram section at given address: */
.myBufBlock 0x20000000 :
KEEP(*(.myRAMSection)) /* keep my variable even if not referenced */
} > SRAM1
This example has included source files bl_interface.c, bl_interface.h from bootloader. The application program can request an update by jumping back into Paulus by writing of the program control command start application program (value 1) on object 1F51h/1. The application program calls the macro BOOTLOADER_JUMP(APPL). This call is implemented in usr_301.c /sdoWrInd(). The application program stores the keyword “APPL” in the shared RAM and jumps into Paulus. Paulus is re-started and stays running until the application program is started by command.
If the example application program is running the CANopen slave starts with his bootup followed by heartbeat messages over the CAN-bus.
CANopen Layer Setting Services and Protocols, CiA
manual “Paulus Checksum Tool”, see file tools/manual_cksum.pdf
manual “Paulus User Manual”, see file UserMan_Paulus_Bootloader_e.pdf