chris/BionxControl
Public Access
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First commit.

Browse Source
This commit is contained in:
DIASPORA\chris
2025-12-15 20:57:09 +01:00
commit a01356342c
33 changed files with 3050 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
can_api/MhsSlCan.dll Normal file
View File

Binary file not shown.

283
can_api/can_drv.h Normal file
View File

@@ -0,0 +1,283 @@
#ifndef __CAN_DRV_H__
#define __CAN_DRV_H__
#include "can_drv_config.h"
#include "can_types.h"
#ifdef __WIN32__
// ****** Windows
#include <windows.h>
#define DRV_CALLBACK_TYPE __stdcall
#else
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#define DRV_CALLBACK_TYPE
#endif
#ifdef __cplusplus
extern "C" {
#endif
/***************************************************************/
/* Define Makros */
/***************************************************************/
// CAN <20>bertragungsgeschwindigkeit
#define CAN_10K_BIT 10 // 10 kBit/s
#define CAN_20K_BIT 20 // 20 kBit/s
#define CAN_50K_BIT 50 // 50 kBit/s
#define CAN_100K_BIT 100 // 100 kBit/s
#define CAN_125K_BIT 125 // 125 kBit/s
#define CAN_250K_BIT 250 // 250 kBit/s
#define CAN_500K_BIT 500 // 500 kBit/s
#define CAN_800K_BIT 800 // 800 kBit/s
#define CAN_1M_BIT 1000 // 1 MBit/s
#define CAN_1M5_BIT 1500 // 1,5 MBit/s
#define CAN_2M_BIT 2000 // 2 MBit/s
#define CAN_3M_BIT 3000 // 3 MBit/s
#define CAN_4M_BIT 4000 // 4 MBit/s
// Time Stamp Mode
#define TIME_STAMP_OFF 0 // keine Time-Stamps
#define TIME_STAMP_SOFT 1 // Software Time-Stamps
#define TIME_STAMP_HW_UNIX 2 // Hardware Time-Stamps, UNIX-Format
#define TIME_STAMP_HW 3 // Hardware Time-Stamps
#define TIME_STAMP_HW_SW_UNIX 4 // Hardware Time-Stamps verwenden wenn verf<72>gbar,
// ansonsten Software Time-Stamps
// Ab Treiber Version 4.08!
// CAN Bus Mode
#define OP_CAN_NO_CHANGE 0 // Aktuellen Zustand nicht <20>ndern
#define OP_CAN_START 1 // Startet den CAN-Bus
#define OP_CAN_STOP 2 // Stopt den CAN-Bus
#define OP_CAN_RESET 3 // Reset CAN Controller (BusOff l<>schen)
#define OP_CAN_START_LOM 4 // Startet den CAN-Bus im Silent Mode (Listen Only Mode)
#define OP_CAN_START_NO_RETRANS 5 // Startet den CAN-Bus im Automatic Retransmission disable Mode
#define OP_CAN_ECU_FLASH_MODE 6 // Start im ECU Flash Mode
#define CAN_CMD_NONE 0x0000
#define CAN_CMD_RXD_OVERRUN_CLEAR 0x0001
#define CAN_CMD_RXD_FIFOS_CLEAR 0x0002
#define CAN_CMD_TXD_OVERRUN_CLEAR 0x0004
#define CAN_CMD_TXD_FIFOS_CLEAR 0x0008
#define CAN_CMD_HW_FILTER_CLEAR 0x0010
#define CAN_CMD_SW_FILTER_CLEAR 0x0020
#define CAN_CMD_TXD_PUFFERS_CLEAR 0x0040
// <*> neu
#define CAN_CMD_START_DATA_TRANSFER 0x1000
#define CAN_CMD_CANCEL_DATA_TRANSFER 0x2000
#define CAN_CMD_START_TEST 0xE000
#define CAN_CMD_STOP_TEST 0xF000
#define CAN_CMD_FIFOS_CLEAR 0x000F
#define CAN_CMD_ALL_CLEAR 0x0FFF
// DrvStatus
#define DRV_NOT_LOAD 0 // Die Treiber DLL wurde noch nicht geladen
#define DRV_STATUS_NOT_INIT 1 // Treiber noch nicht Initialisiert (Funktion "CanInitDrv" noch nicht aufgerufen)
#define DRV_STATUS_INIT 2 // Treiber erfolgrich Initialisiert
#define DRV_STATUS_PORT_NOT_OPEN 3 // Die Schnittstelle wurde nicht ge<67>ffnet
#define DRV_STATUS_PORT_OPEN 4 // Die Schnittstelle wurde ge<67>ffnet
#define DRV_STATUS_DEVICE_FOUND 5 // Verbindung zur Hardware wurde Hergestellt
#define DRV_STATUS_CAN_OPEN 6 // Device wurde ge<67>ffnet und erfolgreich Initialisiert
#define DRV_STATUS_CAN_RUN_TX 7 // CAN Bus RUN nur Transmitter (wird nicht verwendet !)
#define DRV_STATUS_CAN_RUN 8 // CAN Bus RUN
// CanStatus
#define CAN_STATUS_OK 0 // CAN-Controller: Ok
#define CAN_STATUS_ERROR 1 // CAN-Controller: CAN Error
#define CAN_STATUS_WARNING 2 // CAN-Controller: Error warning
#define CAN_STATUS_PASSIV 3 // CAN-Controller: Error passiv
#define CAN_STATUS_BUS_OFF 4 // CAN-Controller: Bus Off
#define CAN_STATUS_UNBEKANNT 5 // CAN-Controller: Status Unbekannt
// Neu f<>r Low-Speed CAN, TJA1055 Fehler
#define BUS_FAILURE 0x10
// Fifo Status
#define FIFO_OK 0 // Fifo-Status: Ok
#define FIFO_HW_OVERRUN 1 // Fifo-Status: Hardware Fifo <20>berlauf
#define FIFO_SW_OVERRUN 2 // Fifo-Status: Software Fifo <20>berlauf
#define FIFO_HW_SW_OVERRUN 3 // Fifo-Status: Hardware & Software Fifo <20>berlauf
#define FIFO_STATUS_UNBEKANNT 4 // Fifo-Status: Unbekannt
// Makros f<>r SetEvent
#define EVENT_ENABLE_PNP_CHANGE 0x0001
#define EVENT_ENABLE_STATUS_CHANGE 0x0002
#define EVENT_ENABLE_RX_FILTER_MESSAGES 0x0004
#define EVENT_ENABLE_RX_MESSAGES 0x0008
#define EVENT_ENABLE_ALL 0x00FF
#define EVENT_DISABLE_PNP_CHANGE 0x0100
#define EVENT_DISABLE_STATUS_CHANGE 0x0200
#define EVENT_DISABLE_RX_FILTER_MESSAGES 0x0400
#define EVENT_DISABLE_RX_MESSAGES 0x0800
#define EVENT_DISABLE_ALL 0xFF00
// <*> Neu
#define TCAN_LOG_FLAG_MESSAGE 0x00000001
#define TCAN_LOG_FLAG_STATUS 0x00000002
#define TCAN_LOG_FLAG_RX_MSG 0x00000004
#define TCAN_LOG_FLAG_TX_MSG 0x00000008
#define TCAN_LOG_FLAG_API_CALL 0x00000010
#define TCAN_LOG_API_CALL_RX 0x00000020
#define TCAN_LOG_API_CALL_TX 0x00000040
#define TCAN_LOG_API_CALL_STATUS 0x00000080
#define TCAN_LOG_FLAG_ERROR 0x00000100
#define TCAN_LOG_FLAG_WARN 0x00000200
#define TCAN_LOG_FLAG_ERR_MSG 0x00000400
#define TCAN_LOG_FLAG_OV_MSG 0x00000800
#define TCAN_LOG_USB 0x00008000 // <*> neu
#define TCAN_LOG_FLAG_DEBUG 0x08000000
#define TCAN_LOG_FLAG_WITH_TIME 0x40000000
#define TCAN_LOG_FLAG_DISABLE_SYNC 0x80000000
/***************************************************************/
/* Typen */
/***************************************************************/
/******************************************/
/* Device Status */
/******************************************/
#pragma pack(push, 1)
struct TDeviceStatus
{
int32_t DrvStatus; // Treiber Status (Device close / Device open / CAN Bus RUN)
unsigned char CanStatus; // Status des CAN Controllers (Ok / ... / Error passiv / Bus off)
unsigned char FifoStatus; // Fifo Status (Ok / ... / Hard. u. Soft. FIFO <20>berlauf)
};
#pragma pack(pop)
#ifdef CAN_API_TRUE_FUNC
int32_t CanInitDriver(char *options);
void CanDownDriver(void);
int32_t CanSetOptions(char *options);
int32_t CanDeviceOpen(uint32_t index, char *parameter);
int32_t CanDeviceClose(uint32_t index);
int32_t CanSetMode(uint32_t index, unsigned char can_op_mode, uint16_t can_command);
int32_t CanTransmit(uint32_t index, struct TCanMsg *msg, int32_t count);
void CanTransmitClear(uint32_t index);
uint32_t CanTransmitGetCount(uint32_t index);
int32_t CanTransmitSet(uint32_t index, uint16_t cmd, uint32_t time);
int32_t CanReceive(uint32_t index, struct TCanMsg *msg, int32_t count);
void CanReceiveClear(uint32_t index);
uint32_t CanReceiveGetCount(uint32_t index);
int32_t CanSetSpeed(uint32_t index, uint16_t speed);
int32_t CanSetSpeedUser(uint32_t index, uint32_t value);
char *CanDrvInfo(void);
char *CanDrvHwInfo(uint32_t index);
int32_t CanSetFilter(uint32_t index, struct TMsgFilter *msg_filter);
int32_t CanGetDeviceStatus(uint32_t index, struct TDeviceStatus *status);
void CanSetPnPEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, int32_t status));
void CanSetStatusEventCallback(void (DRV_CALLBACK_TYPE *event)
(uint32_t index, struct TDeviceStatus *device_status));
void CanSetRxEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index,
struct TCanMsg *msg, int32_t count));
void CanSetEvents(uint16_t events);
uint32_t CanEventStatus(void);
#endif
#if !(defined(CAN_API_TRUE_FUNC)) || defined(CAN_DRV_INCLUDE)
/***************************************************************/
/* Funktionstypen */
/***************************************************************/
typedef int32_t (DRV_CALLBACK_TYPE *TCanInitDriver)(char *options);
typedef void (DRV_CALLBACK_TYPE *TCanDownDriver)(void);
typedef int32_t (DRV_CALLBACK_TYPE *TCanSetOptions)(char *options);
typedef int32_t (DRV_CALLBACK_TYPE *TCanDeviceOpen)(uint32_t index, char *parameter);
typedef int32_t (DRV_CALLBACK_TYPE *TCanDeviceClose)(uint32_t index);
typedef int32_t (DRV_CALLBACK_TYPE *TCanSetMode)(uint32_t index, unsigned char can_op_mode,
uint16_t can_command);
typedef int32_t (DRV_CALLBACK_TYPE *TCanTransmit)(uint32_t index, struct TCanMsg *msg, int32_t count);
typedef void (DRV_CALLBACK_TYPE *TCanTransmitClear)(uint32_t index);
typedef uint32_t (DRV_CALLBACK_TYPE *TCanTransmitGetCount)(uint32_t index);
typedef int32_t (DRV_CALLBACK_TYPE *TCanTransmitSet)(uint32_t index, uint16_t cmd, uint32_t time);
typedef int32_t (DRV_CALLBACK_TYPE *TCanReceive)(uint32_t index, struct TCanMsg *msg, int32_t count);
typedef void (DRV_CALLBACK_TYPE *TCanReceiveClear)(uint32_t index);
typedef uint32_t (DRV_CALLBACK_TYPE *TCanReceiveGetCount)(uint32_t index);
typedef int32_t (DRV_CALLBACK_TYPE *TCanSetSpeed)(uint32_t index, uint16_t speed);
typedef int32_t (DRV_CALLBACK_TYPE *TCanSetSpeedUser)(uint32_t index, uint32_t value);
typedef char * (DRV_CALLBACK_TYPE *TCanDrvInfo)(void);
typedef char * (DRV_CALLBACK_TYPE *TCanDrvHwInfo)(uint32_t index);
typedef int32_t (DRV_CALLBACK_TYPE *TCanSetFilter)(uint32_t index, struct TMsgFilter *msg_filter);
typedef int32_t (DRV_CALLBACK_TYPE *TCanGetDeviceStatus)(uint32_t index, struct TDeviceStatus *status);
typedef void (DRV_CALLBACK_TYPE *TCanSetPnPEventCallback)(void (DRV_CALLBACK_TYPE *event)
(uint32_t index, int32_t status));
typedef void (DRV_CALLBACK_TYPE *TCanSetStatusEventCallback)(void (DRV_CALLBACK_TYPE *event)
(uint32_t index, struct TDeviceStatus *device_status));
typedef void (DRV_CALLBACK_TYPE *TCanSetRxEventCallback)(void (DRV_CALLBACK_TYPE *event)
(uint32_t index, struct TCanMsg *msg, int32_t count));
typedef void (DRV_CALLBACK_TYPE *TCanSetEvents)(uint16_t events);
typedef uint32_t (DRV_CALLBACK_TYPE *TCanEventStatus)(void);
#endif
#ifndef CAN_API_TRUE_FUNC
/***************************************************************/
/* Tiny-CAN API Funktionen */
/***************************************************************/
extern TCanInitDriver CanInitDriver;
extern TCanDownDriver CanDownDriver;
extern TCanSetOptions CanSetOptions;
extern TCanDeviceOpen CanDeviceOpen;
extern TCanDeviceClose CanDeviceClose;
extern TCanSetMode CanSetMode;
extern TCanTransmit CanTransmit;
extern TCanTransmitClear CanTransmitClear;
extern TCanTransmitGetCount CanTransmitGetCount;
extern TCanTransmitSet CanTransmitSet;
extern TCanReceive CanReceive;
extern TCanReceiveClear CanReceiveClear;
extern TCanReceiveGetCount CanReceiveGetCount;
extern TCanSetSpeed CanSetSpeed;
extern TCanSetSpeedUser CanSetSpeedUser;
extern TCanDrvInfo CanDrvInfo;
extern TCanDrvHwInfo CanDrvHwInfo;
extern TCanSetFilter CanSetFilter;
extern TCanGetDeviceStatus CanGetDeviceStatus;
extern TCanSetPnPEventCallback CanSetPnPEventCallback;
extern TCanSetStatusEventCallback CanSetStatusEventCallback;
extern TCanSetRxEventCallback CanSetRxEventCallback;
extern TCanSetEvents CanSetEvents;
extern TCanEventStatus CanEventStatus;
#endif
/***************************************************************/
/* Funktionen Treiber laden/entladen */
/***************************************************************/
int32_t LoadDriver(const char *file_name);
void UnloadDriver(void);
#include "can_drv_ex.h"
#ifdef __cplusplus
}
#endif
#endif

