CANopenNode

CANopenNode is free and open source CANopen protocol stack.

CANopen is the internationally standardized (EN 50325-4) (CiA301) higher-layer protocol for embedded control system built on top of CAN. For more information on CANopen see http://www.can-cia.org/

CANopenNode is written in ANSI C in object-oriented way. It runs on different microcontrollers, as standalone application or with RTOS.

Variables (communication, device, custom) are collected in CANopen Object Dictionary and are accessible from both: C code and from CANopen network.

CANopenNode homepage is https://github.com/CANopenNode/CANopenNode

This is version 4 of CANopenNode with new Object Dictionary implementation. For older versions git checkout branches v1.3-master or v2.0-master.

Characteristics

CANopen

• Object Dictionary offers clear and flexible organisation of any variables. Variables can be accessed directly or via read/write functions.
• NMT slave to start, stop, reset device. Simple NMT master.
• Heartbeat producer/consumer error control for monitoring of CANopen devices. An older alternative, 'node guarding', is also available.
• PDO for broadcasting process data with high priority and no protocol overhead. Variables from Object Dictionary can be dynamically mapped to the TPDO, which is then transmitted according to communication rules and received as RPDO by another device. Bitwise mapping is available.
• SDO server enables expedited, segmented and block transfer access to all Object Dictionary variables inside CANopen device.
• SDO client can access any Object Dictionary variable on any CANopen device inside the network.
• Emergency message producer/consumer.
• Sync producer/consumer enables network synchronized transmission of the PDO objects, etc.
• Time-stamp producer/consumer enables date and time synchronization in millisecond resolution.
• LSS CANopen node-id and bitrate setup, master and slave, LSS fastscan.
• CANopen gateway, CiA309-3 Ascii command interface for NMT master, LSS master and SDO client.
• CANopen Safety, EN 50325-5, CiA304, "PDO like" communication in safety-relevant networks
• CANopen Conformance Test Tool passed.

Other

• Suitable for 16-bit microcontrollers and above
• Multithreaded, real-time
• Object Dictionary editor
• Non-volatile storage for Object Dictionary or other variables. Automatic or controlled by standard CANopen commands, configurable.
• Power saving possible
• Bootloader possible (for firmware update)

Related projects

• CANopenNode (this project): CANopen protocol stack, base for CANopen device. It contains no device specific code (drivers), which must be added separately for each target system. An example shows the basic principles, compiles on any system, but does not connect to any CAN hardware.
• CANopenDemo: Demo device with CANopenNode and different target systems, tutorial and testing tools.
• CANopenNode.github.io: Html documentation, compiled by doxygen, for CANopenDemo, CANopenNode and other devices, available also online: https://canopennode.github.io
• CANopenEditor: Object Dictionary editor, external GUI tool for editing CANopen Object Dictionary for custom device. It generates C source code, electronic data sheet and documentation for the device. It is a fork from libedssharp.
• CANopenLinux: CANopenNode on Linux devices. It can be a basic CANopen device or more advanced with commander functionalities.
• CANopenSTM32: CANopenNode on STM32 microcontrollers.
• Analog Devices Inc.: CANopenNode on Analog Devices Inc. MAX32xx microcontrollers.
• CANopenPIC: CANopenNode on PIC microcontrollers from Microchip. Works with 16-bit and 32 bit devices. Includes example for Arduino style Max32 board.
• doc/deviceSupport.md: List of other implementations of CANopenNode on different devices.

Documentation, support and contributions

All code is documented in the source header files. Some additional documents are in doc directory.

To generate complete html documentation, run doxygen in the project base directory: sudo apt install doxygen graphviz pdf2svg; doxygen > /dev/null

Complete generated documentation is also available online: https://canopennode.github.io

Tutorial, demo device and tests are available in CANopenDemo repository.

Report issues on https://github.com/CANopenNode/CANopenNode/issues

Contributions are welcome. Best way to contribute your code is to fork a project, modify it and then send a pull request. Please follow the Recommended C style and coding rules, use .clang-format file for automatic code formatting.

The CANopenNode files conform to the MISRA C:2012 guidelines, with some noted exceptions, as indicated in MISRA.md.

CANopenNode flowchart

Flowchart of a typical CANopenNode implementation:

                            -----------------------
                           |     Program start     |
                            -----------------------
                                       |
                            -----------------------
                           |     CANopen init      |
                            -----------------------
                                       |
                            -----------------------
                           |     Start threads     |
                            -----------------------
                                 |     |     |
             --------------------      |      --------------------
            |                          |                          |
 ----------------------    ------------------------    -----------------------
| CAN receive thread   |  | Timer interval thread  |  | Mainline thread       |
|                      |  |                        |  |                       |
| - Fast response.     |  | - Realtime thread with |  | - Processing of time  |
| - Detect CAN ID.     |  |   constant interval,   |  |   consuming tasks     |
| - Partially process  |  |   typically 1ms.       |  |   in CANopen objects: |
|   messages and copy  |  | - Network synchronized |  |    - SDO server,      |
|   data to target     |  | - Copy inputs (RPDOs,  |  |    - Emergency,       |
|   CANopen objects.   |  |   HW) to Object Dict.  |  |    - Network state,   |
|                      |  | - May call application |  |    - Heartbeat.       |
|                      |  |   for some processing. |  |    - LSS slave        |
|                      |  | - Copy variables from  |  | - Gateway (optional): |
|                      |  |   Object Dictionary to |  |    - NMT master       |
|                      |  |   outputs (TPDOs, HW). |  |    - SDO client       |
|                      |  |                        |  |    - LSS master       |
|                      |  |                        |  | - May cyclically call |
|                      |  |                        |  |   application code.   |
 ----------------------    ------------------------    -----------------------

