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

Renamed lib to libwin

Browse Source
This commit is contained in:
PANIK\chris
2026-01-04 11:10:43 +01:00
parent 2474d3394c
commit eb21eccb23
22 changed files with 3 additions and 1141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

287
libwin/can_drv.h Normal file
View File

@@ -0,0 +1,287 @@
#ifndef __CAN_DRV_H__
#define __CAN_DRV_H__
#include "can_types.h"
#include "can_drv_config.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_FILE_HEADER 0x10000000 // <*> neu
#define TCAN_LOG_FILE_APPEND 0x20000000 // <*> neu
#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);
#define _CAN_DRV_EX_INCLUDES_
#include "can_drv_ex.h"
#undef _CAN_DRV_EX_INCLUDES_
#ifdef __cplusplus
}
#endif
#endif

26
libwin/can_drv_config.h Normal file
View File

@@ -0,0 +1,26 @@
#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
#ifndef __WIN32__
#ifndef LINUX_HAVE_GET_API_DRIVER_PATH
#define LINUX_HAVE_GET_API_DRIVER_PATH
#endif
#endif
#ifndef MHS_DRV_DEBUG_OUTPUT
// #define MHS_DRV_DEBUG_OUTPUT
#endif
#endif

488
libwin/can_drv_ex.h Normal file
View File