16
can_api/can_drv_config.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef __CAN_DRV_CONFIG_H__
#define __CAN_DRV_CONFIG_H__
#ifndef STRICT_CAN_FD_SUPPORT
//#define STRICT_CAN_FD_SUPPORT
#endif
#ifndef CAN_API_TRUE_FUNC
#define CAN_API_TRUE_FUNC
#endif
#ifndef DRV_REF_LOCKING
#define DRV_REF_LOCKING
#endif
#endif

420
can_api/can_drv_ex.h Normal file
View File

@@ -0,0 +1,420 @@
#ifndef __CAN_DRV_EX_H__
#define __CAN_DRV_EX_H__
#ifdef __cplusplus
extern "C" {
#endif
#define ERR_NO_CAN_DRIVER_LOAD -1000000
#define DEV_LIST_SHOW_TCAN_ONLY 0x01
#define DEV_LIST_SHOW_UNCONNECT 0x02
/***************************************************************/
/* Define Makros */
/***************************************************************/
#define CAN_FEATURE_LOM 0x0001 // Silent Mode (LOM = Listen only Mode)
#define CAN_FEATURE_ARD 0x0002 // Automatic Retransmission disable
#define CAN_FEATURE_TX_ACK 0x0004 // TX ACK (Gesendete Nachrichten best<73>tigen)
#define CAN_FEATURE_ERROR_MSGS 0x0008 // Error Messages Support
#define CAN_FEATURE_FD_HARDWARE 0x0010 // CAN-FD Hardware
#define CAN_FEATURE_FIFO_OV_MODE 0x0020 // FIFO OV Mode (Auto Clear, OV CAN Messages)
#define CAN_FEATURE_ECU_FLASH 0x0040 // Hardware beschleunigung f<>r ISO-TP ECU-Flash programmierung
#define CAN_FEATURE_CAN_TEST 0x4000 // Tiny-CAN Tester Firmware
#define CAN_FEATURE_HW_TIMESTAMP 0x8000 // Hardware Time Stamp
// (V)alue (T)ype
#define VT_BYTE 0x01
#define VT_UBYTE 0x02
#define VT_WORD 0x03
#define VT_UWORD 0x04
#define VT_LONG 0x05
#define VT_ULONG 0x06
#define VT_BYTE_ARRAY 0x07
#define VT_UBYTE_ARRAY 0x08
#define VT_WORD_ARRAY 0x09
#define VT_UWORD_ARRAY 0x0A
#define VT_LONG_ARRAY 0x0B
#define VT_ULONG_ARRAY 0x0C
#define VT_BYTE_RANGE_ARRAY 0x0D
#define VT_UBYTE_RANGE_ARRAY 0x0E
#define VT_WORD_RANGE_ARRAY 0x0F
#define VT_UWORD_RANGE_ARRAY 0x10
#define VT_LONG_RANGE_ARRAY 0x11
#define VT_ULONG_RANGE_ARRAY 0x12
#define VT_HBYTE 0x40
#define VT_HWORD 0x41
#define VT_HLONG 0x42
#define VT_STREAM 0x80
#define VT_STRING 0x81
#define VT_POINTER 0x82
#define VT_REVISION 0x83
#define VT_DATE 0x84
// MHS (EV)ent (S)ource
#define MHS_EVS_STATUS 1
#define MHS_EVS_PNP 2
#define MHS_EVS_OBJECT 3
#define MHS_EVS_DIN 4
#define MHS_EVS_ENC 5
#define MHS_EVS_KEY 6
#define MHS_TERMINATE 0x80000000
// <*> neu
#define CAN_DATA_ST_IDLE 0
#define CAN_DATA_ST_RUN 1
#define CAN_DATA_ST_FINISH 2
#define CAN_DATA_ST_ERR_ACK_TIMEOUT -1
#define CAN_DATA_ST_ERR_NACK -2
#define CAN_DATA_ST_ERR_OVERFLOW -3
#define CAN_DATA_ST_ERR_ISOTP -4
// ISO-TP Flags
#define CAN_DATA_ISOTP_29BIT_ID 0x01
#define CAN_DATA_ISOTP_EXTEND_ADDR 0x02
#define CAN_DATA_ISOTP_TX_PADDING 0x04
#define CAN_DATA_ISOTP_LISTEN_MODE 0x08
// <*> neu
#define TCAN_INFO_KEY_HW_SNR 0x00000000 // Hardware Snr
#define TCAN_INFO_KEY_HW_ID_STR 0x00000001 // Hardware ID String
#define TCAN_INFO_KEY_HW_BIOS_STR 0x00000002 // Bios ID String
#define TCAN_INFO_KEY_HW_REVISION 0x00000003 // Hardware Revision
#define TCAN_INFO_KEY_HW_DATE 0x00000004 // Fertigungsdatum
#define TCAN_INFO_KEY_HW_VARIANT_STR 0x00000005 // Hardware Variante
#define TCAN_INFO_KEY_HW_CAN_COUNT 0x00008000 // Anzahl CAN Interfaces
#define TCAN_INFO_KEY_HW_CAN_DRV 0x00008010 // Treiber
#define TCAN_INFO_KEY_HW_CAN_OPTO 0x00008020 // Opto
#define TCAN_INFO_KEY_HW_CAN_TERM 0x00008030 // Term
#define TCAN_INFO_KEY_HW_CAN_HS 0x00008040 // HighSpeed
#define TCAN_INFO_KEY_HW_I2C_CNT 0x00008100 // Anzahl I2C Interfaces
#define TCAN_INFO_KEY_HW_SPI_CNT 0x00008200 // Anzahl SPI Interfaces
#define TCAN_INFO_KEY_FW_ID 0x00001000 // ID
#define TCAN_INFO_KEY_FW_ID_STR 0x00001001 // ID String
#define TCAN_INFO_KEY_FW_VERSION 0x00001002 // Version
#define TCAN_INFO_KEY_FW_VERSION_STR 0x00001003 // Version String
#define TCAN_INFO_KEY_FW_AUTOR 0x00001004 // Autor
#define TCAN_INFO_KEY_FW_OPTIOS 0x00001005 // Optionen
#define TCAN_INFO_KEY_FW_SNR 0x00001006 // Snr
#define TCAN_INFO_KEY_FW_CAN_FLAGS 0x00008001 // CAN Features Flags
#define TCAN_INFO_KEY_FW_CAN_FLAGS2 0x00008002 // CAN Features Flags2 // <*>
#define TCAN_INFO_KEY_FW_CAN_CLOCK1 0x00008003
#define TCAN_INFO_KEY_FW_CAN_CLOCK2 0x00008004
#define TCAN_INFO_KEY_FW_CAN_CLOCK3 0x00008005
#define TCAN_INFO_KEY_FW_CAN_CLOCK4 0x00008006
#define TCAN_INFO_KEY_FW_CAN_CLOCK5 0x00008007
#define TCAN_INFO_KEY_FW_CAN_CLOCK6 0x00008008
#define TCAN_INFO_KEY_FW_PUFFER_CNT 0x00008050 // Anzahl Interval Puffer
#define TCAN_INFO_KEY_FW_FILTER_CNT 0x00008060 // Anzahl Filter
#define TCAN_INFO_KEY_OPEN_INDEX 0x01000001
#define TCAN_INFO_KEY_HARDWARE_ID 0x01000002
#define TCAN_INFO_KEY_HARDWARE 0x01000003
#define TCAN_INFO_KEY_VENDOR 0x01000004
#define TCAN_INFO_KEY_DEVICE_NAME 0x01000005
#define TCAN_INFO_KEY_SERIAL_NUMBER 0x01000006
#define TCAN_INFO_KEY_CAN_FEATURES 0x01000007
#define TCAN_INFO_KEY_CAN_CHANNELS 0x01000008
#define TCAN_INFO_KEY_RX_FILTER_CNT 0x01000009
#define TCAN_INFO_KEY_TX_BUFFER_CNT 0x0100000A
#define TCAN_INFO_KEY_CAN_CLOCKS 0x0100000B
#define TCAN_INFO_KEY_CAN_CLOCK1 0x0100000C
#define TCAN_INFO_KEY_CAN_CLOCK2 0x0100000D
#define TCAN_INFO_KEY_CAN_CLOCK3 0x0100000E
#define TCAN_INFO_KEY_CAN_CLOCK4 0x0100000F
#define TCAN_INFO_KEY_CAN_CLOCK5 0x01000010
#define TCAN_INFO_KEY_CAN_CLOCK6 0x01000011
#define TCAN_INFO_KEY_API_VERSION 0x02000001
#define TCAN_INFO_KEY_DLL 0x02000002
#define TCAN_INFO_KEY_CFG_APP 0x02000003
/***************************************************************/
/* Typen */
/***************************************************************/
#pragma pack(push, 1)
struct TModulFeatures
{
uint32_t CanClock; // Clock-Frequenz des CAN-Controllers, muss nicht mit
// der Clock-Frequenz des Mikrocontrollers <20>bereinstimmen
uint32_t Flags; // Unterst<73>tzte Features des Moduls:
// Bit 0 -> Silent Mode (LOM = Listen only Mode)
// 1 -> Automatic Retransmission disable
// 2 -> TX ACK (Gesendete Nachrichten best<73>tigen)
// 15 -> Hardware Time Stamp
uint32_t CanChannelsCount; // Anzahl der CAN Schnittstellen, reserviert f<>r
// zuk<75>nftige Module mit mehr als einer Schnittstelle
uint32_t HwRxFilterCount; // Anzahl der zur Verf<72>gung stehenden Receive-Filter
uint32_t HwTxPufferCount; // Anzahl der zur Verf<72>gung stehenden Transmit Puffer mit Timer
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TCanDevicesList
{
uint32_t TCanIdx; // Ist das Device ge<67>ffnet ist der Wert auf dem Device-Index
// gesetzt, ansonsten ist der Wert auf "INDEX_INVALID" gesetzt.
uint32_t HwId; // Ein 32 Bit Schl<68>ssel der die Hardware eindeutig Identifiziert.
// Manche Module m<>ssen erst ge<67>ffnet werden damit dieser Wert
// gesetzt wird
char DeviceName[255]; // Nur Linux: entspricht den Device Namen des USB-Devices,
// z.B. /dev/ttyUSB0
char SerialNumber[16]; // Seriennummer des Moduls
char Description[64]; // Modul Bezeichnung, z.B. "Tiny-CAN IV-XL",
// muss in den USB-Controller programmiert sein,
// was zur Zeit nur bei den Modulen Tiny-CAN II-XL,
// IV-XL u. M1 der Fall ist.
struct TModulFeatures ModulFeatures; // Unterst<73>tzte Features des Moduls, nur g<>ltig
// wenn HwId > 0
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TCanDeviceInfo
{
uint32_t HwId; // Ein 32 Bit Schl<68>ssel der die Hardware eindeutig Identifiziert.
uint32_t FirmwareVersion; // Version der Firmware des Tiny-CAN Moduls
uint32_t FirmwareInfo; // Informationen zum Stand der Firmware Version
// 0 = Unbekannt
// 1 = Firmware veraltet, Device kann nicht ge<67>ffnet werden
// 2 = Firmware veraltet, Funktionsumfang eingeschr<68>nkt
// 3 = Firmware veraltet, keine Einschr<68>nkungen
// 4 = Firmware auf Stand
// 5 = Firmware neuer als Erwartet
char SerialNumber[16]; // Seriennummer des Moduls
char Description[64]; // Modul Bezeichnung, z.B. "Tiny-CAN IV-XL"
struct TModulFeatures ModulFeatures; // Unterst<73>tzte Features des Moduls
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TCanInfoVar // <*> ge<67>ndert von TInfoVar in TCanInfoVar
{
uint32_t Key; // Variablen Schl<68>ssel
uint32_t Type; // Variablen Type
uint32_t Size; // (Max)Gr<47><72>e der Variable in Byte
char Data[255]; // Wert der Variable
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TCanInfoVarList
{
uint32_t Size;
struct TCanInfoVar *List;
};
#pragma pack(pop)
typedef struct _TMhsEvent TMhsEvent;
#pragma pack(push, 1)
struct _TMhsEvent
{
volatile uint32_t Events;
volatile uint32_t EventsMask;
volatile int32_t Waiting;
#ifdef __WIN32__
// ****** Windows
uint32_t WinEventCount;
HANDLE WinEvent[3];
CRITICAL_SECTION EventLock;
#else
// ****** Linux
pthread_cond_t Cond;
pthread_mutex_t Mutex;
#endif
};
#pragma pack(pop)
/***************************************************************/
/* Callback Funktionstypen */
/***************************************************************/
typedef int32_t (DRV_CALLBACK_TYPE *TCanGetDataBlockCB)(uint8_t *tx_data, uint16_t tx_limit, void *user_data);
#ifdef CAN_API_TRUE_FUNC
int32_t CanExGetDeviceCount(int32_t flags);
int32_t CanExGetDeviceList(struct TCanDevicesList **devices_list, int32_t flags);
int32_t CanExGetDeviceListPerform(int32_t flags);
int32_t CanExGetDeviceListGet(struct TCanDevicesList *item);
int32_t CanExGetDeviceInfo(uint32_t index, struct TCanDeviceInfo *device_info,
struct TCanInfoVar **hw_info, uint32_t *hw_info_size);
int32_t CanExGetDeviceInfoPerform(uint32_t index, struct TCanDeviceInfo *device_info);
int32_t CanExGetDeviceInfoGet(struct TCanInfoVar *item);
void CanExDataFree(void **data);
int32_t CanExCreateDevice(uint32_t *index, char *options);
int32_t CanExDestroyDevice(uint32_t *index);
int32_t CanExCreateFifo(uint32_t index, uint32_t size, TMhsEvent *event_obj, uint32_t event, uint32_t channels);
int32_t CanExBindFifo(uint32_t fifo_index, uint32_t device_index, uint32_t bind);
TMhsEvent *CanExCreateEvent(void);
int32_t CanExSetObjEvent(uint32_t index, uint32_t source, TMhsEvent *event_obj, uint32_t event);
void CanExSetEvent(TMhsEvent *event_obj, uint32_t event);
void CanExSetEventAll(uint32_t event);
void CanExResetEvent(TMhsEvent *event_obj, uint32_t event);
uint32_t CanExWaitForEvent(TMhsEvent *event_obj, uint32_t timeout);
int32_t CanExInitDriver(char *options);
int32_t CanExSetOptions(uint32_t index, char *options);
int32_t CanExSetAsByte(uint32_t index, const char *name, char value);
int32_t CanExSetAsWord(uint32_t index, const char *name, int16_t value);
int32_t CanExSetAsLong(uint32_t index, const char *name, int32_t value);
int32_t CanExSetAsUByte(uint32_t index, const char *name, unsigned char value);
int32_t CanExSetAsUWord(uint32_t index, const char *name, uint16_t value);
int32_t CanExSetAsULong(uint32_t index, const char *name, uint32_t value);
int32_t CanExSetAsString(uint32_t index, const char *name, char *value);
int32_t CanExGetAsByte(uint32_t index, const char *name, char *value);
int32_t CanExGetAsWord(uint32_t index, const char *name, int16_t *value);
int32_t CanExGetAsLong(uint32_t index, const char *name, int32_t *value);
int32_t CanExGetAsUByte(uint32_t index, const char *name, unsigned char *value);
int32_t CanExGetAsUWord(uint32_t index, const char *name, uint16_t *value);
int32_t CanExGetAsULong(uint32_t index, const char *name, uint32_t *value);
int32_t CanExGetAsString(uint32_t index, const char *name, char **str);
int32_t CanExGetAsStringCopy(uint32_t index, const char *name, char *dest, uint32_t *dest_size);
// **** CAN-FD
int32_t CanFdTransmit(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count);
int32_t CanFdReceive(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count);
// *** <*> neu
int32_t CanExSetAsData(uint32_t index, const char *name, void *data, uint32_t size);
int32_t CanExSetDataPtr(uint32_t index, const char *name, void *data_ptr, uint32_t size);
int32_t CanExSetDataBlockCB(uint32_t index, TCanGetDataBlockCB func, void *user_data);
int32_t CanExGetInfoList(uint32_t dev_idx, const char *name, struct TCanInfoVarList **devices_info, int32_t flags); // <*> neu
int32_t CanExGetInfoListPerform(uint32_t dev_idx, const char *name, int32_t flags);
int32_t CanExGetInfoListGet(uint32_t list_idx, struct TCanInfoVar *item);
#endif
#if !(defined(CAN_API_TRUE_FUNC)) || defined(CAN_DRV_INCLUDE)
/***************************************************************/
/* Funktionstypen */
/***************************************************************/
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceCount)(int32_t flags);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceList)(struct TCanDevicesList **devices_list, int32_t flags);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceListPerform)(int32_t flags);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceListGet)(struct TCanDevicesList *item);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceInfo)(uint32_t index, struct TCanDeviceInfo *device_info,
struct TCanInfoVar **hw_info, uint32_t *hw_info_size);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceInfoPerform)(uint32_t index, struct TCanDeviceInfo *device_info);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetDeviceInfoGet)(struct TCanInfoVar *item);
typedef void (DRV_CALLBACK_TYPE *TCanExDataFree)(void **data);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExCreateDevice)(uint32_t *index, char *options);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExDestroyDevice)(uint32_t *index);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExCreateFifo)(uint32_t index, uint32_t size, TMhsEvent *event_obj,
uint32_t event, uint32_t channels);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExBindFifo)(uint32_t fifo_index, uint32_t device_index,
uint32_t bind);
typedef TMhsEvent * (DRV_CALLBACK_TYPE *TCanExCreateEvent)(void);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetObjEvent)(uint32_t index, uint32_t source, TMhsEvent *event_obj, uint32_t event);
typedef void (DRV_CALLBACK_TYPE *TCanExSetEvent)(TMhsEvent *event_obj, uint32_t event);
typedef void (DRV_CALLBACK_TYPE *TCanExSetEventAll)(uint32_t event);
typedef void (DRV_CALLBACK_TYPE *TCanExResetEvent)(TMhsEvent *event_obj, uint32_t event);
typedef uint32_t (DRV_CALLBACK_TYPE *TCanExWaitForEvent)(TMhsEvent *event_obj, uint32_t timeout);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExInitDriver)(char *options);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetOptions)(uint32_t index, const char *options);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsByte)(uint32_t index, const char *name, char value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsWord)(uint32_t index, const char *name, int16_t value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsLong)(uint32_t index, const char *name, int32_t value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsUByte)(uint32_t index, const char *name, unsigned char value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsUWord)(uint32_t index, const char *name, uint16_t value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsULong)(uint32_t index, const char *name, uint32_t value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsString)(uint32_t index, const char *name, char *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsByte)(uint32_t index, const char *name, char *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsWord)(uint32_t index, const char *name, int16_t *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsLong)(uint32_t index, const char *name, int32_t *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsUByte)(uint32_t index, const char *name, unsigned char *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsUWord)(uint32_t index, const char *name, uint16_t *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsULong)(uint32_t index, const char *name, uint32_t *value);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsString)(uint32_t index, const char *name, char **str);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetAsStringCopy)(uint32_t index, const char *name, char *dest, uint32_t *dest_size);
// ****** CAN-FD
typedef int32_t (DRV_CALLBACK_TYPE *TCanFdTransmit)(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count);
typedef int32_t (DRV_CALLBACK_TYPE *TCanFdReceive)(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count);
// ***** <*>
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetAsData)(uint32_t index, const char *name, void *data, uint32_t size);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetDataPtr)(uint32_t index, const char *name, void *data_ptr, uint32_t size);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExSetDataBlockCB)(uint32_t index, TCanGetDataBlockCB func, void *user_data);
// ***** <*> neu 2
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetInfoList)(uint32_t dev_idx, const char *name, struct TCanInfoVarList **devices_info, int32_t flags); // <*> neu
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetInfoListPerform)(uint32_t dev_idx, const char *name, int32_t flags);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExGetInfoListGet)(uint32_t list_idx, struct TCanInfoVar *item);
#endif
#ifndef CAN_API_TRUE_FUNC
/***************************************************************/
/* Tiny-CAN API Funktionen */
/***************************************************************/
extern TCanExGetDeviceCount CanExGetDeviceCount;
extern TCanExGetDeviceList CanExGetDeviceList;
extern TCanExGetDeviceListPerform CanExGetDeviceListPerform;
extern TCanExGetDeviceListGet CanExGetDeviceListGet;
extern TCanExGetDeviceInfo CanExGetDeviceInfo;
extern TCanExGetDeviceInfoPerform CanExGetDeviceInfoPerform;
extern TCanExGetDeviceInfoGet CanExGetDeviceInfoGet;
extern TCanExDataFree CanExDataFree;
extern TCanExCreateDevice CanExCreateDevice;
extern TCanExDestroyDevice CanExDestroyDevice;
extern TCanExCreateFifo CanExCreateFifo;
extern TCanExBindFifo CanExBindFifo;
extern TCanExCreateEvent CanExCreateEvent;
extern TCanExSetObjEvent CanExSetObjEvent;
extern TCanExSetEvent CanExSetEvent;
extern TCanExSetEventAll CanExSetEventAll;
extern TCanExResetEvent CanExResetEvent;
extern TCanExWaitForEvent CanExWaitForEvent;
extern TCanExInitDriver CanExInitDriver;
extern TCanExSetOptions CanExSetOptions;
extern TCanExSetAsByte CanExSetAsByte;
extern TCanExSetAsWord CanExSetAsWord;
extern TCanExSetAsLong CanExSetAsLong;
extern TCanExSetAsUByte CanExSetAsUByte;
extern TCanExSetAsUWord CanExSetAsUWord;
extern TCanExSetAsULong CanExSetAsULong;
extern TCanExSetAsString CanExSetAsString;
extern TCanExGetAsByte CanExGetAsByte;
extern TCanExGetAsWord CanExGetAsWord;
extern TCanExGetAsLong CanExGetAsLong;
extern TCanExGetAsUByte CanExGetAsUByte;
extern TCanExGetAsUWord CanExGetAsUWord;
extern TCanExGetAsULong CanExGetAsULong;
extern TCanExGetAsString CanExGetAsString;
extern TCanExGetAsStringCopy CanExGetAsStringCopy;
// ****** CAN-FD
extern TCanFdTransmit CanFdTransmit;
extern TCanFdReceive CanFdReceive;
// **** <*> neu
extern TCanExSetAsData CanExSetAsData;
extern TCanExSetDataPtr CanExSetDataPtr;
extern TCanExSetDataBlockCB CanExSetDataBlockCB;
extern TCanExGetInfoList CanExGetInfoList;
extern TCanExGetInfoListPerform CanExGetInfoListPerform;
extern TCanExGetInfoListGet CanExGetInfoListGet;
#endif
#ifdef __cplusplus
}
#endif
#endif