All code of the CANopenNode is non-blocking. Code in source files is collected into objects. Parts of the code can be enabled/disabled, so only files and parts of code can be used, which are required for the project. See stack configuration in 301/CO_config.h file.

For most efficiency code can run in different thread as seen in above flowchart. This is suitable for microcontrollers. It is also possible to run everything from single thread, as available on Linux devices. Code includes mechanisms, which triggers processing of OD objects when necessary.

In CANopen initialization section all CANopen objects are initialized. In run time CANopen objects are processed cyclically.

Files CANopen.h and CANopen.c is a joint of all CANopen objects. It may seems complex, but offers some flexibility and is suitable for most common configurations of the CANopen objects. CANopen objects can be defined in global space or can be dynamically allocated. Object dictionary can be used default (OD.h/.c files), but configuration with multiple object dictionaries is also possible by using the #CO_config_t structure. CANopen.h and CANopen.c files can also be only a reference for more customized implementation of CANopenNode based device.

Object Dictionary is a collection of all network accessible variables and offers most flexible usage. OD variables can be initialized by object dictionary or application can specify own read/write access functions for specific OD variables. Groups of OD variables are also able to be stored to non-volatile memory, either on command or automatically.

File structure

• 301/ - CANopen application layer and communication profile.
• CO_config.h - Configuration macros for CANopenNode.
• CO_driver.h - Interface between CAN hardware and CANopenNode.
• CO_ODinterface.h/.c - CANopen Object Dictionary interface.
• CO_Emergency.h/.c - CANopen Emergency protocol.
• CO_HBconsumer.h/.c - CANopen Heartbeat consumer protocol.
• CO_NMT_Heartbeat.h/.c - CANopen Network management and Heartbeat producer protocol.
• CO_PDO.h/.c - CANopen Process Data Object protocol.
• CO_SDOclient.h/.c - CANopen Service Data Object - client protocol (master functionality).
• CO_SDOserver.h/.c - CANopen Service Data Object - server protocol.
• CO_SYNC.h/.c - CANopen Synchronisation protocol (producer and consumer).
• CO_TIME.h/.c - CANopen Time-stamp protocol.
• CO_fifo.h/.c - Fifo buffer for SDO and gateway data transfer.
• crc16-ccitt.h/.c - Calculation of CRC 16 CCITT polynomial.
• 303/ - CANopen Recommendation
• CO_LEDs.h/.c - CANopen LED Indicators
• 304/ - CANopen Safety Related Data Object, as specified by EN 50325-5:2010
• CO_SRDO.h/.c - CANopen Safety-relevant Data Object protocol.
• CO_GFC.h/.c - CANopen Global Failsafe Command (producer and consumer).
• 305/ - CANopen layer setting services (LSS) and protocols.
• CO_LSS.h - CANopen Layer Setting Services protocol (common).
• CO_LSSmaster.h/.c - CANopen Layer Setting Service - master protocol.
• CO_LSSslave.h/.c - CANopen Layer Setting Service - slave protocol.
• 309/ - CANopen access from other networks.
• CO_gateway_ascii.h/.c - Ascii mapping: NMT master, LSS master, SDO client.
• storage/
• CO_storage.h/.c - CANopen data storage base object.
• CO_storageEeprom.h/.c - CANopen data storage object for storing data into block device (eeprom).
• CO_eeprom.h - Eeprom interface for use with CO_storageEeprom, functions are target system specific.
• extra/
• CO_trace.h/.c - CANopen trace object for recording variables over time.
• example/ - Directory with basic example, should compile on any system.
• CO_driver_target.h - Example hardware definitions for CANopenNode.
• CO_driver_blank.c - Example blank interface for CANopenNode.
• main_blank.c - Mainline and other threads - example template.
• CO_storageBlank.h/.c - Example blank demonstration for data storage to non-volatile memory.
• Makefile - Makefile for example.
• DS301_profile.xpd - CANopen device description file for DS301. It includes also CANopenNode specific properties. This file is also available in Profiles in Object dictionary editor.
• DS301_profile.eds, DS301_profile.md - Standard CANopen EDS file and markdown documentation file, automatically generated from DS301_profile.xpd.
• OD.h/.c - CANopen Object dictionary source files, automatically generated from DS301_profile.xpd.
• doc/ - Directory with documentation
• CHANGELOG.md - Change Log file.
• deviceSupport.md - Information about supported devices.
• objectDictionary.md - Description of CANopen object dictionary interface.
• CANopenNode.png - Little icon.
• html - Directory with documentation - must be generated by Doxygen.
• CANopen.h/.c - Initialization and processing of CANopen objects, suitable for common configurations.
• Doxyfile - Configuration file for the documentation gen