Datasheet

ManualsBrandsSharp ManualsKitchen AppliancesR-32STM

CAN: Controller Area Network Lab using ST STM32 Cortex-M processors. www.keil.com

Hands-on usin

the Keil Simulator or the STM32F4 Discover

Board

CAN Primer: Creating Your Own Network

ARM

Keil™ MDK™ toolkit featuring Simulator, Serial Wire Viewer and ETM Trace

For the STMicroelectronics STM32F4 Cortex™-M4 V 2.0 Robert Boys bob.boys@arm.com

Introduction:

CAN is extensively used in automotive but it has found applications everywhere. There are many “application” layers

available for CAN such as ISO 15765 (cars), J1939 (trucks), DeviceNET and CANopen (both are for factory automation) but

it is very easy to develop your own protocol that will fit and simplify your needs. Modern CAN transceivers provide a stable

and reliable CAN physical environment without the need for expensive coaxial cables. Nearly all of the mystery of CAN has

dissipated over the years. There is plenty of example CAN software to help you develop your own network.

Many think CAN is just for automotive, but this is not true. CAN has become the standard for vehicle networks, but it has

been adopted in most other fields. As you find out in these pages, there are no attributes in the Bosch CAN specification that

are automotive related. It is completely generic. You can easily

implement your own protocol on top of CAN.

A CAN controller is a sophisticated device. Nearly all the features of

the CAN protocol described here are automatically handled by the

controller with almost no intervention by the host processor. All you

need to do in practice is to configure the controller by writing to its

registers, write data to the controller and the controller then does all

the housekeeping work to get your message on the bus.

The controller will read any frames it sees on the bus and hold them

in a small FIFO memory. It will notify the host processor that this

data is available which it then reads from the controller.

The controller also contains a hardware filter mechanism that can be

programmed to ignore and discard those CAN frames you do not

want passed to the processor. This saves on processor overhead. STMicroelectronics STM32F4 Discovery

MDK provides sample CAN examples for many ARM processors which you can practice with. This document provides

hands-on exercises with both the Keil simulator or with the Discovery board.

Modern bus transceiver chips have made the physical CAN bus much less “finicky” and easier to construct and maintain.

The techniques discussed can be applied to many other microprocessors. We use ARM Keil MDK toolkit for the examples.

There is no charge for the evaluation version: MDK-Lite™. You can use MDK-Lite for all the CAN examples used here.

There are many other CAN examples in MDK for many

boards using ARM processors.

Keil provides a CAN stack as part of MDK-Professional™.

Details are on www.keil.com/rl-arm/rl-can.asp

Keil products are listed on the last page of this document.

See forums.arm.com for more ARM information.

Evaluation boards using STM32 that support CAN:

This document uses the STM32F4 Discovery board but you

can adapt the source code to any board with a CAN node.

The latest version of this document is here: www.keil.com/appnotes/docs/apnt_236.asp

For a general lab on the STM32F4 Discovery: www.keil.com/appnotes/docs/apnt_230.asp

Summary of content (31 pages)

