|
|
Implementation of CANopen |
Implementation of CANopen |
For the implementation of CANopen in embedded devices, protocol stacks are used, which are usually offered
in form of company licenses. IXXAT offers a comprehensively tested CANopen protocol stack either as general
C-code or already adapted to a large number of conventional microcontrollers The CANopen stack, available as
"Slave" or "Master/Slave" , is proven in many applications. Terms "Slave" and "Master" refer to the different
functionality with regard to network management, which is implemented in CANopen in the form of a logical
Master/Slave relationship.
The CANopen stack equips a developer with the complete functionality required for communication, network
management, general system services and device description. Implementation on the basis of a purchasable
protocol stack therefore merely means connecting the application functionality to the protocol stack.
Structure of the CANopen protocol software
The CANopen stack from IXXAT is structured in scalable, modular form in accordance with the various
services of CANopen, such as Network Management (NMT), Process Data Objects (PDOs), Service Data Objects
(SDOs), Emergency (EMCY), Synchronization (SYNC), SDO-Manager (SDM/SDR), Layer Setting Services (LSS) and
Object Dictionary (OBD). All modules have access to the object dictionary, which represents the central instance
of the software package as an interface between the communication interface and the data, parameters and functions
of the application.
Access to the CAN controller (e.g. for transmitting and receiving messages) is carried out via a "Data Link Layer"
interface, which is also integrated in a separate module (DLL-module). This allows fast and simple adaptation of
the CANopen protocol software to different CAN controller implementations.
CANopen
Bus |
 |
 |
CAN
controller |
Data
Link
Layer |
|
Communication
Interface
| SDO |
| PDO |
| SYNC |
| MNS |
| NMM |
| ENCY |
| LED |
| FLY |
| SDM, SRD |
| LSS |
|
|
Object
Dictionary
(OBD) |
|
Application
(USR) |
Software structure of the IXXAT CANopen stack
Simple configuration and optimized memory requirement
The functionality of the IXXAT CANopen stack can be easily adapted to the requirements of the application.
For this, the developer just has to activate or deactivate functions/modules by means of "defines" in a
central configuration file.
For the implementation of a slave with a reasonably useful functional scope on a 16-bit microcontroller,
memory requirements of approx. 13k ROM and 1k RAM can be assumed as standard values. If the developer has
fewer resources available, these values can be further reduced by means of specific modifications.
The important factors are a high degree of flexibility, comprehensive tests and assured
long-term maintenance and further development
IXXAT offers its CANopen protocol software as cross-platform C-source code or already adapted to specific
microcontrollers and CAN controllers. The developer therefore has all degrees of freedom to adapt and manage the
software as necessary, like an own development.
Since the beginning of the CANopen standardisation activities, IXXAT has been actively involved in the CANopen
organizations and is therefore definitely able to implement the latest version of the specifications at an early
stage. IXXAT invests considerable amount of work in the continous advancement and maintenance of its CANopen stacks.
By means of a software maintenance agreement, our customers can participate in this continual further development and
benefit from the expert support of our CANopen specialists.
In order to supply customers with high quality products, IXXAT always tests its protocol stack against the current
conformance test software of the CiA. This, together with the fact that the IXXAT software has been successfully
used in the field for many years, guarantees our customers unproblematic, successful implementation of CANopen in
their products and long-term maintenance.
Develop or buy?
Time and again there are developers who consider whether they should develop CANopen protocol
software themselves, because the specifications are freely available without license costs
and there are also several open source initiatives to date. Of course this is an interesting
development challenge. However, from an economic point of view it is not at all worthwhile, as
mature CANopen protocol software is offered nowadays by several manufacturers at very attractive
prices.
For the development of a sufficiently tested and documented CANopen protocol stack a development
time of at least 4 to 6 months is to be expected, even if the full functional scope of the
specifications is not implemented. However, it remains to be seen whether an "initial
implementation" is already a sufficiently optimized, fault-free product and whether the
"subtleties" of the not exactly straightforward CANopen specification are correctly implemented.
The possible setting up of free or open implementations does little to change this fact. Most
of these approaches are only really of interest for training or other non-commercial environments.
If we assume that an in-house development of a CANopen protocol stack could be accomplished within
4 man months, at an hourly rate of EUR 60, the costs for such a development would be more than
EUR 35.000. However this is a very optimistic estimation and a well tested and reliable solution
supplied as source code off the shelf is available for a fraction of this price. Therefore an
in-house development of a CANopen protocol stack is completely uninteresting from an economic
point of view, including the time-to-market.
What does implementation of CANopen involve?
IXXAT supplies its CANopen protocol stack with comprehensive documentation and sample programs. Project files are supplied with the sample programs that allow direct integration into the corresponding development environments of the compiler manufacturer. All sample programs can be run directly on a reference platform (evaluation board or IXXAT interface card).
The implementation is carried out as follows:
- Adaptation to the hardware of the target platform (Timer, Interrupt system)
- Creation of object dictionary entries
- Adaptation of configuration file
- Compiling and testing. For testing, the sample application can be transferred to the target platform. This can then also serve as the basis for the own application.
Early CANopen implementations on the target system can be set-up within a few days.
Alternatively, implementation can also be carried out by IXXAT. In this case, the requirements are specified together with the customer and then implemented by IXXAT. As the implementation is carried out by experienced engineers who are familiar with the software, this represents a low-cost, fast alternative to self-implementation.
Available CANopen software and tools
An overview of the available IXXAT protocol stacks can be found in the section "Protocol Stacks" or on the
IXXAT website.
Useful tools for development and start-up, such as the canAnalyser, the CANopen Device Manager, or the CANopen ConfigurationStudio (basic) can be found in the section "Tools / Interfaces".
|
 | |
|
CANopen Basics