17
can_api/can_drv_linux.c Normal file
View File

@@ -0,0 +1,17 @@
/*******************************************************************************/
/* Interface zur Tiny-CAN API */
/* --------------------------------------------------------------------------- */
/* Beschreibung : Laden einer Treiber Lib */
/* */
/* Version : 2.10 */
/* Datei Name : can_drv_win.c */
/* --------------------------------------------------------------------------- */
/* Datum : 18.09.15 */
/* Copyright : (C) 2011 - 2015 by MHS-Elektronik GmbH & Co. KG, Germany */
/* www.mhs-elektronik.de */
/* Autor : Demlehner Klaus, info@mhs-elektronik.de */
/*******************************************************************************/
#include "mhs_can_drv.c"

17
can_api/can_drv_win.c Normal file
View File

@@ -0,0 +1,17 @@
/*******************************************************************************/
/* Interface zur Tiny-CAN API */
/* --------------------------------------------------------------------------- */
/* Beschreibung : Laden einer Treiber DLL */
/* */
/* Version : 2.10 */
/* Datei Name : can_drv_win.c */
/* --------------------------------------------------------------------------- */
/* Datum : 18.09.15 */
/* Copyright : (C) 2011 - 2015 by MHS-Elektronik GmbH & Co. KG, Germany */
/* www.mhs-elektronik.de */
/* Autor : Demlehner Klaus, info@mhs-elektronik.de */
/*******************************************************************************/
#include "mhs_can_drv.c"