PAGE 1
CAN Primer: Creating Your Own Network ARM® Keil™ MDK™ toolkit featuring Simulator, Serial Wire Viewer and ETM Trace For the STMicroelectronics STM32F4 Cortex™-M4 V 2.0 Robert Boys bob.boys@arm.com Hands-on using the Keil Simulator or the STM32F4 Discovery Board The latest version of this document is here: For a general lab on the STM32F4 Discovery: www.keil.com/appnotes/docs/apnt_236.asp www.keil.com/appnotes/docs/apnt_230.
PAGE 2
How CAN works: Introduction: 1 Main Features of CAN: 3 CAN System Layout: 3 CAN Node Schematic: 4 A Tiny CAN Network with no Transceiver ICs: 4 Physical Layer: the wires and voltages: a real waveform with oscilloscope: 5 The CAN Frame: the Programming Model: 6 Other Bit Fields: Bit Stuffing, Bus loading, Bus Speed: 7 Bus Errors, Bus Faults: 8 Is NOT CAN but useful: Multiple CAN frames, Types of Frames and Time-outs: 9 Sequence of Transmitting CAN Data: 10 Sequence of Receiving CAN Data
PAGE 3
Main Features of CAN: For the purposes of this article; we will assume a CAN network consists of the physical layer (the voltages and the wires), a frame consisting of an ID and a varying number of data bytes all with the following general attributes: 1. 11 or 29 bit ID and from zero to 8 data bytes. TIP: These attributes can be dynamically changed “on the fly”. 2. Peer to Peer network. Every node can see all messages from all other nodes but it normally can’t see its own. 3.
PAGE 4
A Node Schematic: This is the schematic diagram from the Keil MCBSTM32E™ evaluation board. IC1 is a Texas Instruments CAN transceiver which performs the conversion between the single-ended CAN controller CAN Tx and CAN Rx signals to the bi-directional differential pair of the CAN bus called CAN Hi and CAN Lo (High and Low). This schematic is complete. The STM32 CAN I/O is TTL, CMOS and 5 volt tolerant, all at the same time making it exceptionally easy to design the interface.
PAGE 5
Physical Layer: the wires and the voltages… There are three physical layers used in CAN: Hi-Speed, Fault Tolerant and Single Wire. Hi-Speed is the most common and is the only one we will use in this article. Fault Tolerant offers more robustness as its name implies and is used more often in European autos. Single Wire is used by General Motors and a few others as a low speed body network. Hi-Speed in cars has a speed of 500 Kbps, trucks are 250 Kbps. CANopen runs up to 1 Mbps.
PAGE 6
The CAN Frame: The CAN frame has many fields but we can simplify this to a Programming Model as shown. These fields are accessed by your software through the CAN controller registers. The CAN Frame Programming Model configuration registers are not included here.  IDE (1 bit) IDE: Identifier Extension: 1 bit - specifies if the ID field to be transmitted is 11 or 29 bits: If IDE = 0, then the ID is 11 bits. If IDE = 1, then the ID is 29 bits.
PAGE 7
Other Bit Fields: Only the ACK bit will be mentioned in this document: ACK: This is a one bit field in the CAN frame created by the transmitting node but set by all the other nodes. TIP: The number 1 reason people can’t get their CAN node working is you need at least two nodes to work. When a node puts a message on the bus, it will wait for the ACK bit to be asserted by any other node that has seen the message and determined it to be valid.
PAGE 8
Bus Errors: Recall we said that all nodes (including the transmitting node) check each CAN frame for errors. If an error is detected, here is what happens: 1. All the nodes will signify this fact by driving the bus to logical 0 (dominant state) for at least 6 CAN bits. 2. This violates the Bit Stuffing rule (never > than 5 bits the same polarity) so every node sees this as an error. 3. This so called “Error Frame” signals to all nodes a serious error has occurred if they don’t already know it. 4.
PAGE 9
Bonus TIPS: Here some items NOT part of the CAN specification but might prove helpful in your system: 1) Transmitting data sets greater than 8 bytes: Clearly, transmitting a data set greater than 8 bytes will require multiple frames and this will require some planning. Such schemes can become very complicated as they have to deal with a wide-ranging set of contingencies. If you can focus on a narrow requirement set, design of a simpler protocol is possible.
PAGE 10
Sequence of Transmitting Data on the CAN Bus: 1. You give the transmitter the ID, the size of the ID (IDE), the number of data bytes (DLC) and the data if any. 2. You then set a bit to tell the transmitter in the CAN controller to send this frame. 3. Any node(s), seeing the bus idle for the required minimum time, can start sending a CAN frame. 4. All other nodes start receiving it except those also starting to transmit a message at the same time. 5.
PAGE 11
Sequence of Receiving data from the CAN Bus: 1. All nodes except those currently transmitting frames and those in bus-off mode are in listening mode. 2. A CAN frame is sent using the procedure as described previously: Sequence of Transmitting Data on the CAN Bus: 3. This sent frame is received by all listening nodes. If deemed to be a valid CAN message with no errors – the ACK bit is set by all listeners. In CAN terminology, this set to the “dominant” state as opposed to the recessive state. 4.
PAGE 12
CAN FD: CAN with Flexible Data Rate: CAN FD is a new extension to the standard CAN 2.0 protocol. For more information search the internet for the files can_fd_spec.pdf and can_fd.pdf . CAN FD was created by Robert Bosch GmbH. The CAN frequency and bit overhead added to information carrying bits (ID + data bytes) (also called payload) are limitations to the effective maximum data rate transmission. CAN FD is one solution to this.
PAGE 13
CAN Controllers and their Errata Sheets: CAN controllers are very sophisticated modules. Many times someone is experiencing trouble getting something to work or has an unexpected crash or result and they desperately search their code for the error causing this. Sometimes the answer lies in the errata sheet and not in your software. This document lists all known deviant behaviour from that claimed in the device datasheet. Some CAN controllers have bugs and you should find out what they are.
PAGE 14
CAN Demonstration Software: In order to experiment with a CAN network it is useful to try a simulator before the real hardware. This document shows how to use the complete device simulation included in the Keil® Microcontroller Development Kit (MDK-ARM) for the STM32 ARM® Cortex™-M3 microcontroller. No hardware is needed. We provide an example for the Discovery STM32F4. You can download the latest version of MDK-ARM (4.70 or later) at: www.keil.com/arm/mdk.asp There is no charge for this software.
PAGE 15
Keil Example CAN Program: Using the Keil Simulator: 1. Start µVision® by clicking on its icon on your Desktop. 2. Select Project/Open Project. Open the file C:\Keil\ARM\Boards\Keil\MCBSTM32E\CAN\CAN.uvproj. 3. Select “Simulator” in the Target window. 4. In the file GLCD_16bitIF_STM32.c, change #define DELAY_2N (near line 32) to have a value of 2 instead of 18 in order to start the messages faster the very first time. This is a delay for the LCD which we are not using here.
PAGE 16
2) CAN.c (These are MCBSTM32E example line numbers but might change without notice) Configuring the CAN Controller: (CAN.C) There are several things that must be done to properly configure the CAN controller. These are done in CAN.c by functions that are called by CanDemo.c. Examples are found in the function CAN_setup (lines 37 to 70) as shown in µVision: 1. Enable and set the clock for the CAN controller. TIP: The clock must be stable for CAN. No R-C oscillators here. 2.
PAGE 17
Receiving a CAN Message: Lines 139 to 142 indicate when a CAN message is received. But something more must be going on here. Line 142 shows that the data byte received and inserted in the array[0] is stored in variable val_Rx. How exactly does the CAN data byte get into the member array CAN_RxMsg[0].data[0] ? 139 if (CAN_RxRdy) { /* rx msg on CAN Ctrl #1 140 CAN_RxRdy = 0; 142 val_Rx = CAN_RxMsg.
PAGE 18
Viewing the CAN Frames with the Logic Analyzer (LA): µVision has a Logic Analyzer (LA). This feature is also available using Serial Wire Viewer (SWV) on a real processor or the simulator. You will also get the LA working with the Discovery board. ST-LINK V2 supports SWV. V1 does not. All Keil ULINKs and J-Link (black case V 6 and later) support SWV. This is a very powerful ARM CoreSight debugging feature. 1. Close the Trace Data window and remove all breakpoints. (Type Ctrl-B). Click on RUN. 2.
PAGE 19
Code Coverage: (Available with the Keil Simulator or ULINKpro and ETM Trace) 1. Click on the RUN icon. After a second or so stop the program with the STOP icon. 2. Examine the Disassembly and CanDemo.c windows. Scroll and notice different color blocks in the left margin: 3. This is Code Coverage provided by the Keil Simulator and also the ETM trace. This indicates if an instruction has been executed or not. Colour blocks indicate which assembly instructions were executed: 1.
PAGE 20
Experimenting with the CAN software: The default MCBSTM32E CAN example produces a CAN frame with an ID of 0x21 and one data byte. We will make some modifications to CanDemo.c to show how easy it is to modify it for your own uses. Have the CAN project loaded as before. Be in Edit (not Debug) mode. We will modify these settings first: they are located in CanDemo.c near the lines as indicated: 118 CAN_TxMsg.id = 33; /* initialize msg to send 119 for (i = 0; i < 8; i++) CAN_TxMsg.
PAGE 21
Getting a CAN Network to work on the Discovery board: with Serial Wire Viewer… Below is a real two node CAN network using a STMicroelectronics STM32F4 Discovery board. You can substitute other boards as long as you have at least two CAN nodes. The Discovery board contains two separate CAN nodes but no transceiver chips. You will need to add three parts to create a simple network. We will then make one node talk to the other.
PAGE 22
Running the Example CAN Program on the Discovery: 1. Consider making a copy of the CAN project directory: C:\Keil\ARM\Boards\ST\STM32F4-Discovery\CAN 2. Connect the STM32F4 Discovery CN1 USB connector to a USB port on your PC. 3. Start µVision by clicking on its icon on your Desktop. 4. Select Project/Open Project. Open the file C:\Keil\ARM\Boards\ST\STM32F4-Discovery\CAN\CAN.uvproj. 5. Make sure “STM32F407 Flash” is selected in the Target window. You need MDK 4.70 or later for the CAN software.
PAGE 23
Exception Tracing: CAN1 (the receiver) and CAN2 (the transmitter) use interrupts to tell the processor that a) a CAN message has been received and b) the controller is ready to be loaded with a frame to transmit. These interrupts can easily be displayed with SWV. 1. Enter the Debug mode by clicking on the debug icon. 2. Click on the RUN icon. 3. Click on the arrow beside the Trace Windows icon and select Exceptions: 4. The window similar to the one below appears. Note all exceptions (RESET, NMI etc.
PAGE 24
Data Tracing: displaying the data writes… The ARM CoreSight technology with the STM32 family also includes data tracing – and of course, it is in real-time. 1. Open Debug/Debug Settings and select the Trace tab. Select “on Data R/W sample”. Click OK. 2. Select OK when a window opens asking to stop the program and take new values. 3. Find the global variables val_Tx and val_Rx in CanDemo.c. 4. Right click on val_Tx and select Add val_Tx to… and then select Logic Analyzer. Repeat for val_Rx.
PAGE 25
CAN Waveform: This is an oscilloscope photo of a CAN frame from our example. The first negative edge is the SOF (start of frame). The last negative pulse is the ACK bit. It moves about due to stuffed bits. The first five positive pulses stay the same. They are the ID field. The others change as the data field and CRC change. The most narrow pulse is 2 µsec wide and ½ µsec = 500 kHz. This is the CAN frequency in our example. The base is 0.665 volts and the top is at 3.0 volts. The P-P voltage is ~ 2.
PAGE 26
Watchpoints: (also known as Access Breaks in Keil products) Watchpoints provide breaks on data and address values. There are four Watchpoints in STM32 series. 1. Enter Debug mode. Do not run the program or stop if it is. The program must be stopped to configure Watchpoints. 2. Close the Exceptions window. 3. Open Debug/Breakpoints and an empty window below opens up. You can also use Ctrl-B. 4. Enter in the field Expression: val_tx == 0x6. Don’t hit Enter yet ! 5.
PAGE 27
PC Tracing: Program Counter samples… 1. Open Debug/Debug Settings and click on the Trace tab. Unselect EXCTRC and on Data R/W sample. 2. Select Periodic. Click OK and click RUN. Double-click in the Trace Records window to clear it. 3. Program samples will now be displayed with a timestamp in both CPU cycles and the time in seconds. TIP: In this example every 16,384th PC is displayed. PC Samples are useful as they can give good indication where your CPU is spending its time.
PAGE 28
Experimenting with the CAN software: The default CAN example produces a CAN frame with an ID of 0x21 and one data byte. We will make some modifications to CanDemo.c to show how easy it is to modify it for your own uses. 1. Have the CAN project loaded as before. Close the Trace Records window. Exit Debug mode. Close the LA. 1) Turn OFF CAN Filters and configure Watch 1: 1. Go near lines 223 and 229 in CAN.c. Swap the two comment fields as indicated: //!!* To disable the CAN Filters: 2.
PAGE 29
TIP: If you have more than one CAN controller in your processor you can operate these as parallel receivers. Divide the messages up with the Acceptance Filters. This will help capture all the messages on a very busy bus minimizing or eliminating data frame losses. Each CAN controller will handle its share of the messages.
PAGE 30
How can trace help me find problems ? Trace, either SWV or ETM, adds significant power to debugging efforts. Tells you where the program has been, how it got there, how long it took, when did the interrupts fire and all about data reads and writes.  With RTOS and interrupt driven events – many programs are now asynchronous. Trace helps sort this out and provides for the dynamic analysis of running code.  Putting test or printf code in your project sometimes changes or erases the problem.
PAGE 31
Keil Products: Keil Microcontroller Development Kit (MDK-ARM™)  MDK-Lite™ (Evaluation version) $0  NEW !! MDK-ARM-CM™ (for Cortex-M series processors only – unlimited code limit) - $3,200  MDK-Standard™ (unlimited compile and debug code and data size) - $4,895  MDK-Professional™ (Includes Flash File, TCP/IP, CAN and USB driver libraries) $9,995 For special promotional pricing and offers, please contact Keil Sales for details.