CAN Schnittstelle

/dev/nul · Sep 26th 2006

Hallo, (english see below)
Ich muss die Register TSEG1 und TSEG2vom SJA1000 umprogrammieren.
Leider ist zwar in dem Dokument WINCE_CAN_INTF_eng.pdf die Funktion IOCTL_CAN_WRITE_REGISTER aufgeführt, dummerweise gibt es aber keine Header-Datei, die diesen CTL_CODE auch definiert...
Wie also kann ich das Time-Quantum umprogrammieren?

Gruss
- /dev/nul

(English)
Hi there,
I need to repgrogram the TSEG1 and TSEG2 registers of the SJA1000. Unfortunately the Documentation WINCE_CAN_INTF_eng.pdf describes that there is an API called IOCTL_CAN_WRITE_REGISTER but i cannot find and CTL_CODE definition at all.
Does anybody has an idea how to do it? Or has the CTL_CODE defines for it?

regards
- /dev/nul

fs-support_ZU · Sep 26th 2006

Hello,

thereby canbusio.h with the desired CTL_CODEs:

C

//---------------------------------------------------------------------------
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
//
// Copyright (c) 2002 F&S ELektronik Systeme GmbH
//
// file: canbusio.h
// author: H.Froelich
// purpose: Interface to the CANINTF driver
//
//---------------------------------------------------------------------------
#ifndef __CANBUSIO_H__
#define __CANBUSIO_H__
#define CAN_DRIVER_VERSION (0)
#define MAX_DEVICE_NAME_LENGTH (100)
#define CANBUS_FORMAT_CAN_2_0_A (0)
#define CANBUS_FORMAT_CAN_2_0_B (1)
// Chipset Flags
#define CANBUS_CFS_CAN_2_0_A (1<<0) /* Chipset can used for CAN 2.0 A */
#define CANBUS_CFS_CAN_2_0_B (1<<1) /* Chipset can used for CAN 2.0 B */
#define CANBUS_CFS_EXT_FRAME (1<<2) /* Chipset support extended frame format (only in CAN 2.0B mode) */
#define CANBUS_CFS_POLLING (1<<3) /* (not implemented in canbus driver) Chipset driver supports only polling (interrupts are default) */
// Events
enum t_canbus_events
{
CANBUS_EVENT_RECEIVED=0x001,
CANBUS_EVENT_TRANSMITTED=0x002,
CANBUS_EVENT_BUS_ERROR=0x004,
CANBUS_EVENT_WARNING=0x008,
CANBUS_EVENT_LEAVING_STANDBY=0x010,
CANBUS_EVENT_ARBITRATION_LOST=0x020,
CANBUS_EVENT_OVERRUN=0x040,
CANBUS_EVENT_PASSIVE=0x080,
CANBUS_EVENT_ENTERING_STANDBY=0x100,
CANBUS_EVENT_DEVICE_CHANGED=0x200
};
// Commands
enum t_canbus_commands
{
CANBUS_CMD_ENTER_STANDBY=1,
CANBUS_CMD_ABORT_TRANSMISSION,
CANBUS_CMD_CLEAR_OVERRUN,
CANBUS_CMD_LEAVE_STANDBY,
CANBUS_CMD_SELF_RECEPTION_REQUEST,
CANBUS_CMD_LISTEN_ON,
CANBUS_CMD_LISTEN_OFF,
CANBUS_CMD_VIRTUALIZE_ON,
CANBUS_CMD_VIRTUALIZE_OFF,
CANBUS_CMD_LAST_ENTRY /* this must be the last entry in the list */
};
#define CANBUS_NUMBER_OF_CONSTANT_BAUDRATES (50) /* max. 50 entries for constant baudrates */
// The time is a 64-bit number...
typedef struct tagCAN_TIME
{
unsigned long low;
unsigned long high;
} CAN_TIME, *PCAN_TIME;
// Acceptance Filter (Hardware filter in SJA1000)
typedef struct tagCAN_ACCEPTANCE_FILTER
{
unsigned long code;
unsigned long mask;
} CAN_ACCEPTANCE_FILTER, *PCAN_ACCEPTANCE_FILTER;
// Properties of the selected channel
typedef struct tagCAN_PROPERTIES
{
unsigned long version; // driver version
TCHAR device_name[MAX_DEVICE_NAME_LENGTH];
long min; // min baudrate
long max; // max baudrate
int nCommands; // number of "commands[]" entries
int commands[CANBUS_CMD_LAST_ENTRY]; // supported commands of the selected channel (depends on mode)
int nBaudrates; // 0 if "canbus_set_baudrate()" is supported, otherwise only "baudrates[]" are supported
unsigned long baudrates[CANBUS_NUMBER_OF_CONSTANT_BAUDRATES];
unsigned long chipset_flags; // see: CANBUS_CFS_...
int nRegisters; // for direct acces to the chipset from an application
} CAN_PROPERTIES, *PCAN_PROPERTIES;
#define CANBUS_TRANS_FMT_DEFAULT (0) /* send this data with default frame format */
#define CANBUS_TRANS_FMT_STD (1) /* send this data in 11 bit format */
#define CANBUS_TRANS_FMT_EXT (2) /* send this data in 29 bit format */
// Transmission structure
// With this structure a CAN message will sended
typedef struct tagCAN_TRANSMIT_DATA
{
int fmt; // see CANBUS_TRANS_FMT_...., ignore this in canbus_event-structure (see below)
unsigned long identifier; // CAN Identifier
unsigned char rtr; // Remote Transmission Request bit (0=CAN message with data, 1=request data from receiver)
unsigned char dlc; // Data Length Code (= number of data bytes in "msg[]")
unsigned char msg[8]; // data bytes
} CAN_TRANSMIT_DATA, *PCAN_TRANSMIT_DATA;
typedef struct tagCAN_EVENT
{
int event; // see: t_canbus_events
CAN_TIME time;
//----------- used, if event=CANBUS_ISR_RECEIVED | CANBUS_ISR_TRANSMITTED ---------------
unsigned long lost;
CAN_TRANSMIT_DATA data;
//----------- used, if event=CANBUS_ISR_ARBITRATION_LOST ------------------------------
int arbitration;
} CAN_EVENT, *PCAN_EVENT;
// We'll need some defines
#include "WINIOCTL.h"
// New IOControlCode values
#define FILE_DEVICE_CAN 0x00008007
#define IOCTL_CAN_WRITE_ACCEPTANCE_FILTER \
CTL_CODE(FILE_DEVICE_CAN, 0x801, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_CAN_READ_ACCEPTANCE_FILTER \
CTL_CODE(FILE_DEVICE_CAN, 0x802, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_CAN_SET_BAUDRATE \
CTL_CODE(FILE_DEVICE_CAN, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_GET_BAUDRATE \
CTL_CODE(FILE_DEVICE_CAN, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_INIT \
CTL_CODE(FILE_DEVICE_CAN, 0x805, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_SET_BAUDRATE_BY_CONSTANT \
CTL_CODE(FILE_DEVICE_CAN, 0x806, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_GET_BAUDRATE_BY_CONSTANT \
CTL_CODE(FILE_DEVICE_CAN, 0x807, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_SET_CAN_MODE \
CTL_CODE(FILE_DEVICE_CAN, 0x808, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_SET_COMMAND \
CTL_CODE(FILE_DEVICE_CAN, 0x809, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_WRITE_TRANSMIT_DATA \
CTL_CODE(FILE_DEVICE_CAN, 0x80A, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_CAN_READ_EVENT_DATA \
CTL_CODE(FILE_DEVICE_CAN, 0x80B, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_READ_TIME \
CTL_CODE(FILE_DEVICE_CAN, 0x80C, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_CAN_SET_DEFAULT_FRAME_FORMAT \
CTL_CODE(FILE_DEVICE_CAN, 0x80D, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_TEST_DEVICE \
CTL_CODE(FILE_DEVICE_CAN, 0x80E, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_READ_PROPERTIES \
CTL_CODE(FILE_DEVICE_CAN, 0x80F, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_READ_REGISTER \
CTL_CODE(FILE_DEVICE_CAN, 0x810, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_WRITE_REGISTER \
CTL_CODE(FILE_DEVICE_CAN, 0x811, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_READ_REGISTER_RM \
CTL_CODE(FILE_DEVICE_CAN, 0x812, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CAN_WRITE_REGISTER_RM \
CTL_CODE(FILE_DEVICE_CAN, 0x813, METHOD_BUFFERED, FILE_ANY_ACCESS)
#endif/*__CANBUSIO_H__*/

Display More

/dev/nul · Sep 27th 2006

Many Thanks,
Your version of canbusio.h contains 8 Lines more than mine...
And that was exactly what i needed!

Thanks again
- /dev/nul

quertybert · Dec 4th 2008

Hallo,
ich habe den C# (.Net) Treiber

Das Senden von CAN Nachrichten funktioniert prima.
Jedoch beim Empfangen von CAN Nachrichten habe ich aber ein kleines Problem
Kann ein Event vom CAN-Treiber erzeugt werden wenn eine CAN Nachricht empfangen wurde?
Das pollen mit ReadEventData() über einen Timer ist bestimmt keine gute Lösung.

Danke im vorraus
Eric Boger

fs-support_HK · Dec 4th 2008

Das Lesen der Events sollte man in einen eigenen Thread auslagern. Der kann dann problemlos in der Leseroutine (ReadFile() bzw. IOCTL_CAN_READ_EVENT) oder in WaitCommEvent() blockiert werden, das Hauptprogramm läuft ja trotzdem weiter.

Alternativ könnte man auch mit SetCommTimeouts() einen sehr kleinen Read-Timeout setzen. Wenn es einen Event gibt, bekommt man ihn, sonst kehrt die Lesefunktion eben mit Timeout-Fehler zurück. Dann muss man aber regelmäßig auf diese Weise pollen.

Ich würde den eigenen Thread vorziehen, da er keine Rechenzeit braucht, solange keine Events vorliegen.

Mit freundlichen Grüßen,

H. Keller

Share