@@ -0,0 +1,488 @@
#ifndef _CAN_DRV_EX_INCLUDES_
#error cannot include can_drv_ex.h directly, use can_drv.h
#endif
#ifndef __CAN_DRV_EX_H__
#define __CAN_DRV_EX_H__
#ifdef __cplusplus
extern "C" {
#endif
#define ENABLE_EX_IO_SUPPORT // <*> Experimentell
#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 // CAN Clock 1
#define TCAN_INFO_KEY_FW_CAN_CLOCK2 0x00008004 // CAN Clock 2
#define TCAN_INFO_KEY_FW_CAN_CLOCK3 0x00008005 // CAN Clock 3
#define TCAN_INFO_KEY_FW_CAN_CLOCK4 0x00008006 // CAN Clock 4
#define TCAN_INFO_KEY_FW_CAN_CLOCK5 0x00008007 // CAN Clock 5
#define TCAN_INFO_KEY_FW_CAN_CLOCK6 0x00008008 // CAN Clock 6
#define TCAN_INFO_KEY_FW_CAN_CLOCK7 0x00008009 // CAN Clock 7
#define TCAN_INFO_KEY_FW_CAN_CLOCK8 0x0000800A // CAN Clock 8
#define TCAN_INFO_KEY_FW_CAN_CLOCK9 0x0000800B // CAN Clock 9
#define TCAN_INFO_KEY_FW_CAN_CLOCK10 0x0000800C // CAN Clock 10
#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_CAN_CLOCK7 0x01000012
#define TCAN_INFO_KEY_CAN_CLOCK8 0x01000013
#define TCAN_INFO_KEY_CAN_CLOCK9 0x01000014
#define TCAN_INFO_KEY_CAN_CLOCK10 0x01000015
#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 Define-Makro
// 0x0001 CAN_FEATURE_LOM -> Silent Mode (LOM = Listen only Mode)
// 0x0002 CAN_FEATURE_ARD -> Automatic Retransmission disable
// 0x0004 CAN_FEATURE_TX_ACK -> TX ACK (Gesendete Nachrichten best<73>tigen)
// 0x0008 CAN_FEATURE_ERROR_MSGS -> Error Messages Support
// 0x0010 CAN_FEATURE_FD_HARDWARE -> CAN-FD Hardware
// 0x0020 CAN_FEATURE_FIFO_OV_MODE -> FIFO OV Mode (Auto Clear, OV CAN Messages)
// 0x0040 CAN_FEATURE_ECU_FLASH -> Hardware beschleunigung f<>r ISO-TP ECU-Flash programmierung
// 0x4000 CAN_FEATURE_CAN_TEST -> Tiny-CAN Tester Firmware
// 0x8000 CAN_FEATURE_HW_TIMESTAMP -> 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)
#ifdef ENABLE_EX_IO_SUPPORT // <*> neu
#define RS485_TX_STATUS_FINISH 1
#define RS485_TX_STATUS_ERROR 2
#define RS485_RX_STATUS_FINISH 1
#define RS485_RX_STATUS_TIMEOUT 2
#define RS485_RX_STATUS_ERROR 3
#define RS485_RX_STATUS_OV 4
typedef struct _TRS485MsData TRS485MsData;
#pragma pack(push, 1)
struct _TRS485MsData
{
uint16_t Flags;
uint8_t TxStatus;
uint8_t RxStatus;
uint16_t TxSize;
uint8_t TxData[4096];
uint16_t RxSize;
uint8_t RxData[4096];
};
#pragma pack(pop)
#endif
/***************************************************************/
/* 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);
int32_t MhsCanGetApiHandle(void **api_handle);
#ifdef ENABLE_EX_IO_SUPPORT // <*> neu
int32_t CanExIoOpen(uint32_t index, const char *name, uint32_t *io_id);
int32_t CanExIoClose(uint32_t io_id);
int32_t CanExIoWrite(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout);
int32_t CanExIoRead(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout);
#endif
#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);
// ***** <*> neu 3
typedef int32_t (DRV_CALLBACK_TYPE *TMhsCanGetApiHandle)(void **api_handle);
#ifdef ENABLE_EX_IO_SUPPORT // <*> neu
typedef int32_t (DRV_CALLBACK_TYPE *TCanExIoOpen)(uint32_t index, const char *name, uint32_t *io_id);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExIoClose)(uint32_t io_id);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExIoWrite)(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout);
typedef int32_t (DRV_CALLBACK_TYPE *TCanExIoRead)(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout);
#endif
#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;
extern TMhsCanGetApiHandle MhsCanGetApiHandle;
#endif
#ifdef __cplusplus
}
#endif
#endif

17
libwin/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
libwin/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"

384
libwin/can_types.h Normal file
View File

@@ -0,0 +1,384 @@
#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_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; // Len -> 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; // Len -> Datenl<6E>nge 0 - 64 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

3269
libwin/mhs_can_drv.c Normal file
View File

File diff suppressed because it is too large Load Diff

646
libwin/mhscanutil.c Normal file
View File

@@ -0,0 +1,646 @@
/***************************************************************************
mhscanutil.c - description
-------------------
begin : 06.02.2022
last modify : 15.08.2022
copyright : (C) 2022 by MHS-Elektronik GmbH & Co. KG, Germany
author : Klaus Demlehner, klaus@mhs-elektronik.de
***************************************************************************/
#ifdef __WIN32__
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <windows.h>
#else
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#endif
#include "mhscanutil.h"
#ifdef __WIN32__
static HINSTANCE CanUtilDllHandle = 0; // Handle to DLL
static char *CanUtilDllFileName = NULL;
#else
static void *CanUtilDllHandle = NULL;
#endif
#ifdef __WIN32__
// ****** Windows
#define mhs_sleep(x) Sleep(x)
#define MhsGetProcAddress(h, s) (void *)GetProcAddress((h), (LPCSTR)(s))
#else
// ****** Linux
#define mhs_sleep(x) usleep((x) * 1000)
#define MhsGetProcAddress(h, s) dlsym((h), (s))
#endif
#ifdef __WIN32__
#define MhsSafeFree(d) do { \
if ((d)) \
{ \
free((d)); \
(d) = NULL; \
} \
} while(0)
static char *GetCanUtilDllWithPath(void);
#endif
typedef int32_t (API_CALL *TCanUtilInit)(void);
typedef void (API_CALL *TCanUtilDown)(void);
typedef int32_t (API_CALL *TCanUtilRegisterDriver)(void *api_handle, int32_t res);
typedef int32_t (API_CALL *TCanUtilCloseWin)(uint32_t win_idx);
typedef int32_t (API_CALL *TCanUtilBitrateSelSetHw)(const char *tiny_can, uint32_t revision, const char *snr,
struct TCanInfoVar *hw_info, uint32_t hw_info_size, uint32_t index);
typedef int32_t (API_CALL *TCanUtilBitrateSelSetDefaults)(uint32_t flags, uint32_t bitrate, double sp, double sp_error,
uint32_t fd_bitrate, double fd_sp, double fd_sp_error);
typedef int32_t (API_CALL *TCanUtilBitrateSelGetHwResult)(uint32_t *nbtr_value, uint32_t *bitrate, uint32_t *clock_idx, char *bitrate_str, char *description,
uint32_t *dbtr_value, uint32_t *fd_bitrate, char *fd_bitrate_str, char *fd_description);
typedef int32_t (API_CALL *TCanUtilBitrateSelShowDialog)(const char *title, const char *sub_title, uint32_t flags);
typedef int32_t (API_CALL *TCanUtilGetDriverList)(struct TCanUtilDrvInfo **drv_info_list);
typedef int32_t (API_CALL *TCanUtilGetDriverListGet)(struct TCanUtilDrvInfo *item);
typedef int32_t (API_CALL *TCanUtilGetSelectedDriver)(struct TCanUtilDrvInfo *selected_drv);
typedef int32_t (API_CALL *TCanUtilShowDriverList)(const char *title, const char *sub_title, uint32_t flags, char *name);
typedef int32_t (API_CALL *TCanUtilGetHwList)(struct TCanDevicesList **list);
typedef int32_t (API_CALL *TCanUtilGetHwListGet)(struct TCanDevicesList *item);
typedef uint32_t (API_CALL *TCanUtilGetSelectedHw)(struct TCanDevicesList *sel_dev);
typedef int32_t (API_CALL *TCanUtilShowHwWin)(const char *title, const char *sub_title, uint32_t flags, char *snr);
typedef int32_t (API_CALL *TCanUtilHwInfoWin)(const char *title, const char *sub_title, uint32_t flags, struct TCanInfoVar *hw_info, uint32_t hw_info_size, uint32_t index);
static TCanUtilInit PCanUtilInit = NULL;
static TCanUtilDown PCanUtilDown = NULL;
static TCanUtilRegisterDriver PCanUtilRegisterDriver = NULL;
static TCanUtilCloseWin PCanUtilCloseWin = NULL;
static TCanUtilBitrateSelSetHw PCanUtilBitrateSelSetHw = NULL;
static TCanUtilBitrateSelSetDefaults PCanUtilBitrateSelSetDefaults = NULL;
static TCanUtilBitrateSelGetHwResult PCanUtilBitrateSelGetHwResult = NULL;
static TCanUtilBitrateSelShowDialog PCanUtilBitrateSelShowDialog = NULL;
static TCanUtilGetDriverList PCanUtilGetDriverList = NULL;
static TCanUtilGetDriverListGet PCanUtilGetDriverListGet = NULL;
static TCanUtilGetSelectedDriver PCanUtilGetSelectedDriver = NULL;
static TCanUtilShowDriverList PCanUtilShowDriverList = NULL;
static TCanUtilGetHwList PCanUtilGetHwList = NULL;
static TCanUtilGetHwListGet PCanUtilGetHwListGet = NULL;
static TCanUtilGetSelectedHw PCanUtilGetSelectedHw = NULL;
static TCanUtilShowHwWin PCanUtilShowHwWin = NULL;
static TCanUtilHwInfoWin PCanUtilHwInfoWin = NULL;
/***************************************************************/
/* Treiber DLL laden */
/***************************************************************/
int32_t LoadCanUtil(void)
{
int32_t error;
error = 0;
UnloadCanUtil();
#ifdef __WIN32__
if (!(CanUtilDllFileName = GetCanUtilDllWithPath()))
return(-100);
CanUtilDllHandle = LoadLibraryA(CanUtilDllFileName);
#else
CanUtilDllHandle = dlopen(file_name, RTLD_LAZY);
#endif
if (CanUtilDllHandle)
{
if (!(PCanUtilInit = (TCanUtilInit)MhsGetProcAddress(CanUtilDllHandle, "CanUtilInit")))
error = -1;
else if (!(PCanUtilDown = (TCanUtilDown)MhsGetProcAddress(CanUtilDllHandle, "CanUtilDown")))
error = -1;
else if (!(PCanUtilRegisterDriver = (TCanUtilRegisterDriver)MhsGetProcAddress(CanUtilDllHandle, "CanUtilRegisterDriver")))
error = -1;
else if (!(PCanUtilCloseWin = (TCanUtilCloseWin)MhsGetProcAddress(CanUtilDllHandle, "CanUtilCloseWin")))
error = -1;
else if (!(PCanUtilBitrateSelSetHw = (TCanUtilBitrateSelSetHw)MhsGetProcAddress(CanUtilDllHandle, "CanUtilBitrateSelSetHw")))
error = -1;
else if (!(PCanUtilBitrateSelSetDefaults = (TCanUtilBitrateSelSetDefaults)MhsGetProcAddress(CanUtilDllHandle, "CanUtilBitrateSelSetDefaults")))
error = -1;
else if (!(PCanUtilBitrateSelGetHwResult = (TCanUtilBitrateSelGetHwResult)MhsGetProcAddress(CanUtilDllHandle, "CanUtilBitrateSelGetHwResult")))
error = -1;
else if (!(PCanUtilBitrateSelShowDialog = (TCanUtilBitrateSelShowDialog)MhsGetProcAddress(CanUtilDllHandle, "CanUtilBitrateSelShowDialog")))
error = -1;
else if (!(PCanUtilGetDriverList = (TCanUtilGetDriverList)MhsGetProcAddress(CanUtilDllHandle, "CanUtilGetDriverList")))
error = -1;
else if (!(PCanUtilGetDriverListGet = (TCanUtilGetDriverListGet)MhsGetProcAddress(CanUtilDllHandle, "CanUtilGetDriverListGet")))
error = -1;
else if (!(PCanUtilGetSelectedDriver = (TCanUtilGetSelectedDriver)MhsGetProcAddress(CanUtilDllHandle, "CanUtilGetSelectedDriver")))
error = -1;
else if (!(PCanUtilShowDriverList = (TCanUtilShowDriverList)MhsGetProcAddress(CanUtilDllHandle, "CanUtilShowDriverList")))
error = -1;
else if (!(PCanUtilGetHwList = (TCanUtilGetHwList)MhsGetProcAddress(CanUtilDllHandle, "CanUtilGetHwList")))
error = -1;
else if (!(PCanUtilGetHwListGet = (TCanUtilGetHwListGet)MhsGetProcAddress(CanUtilDllHandle, "CanUtilGetHwListGet")))
error = -1;
else if (!(PCanUtilGetSelectedHw = (TCanUtilGetSelectedHw)MhsGetProcAddress(CanUtilDllHandle, "CanUtilGetSelectedHw")))
error = -1;
else if (!(PCanUtilShowHwWin = (TCanUtilShowHwWin)MhsGetProcAddress(CanUtilDllHandle, "CanUtilShowHwWin")))
error = -1;
else if (!(PCanUtilHwInfoWin = (TCanUtilHwInfoWin)MhsGetProcAddress(CanUtilDllHandle, "CanUtilHwInfoWin")))
error = -1;
}
else
error = -1000;
if (error)
UnloadCanUtil();
return(error);
}
/***************************************************************/
/* Treiber DLL entladen */
/***************************************************************/
void UnloadCanUtil(void)
{
#ifdef __WIN32__
HINSTANCE driver_handle;
#else
void *driver_handle;
#endif
driver_handle = CanUtilDllHandle;
CanUtilDllHandle = NULL;
#ifdef __WIN32__
MhsSafeFree(CanUtilDllFileName);
#endif
PCanUtilInit = NULL;
PCanUtilDown = NULL;
PCanUtilRegisterDriver = NULL;
PCanUtilCloseWin = NULL;
PCanUtilBitrateSelSetHw = NULL;
PCanUtilBitrateSelSetDefaults = NULL;
PCanUtilBitrateSelGetHwResult = NULL;
PCanUtilBitrateSelShowDialog = NULL;
PCanUtilGetDriverList = NULL;
PCanUtilGetDriverListGet = NULL;
PCanUtilGetSelectedDriver = NULL;
PCanUtilShowDriverList = NULL;
PCanUtilGetHwList = NULL;
PCanUtilGetHwListGet = NULL;
PCanUtilGetSelectedHw = NULL;
PCanUtilShowHwWin = NULL;
PCanUtilHwInfoWin = NULL;
if (driver_handle)
{
#ifdef __WIN32__
FreeLibrary(driver_handle);
#else
dlclose(driver_handle);
#endif
}
}
int32_t CanUtilInit(void)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilInit))
err = (PCanUtilInit)();
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
void CanUtilDown(void)
{
if ((CanUtilDllHandle) && (PCanUtilInit))
(PCanUtilDown)();
}
int32_t CanUtilRegisterDriver(void *api_handle, int32_t res)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilRegisterDriver))
err = (PCanUtilRegisterDriver)(api_handle, res);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilCloseWin(uint32_t win_idx)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilCloseWin))
err = (PCanUtilCloseWin)(win_idx);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilBitrateSelSetHw(const char *tiny_can, uint32_t revision, const char *snr,
struct TCanInfoVar *hw_info, uint32_t hw_info_size, uint32_t index)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilBitrateSelSetHw))
err = (PCanUtilBitrateSelSetHw)(tiny_can, revision, snr, hw_info, hw_info_size, index);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilBitrateSelSetDefaults(uint32_t flags, uint32_t bitrate, double sp, double sp_error,
uint32_t fd_bitrate, double fd_sp, double fd_sp_error);
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilBitrateSelSetDefaults))
err = (PCanUtilBitrateSelSetDefaults)(flags, bitrate, sp, sp_error, fd_bitrate, fd_sp, fd_sp_error);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilBitrateSelGetHwResult(uint32_t *nbtr_value, uint32_t *bitrate, uint32_t *clock_idx, char *bitrate_str, char *description,
uint32_t *dbtr_value, uint32_t *fd_bitrate, char *fd_bitrate_str, char *fd_description)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilBitrateSelGetHwResult))
err = (PCanUtilBitrateSelGetHwResult)(nbtr_value, bitrate, clock_idx, bitrate_str, description,
dbtr_value, fd_bitrate, fd_bitrate_str, fd_description);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilBitrateSelShowDialog(const char *title, const char *sub_title, uint32_t flags)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilBitrateSelShowDialog))
err = (PCanUtilBitrateSelShowDialog)(title, sub_title, flags);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
/**************************************************************************************/
/* Driver DLLs Info */
/**************************************************************************************/
int32_t CanUtilGetDriverList(struct TCanUtilDrvInfo **drv_info_list)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilGetDriverList))
err = (PCanUtilGetDriverList)(drv_info_list);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilGetDriverListGet(struct TCanUtilDrvInfo *item)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilGetDriverListGet))
err = (PCanUtilGetDriverListGet)(item);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilGetSelectedDriver(struct TCanUtilDrvInfo *selected_drv)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilGetSelectedDriver))
err = (PCanUtilGetSelectedDriver)(selected_drv);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilShowDriverList(const char *title, const char *sub_title, uint32_t flags, char *name)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilShowDriverList))
err = (PCanUtilShowDriverList)(title, sub_title, flags, name);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
/**************************************************************************************/
/* Connected Hardware */
/**************************************************************************************/
int32_t CanUtilGetHwList(struct TCanDevicesList **list)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilGetHwList))
err = (PCanUtilGetHwList)(list);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilGetHwListGet(struct TCanDevicesList *item)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilGetHwListGet))
err = (PCanUtilGetHwListGet)(item);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
int32_t CanUtilGetSelectedHw(struct TCanDevicesList *sel_dev)
{
if ((CanUtilDllHandle) && (PCanUtilGetSelectedHw))
return((PCanUtilGetSelectedHw)(sel_dev));
else
return(ERR_NO_CAN_UTIL_DLL_LOAD);
}
int32_t CanUtilShowHwWin(const char *title, const char *sub_title, uint32_t flags, char *snr)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilShowHwWin))
err = (PCanUtilShowHwWin)(title, sub_title, flags, snr);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
/**************************************************************************************/
/* Show Hardware Info */
/**************************************************************************************/
int32_t CanUtilHwInfoWin(const char *title, const char *sub_title, uint32_t flags, struct TCanInfoVar *hw_info, uint32_t *hw_info_size, uint32_t index)
{
int32_t err;
if ((CanUtilDllHandle) && (PCanUtilHwInfoWin))
err = (PCanUtilHwInfoWin)(title, sub_title, flags, hw_info, hw_info_size, index);
else
err = ERR_NO_CAN_UTIL_DLL_LOAD;
return(err);
}
#ifdef __WIN32__
/***************************************************************/
/* API Treiber Path ermitteln */
/***************************************************************/
#define MAX_PATH_LEN 255
#define DIR_SEPARATOR '\\'
#define DIR_SEPARATOR_STR "\\"
/**************************************************************************/
/* C O N S T A N T E N */
/**************************************************************************/
#ifdef _WIN64
static const char REG_TINY_CAN_API[] = {"Software\\Wow6432Node\\Tiny-CAN\\API"};
#else
static const char REG_TINY_CAN_API[] = {"Software\\Tiny-CAN\\API"};
#endif
static const char REG_TINY_CAN_API_PATH_ENTRY[] = {"PATH"};
static const char MHS_CAN_UTIL_DLL[] = {"mhscanutil.dll"};
#ifdef _WIN64
static const char API_DRIVER_X64_DIR[] = {"x64"};
#endif
/**************************************************************************/
/* F U N K T I O N E N */
/**************************************************************************/
static char *MhsStpCpy(char *dest, const char *src)
{
register char *d = dest;
register const char *s = src;
do
*d++ = *s;
while (*s++);
return(d - 1);
}
static char *MhsStrDup(const char *str)
{
size_t len;
char *new_str;
if (str)
{
len = strlen(str) + 1;
new_str = (char *)malloc(len);
if (!new_str)
return(NULL);
memcpy(new_str, str, len);
return(new_str);
}
else
return(NULL);
}
static char *MhsStrconcat(const char *string1, ...)
{
size_t l;
va_list args;
char *s, *concat, *ptr;
if (!string1)
return(NULL);
l = 1 + strlen(string1);
va_start(args, string1);
s = va_arg(args, char*);
while (s)
{
l += strlen(s);
s = va_arg(args, char*);
}
va_end(args);
concat = (char *)malloc(l);
if (!concat)
return(NULL);
ptr = concat;
ptr = MhsStpCpy(ptr, string1);
va_start (args, string1);
s = va_arg (args, char*);
while (s)
{
ptr = MhsStpCpy(ptr, s);
s = va_arg(args, char*);
}
va_end (args);
return(concat);
}
static char *MhsCreateFileName(const char *dir, const char *sub_dir, const char *file_name)
{
if (!dir)
return(MhsStrDup(file_name));
if (!file_name)
return(NULL);
if (strchr(file_name, DIR_SEPARATOR))
return(MhsStrDup(file_name));
else
{
if (sub_dir)
{
if (dir[strlen(dir)-1] == DIR_SEPARATOR)
{
if (sub_dir[strlen(sub_dir)-1] == DIR_SEPARATOR)
return(MhsStrconcat(dir, sub_dir, file_name, NULL));
else
return(MhsStrconcat(dir, sub_dir, DIR_SEPARATOR_STR, file_name, NULL));
}
else
{
if (sub_dir[strlen(sub_dir)-1] == DIR_SEPARATOR)
return(MhsStrconcat(dir, DIR_SEPARATOR_STR, sub_dir, file_name, NULL));
else
return(MhsStrconcat(dir, DIR_SEPARATOR_STR, sub_dir, DIR_SEPARATOR_STR, file_name, NULL));
}
}
else
{
if (dir[strlen(dir)-1] == DIR_SEPARATOR)
return(MhsStrconcat(dir, file_name, NULL));
else
return(MhsStrconcat(dir, DIR_SEPARATOR_STR, file_name, NULL));
}
}
}
static char *MhsRegGetString(HKEY key, const char *value_name)
{
DWORD type, data_size;
char *str;
type = 0;
data_size = 0;
if ((!key) || (!value_name))
return(NULL);
// Länge des Strings ermitteln
if (RegQueryValueExA(key, value_name, 0, &type, NULL, &data_size) != ERROR_SUCCESS)
return(NULL);
// Wert ist String ?
if (type != REG_SZ)
return(NULL);
str = malloc(data_size+1);
if (!str)
return(NULL);
// String lesen
if (RegQueryValueExA(key, value_name, 0, &type, (LPBYTE)str, &data_size) != ERROR_SUCCESS)
{
free(str);
return(NULL);
}
str[data_size] = '\0';
return(str);
}
static char *MhsRegReadStringEntry(const char *path, const char *entry)
{
HKEY key;
char *value;
value = NULL;
// HKEY_CURRENT_USER ?
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, path, 0, KEY_QUERY_VALUE, &key) == ERROR_SUCCESS) // KEY_READ
{
value = MhsRegGetString(key, entry);
RegCloseKey(key);
}
return(value);
}
static int32_t TestApi(const char *file_name)
{
HINSTANCE driver_dll;
TCanUtilBitrateSelSetup func;
func = NULL;
driver_dll = LoadLibraryA(file_name);
if (driver_dll)
{
func = (TCanUtilBitrateSelSetup)(void *)GetProcAddress(driver_dll, (LPCSTR)"CanUtilBitrateSelSetup");
FreeLibrary(driver_dll);
}
if (func)
return(0);
else
return(-1);
}
static char *GetCanUtilDllWithPath(void)
{
char *path, *file_name;
char app_file[MAX_PATH_LEN];
char app_path[MAX_PATH_LEN];
char *ptr;
file_name = NULL;
if ((path = MhsRegReadStringEntry(REG_TINY_CAN_API, REG_TINY_CAN_API_PATH_ENTRY)))
{
#ifdef _WIN64
file_name = MhsCreateFileName(path, API_DRIVER_X64_DIR, MHS_CAN_UTIL_DLL);
#else
file_name = MhsCreateFileName(path, NULL, MHS_CAN_UTIL_DLL);
#endif
if (TestApi(file_name))
MhsSafeFree(file_name);
free(path);
}
if (!file_name)
{
// Programm Path ermitteln
GetModuleFileNameA(GetModuleHandle(NULL), app_file, MAX_PATH_LEN);
GetFullPathNameA(app_file, sizeof(app_file), app_path, &ptr);
app_path[ptr-app_path] = '\0';
file_name = MhsCreateFileName(app_path, NULL, MHS_CAN_UTIL_DLL);
if (TestApi(file_name))
MhsSafeFree(file_name);
}
return(file_name);
}
#endif

