CAN / CANopen for QNX and PREEMPT_RT Linux
DACHS Components for CAN / CANopen FLYER
Resource managers, APIs, Soft Logic Control, graphical programming tools for realtime applications
We offer real-time support packages with CAN boards for normal and extended temperature range from different manufacturers and in different formats, as well as customized solutions. Supported CAN-controllers are e.g. Intel 82527 or Bosch CC770, SJA 1000, and MSCAN on MPC5200. - A special offer are support packages for the embedded processor MPC5200B.
All DACHS CAN real-time drivers are running completely interrupt driven. Supported non co-processor boards allow a maximum frame throughput. The interrupt oriented processing optimizes the CPU load!
In the DACHS® product suite from STEINHOFF are offered for application development optional
- C-examples and C-libraries, documentation
- DACHSview for easy component-based cross-development CAN application realized with DACHSview
- DACHSview-SDL for graphical realtime applications in a rapid time to market
All DACHS CAN C-APIs are also available as function block library for DACHSview and DACHSview-SDL.
DACHS® - CAN is used for various automotive-applications, autonomous vehicles, robotics, for machine control, in medical devices, for aeroplane industry, in test equipment and many other critical applications.
Special DACHS-CANopen OEM solutions are offered for different CAN controllers from Siemens, Bosch, Intel, Phillips, and MSCAN from Motorola/Freecale. All CPU architectures supported by QNX 6.x are also supported under PREEMPT_RT Linux.
CANopen binary support for single CAN channels is also available for all supported CAN boards.
For these non-coprocessor boards we offer a package with a CANopen library, a selected frame level driver and an example application. These packages avoid the bottelneck built by slow micro controllers of co-processor boards.
Basic package for the DACHS CANopen Master Implementation
for QNX 6 or PREEMPT_RT Linux
system independent CANopen Master/Slave stack in ANSI C sources (single line version) from Port GmbH
Reference Manual from Port GmbH
User Manual from Port GmbH with extensions for QNX or Linux from STEINHOFF
QNX or Linux specific ANSI C stack sources for CANopen Master
documented CANopen Master application in C sources for QNX 6.x or Linux (template)
native CANopen API for QNX 6.x or Linux
CANopen driver interface modules for one DACHS CAN Layer2 driver with a controller from Phillips, Intel, or Motorola - only one of these interfaces, specified with the order, belongs to the delivery package
call back interface for confirmations and indications (error treatment, advanced real-time aspects a.s.o )
-
Agreement and NDA
DACHS®- Software and Hardware Components for CAN or CANopen
Up to 4 controller boards are supported in one PC.
support with real-time drivers, C-APIs, PVM-API, DACHSview
single, dual or 4channel PCI boards, Full CAN CC7700
Dual-CAN PC/104-Plus Board from Connect Tech for extended temperature
Janus-MM board from Diamond Systems
single or dual channel PCAN-PCI, -PCIe and -PC/104 Plus for extended temperature
two or four channels
PCAN-cPCI for extended temperature 
single, dual, or 4 channel PC/104 boards, SJA 1000 for extended temperature
single or dual channel PC/104 Plus boards, SJA 1000 for extended temperature
dual channel PC/104 board with CAN 2.0B controllers, Intel 82527 (1Mb/s) (also for extended temperature)
dual channel PC/104 board, Intel 82527 (1Mb/s), COM-1270 (EuroTech)
CAN controller (Intel 82527 CAN 2.0B) of MPL's IPCs PIP 7 and PIP 8
CAN controller board (Intel 82527 CAN 2.0B) for the PROVIT 5000 (B&R)
MSCAN on MPC 5200 embedded PPC controller *
-
CANopen for selected target CAN boards
*) Special CAN OEM offers for customized hardware with the MPC5200B
or other commercial boards.
CAN or CANopen Co-Processor boards
Janus MM board
Dual-CAN PC/104 Board from Diamond Systems.
The resource manager "can_dual" supports both physical CAN channels concurrently.
PCAN boards
Dual-CAN PCAN-PCI and PCAN-PC/104-Plus Boards from PEAK-Systems. The CPU load of the resource managers is less than 4% of a 400 MHz CPU with a frame rate of 100 frames/sec.
DACHS®-Software and Hardware Components
Full CAN Boards with real-time drivers, C-APIs, PVM-API, and DACHSview
for PC/104 and PC/ISA boards with the CAN 2.0B controller Intel 82527 / BOSCH CC770 (1Mb/s)
These CAN controller boards support the CAN protocol according to the CiA standards ISO/DIS 11898 and 11519-1. The PC/104 board can be used with every PC/104 compatible CPU board which supports the 16 Bit PC/104 bus. The 82527 CAN controller is compliant to the CAN standard 2.0B, that means it supports extended CAN frame identifiers. The CAN controller is handled directly by the driver for maximum speed. The physical data lines are driven by a 82C250 CAN transceiver according to the ISO DIS 11898 CiA standard; possible data rates are in the range from 1 Mb/s down to 10 kBit/s.
The C-API provides an easy method for developing realtime applications for QNX systems based on native QNX message passing. The library calls enable QNX applications to send and receive CAN messages via 15 logical channels (each channel has a FIFO for 64 frames). Furthermore, the library provides calls for board initialization, such as baudrate setting, filter definition and diagnose a.s.o.
An additional option is a C-API based on PVM based message passing. This API allows the transparent communication with the CAN driver from any point of the ETHERNET for QNX4, QNX6, LINUX and Windows machines running PVM.
For object oriented programming are offered language bindings for the object oriented interpreter Python. This extended DACHS-CAN API allows to use CAN C-API calls directly as language objects. It speeds up the prototype development.
A Board and its resource manager for QNX4 or QNX 6 come together as package. The DACHS-CAN developer's seat includes the C-API, board/driver package and basic support. Additional options like PVM-API and PyDACHS for CAN can be ordered with the extension package of the developer's seat. DACHSview is a new and interesting option for visual programming of CAN communication. DACHSview CAN-Application
CAN PCI board with the CAN 2.0B controller SJA-1000 (1Mb/s)
Available with one, two, or four physical CAN channels
This CAN controller board supports the CAN protocol according to the CiA standards ISO/DIS 11898 and 11519-1. The board can be used with every PCI compatible CPU board. The CAN controller SJA-1000 is compliant to the CAN standard 2.0B, that means it supports extended CAN frame identifiers.
The CAN controller is handled directly by the driver for maximum speed. The physical bus is driven by a 82C250 CAN transceiver according to the ISO DIS 11898 CiA standard; possible data rates are in the range from 1 Mb/s down to 10 kBit/s. The API calls enable RTOS applications to send and receive CAN messages (each physical CAN channel has an additional receive FIFO for 64 frames). Furthermore, the API provides calls for board initialization, such as baudrate setting, filter definition and diagnose a.s.o.
The DACHS-CAN developer's seat includes the C-API, board/driver package and basic support. DACHSview is an interesting option for visual programming of CAN communication. DACHSview CAN-Application
QNX C-coding example e.g. for the DACHS PCI CAN board
#include <stdio.h> 
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/neutrino.h>
// CAN includes
#include "../include/candef.h"
#include "../include/canstr.h"
#include "../include/canglob.h"
int NameId;
short resp, k;
struct can_object msg, rmsg;
struct status st;
// Task : recv
// Purpose : receiving of frames
int main (void)
{
unsigned short i, j, id;
struct sigevent pulse_event;
struct _pulse pulse;
int chid, coid, rcvid;
// create notification channel
if ((chid = ChannelCreate(0)) == -1) exit( -1);
if ((coid = ConnectAttach(0, 0, chid, _NTO_SIDE_CHANNEL, 0)) == -1)
{
ChannelDestroy(chid);
exit( -1);
}
// initialize notification event
SIGEV_PULSE_INIT(&pulse_event, coid, getprio(0), _PULSE_CODE_MINAVAIL, 0);
if (ConnectDriver (0, "can2") < 0)
{
printf ("CAN recv: can't connect the CAN driver. STOP\n");
exit (-1);
}
printf ("\nCAN status: %04x\n", CanGetStatus(&st));
RegRdProxy(&pulse_event);
for (;;)
{
// a pulse will be triggerd after a frame or more were received
rcvid = MsgReceivePulse(chid, &pulse, sizeof(struct _pulse), NULL);
if(rcvid == -1)
perror("recv\n");
else
{
resp = CanRead (&rmsg, NULL); // read the next frame
do
{
printf("CAN Status: %04x %d", CanGetStatus(&st), rmsg.frame_inf.inf.DLC);
printf (".%04x", rmsg.id);
for (i = 0; i < 7; i++)
printf (".%02x", rmsg.data[i]);
printf (" 0: %d\n", resp);
resp = CanRead (&rmsg, NULL); // read and register pulse again
} while (resp != -1); // read until FIFO is empty
}
// arm the driver again ...
RegRdProxy(&pulse_event);
}
}
Soft PLC
Visual programming of hard real-time applications