385
can_api/can_types.h Normal file
View File

@@ -0,0 +1,385 @@
#ifndef __CAN_TYPES_H__
#define __CAN_TYPES_H__
#if defined(WIN32) || defined(_WIN32)
#ifndef __WIN32__
#define __WIN32__
#endif
#endif
#ifdef __WIN32__
// Windows
#if !defined(WINVER)
#define WINVER 0x0500
#endif
#if !defined(_WIN32_IE)
#define _WIN32_IE 0x0501
#endif
#include <windows.h>
#if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1900)
#include <stdint.h>
#else
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
#endif
#else
// Linux & Mac
#include <stdint.h>
#endif
#ifdef __GNUC__
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#ifndef M_FORCE_INLINE
#define M_FORCE_INLINE static __inline__ __attribute__((__always_inline__,__gnu_inline__))
//inline __attribute__((always_inline)) <*>
#endif
#else
#ifndef M_FORCE_INLINE
#define M_FORCE_INLINE static __forceinline
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define INDEX_INVALID 0xFFFFFFFF
#define INDEX_FIFO_PUFFER_MASK 0x0000FFFF
#define INDEX_SOFT_FLAG 0x02000000
// #define INDEX_RXD_TXT_FLAG 0x01000000 <*>
#define INDEX_TXT_FLAG 0x01000000
#define INDEX_CAN_KANAL_MASK 0x000F0000
#define INDEX_CAN_DEVICE_MASK 0x00F00000
#define INDEX_FIFO_VIRTUAL 0x80000000
#define INDEX_USER_MASK 0xFC000000
#define INDEX_CAN_KANAL_A 0x00000000
#define INDEX_CAN_KANAL_B 0x00010000
/***************************************************************/
/* Typen */
/***************************************************************/
/******************************************/
/* CAN Message Type */
/******************************************/
#define MsgFlags Flags.Long
#define MsgLen Flags.Flag.Len
#define MsgRTR Flags.Flag.RTR
#define MsgEFF Flags.Flag.EFF
#define MsgTxD Flags.Flag.TxD
#define MsgErr Flags.Flag.Error
#define MsgSource Flags.Flag.Source
#define MsgFilHit Flags.Flag.FilHit
#define MsgOV Flags.Flag.OV
#define MsgData Data.Bytes
/*
Byte
0 -> LEC Last Error Code
1 = Stuff Error More than 5 equal bits in a sequence have occurred in a part of a
received message where this is not allowed.
2 = Form Error A fixed format part of a received frame has the wrong format.
3 = AckError The message this CAN Core transmitted was not acknowledged by another node.
4 = Bit1Error During the transmission of a message (with the exception of the
arbitration field), the device wanted to send a recessive level (bit of logical
value '1'), but the monitored busvalue was dominant.
5 = Bit0Error During the transmission of a message (or acknowledge bit or active error
flag, or overload flag), the device wanted to send a dominant level (data or
identifier bit logical value '0'), but the monitored Bus value was recessive.
During busoff recovery this status is set each time a sequence of 11 recessive bits
has been monitored. This enables the CPU to monitor the proceeding of the busoff
recovery sequence (indicating the bus is not stuck at dominant level or continuously
disturbed).
6 = CRCError The CRC check sum was incorrect in the message received, the CRC received
for an incoming message does not match with the calculated CRC for the received data.
1 -> Bus Status (Bit 0 - 3)
0 = Ok
1 = Error Warning
2 = Error Passiv
3 = Bus Off
Bus-Failure -> Bit4
2 -> Receive Error Counter
3 -> Transmit Error Counter
<*> Neu
OV -> FIFO Overflow Frame
Byte 0
0 -> Source
1 = CAN Controller
2 = CAN Hardware
3 = API
1,2 -> Messages Lost <*> muss noch implementiert werden
*/
struct TCanFlagsBits
{
unsigned Len:4; // DLC -> Datenl<6E>nge 0 - 8 Byte
unsigned TxD:1; // TxD -> 1 = Tx CAN Nachricht, 0 = Rx CAN Nachricht
// Eine Erfolgreich versendete Nachricht wird als Best<73>tigung
// ins Empfangsfifo zur<75>ckgeschrieben
// Nicht alle Module unterst<73>tzen diese Funktion u. das
// Feature muss aktiveirt sein
unsigned Error:1; // Error -> 1 = CAN Bus Fehler Nachricht
// Nicht alle Module unterst<73>tzen diese Funktion u. das
// Feature muss aktiveirt sein
unsigned RTR:1; // Remote Transmition Request bit -> Kennzeichnet eine RTR Nachricht
unsigned EFF:1; // Extended Frame Format bit -> 1 = 29 Bit Id's, 0 = 11 Bit Id's
unsigned Source:8; // Quelle der Nachricht (Device)
// Neu
unsigned FilHit:1; // FilHit -> 1 = Filter Hit
unsigned OV:1; // <*> Neu FIFO Overflow
unsigned Res1:1;
unsigned Res3:1;
unsigned Res4:4;
unsigned Res5:8;
};
#pragma pack(push, 1)
union TCanFlags
{
struct TCanFlagsBits Flag;
uint32_t Long;
};
#pragma pack(pop)
#pragma pack(push, 1)
union TCanData
{
char Chars[8];
unsigned char Bytes[8];
uint16_t Words[4];
uint32_t Longs[2];
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TTime
{
uint32_t Sec;
uint32_t USec;
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TCanMsg
{
uint32_t Id;
union TCanFlags Flags;
union TCanData Data;
struct TTime Time;
};
#pragma pack(pop)
/******************************************/
/* CAN FD */
/******************************************/
#define MsgFD Flags.Flag.FD // FD Format
#define MsgBRS Flags.Flag.BRS // Bit Rate Switch
struct TCanFdFlagsBits
{
unsigned Source:8; // Quelle der Nachricht (Device)
unsigned Len:8; // DLC -> Datenl<6E>nge 0 - 8 Byte
unsigned TxD:1; // TxD -> 1 = Tx CAN Nachricht, 0 = Rx CAN Nachricht
// Eine Erfolgreich versendete Nachricht wird als Best<73>tigung
// ins Empfangsfifo zur<75>ckgeschrieben
// Nicht alle Module unterst<73>tzen diese Funktion u. das
// Feature muss aktiveirt sein
unsigned Error:1; // Error -> 1 = CAN Bus Fehler Nachricht
// Nicht alle Module unterst<73>tzen diese Funktion u. das
// Feature muss aktiveirt sein
unsigned RTR:1; // Remote Transmition Request bit -> Kennzeichnet eine RTR Nachricht
unsigned EFF:1; // Extended Frame Format bit -> 1 = 29 Bit Id's, 0 = 11 Bit Id's
unsigned FD:1; // CAN-FD Frame
unsigned BRS:1; // Bit Rate Switch
unsigned Res0:1;
unsigned OV:1; // <*> Neu FIFO Overflow
unsigned Res2:1;
unsigned Res3:1;
unsigned Res4:1;
unsigned Res5:1;
unsigned Res6:1;
unsigned Res7:1;
unsigned Res8:1;
unsigned FilHit:1; // FilHit -> 1 = Filter Hit
};
#pragma pack(push, 1)
union TCanFdFlags
{
struct TCanFdFlagsBits Flag;
uint32_t Long;
};
#pragma pack(pop)
#pragma pack(push, 1)
union TCanFdData
{
char Chars[64];
unsigned char Bytes[64];
uint16_t Words[32];
uint32_t Longs[16];
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TCanFdMsg
{
uint32_t Id;
union TCanFdFlags Flags;
union TCanFdData Data;
struct TTime Time;
};
#pragma pack(pop)
/******************************************/
/* CAN Message Filter Type */
/******************************************/
#define FilFlags Flags.Long
#define FilRTR Flags.Flag.RTR
#define FilEFF Flags.Flag.EFF
#define FilMode Flags.Flag.Mode
#define FilIdMode Flags.Flag.IdMode
#define FilEnable Flags.Flag.Enable
// * = Reserviert, zur Zeit noch unbenutzt
struct TMsgFilterFlagsBits
{
// 1. Byte
unsigned Len:4; // * Dlc
unsigned Res:2; // Reserviert
unsigned RTR:1; // Remote Transmition Request
unsigned EFF:1; // Extended Frame Format
// 2. Byte
unsigned IdMode:2; // 0 = Maske & Code
// 1 = Start & Stop
// 2 = Single Id
unsigned DLCCheck:1; // *
unsigned DataCheck:1; // *
unsigned Res1:4;
// 3. Byte
unsigned Res2:8;
// 4. Byte
unsigned Type:4; // 0 = Single Puffer
unsigned Res3:2;
unsigned Mode:1; // 0 = Message entfernen
// 1 = Message nicht entfernen
unsigned Enable:1; // 0 = Filter sperren
// 1 = Filter freigeben
};
#pragma pack(push, 1)
union TMsgFilterFlags
{
struct TMsgFilterFlagsBits Flag;
uint32_t Long;
};
#pragma pack(pop)
#pragma pack(push, 1)
struct TMsgFilter
{ // IdMode -> Maske & Code | Start & Stop | Single Id
// --------------------------+--------------+-----------
uint32_t Maske; // Filter-Id -> Maske | Stop |
uint32_t Code; // Filter-Id -> Code | Start | Id
union TMsgFilterFlags Flags;
union TCanData Data; // *
};
#pragma pack(pop)
struct TCanIndexSource
{
// 1. u. 2 Byte
unsigned SubIndex:16;
// 3. Byte
unsigned Source:8;
// 4. Byte
unsigned TxD:1;
unsigned Soft:1;
unsigned User:5;
unsigned Virtual:1;
};
struct TCanIndexBits
{
// 1. u. 2 Byte
unsigned SubIndex:16;
// 3. Byte
unsigned Channel:4;
unsigned Device:4;
// 4. Byte
unsigned TxD:1;
unsigned Soft:1;
unsigned User:5;
unsigned Virtual:1;
};
union TCanIndex
{
struct TCanIndexBits Item;
struct TCanIndexSource SrcItem;
uint32_t Long;
};
M_FORCE_INLINE void CanFdToCan(struct TCanMsg *dst, const struct TCanFdMsg *src)
{
uint8_t len;
dst->Id = src->Id;
len = src->MsgLen;
dst->MsgFlags = (src->MsgFlags >> 12) & 0x000000F0;
if (len > 8)
len = 8;
dst->MsgLen = len;
dst->MsgSource = src->MsgSource;
dst->MsgFilHit = src->MsgFilHit;
dst->Data.Longs[0] = src->Data.Longs[0];
dst->Data.Longs[1] = src->Data.Longs[1];
dst->Time.Sec = src->Time.Sec;
dst->Time.USec = src->Time.USec;
}
M_FORCE_INLINE void CanToCanFd(struct TCanFdMsg *dst, const struct TCanMsg *src)
{
dst->Id = src->Id;
dst->MsgFlags = (src->MsgFlags << 12) & 0x000F0000;
dst->MsgLen = src->MsgLen;
dst->MsgSource = src->MsgSource;
dst->MsgFilHit = src->MsgFilHit;
dst->Data.Longs[0] = src->Data.Longs[0];
dst->Data.Longs[1] = src->Data.Longs[1];
dst->Time.Sec = src->Time.Sec;
dst->Time.USec = src->Time.USec;
}
#ifdef __cplusplus
}
#endif
#endif

BIN
can_api/mhspassthru.dll Normal file
View File

Binary file not shown.

BIN
can_api/mhstcan.dll Normal file
View File

Binary file not shown.

BIN
can_api/mhstcan.lib Normal file
View File

Binary file not shown.

BIN
can_api/x64/mhstcan.dll Normal file
View File

Binary file not shown.

BIN
can_api/x64/mhstcan.lib Normal file
View File

Binary file not shown.