130
libwin/mhscanutil.h Normal file
View File

@@ -0,0 +1,130 @@
#ifndef __MHS_CAN_UTIL_H__
#define __MHS_CAN_UTIL_H__
#include "can_drv.h"
#ifdef __cplusplus
extern "C" {
#endif
#define API_CALL __stdcall
#define ERR_NO_CAN_UTIL_DLL_LOAD -10000
#define CAN_CFG_SP_FLAGS_CLR 0xFFFFCFFF
#define CAN_CFG_FD_SP_FLAGS_CLR 0xFFFF3FFF
#define CAN_CFG_CLOCK_IDX_MASK 0x0000007F
#define CAN_CFG_CLOCK_SELECT_ONE 0x00000080
#define CAN_CFG_USE_ONE_CLOCK 0x00000100
#define CAN_CFG_USE_CIA_SP 0x00001000
#define CAN_CFG_USE_SP_RANGE 0x00002000
#define CAN_CFG_FD_USE_CIA_SP 0x00004000
#define CAN_CFG_FD_USE_SP_RANGE 0x00008000
#define CAN_CFG_USE_SAM 0x00010000
#define CAN_CFG_USE_TDC 0x00020000
#define CAN_CFG_USE_FD 0x00040000
#define CAN_CFG_AUTO_SJW 0x00100000
#define CAN_CFG_FD_AUTO_SJW 0x00200000
#define CAN_CFG_AUTO_CLEAN_BITRATE_ERRORS 0x01000000
#define CAN_CFG_FD_ONLY_SAME_BRP 0x02000000
#define CAN_CFG_FD_AUTO_SAME_BRP 0x04000000
#define CUTIL_WIN_IDX_ANY 0
#define CUTIL_WIN_IDX_DRIVER_LIST 1
#define CUTIL_WIN_IDX_HW_LIST 2
#define CUTIL_WIN_IDX_HW_INFO 3
#define CUTIL_WIN_IDX_BITCALC_START 4
#define CUTIL_WIN_IDX_BITCALC_FD_CFG 5
#define CUTIL_WIN_IDX_BITCALC_STD_CFG 6
#define CUTIL_WIN_IDX_BITCALC_FD 7
#define CUTIL_WIN_IDX_BITCALC_STD 8
#define CUTIL_INFO_ONLY 0x00000001
#define CUTIL_HW_SCAN_ACTIVE 0x00000010
#define CUTIL_HW_SCAN_DISABLE 0x00000020
#define CUTIL_HW_SHOW_ALL 0x00000040
#define CUTIL_BITCALC_EXIT_BUTTON 0x00000100
#define CUTIL_BITCALC_EXTRA_BUTTONS 0x00000200
#define CUTIL_BITCALC_CONTROLLER_SEL 0x00000400
#define CUTIL_BITCALC_SHOW_BTR_REGISTER 0x00001000
#pragma pack(push, 1)
struct TCanUtilDrvInfo
{
char Filename[255];
char Name[40];
char Version[40];
char Summary[255];
char Description[255];
uint32_t InterfaceType;
};
#pragma pack(pop)
int32_t LoadCanUtil(void);
void UnloadCanUtil(void);
/**************************************************************************************/
/* CAN Util Init/Down */
/**************************************************************************************/
int32_t CanUtilInit(void);
void CanUtilDown(void);
/**************************************************************************************/
/* CAN API Treiber */
/**************************************************************************************/
int32_t CanUtilRegisterDriver(void *api_handle, int32_t res);
/**************************************************************************************/
/* Public */
/**************************************************************************************/
int32_t CanUtilCloseWin(uint32_t win_idx);
/**************************************************************************************/
/* Bit Timing */
/**************************************************************************************/
int32_t CanUtilBitrateSelSetHw(const char *tiny_can, uint32_t revision, const char *snr,
struct TCanInfoVar *hw_info, uint32_t hw_info_size, uint32_t index);
int32_t CanUtilBitrateSelSetDefaults(uint32_t flags, uint32_t bitrate, double sp, double sp_error,
uint32_t fd_bitrate, double fd_sp, double fd_sp_error);
int32_t CanUtilBitrateSelGetHwResult(uint32_t *nbtr_value, uint32_t *bitrate, uint32_t *clock_idx, char *bitrate_str,
char *description, uint32_t *dbtr_value, uint32_t *fd_bitrate, char *fd_bitrate_str, char *fd_description);
int32_t CanUtilBitrateSelShowDialog(const char *title, const char *sub_title, uint32_t flags);
/**************************************************************************************/
/* Driver DLLs Info */
/**************************************************************************************/
int32_t CanUtilGetDriverList(struct TCanUtilDrvInfo **drv_info_list);
int32_t CanUtilGetDriverListGet(struct TCanUtilDrvInfo *item);
int32_t CanUtilGetSelectedDriver(struct TCanUtilDrvInfo *selected_drv);
int32_t CanUtilShowDriverList(const char *title, const char *sub_title, uint32_t flags, char *name);
/**************************************************************************************/
/* Connected Hardware */
/**************************************************************************************/
int32_t CanUtilGetHwList(struct TCanDevicesList **list);
int32_t CanUtilGetHwListGet(struct TCanDevicesList *item);
int32_t CanUtilGetSelectedHw(struct TCanDevicesList *sel_dev);
int32_t CanUtilShowHwWin(const char *title, const char *sub_title, uint32_t flags, char *snr);
/**************************************************************************************/
/* Show Hardware Info */
/**************************************************************************************/
int32_t CanUtilHwInfoWin(const char *title, const char *sub_title, uint32_t flags,
struct TCanInfoVar *hw_info, uint32_t hw_info_size, uint32_t index);
#ifdef __cplusplus
}
#endif
#endif