diff --git a/.qtcreator/BionxControl.pro.user b/.qtcreator/BionxControl.pro.user index aed09f7..9389c67 100644 --- a/.qtcreator/BionxControl.pro.user +++ b/.qtcreator/BionxControl.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId @@ -8,7 +8,7 @@ ProjectExplorer.Project.ActiveTarget - 0 + 1 ProjectExplorer.Project.EditorSettings @@ -288,11 +288,12 @@ false -e cpu-cycles --call-graph "dwarf,4096" -F 250 - ProjectExplorer.CustomExecutableRunConfiguration - + Qt4ProjectManager.Qt4RunConfiguration: + C:/syncMePlease/projects.now/BionxControl/BionxControl.pro false true + true true %{RunConfig:Executable:Path} @@ -324,11 +325,12 @@ false -e cpu-cycles --call-graph "dwarf,4096" -F 250 - ProjectExplorer.CustomExecutableRunConfiguration - + Qt4ProjectManager.Qt4RunConfiguration: + C:/syncMePlease/projects.now/BionxControl/BionxControl.pro false true + true true %{RunConfig:Executable:Path} diff --git a/BionxControl.pro b/BionxControl.pro index bba41ca..c11699f 100644 --- a/BionxControl.pro +++ b/BionxControl.pro @@ -8,7 +8,7 @@ CONFIG += c++20 # In order to do so, uncomment the following line. #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 -INCLUDEPATH += . static lib +INCLUDEPATH += . lib linux { #LIBS += -lpigpio -lpigpiod_if2 -lrt @@ -17,7 +17,7 @@ linux { windows { - LIBS += -L$$PWD/can_api -lmhstcan -lAdvapi32 + #LIBS += -L$$PWD/can_api -lmhstcan -lAdvapi32 } # You can make your code fail to compile if it uses deprecated APIs. @@ -25,6 +25,10 @@ windows #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 SOURCES += \ + bc.cpp \ + lib/can_drv_win.c \ + bccandriver.cpp \ + bccandrivertinycan.cpp \ bccommand.cpp \ bccommandrunner.cpp \ bcvalue.cpp \ @@ -36,6 +40,8 @@ SOURCES += \ HEADERS += \ bc.h \ + bccandriver.h \ + bccandrivertinycan.h \ bccommand.h \ bccommandrunner.h \ bcmainwindow.h \ diff --git a/bc.h b/bc.h index ab3aee2..4219366 100644 --- a/bc.h +++ b/bc.h @@ -50,6 +50,21 @@ namespace cbc [[maybe_unused]] constexpr static double NORMALIZED_VOLTAGE_OFFSET = 20.8333; [[maybe_unused]] constexpr static double NORMALIZED_VOLTAGE_FAKTOR = 0.416667; + // misc + //#define cbc::Version "CanBusControl 0.0.01 / 02.07.2022" + [[maybe_unused]] constexpr static const char* Version = "CanBusControl 0.1.00 / 08.11.2022 © 2022 chris@sourceworx.org"; + + [[maybe_unused]] constexpr static const char* OrgName = "source::worx"; + [[maybe_unused]] constexpr static const char* DomainName = "sourceworx.org"; + [[maybe_unused]] constexpr static const char* AppName = "CanBusControl"; + + + // timer + void delay_seconds( uint32_t ); + void delay_millis( uint32_t ); + void delay_micros( uint32_t ); + + QString formatInt( int count, int len ); } // namespace cbc // abbreviations: @@ -301,13 +316,9 @@ public: Reg_Battery_Rev_Bom = 0x41, // Identification Of Printed Circuit Board Bill Of Material Version. 1: All Smc6.2 And Smc#6.3r1. 8: Smc#6.3r4 Reg_Battery_Config_Taillamp_Intensity = 0x43, // Controls The Intensity Of The Tail Lamp. 0: Off. 1-100%: On - Reg_Battery_Config_Accessory_Mounted = 0x44, // - - Reg_Battery_Config_Battint_Voltage_Enable = 0x45, // Enable/Disable Vbattint - Reg_Battery_Config_Diag = 0x46, // - - Reg_Battery_Config_Force_Done = 0x47, // ++++ Setting This Register To 0x45 Will Force Soc To 100% Battery_Config_Force_Done = 0x45, @@ -519,21 +530,21 @@ public: Reg_Charger_Final_Voltage_Hi = 0x12, // Set Final Charge Voltage [Unit:V, Factor:0.01] Reg_Charger_Final_Voltage_Lo = 0x13, - Reg_Charger_Current_Hi = 0x14, // Set Charge Current [Unit:A, Factor:0.001] - Reg_Charger_Current_Lo = 0x15, + Reg_Charger_Current_Hi = 0x14, // Set Charge Current [Unit:A, Factor:0.001] + Reg_Charger_Current_Lo = 0x15, - Reg_Charger_Voltage_Calibration_Hi = 0x42, // Multiplier Applied On Charger Voltage Reading For Its Calibration - Reg_Charger_Voltage_Calibration_Lo = 0x43, + Reg_Charger_Voltage_Calibration_Hi = 0x42, // Multiplier Applied On Charger Voltage Reading For Its Calibration + Reg_Charger_Voltage_Calibration_Lo = 0x43, - Reg_Charger_Current_Calibration_Hi = 0x46, // Multiplier Applied On Charger Current Reading For Its Calibration - Reg_Charger_Current_Calibration_Lo = 0x47, + Reg_Charger_Current_Calibration_Hi = 0x46, // Multiplier Applied On Charger Current Reading For Its Calibration + Reg_Charger_Current_Calibration_Lo = 0x47, - Reg_Charger_Rev_Charger = 0x56, // - + Reg_Charger_Rev_Charger = 0x56, // - //{%Endregion} // {%Region Motor} - ID_Motor = 0x20, + ID_Motor = 0x20, // ID_Motor_Response = 0x08, Motor_Assist_Level = 0x09, // [Unit:%, Range:-100..100, Factor:1.5625] !!! Signed !!! @@ -595,20 +606,20 @@ public: Motor_Status_5v_Voltage_Hi = 0x74, // - [Unit:V, Factor:0.001] Motor_Status_5v_Voltage_Lo = 0x75, - Motor_Stat_Max_Power_Voltage_Hi = 0x80, // - [Unit:V, Factor:0.001] - Motor_Stat_Max_Power_Voltage_Lo = 0x81, + Motor_Stat_Max_Power_Voltage_Hi = 0x80, // - [Unit:V, Factor:0.001] + Motor_Stat_Max_Power_Voltage_Lo = 0x81, - Motor_Stat_Max_Temperature_Hi = 0x82, // - - Motor_Stat_Max_Temperature_Lo = 0x83, + Motor_Stat_Max_Temperature_Hi = 0x82, // - + Motor_Stat_Max_Temperature_Lo = 0x83, - Motor_Stat_Odo_Hi = 0x84, // - [Unit:Km] - Motor_Stat_Odo_Lo = 0x85, + Motor_Stat_Odo_Hi = 0x84, // - [Unit:Km] + Motor_Stat_Odo_Lo = 0x85, - Motor_Stat_Chrono_Hours_Hi = 0x86, // - [Unit:H] - Motor_Stat_Chrono_Hours_Lo = 0x87, + Motor_Stat_Chrono_Hours_Hi = 0x86, // - [Unit:H] + Motor_Stat_Chrono_Hours_Lo = 0x87, - Motor_Stat_Chrono_Seconds_Hi = 0x88, // - [Unit:S] - Motor_Stat_Chrono_Seconds_Lo = 0x89, + Motor_Stat_Chrono_Seconds_Hi = 0x88, // - [Unit:S] + Motor_Stat_Chrono_Seconds_Lo = 0x89, Motor_Preference_Region = 0x8a, // - @@ -622,20 +633,20 @@ public: Motor_Protect_Unlock = 0xa5, // Unlock Register, Write Unlock_Key Here Before Setting Protected Registers - Motor_Protect_Unlock_Key = 0xaa, - Motor_Protect_Lock_Key = 0x00, + Motor_Protect_Unlock_Key = 0xaa, + Motor_Protect_Lock_Key = 0x00, - Motor_Stat_Hall_Dchs_Hi = 0xb0, // - - Motor_Stat_Hall_Dchs_Lo = 0xb1, + Motor_Stat_Hall_Dchs_Hi = 0xb0, // - + Motor_Stat_Hall_Dchs_Lo = 0xb1, - Motor_Stat_Hall_Trans_Hi = 0xb2, // - - Motor_Stat_Hall_Trans_Lo = 0xb3, + Motor_Stat_Hall_Trans_Hi = 0xb2, // - + Motor_Stat_Hall_Trans_Lo = 0xb3, - Motor_Stat_Hall_Ring_Hi = 0xb4, // - - Motor_Stat_Hall_Ring_Lo = 0xb5, + Motor_Stat_Hall_Ring_Hi = 0xb4, // - + Motor_Stat_Hall_Ring_Lo = 0xb5, - Motor_Stat_Hall_Lost_Hi = 0xb6, // - - Motor_Stat_Hall_Lost_Lo = 0xb7, + Motor_Stat_Hall_Lost_Hi = 0xb6, // - + Motor_Stat_Hall_Lost_Lo = 0xb7, Motor_Torque_Gauge_Noise_Hi = 0xc4, // - [Unit:%, Range:0..100, Factor:0.0015259] Motor_Torque_Gauge_Noise_Lo = 0xc5, diff --git a/bcmainwindow.cpp b/bcmainwindow.cpp index d873d38..6ba0144 100644 --- a/bcmainwindow.cpp +++ b/bcmainwindow.cpp @@ -28,6 +28,7 @@ ***************************************************************************/ #include +#include #include BCMainWindow::BCMainWindow(QWidget *parent) @@ -38,10 +39,18 @@ BCMainWindow::BCMainWindow(QWidget *parent) auto model = _valueManager.getModel( "Console"_L1 ); if( model) _valueView->setModel( *model ); + _valueView->setItemDelegate( new BCValueDelegate( _valueView) ); + connect( _connectButton, &QPushButton::clicked, &_valueManager, &BCValueManager::onToggleConnectionState ); } BCMainWindow::~BCMainWindow() { } + + +void BCMainWindow::onConnectButtonToggled(bool checked ) +{ + //_valueManager.setDriverConnectionState( checked ); +} diff --git a/bcmainwindow.h b/bcmainwindow.h index 6ef6153..53cd15a 100644 --- a/bcmainwindow.h +++ b/bcmainwindow.h @@ -49,6 +49,8 @@ public: public slots: + void onConnectButtonToggled(bool active ); + protected: BCValueManager _valueManager; diff --git a/bcmainwindow.ui b/bcmainwindow.ui index cbb6db3..0f3fac0 100644 --- a/bcmainwindow.ui +++ b/bcmainwindow.ui @@ -27,7 +27,7 @@ QFrame::Shadow::Raised - + 30 @@ -40,7 +40,7 @@ PushButton - + 20 @@ -50,7 +50,10 @@ - PushButton + Connect + + + true diff --git a/bcvaluedelegate.cpp b/bcvaluedelegate.cpp index 9a8aa9b..b269385 100644 --- a/bcvaluedelegate.cpp +++ b/bcvaluedelegate.cpp @@ -8,15 +8,20 @@ #include "bcvalue.h" -BCValueDelegate::BCValueDelegate(QObject *parent) : QStyledItemDelegate(parent) {} +BCValueDelegate::BCValueDelegate(QObject *parent) + : QStyledItemDelegate(parent) +{ -// --- TEIL 1: DIE NORMALE ANZEIGE --- -QString BCValueDelegate::displayText(const QVariant &value, const QLocale &locale) const +} + + +QString BCValueDelegate::displayText(const QVariant& dataValue, const QLocale& locale) const { // Wir prüfen, ob im Variant unser Struct steckt - if (value.canConvert()) { - BCValue bc = value.value(); - + if (dataValue.canConvert()) + { + BCValue bc = dataValue.value(); + //qDebug() << " --- YES: " << bc.label; // Hier bauen wir den String zusammen, den man sieht, // wenn KEIN Editor offen ist. // Format: "Label: Wert Einheit" @@ -24,10 +29,10 @@ QString BCValueDelegate::displayText(const QVariant &value, const QLocale &local } // Fallback für normale Strings/Zahlen - return QStyledItemDelegate::displayText(value, locale); + return QStyledItemDelegate::displayText(dataValue, locale); } -// --- TEIL 2: DER EDITOR (SLIDER) --- + QWidget *BCValueDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const { QVariant rawData = index.data(Qt::EditRole); diff --git a/bcvaluedelegate.h b/bcvaluedelegate.h index 8656621..19636aa 100644 --- a/bcvaluedelegate.h +++ b/bcvaluedelegate.h @@ -13,7 +13,7 @@ public: explicit BCValueDelegate(QObject *parent = nullptr); // WICHTIG: Zuständig für die normale Anzeige (ohne Editor) - QString displayText(const QVariant &value, const QLocale &locale) const override; + QString displayText(const QVariant& dataValue, const QLocale& locale) const override; // Zuständig für den Edit-Modus (Doppelklick) QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override; diff --git a/bcvaluemanager.cpp b/bcvaluemanager.cpp index 691f13a..1770b0e 100644 --- a/bcvaluemanager.cpp +++ b/bcvaluemanager.cpp @@ -56,6 +56,46 @@ BCValueManager::~BCValueManager() // our models are autokilled. } +void BCValueManager::onToggleConnectionState( bool connect ) +{ + if( connect ) + { + if( BCCanDriver::sIdle == _canDriver.getState() ) + _canDriver.onStartDriver(); + + int hwVersion = _canDriver.getValue( BCDevice::ID::Console, BC::ID::Cons_Rev_Hw); + + if (hwVersion == 0) + { + qDebug() << "Console not responding"; + } + else { + /* + swVersion = getValue(CONSOLE, CONSOLE_REF_SW); + printf( "Console information:" _NL + " hardware version ........: %02d" _NL + " software version ........: %02d" _NL + " assistance level ........: %d" _NL, + hwVersion, swVersion, + getValue(CONSOLE, CONSOLE_ASSIST_INITLEVEL) + ); + + if (!gNoSerialNumbers) + printf( " part number .............: %05d" _NL + " item number .............: %05d" _NL _NL, + ((getValue(CONSOLE, CONSOLE_SN_PN_HI) << 8) + getValue(CONSOLE, CONSOLE_SN_PN_LO)), + ((getValue(CONSOLE, CONSOLE_SN_ITEM_HI) << 8) + getValue(CONSOLE, CONSOLE_SN_ITEM_LO)) + ); + */ + + } + + + } + + +} + std::optional BCValueManager::getModel(const QString& key ) { if( _valueModels.contains( key) ) @@ -267,6 +307,7 @@ BCValue BCValueManager::makeValue( BCDevice::ID deviceID, const BCValueParams& p newValue.defaultValue.setValue( params.Label ); newValue.value.setValue( params.Current ); newValue.label = params.Label; + //qDebug() << " --- created: " << params.Label; } return newValue; diff --git a/bcvaluemanager.h b/bcvaluemanager.h index 980c625..05a777a 100644 --- a/bcvaluemanager.h +++ b/bcvaluemanager.h @@ -37,6 +37,7 @@ #include #include +#include class BCValueManager : public QObject { @@ -47,13 +48,19 @@ public: BCValueManager(); virtual ~BCValueManager(); - void loadXml(); - void saveXml(); - std::optional getModel(const QString& key ); BCValue makeValue(BCDevice::ID deviceID, const BCValueParams& params ); +public slots: + + void loadXml(); + void saveXml(); + void onToggleConnectionState( bool connect ); + +signals: + + protected: void readDevice( BCValueList& parsedValues ); @@ -63,6 +70,7 @@ protected: BCDevice::ID _currentDeviceID{BCDevice::ID::Invalid}; QMetaEnum _bcDeviceEnum{QMetaEnum::fromType()}; + BCCanDriverTinyCan _canDriver; }; #endif // BCVALUEMANAGER_H diff --git a/lib/can_drv.h b/lib/can_drv.h new file mode 100644 index 0000000..037772b --- /dev/null +++ b/lib/can_drv.h @@ -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 + #define DRV_CALLBACK_TYPE __stdcall +#else + #include + #include + #include + #define DRV_CALLBACK_TYPE +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +/***************************************************************/ +/* Define Makros */ +/***************************************************************/ + +// CAN Ü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ügbar, + // ansonsten Software Time-Stamps + // Ab Treiber Version 4.08! + +// CAN Bus Mode +#define OP_CAN_NO_CHANGE 0 // Aktuellen Zustand nicht ä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öffnet +#define DRV_STATUS_PORT_OPEN 4 // Die Schnittstelle wurde geöffnet +#define DRV_STATUS_DEVICE_FOUND 5 // Verbindung zur Hardware wurde Hergestellt +#define DRV_STATUS_CAN_OPEN 6 // Device wurde geö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 Überlauf +#define FIFO_SW_OVERRUN 2 // Fifo-Status: Software Fifo Überlauf +#define FIFO_HW_SW_OVERRUN 3 // Fifo-Status: Hardware & Software Fifo Ü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 Ü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 diff --git a/lib/can_drv_config.h b/lib/can_drv_config.h new file mode 100644 index 0000000..456e05c --- /dev/null +++ b/lib/can_drv_config.h @@ -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 diff --git a/lib/can_drv_ex.h b/lib/can_drv_ex.h new file mode 100644 index 0000000..7ad6fee --- /dev/null +++ b/lib/can_drv_ex.h @@ -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ä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 übereinstimmen + uint32_t Flags; // Unterstü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ä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ünftige Module mit mehr als einer Schnittstelle + uint32_t HwRxFilterCount; // Anzahl der zur Verfügung stehenden Receive-Filter + uint32_t HwTxPufferCount; // Anzahl der zur Verfügung stehenden Transmit Puffer mit Timer + }; +#pragma pack(pop) + +#pragma pack(push, 1) +struct TCanDevicesList + { + uint32_t TCanIdx; // Ist das Device geöffnet ist der Wert auf dem Device-Index + // gesetzt, ansonsten ist der Wert auf "INDEX_INVALID" gesetzt. + uint32_t HwId; // Ein 32 Bit Schlüssel der die Hardware eindeutig Identifiziert. + // Manche Module müssen erst geö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ü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ü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öffnet werden + // 2 = Firmware veraltet, Funktionsumfang eingeschränkt + // 3 = Firmware veraltet, keine Einschrä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ützte Features des Moduls + }; +#pragma pack(pop) + + +#pragma pack(push, 1) +struct TCanInfoVar // <*> geändert von TInfoVar in TCanInfoVar + { + uint32_t Key; // Variablen Schlüssel + uint32_t Type; // Variablen Type + uint32_t Size; // (Max)Größ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 diff --git a/lib/can_drv_linux.c b/lib/can_drv_linux.c new file mode 100644 index 0000000..69fff89 --- /dev/null +++ b/lib/can_drv_linux.c @@ -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" + + + diff --git a/lib/can_drv_win.c b/lib/can_drv_win.c new file mode 100644 index 0000000..e0c183a --- /dev/null +++ b/lib/can_drv_win.c @@ -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" + + + diff --git a/lib/can_types.h b/lib/can_types.h new file mode 100644 index 0000000..c5ecb18 --- /dev/null +++ b/lib/can_types.h @@ -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 + #if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1900) + #include + #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 +#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änge 0 - 8 Byte + unsigned TxD:1; // TxD -> 1 = Tx CAN Nachricht, 0 = Rx CAN Nachricht + // Eine Erfolgreich versendete Nachricht wird als Bestätigung + // ins Empfangsfifo zurückgeschrieben + // Nicht alle Module unterstützen diese Funktion u. das + // Feature muss aktiveirt sein + unsigned Error:1; // Error -> 1 = CAN Bus Fehler Nachricht + // Nicht alle Module unterstü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änge 0 - 64 Byte + + unsigned TxD:1; // TxD -> 1 = Tx CAN Nachricht, 0 = Rx CAN Nachricht + // Eine Erfolgreich versendete Nachricht wird als Bestätigung + // ins Empfangsfifo zurückgeschrieben + // Nicht alle Module unterstützen diese Funktion u. das + // Feature muss aktiveirt sein + unsigned Error:1; // Error -> 1 = CAN Bus Fehler Nachricht + // Nicht alle Module unterstü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 diff --git a/lib/mhs_can_drv.c b/lib/mhs_can_drv.c new file mode 100644 index 0000000..8c59dd1 --- /dev/null +++ b/lib/mhs_can_drv.c @@ -0,0 +1,3269 @@ +/*************************************************************************** + Interface zur Tiny-CAN API + ------------------- + begin : 11.10.2011 + last modify : 04.05.2023 + copyright : (C) 2011 - 2023 by MHS-Elektronik GmbH & Co. KG, Germany + author : Klaus Demlehner, klaus@mhs-elektronik.de + ***************************************************************************/ +#define CAN_DRV_INCLUDE + +#include "can_drv.h" + +#ifdef __WIN32__ + #include + #include + #if defined(MHS_DRV_DEBUG_OUTPUT) + #include + #include + #endif +#else + #include + #include + #include + #include + #include + #if defined(LINUX_HAVE_GET_API_DRIVER_PATH) + #include + #include + #include + #include + #include /* PATH_MAX */ + #endif + #if defined(MHS_DRV_DEBUG_OUTPUT) || defined(LINUX_HAVE_GET_API_DRIVER_PATH) + #include + #endif +#endif + + +#ifdef CAN_API_TRUE_FUNC +static TCanInitDriver PCanInitDriver = NULL; +static TCanDownDriver PCanDownDriver = NULL; +static TCanSetOptions PCanSetOptions = NULL; +static TCanDeviceOpen PCanDeviceOpen = NULL; +static TCanDeviceClose PCanDeviceClose = NULL; +static TCanSetMode PCanSetMode = NULL; +static TCanTransmit PCanTransmit = NULL; +static TCanTransmitClear PCanTransmitClear = NULL; +static TCanTransmitGetCount PCanTransmitGetCount = NULL; +static TCanTransmitSet PCanTransmitSet = NULL; +static TCanReceive PCanReceive = NULL; +static TCanReceiveClear PCanReceiveClear = NULL; +static TCanReceiveGetCount PCanReceiveGetCount = NULL; +static TCanSetSpeed PCanSetSpeed = NULL; +static TCanSetSpeedUser PCanSetSpeedUser = NULL; +static TCanDrvInfo PCanDrvInfo = NULL; +static TCanDrvHwInfo PCanDrvHwInfo = NULL; +static TCanSetFilter PCanSetFilter = NULL; +static TCanGetDeviceStatus PCanGetDeviceStatus = NULL; +static TCanSetPnPEventCallback PCanSetPnPEventCallback = NULL; +static TCanSetStatusEventCallback PCanSetStatusEventCallback = NULL; +static TCanSetRxEventCallback PCanSetRxEventCallback = NULL; +static TCanSetEvents PCanSetEvents = NULL; +static TCanEventStatus PCanEventStatus = NULL; +// EX-Funktionen +static TCanExGetDeviceCount PCanExGetDeviceCount = NULL; +static TCanExGetDeviceList PCanExGetDeviceList = NULL; +static TCanExGetDeviceListPerform PCanExGetDeviceListPerform = NULL; +static TCanExGetDeviceListGet PCanExGetDeviceListGet = NULL; +static TCanExGetDeviceInfo PCanExGetDeviceInfo = NULL; +static TCanExGetDeviceInfoPerform PCanExGetDeviceInfoPerform = NULL; +static TCanExGetDeviceInfoGet PCanExGetDeviceInfoGet = NULL; +static TCanExDataFree PCanExDataFree = NULL; +static TCanExCreateDevice PCanExCreateDevice = NULL; +static TCanExDestroyDevice PCanExDestroyDevice = NULL; +static TCanExCreateFifo PCanExCreateFifo = NULL; +static TCanExBindFifo PCanExBindFifo = NULL; +static TCanExCreateEvent PCanExCreateEvent = NULL; +static TCanExSetObjEvent PCanExSetObjEvent = NULL; +static TCanExSetEvent PCanExSetEvent = NULL; +static TCanExSetEventAll PCanExSetEventAll = NULL; +static TCanExResetEvent PCanExResetEvent = NULL; +static TCanExWaitForEvent PCanExWaitForEvent = NULL; +static TCanExInitDriver PCanExInitDriver = NULL; +static TCanExSetOptions PCanExSetOptions = NULL; +static TCanExSetAsByte PCanExSetAsByte = NULL; +static TCanExSetAsWord PCanExSetAsWord = NULL; +static TCanExSetAsLong PCanExSetAsLong = NULL; +static TCanExSetAsUByte PCanExSetAsUByte = NULL; +static TCanExSetAsUWord PCanExSetAsUWord = NULL; +static TCanExSetAsULong PCanExSetAsULong = NULL; +static TCanExSetAsString PCanExSetAsString = NULL; +static TCanExGetAsByte PCanExGetAsByte = NULL; +static TCanExGetAsWord PCanExGetAsWord = NULL; +static TCanExGetAsLong PCanExGetAsLong = NULL; +static TCanExGetAsUByte PCanExGetAsUByte = NULL; +static TCanExGetAsUWord PCanExGetAsUWord = NULL; +static TCanExGetAsULong PCanExGetAsULong = NULL; +static TCanExGetAsString PCanExGetAsString = NULL; +static TCanExGetAsStringCopy PCanExGetAsStringCopy = NULL; +// **** CAN-FD +static TCanFdTransmit PCanFdTransmit = NULL; +static TCanFdReceive PCanFdReceive = NULL; +// **** <*> neu +static TCanExSetAsData PCanExSetAsData = NULL; +static TCanExSetDataPtr PCanExSetDataPtr = NULL; +static TCanExSetDataBlockCB PCanExSetDataBlockCB = NULL; + +static TCanExGetInfoList PCanExGetInfoList = NULL; +static TCanExGetInfoListPerform PCanExGetInfoListPerform = NULL; +static TCanExGetInfoListGet PCanExGetInfoListGet = NULL; + +static TMhsCanGetApiHandle PMhsCanGetApiHandle = NULL; +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +static TCanExIoOpen PCanExIoOpen = NULL; +static TCanExIoClose PCanExIoClose = NULL; +static TCanExIoWrite PCanExIoWrite = NULL; +static TCanExIoRead PCanExIoRead = NULL; +#endif + +#else +int32_t DRV_CALLBACK_TYPE DefCanInitDriver(char *options); +void DRV_CALLBACK_TYPE DefCanDownDriver(void); +int32_t DRV_CALLBACK_TYPE DefCanSetOptions(char *options); +int32_t DRV_CALLBACK_TYPE DefCanDeviceOpen(uint32_t index, char *parameter); +int32_t DRV_CALLBACK_TYPE DefCanDeviceClose(uint32_t index); + +int32_t DRV_CALLBACK_TYPE DefCanSetMode(uint32_t index, unsigned char can_op_mode, uint16_t can_command); + +int32_t DRV_CALLBACK_TYPE DefCanTransmit(uint32_t index, struct TCanMsg *msg, int32_t count); +void DRV_CALLBACK_TYPE DefCanTransmitClear(uint32_t index); +uint32_t DRV_CALLBACK_TYPE DefCanTransmitGetCount(uint32_t index); +int32_t DRV_CALLBACK_TYPE DefCanTransmitSet(uint32_t index, uint16_t cmd, + uint32_t time); +int32_t DRV_CALLBACK_TYPE DefCanReceive(uint32_t index, struct TCanMsg *msg, int32_t count); +void DRV_CALLBACK_TYPE DefCanReceiveClear(uint32_t index); +uint32_t DRV_CALLBACK_TYPE DefCanReceiveGetCount(uint32_t index); + +int32_t DRV_CALLBACK_TYPE DefCanSetSpeed(uint32_t index, uint16_t speed); +int32_t DRV_CALLBACK_TYPE DefCanSetSpeedUser(uint32_t index, uint32_t value); +char * DRV_CALLBACK_TYPE DefCanDrvInfo(void); +char * DRV_CALLBACK_TYPE DefCanDrvHwInfo(uint32_t index); +int32_t DRV_CALLBACK_TYPE DefCanSetFilter(uint32_t index, struct TMsgFilter *msg_filter); +int32_t DRV_CALLBACK_TYPE DefCanGetDeviceStatus(uint32_t index, struct TDeviceStatus *status); +void DRV_CALLBACK_TYPE DefCanSetPnPEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, int32_t status)); +void DRV_CALLBACK_TYPE DefCanSetStatusEventCallback(void (DRV_CALLBACK_TYPE *event) + (uint32_t index, struct TDeviceStatus *device_status)); +void DRV_CALLBACK_TYPE DefCanSetRxEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, + struct TCanMsg *msg, int32_t count)); + +void DRV_CALLBACK_TYPE DefCanSetEvents(uint16_t events); +uint32_t DRV_CALLBACK_TYPE DefCanEventStatus(void); + +// EX-Funktionen +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceCount(int32_t flags); +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceList(struct TCanDevicesList **devices_list, int32_t flags); +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceListPerform(int32_t flags); +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceListGet(struct TCanDevicesList *item); +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceInfo(uint32_t index, struct TCanDeviceInfo *device_info, + struct TCanInfoVar **hw_info, uint32_t *hw_info_size); +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceInfoPerform(uint32_t index, struct TCanDeviceInfo *device_info); +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceInfoGet(struct TCanInfoVar *item); +void DRV_CALLBACK_TYPE DefCanExDataFree(void **data); +int32_t DRV_CALLBACK_TYPE DefCanExCreateDevice(uint32_t *index, char *options); +int32_t DRV_CALLBACK_TYPE DefCanExDestroyDevice(uint32_t *index); +int32_t DRV_CALLBACK_TYPE DefCanExCreateFifo(uint32_t index, uint32_t size, TMhsEvent *event_obj, uint32_t event, uint32_t channels); +int32_t DRV_CALLBACK_TYPE DefCanExBindFifo(uint32_t fifo_index, uint32_t device_index, uint32_t bind); +TMhsEvent * DRV_CALLBACK_TYPE DefCanExCreateEvent(void); +int32_t DRV_DRV_CALLBACK_TYPE_TYPE DefCanExSetObjEvent(uint32_t index, uint32_t source, TMhsEvent *event_obj, uint32_t event); +void DRV_CALLBACK_TYPE DefCanExSetEvent(TMhsEvent *event_obj, uint32_t event); +void DRV_CALLBACK_TYPE DefCanExSetEventAll(uint32_t event); +void DRV_CALLBACK_TYPE DefCanExResetEvent(TMhsEvent *event_obj, uint32_t event); +uint32_t DRV_CALLBACK_TYPE DefCanExWaitForEvent(TMhsEvent *event_obj, uint32_t timeout); +int32_t DRV_CALLBACK_TYPE DefCanExInitDriver(char *options); +int32_t DRV_CALLBACK_TYPE DefCanExSetOptions(uint32_t index, char *options); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsByte(uint32_t index, char *name, char value); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsWord(uint32_t index, char *name, int16_t value); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsLong(uint32_t index, char *name, int32_t value); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsUByte(uint32_t index, char *name, unsigned char value); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsUWord(uint32_t index, char *name, uint16_t value); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsULong(uint32_t index, char *name, uint32_t value); +int32_t DRV_CALLBACK_TYPE DefCanExSetAsString(uint32_t index, char *name, char *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsByte(uint32_t index, char *name, char *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsWord(uint32_t index, char *name, int16_t *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsLong(uint32_t index, char *name, int32_t *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsUByte(uint32_t index, char *name, unsigned char *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsUWord(uint32_t index, char *name, uint16_t *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsULong(uint32_t index, char *name, uint32_t *value); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsString(uint32_t index, char *name, char **str); +int32_t DRV_CALLBACK_TYPE DefCanExGetAsStringCopy(uint32_t index, char *name, char *dest, uint32_t *dest_size); +// **** CAN-FD +int32_t DRV_CALLBACK_TYPE DefCanFdTransmit(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count); +int32_t DRV_CALLBACK_TYPE DefCanFdReceive(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count); +// **** <*> neu +int32_t DRV_CALLBACK_TYPE DefCanExSetAsData(uint32_t index, char *name, void *data, uint32_t size); +int32_t DRV_CALLBACK_TYPE DefCanExSetDataPtr(uint32_t index, char *name, void *data_ptr, uint32_t size); +int32_t DRV_CALLBACK_TYPE DefCanExSetDataBlockCB(uint32_t index, TCanGetDataBlockCB func, void *user_data); + +int32_t DRV_CALLBACK_TYPE DefCanExGetInfoList(uint32_t dev_idx, const char *name, struct TCanInfoVarList **devices_info, int32_t flags); +int32_t DRV_CALLBACK_TYPE DefCanExGetInfoListPerform(uint32_t dev_idx, const char *name, int32_t flags); +int32_t DRV_CALLBACK_TYPE DefCanExGetInfoListGet(uint32_t list_idx, struct TCanInfoVar *item); +int32_t DRV_CALLBACK_TYPE DefMhsCanGetApiHandle(void **api_handle); + +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +int32_t DRV_CALLBACK_TYPE CanExIoOpen(uint32_t index, const char *name, uint32_t *io_id); +int32_t DRV_CALLBACK_TYPE CanExIoClose(uint32_t io_id); +int32_t DRV_CALLBACK_TYPE CanExIoWrite(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout); +int32_t DRV_CALLBACK_TYPE CanExIoRead(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout); +#endif + +TCanInitDriver CanInitDriver = DefCanInitDriver; +TCanDownDriver CanDownDriver = DefCanDownDriver; +TCanSetOptions CanSetOptions = DefCanSetOptions; +TCanDeviceOpen CanDeviceOpen = DefCanDeviceOpen; +TCanDeviceClose CanDeviceClose = DefCanDeviceClose; +TCanSetMode CanSetMode = DefCanSetMode; +TCanTransmit CanTransmit = DefCanTransmit; +TCanTransmitClear CanTransmitClear = DefCanTransmitClear; +TCanTransmitGetCount CanTransmitGetCount = DefCanTransmitGetCount; +TCanTransmitSet CanTransmitSet = DefCanTransmitSet; +TCanReceive CanReceive = DefCanReceive; +TCanReceiveClear CanReceiveClear = DefCanReceiveClear; +TCanReceiveGetCount CanReceiveGetCount = DefCanReceiveGetCount; +TCanSetSpeed CanSetSpeed = DefCanSetSpeed; +TCanSetSpeedUser CanSetSpeedUser = DefCanSetSpeedUser; +TCanDrvInfo CanDrvInfo = DefCanDrvInfo; +TCanDrvHwInfo CanDrvHwInfo = DefCanDrvHwInfo; +TCanSetFilter CanSetFilter = DefCanSetFilter; +TCanGetDeviceStatus CanGetDeviceStatus = DefCanGetDeviceStatus; +TCanSetPnPEventCallback CanSetPnPEventCallback = DefCanSetPnPEventCallback; +TCanSetStatusEventCallback CanSetStatusEventCallback = DefCanSetStatusEventCallback; +TCanSetRxEventCallback CanSetRxEventCallback = DefCanSetRxEventCallback; +TCanSetEvents CanSetEvents = DefCanSetEvents; +TCanEventStatus CanEventStatus = DefCanEventStatus; + +// EX-Funktionen +TCanExGetDeviceCount CanExGetDeviceCount = DefCanExGetDeviceCount; +TCanExGetDeviceList CanExGetDeviceList = DefCanExGetDeviceList; +TCanExGetDeviceListPerform CanExGetDeviceListPerform = DefCanExGetDeviceListPerform; +TCanExGetDeviceListGet CanExGetDeviceListGet = DefCanExGetDeviceListGet; +TCanExGetDeviceInfo CanExGetDeviceInfo = DefCanExGetDeviceInfo; +TCanExGetDeviceInfoPerform CanExGetDeviceInfoPerform = DefCanExGetDeviceInfoPerform; +TCanExGetDeviceInfoGet CanExGetDeviceInfoGet = DefCanExGetDeviceInfoGet; +TCanExDataFree CanExDataFree = DefCanExDataFree; +TCanExCreateDevice CanExCreateDevice = DefCanExCreateDevice; +TCanExDestroyDevice CanExDestroyDevice = DefCanExDestroyDevice; +TCanExCreateFifo CanExCreateFifo = DefCanExCreateFifo; +TCanExBindFifo CanExBindFifo = DefCanExBindFifo; +TCanExCreateEvent CanExCreateEvent = DefCanExCreateEvent; +TCanExSetObjEvent CanExSetObjEvent = DefCanExSetObjEvent; +TCanExSetEvent CanExSetEvent = DefCanExSetEvent; +TCanExSetEventAll CanExSetEventAll = DefCanExSetEventAll; +TCanExResetEvent CanExResetEvent = DefCanExResetEvent; +TCanExWaitForEvent CanExWaitForEvent = DefCanExWaitForEvent; +TCanExInitDriver CanExInitDriver = DefCanExInitDriver; +TCanExSetOptions CanExSetOptions = DefCanExSetOptions; +TCanExSetAsByte CanExSetAsByte = DefCanExSetAsByte; +TCanExSetAsWord CanExSetAsWord = DefCanExSetAsWord; +TCanExSetAsLong CanExSetAsLong = DefCanExSetAsLong; +TCanExSetAsUByte CanExSetAsUByte = DefCanExSetAsUByte; +TCanExSetAsUWord CanExSetAsUWord = DefCanExSetAsUWord; +TCanExSetAsULong CanExSetAsULong = DefCanExSetAsULong; +TCanExSetAsString CanExSetAsString = DefCanExSetAsString; +TCanExGetAsByte CanExGetAsByte = DefCanExGetAsByte; +TCanExGetAsWord CanExGetAsWord = DefCanExGetAsWord; +TCanExGetAsLong CanExGetAsLong = DefCanExGetAsLong; +TCanExGetAsUByte CanExGetAsUByte = DefCanExGetAsUByte; +TCanExGetAsUWord CanExGetAsUWord = DefCanExGetAsUWord; +TCanExGetAsULong CanExGetAsULong = DefCanExGetAsULong; +TCanExGetAsString CanExGetAsString = DefCanExGetAsString; +TCanExGetAsStringCopy CanExGetAsStringCopy = DefCanExGetAsStringCopy; +// **** CAN-FD +TCanFdTransmit CanFdTransmit = DefCanFdTransmit; +TCanFdReceive CanFdReceive = DefCanFdReceive; +// <*> neu +TCanExSetAsData CanExSetAsData = DefCanExSetAsData; +TCanExSetDataPtr CanExSetDataPtr = DefCanExSetDataPtr; +TCanExSetDataBlockCB CanExSetDataBlockCB = DefCanExSetDataBlockCB; + +TCanExGetInfoList CanExGetInfoList = DefCanExGetInfoList; +TCanExGetInfoListPerform CanExGetInfoListPerform = DefCanExGetInfoListPerform; +TCanExGetInfoListGet CanExGetInfoListGet = DefCanExGetInfoListGet; + +TMhsCanGetApiHandle MhsCanGetApiHandle = DefMhsCanGetApiHandle; + +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +TCanExIoOpen CanExIoOpen = DefCanExIoOpen; +TCanExIoClose CanExIoClose = DefCanExIoClose; +TCanExIoWrite CanExIoWrite = DefCanExIoWrite; +TCanExIoRead CanExIoRead = DefCanExIoRead; +#endif + + +#endif + +#ifdef LINUX_HAVE_GET_API_DRIVER_PATH +static char *DriverFileName = NULL; +#endif + +#ifdef __WIN32__ +static HINSTANCE DriverHandle = 0; // Handle to DLL +static char *DriverFileName = NULL; + + #if _MSC_VER >= 1500 + #define INTERLOCK_TYPE_CONV + #else + #define INTERLOCK_TYPE_CONV (volatile LPLONG) + #endif +#else +static void *DriverHandle = NULL; +#endif + + +#ifdef DRV_REF_LOCKING + + #ifdef __WIN32__ + // ****** Windows +static volatile LONG TCanDrvRefCounter = 0; + + #define CAN_DRV_REF() (void)InterlockedIncrement(INTERLOCK_TYPE_CONV&TCanDrvRefCounter) + #define CAN_DRV_UNREF() (void)InterlockedDecrement(INTERLOCK_TYPE_CONV&TCanDrvRefCounter) + #else + // ****** Linux +static volatile uint32_t TCanDrvRefCounter = 0; + #define CAN_DRV_REF() (void) __sync_fetch_and_add(&TCanDrvRefCounter, 1) + #define CAN_DRV_UNREF() (void) __sync_fetch_and_sub(&TCanDrvRefCounter, 1) + #endif +#else + #define CAN_DRV_REF() + #define CAN_DRV_UNREF() +#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 + + +#if defined(__WIN32__) || defined(LINUX_HAVE_GET_API_DRIVER_PATH) + +#ifdef __GNUC__ + #define SafeSprintf snprintf +#endif + +#ifdef __WIN32__ + #ifndef __GNUC__ + #if defined(_MSC_VER) && _MSC_VER >= 1500 + #define SafeSprintf(dst, dst_max, format, ...) _snprintf_s(dst, dst_max, _TRUNCATE, format, __VA_ARGS__) + #else + #define SafeSprintf _snprintf + #endif + #endif +#endif + +#define MhsSafeFree(d) do { \ + if ((d)) \ + { \ + free((d)); \ + (d) = NULL; \ + } \ + } while(0) + +static char *GetApiDriverWithPath(const char *driver_file); +#endif + + +/***************************************************************/ +/* Treiber DLL laden */ +/***************************************************************/ +int32_t LoadDriver(const char *file_name) +{ +int32_t error; + +error = 0; +UnloadDriver(); +#ifdef __WIN32__ +if (!(DriverFileName = GetApiDriverWithPath(file_name))) + { +#ifdef MHS_DRV_DEBUG_OUTPUT +printf("Fehler bei GetApiDriverWithPath\n\r"); +#endif + return(-100); + } +DriverHandle = LoadLibraryA(DriverFileName); + #ifdef MHS_DRV_DEBUG_OUTPUT +if (DriverHandle) + printf("API driver file \"%s\" loaded.\n\r", DriverFileName); +else + printf("Error load: %s\n\r", DriverFileName); + #endif +#else + #ifdef LINUX_HAVE_GET_API_DRIVER_PATH +if (!(DriverFileName = GetApiDriverWithPath(file_name))) + { +#ifdef MHS_DRV_DEBUG_OUTPUT +printf("Fehler bei GetApiDriverWithPath\n\r"); +#endif + return(-100); + } +DriverHandle = dlopen(DriverFileName, RTLD_LAZY); + #else +DriverHandle = dlopen(file_name, RTLD_LAZY); + #endif + #ifdef MHS_DRV_DEBUG_OUTPUT +if (DriverHandle) + printf("API driver file \"%s\" loaded.\n\r", DriverFileName); +else + printf("Error load: %s\n\r, ", dlerror()); + #endif +#endif +if (DriverHandle) + { +#ifdef CAN_API_TRUE_FUNC + if (!(PCanInitDriver = (TCanInitDriver)MhsGetProcAddress(DriverHandle, "CanInitDriver"))) + error = -1; + else if (!(PCanDownDriver = (TCanDownDriver)MhsGetProcAddress(DriverHandle, "CanDownDriver"))) + error = -2; + else if (!(PCanSetOptions = (TCanSetOptions)MhsGetProcAddress(DriverHandle, "CanSetOptions"))) + error = -3; + else if (!(PCanDeviceOpen = (TCanDeviceOpen)MhsGetProcAddress(DriverHandle, "CanDeviceOpen"))) + error = -4; + else if (!(PCanDeviceClose = (TCanDeviceClose)MhsGetProcAddress(DriverHandle, "CanDeviceClose"))) + error = -5; + else if (!(PCanSetMode = (TCanSetMode)MhsGetProcAddress(DriverHandle, "CanSetMode"))) + error = -6; + else if (!(PCanTransmit = (TCanTransmit)MhsGetProcAddress(DriverHandle, "CanTransmit"))) + error = -7; + else if (!(PCanTransmitClear = (TCanTransmitClear)MhsGetProcAddress(DriverHandle, "CanTransmitClear"))) + error = -8; + else if (!(PCanTransmitGetCount = (TCanTransmitGetCount)MhsGetProcAddress(DriverHandle, "CanTransmitGetCount"))) + error = -9; + else if (!(PCanTransmitSet = (TCanTransmitSet)MhsGetProcAddress(DriverHandle, "CanTransmitSet"))) + error = -10; + else if (!(PCanReceive = (TCanReceive)MhsGetProcAddress(DriverHandle, "CanReceive"))) + error = -11; + else if (!(PCanReceiveClear = (TCanReceiveClear)MhsGetProcAddress(DriverHandle, "CanReceiveClear"))) + error = -12; + else if (!(PCanReceiveGetCount = (TCanReceiveGetCount)MhsGetProcAddress(DriverHandle, "CanReceiveGetCount"))) + error = -13; + else if (!(PCanSetSpeed = (TCanSetSpeed)MhsGetProcAddress(DriverHandle, "CanSetSpeed"))) + error = -14; + else if (!(PCanSetSpeedUser = (TCanSetSpeedUser)MhsGetProcAddress(DriverHandle, "CanSetSpeedUser"))) + error = -15; + else if (!(PCanDrvInfo = (TCanDrvInfo)MhsGetProcAddress(DriverHandle, "CanDrvInfo"))) + error = -16; + else if (!(PCanDrvHwInfo = (TCanDrvHwInfo)MhsGetProcAddress(DriverHandle, "CanDrvHwInfo"))) + error = -17; + else if (!(PCanSetFilter = (TCanSetFilter)MhsGetProcAddress(DriverHandle, "CanSetFilter"))) + error = -18; + else if (!(PCanGetDeviceStatus = (TCanGetDeviceStatus)MhsGetProcAddress(DriverHandle, "CanGetDeviceStatus"))) + error = -19; + else if (!(PCanSetPnPEventCallback = (TCanSetPnPEventCallback)MhsGetProcAddress(DriverHandle, "CanSetPnPEventCallback"))) + error = -20; + else if (!(PCanSetStatusEventCallback = (TCanSetStatusEventCallback)MhsGetProcAddress(DriverHandle, "CanSetStatusEventCallback"))) + error = -21; + else if (!(PCanSetRxEventCallback = (TCanSetRxEventCallback)MhsGetProcAddress(DriverHandle, "CanSetRxEventCallback"))) + error = -22; + else if (!(PCanSetEvents = (TCanSetEvents)MhsGetProcAddress(DriverHandle, "CanSetEvents"))) + error = -23; + else if (!(PCanEventStatus = (TCanEventStatus)MhsGetProcAddress(DriverHandle, "CanEventStatus"))) + error = -24; + // EX-Funktionen + else if (!(PCanExGetDeviceCount = (TCanExGetDeviceCount)MhsGetProcAddress(DriverHandle, "CanExGetDeviceCount"))) + error = -25; + else if (!(PCanExGetDeviceList = (TCanExGetDeviceList)MhsGetProcAddress(DriverHandle, "CanExGetDeviceList"))) + error = -26; + else if (!(PCanExGetDeviceListPerform = (TCanExGetDeviceListPerform)MhsGetProcAddress(DriverHandle, "CanExGetDeviceListPerform"))) + error = -27; + else if (!(PCanExGetDeviceListGet = (TCanExGetDeviceListGet)MhsGetProcAddress(DriverHandle, "CanExGetDeviceListGet"))) + error = -28; + else if (!(PCanExGetDeviceInfo = (TCanExGetDeviceInfo)MhsGetProcAddress(DriverHandle, "CanExGetDeviceInfo"))) + error = -29; + else if (!(PCanExGetDeviceInfoPerform = (TCanExGetDeviceInfoPerform)MhsGetProcAddress(DriverHandle, "CanExGetDeviceInfoPerform"))) + error = -30; + else if (!(PCanExGetDeviceInfoGet = (TCanExGetDeviceInfoGet)MhsGetProcAddress(DriverHandle, "CanExGetDeviceInfoGet"))) + error = -31; + else if (!(PCanExDataFree = (TCanExDataFree)MhsGetProcAddress(DriverHandle, "CanExDataFree"))) + error = -32; + else if (!(PCanExCreateDevice = (TCanExCreateDevice)MhsGetProcAddress(DriverHandle, "CanExCreateDevice"))) + error = -33; + else if (!(PCanExDestroyDevice = (TCanExDestroyDevice)MhsGetProcAddress(DriverHandle, "CanExDestroyDevice"))) + error = -34; + else if (!(PCanExCreateFifo = (TCanExCreateFifo)MhsGetProcAddress(DriverHandle, "CanExCreateFifo"))) + error = -35; + else if (!(PCanExBindFifo = (TCanExBindFifo)MhsGetProcAddress(DriverHandle, "CanExBindFifo"))) + error = -36; + else if (!(PCanExCreateEvent = (TCanExCreateEvent)MhsGetProcAddress(DriverHandle, "CanExCreateEvent"))) + error = -37; + else if (!(PCanExSetObjEvent = (TCanExSetObjEvent)MhsGetProcAddress(DriverHandle, "CanExSetObjEvent"))) + error = -38; + else if (!(PCanExSetEvent = (TCanExSetEvent)MhsGetProcAddress(DriverHandle, "CanExSetEvent"))) + error = -39; + else if (!(PCanExResetEvent = (TCanExResetEvent)MhsGetProcAddress(DriverHandle, "CanExResetEvent"))) + error = -40; + else if (!(PCanExWaitForEvent = (TCanExWaitForEvent)MhsGetProcAddress(DriverHandle, "CanExWaitForEvent"))) + error = -41; + else if (!(PCanExInitDriver = (TCanExInitDriver)MhsGetProcAddress(DriverHandle, "CanExInitDriver"))) + error = -42; + else if (!(PCanExSetOptions = (TCanExSetOptions)MhsGetProcAddress(DriverHandle, "CanExSetOptions"))) + error = -43; + else if (!(PCanExSetAsByte = (TCanExSetAsByte)MhsGetProcAddress(DriverHandle, "CanExSetAsByte"))) + error = -44; + else if (!(PCanExSetAsWord = (TCanExSetAsWord)MhsGetProcAddress(DriverHandle, "CanExSetAsWord"))) + error = -45; + else if (!(PCanExSetAsLong = (TCanExSetAsLong)MhsGetProcAddress(DriverHandle, "CanExSetAsLong"))) + error = -46; + else if (!(PCanExSetAsUByte = (TCanExSetAsUByte)MhsGetProcAddress(DriverHandle, "CanExSetAsUByte"))) + error = -47; + else if (!(PCanExSetAsUWord = (TCanExSetAsUWord)MhsGetProcAddress(DriverHandle, "CanExSetAsUWord"))) + error = -48; + else if (!(PCanExSetAsULong = (TCanExSetAsULong)MhsGetProcAddress(DriverHandle, "CanExSetAsULong"))) + error = -49; + else if (!(PCanExSetAsString = (TCanExSetAsString)MhsGetProcAddress(DriverHandle, "CanExSetAsString"))) + error = -50; + else if (!(PCanExGetAsByte = (TCanExGetAsByte)MhsGetProcAddress(DriverHandle, "CanExGetAsByte"))) + error = -51; + else if (!(PCanExGetAsWord = (TCanExGetAsWord)MhsGetProcAddress(DriverHandle, "CanExGetAsWord"))) + error = -52; + else if (!(PCanExGetAsLong = (TCanExGetAsLong)MhsGetProcAddress(DriverHandle, "CanExGetAsLong"))) + error = -53; + else if (!(PCanExGetAsUByte = (TCanExGetAsUByte)MhsGetProcAddress(DriverHandle, "CanExGetAsUByte"))) + error = -54; + else if (!(PCanExGetAsUWord = (TCanExGetAsUWord)MhsGetProcAddress(DriverHandle, "CanExGetAsUWord"))) + error = -55; + else if (!(PCanExGetAsULong = (TCanExGetAsULong)MhsGetProcAddress(DriverHandle, "CanExGetAsULong"))) + error = -56; + else if (!(PCanExGetAsString = (TCanExGetAsString)MhsGetProcAddress(DriverHandle, "CanExGetAsString"))) + error = -57; + else if (!(PCanExGetAsStringCopy = (TCanExGetAsStringCopy)MhsGetProcAddress(DriverHandle, "CanExGetAsStringCopy"))) + error = -58; + else if (!(PCanExSetEventAll = (TCanExSetEventAll)MhsGetProcAddress(DriverHandle, "CanExSetEventAll"))) + error = -59; + // **** CAN-FD +#ifdef STRICT_CAN_FD_SUPPORT + else if (!(PCanFdTransmit = (TCanFdTransmit)MhsGetProcAddress(DriverHandle, "CanFdTransmit"))) + error = -60; + else if (!(PCanFdReceive = (TCanFdReceive)MhsGetProcAddress(DriverHandle, "CanFdReceive"))) + error = -61; +#else + PCanFdTransmit = (TCanFdTransmit)MhsGetProcAddress(DriverHandle, "CanFdTransmit"); + PCanFdReceive = (TCanFdReceive)MhsGetProcAddress(DriverHandle, "CanFdReceive"); +#endif +// ****** <*> neu +#ifdef STRICT_ECU_FLASH_SUPPORT + if (!(PCanExSetAsData = (TCanExSetAsData)MhsGetProcAddress(DriverHandle, "CanExSetAsData"))) + error = -62; + if (!(PCanExSetDataPtr = (TCanExSetDataPtr)MhsGetProcAddress(DriverHandle, "CanExSetDataPtr"))) + error = -63; + if (!(PCanExSetDataBlockCB = (TCanExSetDataBlockCB)MhsGetProcAddress(DriverHandle, "CanExSetDataBlockCB"))) + error = -64; +#else + PCanExSetAsData = (TCanExSetAsData)MhsGetProcAddress(DriverHandle, "CanExSetAsData"); + PCanExSetDataPtr = (TCanExSetDataPtr)MhsGetProcAddress(DriverHandle, "CanExSetDataPtr"); + PCanExSetDataBlockCB = (TCanExSetDataBlockCB)MhsGetProcAddress(DriverHandle, "CanExSetDataBlockCB"); +#endif +// ****** <*> neu2 + PCanExGetInfoList = (TCanExGetInfoList)MhsGetProcAddress(DriverHandle, "CanExGetInfoList"); + PCanExGetInfoListPerform = (TCanExGetInfoListPerform)MhsGetProcAddress(DriverHandle, "CanExGetInfoListPerform"); + PCanExGetInfoListGet = (TCanExGetInfoListGet)MhsGetProcAddress(DriverHandle, "CanExGetInfoListGet"); + PMhsCanGetApiHandle = (TMhsCanGetApiHandle)MhsGetProcAddress(DriverHandle, "MhsCanGetApiHandle"); +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu + PCanExIoOpen = (TCanExIoOpen)MhsGetProcAddress(DriverHandle, "CanExIoOpen"); + PCanExIoClose = (TCanExIoClose)MhsGetProcAddress(DriverHandle, "CanExIoClose"); + PCanExIoWrite = (TCanExIoWrite)MhsGetProcAddress(DriverHandle, "CanExIoWrite"); + PCanExIoRead = (TCanExIoRead)MhsGetProcAddress(DriverHandle, "CanExIoRead"); +#endif +#else + if (!(CanInitDriver = (TCanInitDriver)MhsGetProcAddress(DriverHandle, "CanInitDriver"))) + error = -1; + else if (!(CanDownDriver = (TCanDownDriver)MhsGetProcAddress(DriverHandle, "CanDownDriver"))) + error = -2; + else if (!(CanSetOptions = (TCanSetOptions)MhsGetProcAddress(DriverHandle, "CanSetOptions"))) + error = -3; + else if (!(CanDeviceOpen = (TCanDeviceOpen)MhsGetProcAddress(DriverHandle, "CanDeviceOpen"))) + error = -4; + else if (!(CanDeviceClose = (TCanDeviceClose)MhsGetProcAddress(DriverHandle, "CanDeviceClose"))) + error = -5; + else if (!(CanSetMode = (TCanSetMode)MhsGetProcAddress(DriverHandle, "CanSetMode"))) + error = -7; + else if (!(CanTransmit = (TCanTransmit)MhsGetProcAddress(DriverHandle, "CanTransmit"))) + error = -10; + else if (!(CanTransmitClear = (TCanTransmitClear)MhsGetProcAddress(DriverHandle, "CanTransmitClear"))) + error = -11; + else if (!(CanTransmitGetCount = (TCanTransmitGetCount)MhsGetProcAddress(DriverHandle, "CanTransmitGetCount"))) + error = -12; + else if (!(CanTransmitSet = (TCanTransmitSet)MhsGetProcAddress(DriverHandle, "CanTransmitSet"))) + error = -13; + else if (!(CanReceive = (TCanReceive)MhsGetProcAddress(DriverHandle, "CanReceive"))) + error = -14; + else if (!(CanReceiveClear = (TCanReceiveClear)MhsGetProcAddress(DriverHandle, "CanReceiveClear"))) + error = -15; + else if (!(CanReceiveGetCount = (TCanReceiveGetCount)MhsGetProcAddress(DriverHandle, "CanReceiveGetCount"))) + error = -16; + else if (!(CanSetSpeed = (TCanSetSpeed)MhsGetProcAddress(DriverHandle, "CanSetSpeed"))) + error = -17; + else if (!(CanSetSpeedUser = (TCanSetSpeedUser)MhsGetProcAddress(DriverHandle, "CanSetSpeedUser"))) + error = -18; + else if (!(CanDrvInfo = (TCanDrvInfo)MhsGetProcAddress(DriverHandle, "CanDrvInfo"))) + error = -19; + else if (!(CanDrvHwInfo = (TCanDrvHwInfo)MhsGetProcAddress(DriverHandle, "CanDrvHwInfo"))) + error = -20; + else if (!(CanSetFilter = (TCanSetFilter)MhsGetProcAddress(DriverHandle, "CanSetFilter"))) + error = -21; + else if (!(CanGetDeviceStatus = (TCanGetDeviceStatus)MhsGetProcAddress(DriverHandle, "CanGetDeviceStatus"))) + error = -22; + else if (!(CanSetPnPEventCallback = (TCanSetPnPEventCallback)MhsGetProcAddress(DriverHandle, "CanSetPnPEventCallback"))) + error = -23; + else if (!(CanSetStatusEventCallback = (TCanSetStatusEventCallback)MhsGetProcAddress(DriverHandle, "CanSetStatusEventCallback"))) + error = -24; + else if (!(CanSetRxEventCallback = (TCanSetRxEventCallback)MhsGetProcAddress(DriverHandle, "CanSetRxEventCallback"))) + error = -25; + else if (!(CanSetEvents = (TCanSetEvents)MhsGetProcAddress(DriverHandle, "CanSetEvents"))) + error = -26; + else if (!(CanEventStatus = (TCanEventStatus)MhsGetProcAddress(DriverHandle, "CanEventStatus"))) + error = -27; + // EX-Funktionen + else if (!(CanExGetDeviceCount = (TCanExGetDeviceCount)MhsGetProcAddress(DriverHandle, "CanExGetDeviceCount"))) + error = -28; + else if (!(CanExGetDeviceList = (TCanExGetDeviceList)MhsGetProcAddress(DriverHandle, "CanExGetDeviceList"))) + error = -29; + else if (!(CanExGetDeviceListPerform = (TCanExGetDeviceListPerform)MhsGetProcAddress(DriverHandle, "CanExGetDeviceListPerform"))) + error = -57; + else if (!(CanExGetDeviceListGet = (TCanExGetDeviceListGet)MhsGetProcAddress(DriverHandle, "CanExGetDeviceListGet"))) + error = -58; + else if (!(CanExGetDeviceInfo = (TCanExGetDeviceInfo)MhsGetProcAddress(DriverHandle, "CanExGetDeviceInfo"))) + error = -30; + else if (!(CanExGetDeviceInfoPerform = (TCanExGetDeviceInfoPerform)MhsGetProcAddress(DriverHandle, "CanExGetDeviceInfoPerform"))) + error = -59; + else if (!(CanExGetDeviceInfoGet = (TCanExGetDeviceInfoGet)MhsGetProcAddress(DriverHandle, "CanExGetDeviceInfoGet"))) + error = -60; + else if (!(CanExDataFree = (TCanExDataFree)MhsGetProcAddress(DriverHandle, "CanExDataFree"))) + error = -31; + else if (!(CanExCreateDevice = (TCanExCreateDevice)MhsGetProcAddress(DriverHandle, "CanExCreateDevice"))) + error = -32; + else if (!(CanExDestroyDevice = (TCanExDestroyDevice)MhsGetProcAddress(DriverHandle, "CanExDestroyDevice"))) + error = -33; + else if (!(CanExCreateFifo = (TCanExCreateFifo)MhsGetProcAddress(DriverHandle, "CanExCreateFifo"))) + error = -34; + else if (!(CanExBindFifo = (TCanExBindFifo)MhsGetProcAddress(DriverHandle, "CanExBindFifo"))) + error = -35; + else if (!(CanExCreateEvent = (TCanExCreateEvent)MhsGetProcAddress(DriverHandle, "CanExCreateEvent"))) + error = -36; + else if (!(CanExSetObjEvent = (TCanExSetObjEvent)MhsGetProcAddress(DriverHandle, "CanExSetObjEvent"))) + error = -37; + else if (!(CanExSetEvent = (TCanExSetEvent)MhsGetProcAddress(DriverHandle, "CanExSetEvent"))) + error = -38; + else if (!(CanExResetEvent = (TCanExResetEvent)MhsGetProcAddress(DriverHandle, "CanExResetEvent"))) + error = -39; + else if (!(CanExWaitForEvent = (TCanExWaitForEvent)MhsGetProcAddress(DriverHandle, "CanExWaitForEvent"))) + error = -40; + else if (!(CanExInitDriver = (TCanExInitDriver)MhsGetProcAddress(DriverHandle, "CanExInitDriver"))) + error = -41; + else if (!(CanExSetOptions = (TCanExSetOptions)MhsGetProcAddress(DriverHandle, "CanExSetOptions"))) + error = -42; + else if (!(CanExSetAsByte = (TCanExSetAsByte)MhsGetProcAddress(DriverHandle, "CanExSetAsByte"))) + error = -43; + else if (!(CanExSetAsWord = (TCanExSetAsWord)MhsGetProcAddress(DriverHandle, "CanExSetAsWord"))) + error = -44; + else if (!(CanExSetAsLong = (TCanExSetAsLong)MhsGetProcAddress(DriverHandle, "CanExSetAsLong"))) + error = -45; + else if (!(CanExSetAsUByte = (TCanExSetAsUByte)MhsGetProcAddress(DriverHandle, "CanExSetAsUByte"))) + error = -46; + else if (!(CanExSetAsUWord = (TCanExSetAsUWord)MhsGetProcAddress(DriverHandle, "CanExSetAsUWord"))) + error = -47; + else if (!(CanExSetAsULong = (TCanExSetAsULong)MhsGetProcAddress(DriverHandle, "CanExSetAsULong"))) + error = -48; + else if (!(CanExSetAsString = (TCanExSetAsString)MhsGetProcAddress(DriverHandle, "CanExSetAsString"))) + error = -49; + else if (!(CanExGetAsByte = (TCanExGetAsByte)MhsGetProcAddress(DriverHandle, "CanExGetAsByte"))) + error = -50; + else if (!(CanExGetAsWord = (TCanExGetAsWord)MhsGetProcAddress(DriverHandle, "CanExGetAsWord"))) + error = -51; + else if (!(CanExGetAsLong = (TCanExGetAsLong)MhsGetProcAddress(DriverHandle, "CanExGetAsLong"))) + error = -52; + else if (!(CanExGetAsUByte = (TCanExGetAsUByte)MhsGetProcAddress(DriverHandle, "CanExGetAsUByte"))) + error = -53; + else if (!(CanExGetAsUWord = (TCanExGetAsUWord)MhsGetProcAddress(DriverHandle, "CanExGetAsUWord"))) + error = -54; + else if (!(CanExGetAsULong = (TCanExGetAsULong)MhsGetProcAddress(DriverHandle, "CanExGetAsULong"))) + error = -55; + else if (!(CanExGetAsString = (TCanExGetAsString)MhsGetProcAddress(DriverHandle, "CanExGetAsString"))) + error = -56; + else if (!(CanExGetAsStringCopy = (TCanExGetAsStringCopy)MhsGetProcAddress(DriverHandle, "CanExGetAsStringCopy"))) + error = -61; + else if (!(CanExSetEventAll = (TCanExSetEventAll)MhsGetProcAddress(DriverHandle, "CanExSetEventAll"))) + error = -62; +#ifdef STRICT_CAN_FD_SUPPORT + else if (!(CanFdTransmit = (TCanFdTransmit)MhsGetProcAddress(DriverHandle, "CanFdTransmit"))) + error = -63; + else if (!(CanFdReceive = (TCanFdReceive)MhsGetProcAddress(DriverHandle, "CanFdReceive"))) + error = -64; +#else + if (!(CanFdTransmit = (TCanFdTransmit)MhsGetProcAddress(DriverHandle, "CanFdTransmit"))) + CanFdTransmit = DefCanFdTransmit; + if (!(CanFdReceive = (TCanFdReceive)MhsGetProcAddress(DriverHandle, "CanFdReceive"))) + CanFdReceive = DefCanFdReceive; +#endif + // **** <*> neu +#ifdef STRICT_ECU_FLASH_SUPPORT + if (!(CanExSetAsData = (TCanExSetAsData)MhsGetProcAddress(DriverHandle, "CanExSetAsData"))) + error = -65; + if (!(CanExSetDataPtr = (TCanExSetDataPtr)MhsGetProcAddress(DriverHandle, "CanExSetDataPtr"))) + error = -66; + if (!(CanExSetDataBlockCB = (TCanExSetDataBlockCB)MhsGetProcAddress(DriverHandle, "CanExSetDataBlockCB"))) + error = -64; +#else + if (!(CanExSetAsData = (TCanExSetAsData)MhsGetProcAddress(DriverHandle, "CanExSetAsData"))) + CanExSetAsData = DefCanExSetAsData; + if (!(CanExSetDataPtr = (TCanExSetDataPtr)MhsGetProcAddress(DriverHandle, "CanExSetDataPtr"))) + CanExSetDataPtr = DefCanExSetDataPtr; + if (!(CanExSetDataBlockCB = (TCanExSetDataBlockCB)MhsGetProcAddress(DriverHandle, "CanExSetDataBlockCB"))) + CanExSetDataBlockCB = DefCanExSetDataBlockCB; +#endif + if (!(CanExGetInfoList = (TCanExGetInfoList)MhsGetProcAddress(DriverHandle, "CanExGetInfoList"))) + CanExGetInfoList = DefCanExGetInfoList; + if (!(CanExGetInfoListPerform = (TCanExGetInfoListPerform)MhsGetProcAddress(DriverHandle, "CanExGetInfoListPerform"))) + CanExGetInfoListPerform = DefCanExGetInfoListPerform; + if (!(CanExGetInfoListGet = (TCanExGetInfoListGet)MhsGetProcAddress(DriverHandle, "CanExGetInfoListGet"))) + CanExGetInfoListGet = DefCanExGetInfoListGet; + if (!(MhsCanGetApiHandle = (TMhsCanGetApiHandle)MhsGetProcAddress(DriverHandle, "MhsCanGetApiHandle"))) + MhsCanGetApiHandle = DefMhsCanGetApiHandle; +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu + if (!(CanExIoOpen = (TCanExIoOpen)MhsGetProcAddress(DriverHandle, "CanExIoOpen"))) + CanExIoOpen = DefCanExIoOpen; + if (!(CanExIoClose = (TCanExIoClose)MhsGetProcAddress(DriverHandle, "CanExIoClose"))) + CanExIoClose = DefCanExIoClose; + if (!(CanExIoWrite = (TCanExIoWrite)MhsGetProcAddress(DriverHandle, "CanExIoWrite"))) + CanExIoWrite = DefCanExIoWrite; + if (!(CanExIoRead = (TCanExIoRead)MhsGetProcAddress(DriverHandle, "CanExIoRead"))) + CanExIoRead = DefCanExIoRead; +#endif +#endif + } +else + error = -100; +if (error) + UnloadDriver(); +return(error); +} + + +/***************************************************************/ +/* Treiber DLL entladen */ +/***************************************************************/ +void UnloadDriver(void) +{ +#ifdef __WIN32__ +HINSTANCE driver_handle; +#else +void *driver_handle; +#endif + +driver_handle = DriverHandle; +DriverHandle = NULL; +#ifdef __WIN32__ +MhsSafeFree(DriverFileName); +#endif +if (driver_handle) + CanDownDriver(); +#ifdef CAN_API_TRUE_FUNC +PCanInitDriver = NULL; +PCanDownDriver = NULL; +PCanSetOptions = NULL; +PCanDeviceOpen = NULL; +PCanDeviceClose = NULL; +PCanSetMode = NULL; +PCanTransmit = NULL; +PCanTransmitClear = NULL; +PCanTransmitGetCount = NULL; +PCanTransmitSet = NULL; +PCanReceive = NULL; +PCanReceiveClear = NULL; +PCanReceiveGetCount = NULL; +PCanSetSpeed = NULL; +PCanSetSpeedUser = NULL; +PCanDrvInfo = NULL; +PCanDrvHwInfo = NULL; +PCanSetFilter = NULL; +PCanGetDeviceStatus = NULL; +PCanSetPnPEventCallback = NULL; +PCanSetStatusEventCallback = NULL; +PCanSetRxEventCallback = NULL; +PCanSetEvents = NULL; +PCanEventStatus = NULL; +// EX-Funktionen +PCanExGetDeviceCount = NULL; +PCanExGetDeviceList = NULL; +PCanExGetDeviceListPerform = NULL; +PCanExGetDeviceListGet = NULL; +PCanExGetDeviceInfo = NULL; +PCanExGetDeviceInfoPerform = NULL; +PCanExGetDeviceInfoGet = NULL; +PCanExDataFree = NULL; +PCanExCreateDevice = NULL; +PCanExDestroyDevice = NULL; +PCanExCreateFifo = NULL; +PCanExBindFifo = NULL; +PCanExCreateEvent = NULL; +PCanExSetObjEvent = NULL; +PCanExSetEvent = NULL; +PCanExSetEventAll = NULL; +PCanExResetEvent = NULL; +PCanExWaitForEvent = NULL; +PCanExInitDriver = NULL; +PCanExSetOptions = NULL; +PCanExSetAsByte = NULL; +PCanExSetAsWord = NULL; +PCanExSetAsLong = NULL; +PCanExSetAsUByte = NULL; +PCanExSetAsUWord = NULL; +PCanExSetAsULong = NULL; +PCanExSetAsString = NULL; +PCanExGetAsByte = NULL; +PCanExGetAsWord = NULL; +PCanExGetAsLong = NULL; +PCanExGetAsUByte = NULL; +PCanExGetAsUWord = NULL; +PCanExGetAsULong = NULL; +PCanExGetAsString = NULL; +PCanExGetAsStringCopy = NULL; +// **** CAN-FD +PCanFdTransmit = NULL; +PCanFdReceive = NULL; +// <*> neu +PCanExSetAsData = NULL; +PCanExSetDataPtr = NULL; +PCanExSetDataBlockCB = NULL; +PCanExGetInfoList = NULL; +PCanExGetInfoListPerform = NULL; +PCanExGetInfoListGet = NULL; +PMhsCanGetApiHandle = NULL; +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +PCanExIoOpen = NULL; +PCanExIoClose = NULL; +PCanExIoWrite = NULL; +PCanExIoRead = NULL; +#endif +#else +CanInitDriver = DefCanInitDriver; +CanDownDriver = DefCanDownDriver; +CanSetOptions = DefCanSetOptions; +CanDeviceOpen = DefCanDeviceOpen; +CanDeviceClose = DefCanDeviceClose; +CanSetMode = DefCanSetMode; +CanTransmit = DefCanTransmit; +CanTransmitClear = DefCanTransmitClear; +CanTransmitGetCount = DefCanTransmitGetCount; +CanTransmitSet = DefCanTransmitSet; +CanReceive = DefCanReceive; +CanReceiveClear = DefCanReceiveClear; +CanReceiveGetCount = DefCanReceiveGetCount; +CanSetSpeed = DefCanSetSpeed; +CanSetSpeedUser = DefCanSetSpeedUser; +CanDrvInfo = DefCanDrvInfo; +CanDrvHwInfo = DefCanDrvHwInfo; +CanSetFilter = DefCanSetFilter; +CanGetDeviceStatus = DefCanGetDeviceStatus; +CanSetPnPEventCallback = DefCanSetPnPEventCallback; +CanSetStatusEventCallback = DefCanSetStatusEventCallback; +CanSetRxEventCallback = DefCanSetRxEventCallback; +CanSetEvents = DefCanSetEvents; +CanEventStatus = DefCanEventStatus; +// EX-Funktionen +CanExGetDeviceCount = DefCanExGetDeviceCount; +CanExGetDeviceList = DefCanExGetDeviceList; +CanExGetDeviceListPerform = DefCanExGetDeviceListPerform; +CanExGetDeviceListGet = DefCanExGetDeviceListGet; +CanExGetDeviceInfo = DefCanExGetDeviceInfo; +CanExGetDeviceInfoPerform = DefCanExGetDeviceInfoPerform; +CanExGetDeviceInfoGet = DefCanExGetDeviceInfoGet; +CanExDataFree = DefCanExDataFree; +CanExCreateDevice = DefCanExCreateDevice; +CanExDestroyDevice = DefCanExDestroyDevice; +CanExCreateFifo = DefCanExCreateFifo; +CanExBindFifo = DefCanExBindFifo; +CanExCreateEvent = DefCanExCreateEvent; +CanExSetObjEvent = DefCanExSetObjEvent; +CanExSetEvent = DefCanExSetEvent; +CanExSetEventAll = DefCanExSetEventAll; +CanExResetEvent = DefCanExResetEvent; +CanExWaitForEvent = DefCanExWaitForEvent; +CanExInitDriver = DefCanExInitDriver; +CanExSetOptions = DefCanExSetOptions; +CanExSetAsByte = DefCanExSetAsByte; +CanExSetAsWord = DefCanExSetAsWord; +CanExSetAsLong = DefCanExSetAsLong; +CanExSetAsUByte = DefCanExSetAsUByte; +CanExSetAsUWord = DefCanExSetAsUWord; +CanExSetAsULong = DefCanExSetAsULong; +CanExSetAsString = DefCanExSetAsString; +CanExGetAsByte = DefCanExGetAsByte; +CanExGetAsWord = DefCanExGetAsWord; +CanExGetAsLong = DefCanExGetAsLong; +CanExGetAsUByte = DefCanExGetAsUByte; +CanExGetAsUWord = DefCanExGetAsUWord; +CanExGetAsULong = DefCanExGetAsULong; +CanExGetAsString = DefCanExGetAsString; +CanExGetAsStringCopy = DefCanExGetAsStringCopy; +CanFdTransmit = DefCanFdTransmit; +CanFdReceive = DefCanFdReceive; +// <*> neu +CanExSetAsData = DefCanExSetAsData; +CanExSetDataPtr = DefCanExSetDataPtr; +CanExSetDataBlockCB = DefCanExSetDataBlockCB; +CanExGetInfoList = DefCanExGetInfoList; +CanExGetInfoListPerform = DefCanExGetInfoListPerform; +CanExGetInfoListGet = DefCanExGetInfoListGet; +MhsCanGetApiHandle = DefMhsCanGetApiHandle; +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +CanExIoOpen = DefCanExIoOpen; +CanExIoClose = DefCanExIoClose; +CanExIoWrite = DefCanExIoWrite; +CanExIoRead = DefCanExIoRead; +#endif + +#endif +if (driver_handle) + { +#ifdef __WIN32__ + FreeLibrary(driver_handle); +#else + dlclose(driver_handle); +#endif + } +} + + +#ifdef CAN_API_TRUE_FUNC + +/***************************************************************/ +/* API Funktionen */ +/***************************************************************/ +int32_t CanInitDriver(char *options) +{ +if (PCanInitDriver) + return((PCanInitDriver)(options)); +else + return(ERR_NO_CAN_DRIVER_LOAD); +} + + +void CanDownDriver(void) +{ +#ifdef DRV_REF_LOCKING +uint32_t cnt, i; +#endif + +if (PCanDownDriver) + { + // **** Alle Events sperren + if (PCanSetEvents) // CanSetEvents(0); + (PCanSetEvents)(0); + if (PCanExSetEventAll) // CanExSetEventAll(MHS_TERMINATE); + (PCanExSetEventAll)(MHS_TERMINATE); +#ifdef DRV_REF_LOCKING + for (i = 5; i; i--) + { + cnt = 100; + while (TCanDrvRefCounter) + { + mhs_sleep(25); + if (!--cnt) + break; + } + mhs_sleep(1); + if (!TCanDrvRefCounter) + break; + } + TCanDrvRefCounter = 0; +#endif + (PCanDownDriver)(); + } +} + + +int32_t CanSetOptions(char *options) +{ +int32_t err; + +if ((DriverHandle) && (PCanSetOptions)) + { + CAN_DRV_REF(); + err = (PCanSetOptions)(options); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanDeviceOpen(uint32_t index, char *parameter) +{ +int32_t err; + +if ((DriverHandle) && (PCanDeviceOpen)) + { + CAN_DRV_REF(); + err = (PCanDeviceOpen)(index, parameter); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanDeviceClose(uint32_t index) +{ +int32_t err; + +if ((DriverHandle) && (PCanDeviceClose)) + { + CAN_DRV_REF(); + err = (PCanDeviceClose)(index); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanSetMode(uint32_t index, unsigned char can_op_mode, uint16_t can_command) +{ +int32_t err; + +if ((DriverHandle) && (PCanSetMode)) + { + CAN_DRV_REF(); + err = (PCanSetMode)(index, can_op_mode, can_command); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanTransmit(uint32_t index, struct TCanMsg *msg, int32_t count) +{ +int32_t err; + +if ((DriverHandle) && (PCanTransmit)) + { + CAN_DRV_REF(); + err = (PCanTransmit)(index, msg, count); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +void CanTransmitClear(uint32_t index) +{ +if ((DriverHandle) && (PCanTransmitClear)) + { + CAN_DRV_REF(); + (PCanTransmitClear)(index); + CAN_DRV_UNREF(); + } +} + + +uint32_t CanTransmitGetCount(uint32_t index) +{ +int32_t res; + +res = 0; +if ((DriverHandle) && (PCanTransmitGetCount)) + { + CAN_DRV_REF(); + res = (PCanTransmitGetCount)(index); + CAN_DRV_UNREF(); + } +return(res); +} + + +int32_t CanTransmitSet(uint32_t index, uint16_t cmd, uint32_t time) +{ +int32_t err; + +if ((DriverHandle) && (PCanTransmitSet)) + { + CAN_DRV_REF(); + err = (PCanTransmitSet)(index, cmd, time); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanReceive(uint32_t index, struct TCanMsg *msg, int32_t count) +{ +int32_t err; + +if ((DriverHandle) && (PCanReceive)) + { + CAN_DRV_REF(); + err = (PCanReceive)(index, msg, count); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +void CanReceiveClear(uint32_t index) +{ +if ((DriverHandle) && (PCanReceiveClear)) + { + CAN_DRV_REF(); + (PCanReceiveClear)(index); + CAN_DRV_UNREF(); + } +} + + +uint32_t CanReceiveGetCount(uint32_t index) +{ +uint32_t res; + +res = 0; +if ((DriverHandle) && (PCanReceiveGetCount)) + { + CAN_DRV_REF(); + res = (PCanReceiveGetCount)(index); + CAN_DRV_UNREF(); + } +return(res); +} + + +int32_t CanSetSpeed(uint32_t index, uint16_t speed) +{ +int32_t err; + +if ((DriverHandle) && (PCanSetSpeed)) + { + CAN_DRV_REF(); + err = (PCanSetSpeed)(index, speed); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanSetSpeedUser(uint32_t index, uint32_t value) +{ +int32_t err; + +if ((DriverHandle) && (PCanSetSpeedUser)) + { + CAN_DRV_REF(); + err = (PCanSetSpeedUser)(index, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +char *CanDrvInfo(void) +{ +char *res; + +res = NULL; +if ((DriverHandle) && (PCanDrvInfo)) + { + CAN_DRV_REF(); + res = (PCanDrvInfo)(); + CAN_DRV_UNREF(); + } +return(res); +} + + +char *CanDrvHwInfo(uint32_t index) +{ +char *res; + +res = NULL; +if ((DriverHandle) && (PCanDrvHwInfo)) + { + CAN_DRV_REF(); + res = (PCanDrvHwInfo)(index); + CAN_DRV_UNREF(); + } +return(res); +} + + +int32_t CanSetFilter(uint32_t index, struct TMsgFilter *msg_filter) +{ +int32_t err; + +if ((DriverHandle) && (PCanSetFilter)) + { + CAN_DRV_REF(); + err = (PCanSetFilter)(index, msg_filter); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanGetDeviceStatus(uint32_t index, struct TDeviceStatus *status) +{ +int32_t err; + +err = 0; +if ((DriverHandle) && (PCanGetDeviceStatus)) + { + CAN_DRV_REF(); + err = (PCanGetDeviceStatus)(index, status); + CAN_DRV_UNREF(); + } +else + { + if (status) + { + status->CanStatus = CAN_STATUS_UNBEKANNT; + status->FifoStatus = FIFO_STATUS_UNBEKANNT; + status->DrvStatus = DRV_NOT_LOAD; + } + } +return(err); +} + + +void CanSetPnPEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, int32_t status)) +{ +if ((DriverHandle) && (PCanSetPnPEventCallback)) + { + CAN_DRV_REF(); + (PCanSetPnPEventCallback)(event); + CAN_DRV_UNREF(); + } +} + + +void CanSetStatusEventCallback(void (DRV_CALLBACK_TYPE *event) + (uint32_t index, struct TDeviceStatus *device_status)) +{ +if ((DriverHandle) && (PCanSetStatusEventCallback)) + { + CAN_DRV_REF(); + (PCanSetStatusEventCallback)(event); + CAN_DRV_UNREF(); + } +} + + +void CanSetRxEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, + struct TCanMsg *msg, int32_t count)) +{ +if ((DriverHandle) && (PCanSetRxEventCallback)) + { + CAN_DRV_REF(); + (PCanSetRxEventCallback)(event); + CAN_DRV_UNREF(); + } +} + + +void CanSetEvents(uint16_t events) +{ +if ((DriverHandle) && (PCanSetEvents)) + { + CAN_DRV_REF(); + (PCanSetEvents)(events); + CAN_DRV_UNREF(); + } +} + + +uint32_t CanEventStatus(void) +{ +int32_t err; + +if ((DriverHandle) && (PCanEventStatus)) + { + CAN_DRV_REF(); + err = (PCanEventStatus)(); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +// EX-Funktionen +int32_t CanExGetDeviceCount(int32_t flags) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceCount)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceCount)(flags); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetDeviceList(struct TCanDevicesList **devices_list, int32_t flags) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceList)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceList)(devices_list, flags); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetDeviceListPerform(int32_t flags) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceListPerform)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceListPerform)(flags); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetDeviceListGet(struct TCanDevicesList *item) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceListGet)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceListGet)(item); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetDeviceInfo(uint32_t index, struct TCanDeviceInfo *device_info, + struct TCanInfoVar **hw_info, uint32_t *hw_info_size) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceInfo)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceInfo)(index, device_info, hw_info, hw_info_size); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetDeviceInfoPerform(uint32_t index, struct TCanDeviceInfo *device_info) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceInfoPerform)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceInfoPerform)(index, device_info); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetDeviceInfoGet(struct TCanInfoVar *item) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetDeviceInfoGet)) + { + CAN_DRV_REF(); + err = (PCanExGetDeviceInfoGet)(item); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +void CanExDataFree(void **data) +{ +if ((DriverHandle) && (PCanExDataFree)) + { + CAN_DRV_REF(); + (PCanExDataFree)(data); + CAN_DRV_UNREF(); + } +} + + +int32_t CanExCreateDevice(uint32_t *index, char *options) +{ +int32_t err; + +if ((DriverHandle) && (PCanExCreateDevice)) + { + CAN_DRV_REF(); + err = (PCanExCreateDevice)(index, options); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExDestroyDevice(uint32_t *index) +{ +int32_t err; + +if ((DriverHandle) && (PCanExDestroyDevice)) + { + CAN_DRV_REF(); + err = (PCanExDestroyDevice)(index); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExCreateFifo(uint32_t index, uint32_t size, TMhsEvent *event_obj, uint32_t event, uint32_t channels) +{ +int32_t err; + +if ((DriverHandle) && (PCanExCreateFifo)) + { + CAN_DRV_REF(); + err = (PCanExCreateFifo)(index, size, event_obj, event, channels); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExBindFifo(uint32_t fifo_index, uint32_t device_index, uint32_t bind) +{ +int32_t err; + +if ((DriverHandle) && (PCanExBindFifo)) + { + CAN_DRV_REF(); + err = (PCanExBindFifo)(fifo_index, device_index, bind); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +TMhsEvent *CanExCreateEvent(void) +{ +TMhsEvent *event; + +event = NULL; +if ((DriverHandle) && (PCanExCreateEvent)) + { + CAN_DRV_REF(); + event = (PCanExCreateEvent)(); + CAN_DRV_UNREF(); + } +return(event); +} + + +int32_t CanExSetObjEvent(uint32_t index, uint32_t source, TMhsEvent *event_obj, uint32_t event) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetObjEvent)) + { + CAN_DRV_REF(); + err = (PCanExSetObjEvent)(index, source, event_obj, event); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +void CanExSetEvent(TMhsEvent *event_obj, uint32_t event) +{ +if ((DriverHandle) && (PCanExSetEvent)) + { + CAN_DRV_REF(); + (PCanExSetEvent)(event_obj, event); + CAN_DRV_UNREF(); + } +} + + +void CanExSetEventAll(uint32_t event) +{ +if ((DriverHandle) && (PCanExSetEventAll)) + { + CAN_DRV_REF(); + (PCanExSetEventAll)(event); + CAN_DRV_UNREF(); + } +} + + +void CanExResetEvent(TMhsEvent *event_obj, uint32_t event) +{ +if ((DriverHandle) && (PCanExResetEvent)) + { + CAN_DRV_REF(); + (PCanExResetEvent)(event_obj, event); + CAN_DRV_UNREF(); + } +} + + +uint32_t CanExWaitForEvent(TMhsEvent *event_obj, uint32_t timeout) +{ +uint32_t res; + +res = MHS_TERMINATE; +if ((DriverHandle) && (PCanExWaitForEvent)) + { + CAN_DRV_REF(); + res = (PCanExWaitForEvent)(event_obj, timeout); + CAN_DRV_UNREF(); + } +return(res); +} + + +int32_t CanExInitDriver(char *options) +{ +if ((DriverHandle) && (PCanExInitDriver)) + return((PCanExInitDriver)(options)); +else + return(ERR_NO_CAN_DRIVER_LOAD); +} + + +int32_t CanExSetOptions(uint32_t index, char *options) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetOptions)) + { + CAN_DRV_REF(); + err = (PCanExSetOptions)(index, options); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsByte(uint32_t index, const char *name, char value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsByte)) + { + CAN_DRV_REF(); + err = (PCanExSetAsByte)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsWord(uint32_t index, const char *name, int16_t value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsWord)) + { + CAN_DRV_REF(); + err = (PCanExSetAsWord)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsLong(uint32_t index, const char *name, int32_t value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsLong)) + { + CAN_DRV_REF(); + err = (PCanExSetAsLong)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsUByte(uint32_t index, const char *name, unsigned char value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsUByte)) + { + CAN_DRV_REF(); + err = (PCanExSetAsUByte)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsUWord(uint32_t index, const char *name, uint16_t value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsUWord)) + { + CAN_DRV_REF(); + err = (PCanExSetAsUWord)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsULong(uint32_t index, const char *name, uint32_t value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsULong)) + { + CAN_DRV_REF(); + err = (PCanExSetAsULong)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetAsString(uint32_t index, const char *name, char *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsString)) + { + CAN_DRV_REF(); + err = (PCanExSetAsString)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsByte(uint32_t index, const char *name, char *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsByte)) + { + CAN_DRV_REF(); + err = (PCanExGetAsByte)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsWord(uint32_t index, const char *name, int16_t *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsWord)) + { + CAN_DRV_REF(); + err = (PCanExGetAsWord)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsLong(uint32_t index, const char *name, int32_t *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsLong)) + { + CAN_DRV_REF(); + err = (PCanExGetAsLong)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsUByte(uint32_t index, const char *name, unsigned char *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsUByte)) + { + CAN_DRV_REF(); + err = (PCanExGetAsUByte)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsUWord(uint32_t index, const char *name, uint16_t *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsUWord)) + { + CAN_DRV_REF(); + err = (PCanExGetAsUWord)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsULong(uint32_t index, const char *name, uint32_t *value) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsULong)) + { + CAN_DRV_REF(); + err = (PCanExGetAsULong)(index, name, value); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsString(uint32_t index, const char *name, char **str) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsString)) + { + CAN_DRV_REF(); + err = (PCanExGetAsString)(index, name, str); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetAsStringCopy(uint32_t index, const char *name, char *dest, uint32_t *dest_size) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetAsStringCopy)) + { + CAN_DRV_REF(); + err = (PCanExGetAsStringCopy)(index, name, dest, dest_size); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +// <*> neu +int32_t CanExSetAsData(uint32_t index, const char *name, void *data, uint32_t size) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetAsData)) + { + CAN_DRV_REF(); + err = (PCanExSetAsData)(index, name, data, size); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetDataPtr(uint32_t index, const char *name, void *data_ptr, uint32_t size) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetDataPtr)) + { + CAN_DRV_REF(); + err = (PCanExSetDataPtr)(index, name, data_ptr, size); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExSetDataBlockCB(uint32_t index, TCanGetDataBlockCB func, void *user_data) +{ +int32_t err; + +if ((DriverHandle) && (PCanExSetDataBlockCB)) + { + CAN_DRV_REF(); + err = (PCanExSetDataBlockCB)(index, func, user_data); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetInfoList(uint32_t dev_idx, const char *name, struct TCanInfoVarList **devices_info, int32_t flags) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetInfoList)) + { + CAN_DRV_REF(); + err = (PCanExGetInfoList)(dev_idx, name, devices_info, flags); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetInfoListPerform(uint32_t dev_idx, const char *name, int32_t flags) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetInfoListPerform)) + { + CAN_DRV_REF(); + err = (PCanExGetInfoListPerform)(dev_idx, name, flags); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExGetInfoListGet(uint32_t list_idx, struct TCanInfoVar *item) +{ +int32_t err; + +if ((DriverHandle) && (PCanExGetInfoListGet)) + { + CAN_DRV_REF(); + err = (PCanExGetInfoListGet)(list_idx, item); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t MhsCanGetApiHandle(void **api_handle) +{ +int32_t err; + +if ((DriverHandle) && (PMhsCanGetApiHandle)) + { + CAN_DRV_REF(); + err = (PMhsCanGetApiHandle)(api_handle); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +// **** CAN-FD +int32_t CanFdTransmit(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count) +{ +int32_t err; + +if (!DriverHandle) + err = ERR_NO_CAN_DRIVER_LOAD; +else if (PCanFdTransmit) + { + CAN_DRV_REF(); + err = (PCanFdTransmit)(index, fd_msg, count); + CAN_DRV_UNREF(); + } +else +#ifdef STRICT_CAN_FD_SUPPORT + err = ERR_NO_CAN_DRIVER_LOAD; +#else + err = -1; // <*> +#endif +return(err); +} + + +int32_t CanFdReceive(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count) +{ +int32_t err; + +if (!DriverHandle) + err = ERR_NO_CAN_DRIVER_LOAD; +else if (PCanFdReceive) + { + CAN_DRV_REF(); + err = (PCanFdReceive)(index, fd_msg, count); + CAN_DRV_UNREF(); + } +else +#ifdef STRICT_CAN_FD_SUPPORT + err = ERR_NO_CAN_DRIVER_LOAD; +#else + err = -1; // <*> +#endif +return(err); +} + + +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +int32_t CanExIoOpen(uint32_t index, const char *name, uint32_t *io_id) +{ +int32_t err; + +if ((DriverHandle) && (PCanExIoOpen)) + { + CAN_DRV_REF(); + err = (PCanExIoOpen)(index, name, io_id); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExIoClose(uint32_t io_id) +{ +int32_t err; + +if ((DriverHandle) && (PCanExIoClose)) + { + CAN_DRV_REF(); + err = (PCanExIoClose)(io_id); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExIoWrite(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout) +{ +int32_t err; + +if ((DriverHandle) && (PCanExIoWrite)) + { + CAN_DRV_REF(); + err = (PCanExIoWrite)(io_id, data, size, timeout); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + + +int32_t CanExIoRead(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout) +{ +int32_t err; + +if ((DriverHandle) && (PCanExIoRead)) + { + CAN_DRV_REF(); + err = (PCanExIoRead)(io_id, data, size, timeout); + CAN_DRV_UNREF(); + } +else + err = ERR_NO_CAN_DRIVER_LOAD; +return(err); +} + +#endif + +#else + +/***************************************************************/ +/* Default Call */ +/***************************************************************/ +void DefDriverProcedure(int32_t func) +{ +(void)func; +} + + +/***************************************************************/ +/* Default Funktionen */ +/***************************************************************/ +int32_t DRV_CALLBACK_TYPE DefCanInitDriver(char *options) +{ +(void)options; + +DefDriverProcedure(1); +return(0); +} + + +void DRV_CALLBACK_TYPE DefCanDownDriver(void) +{ +// DefDriverProcedure(1); +} + + +int32_t DRV_CALLBACK_TYPE DefCanSetOptions(char *options) +{ +(void)options; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanDeviceOpen(uint32_t index, char *parameter) +{ +(void)index; +(void)parameter; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanDeviceClose(uint32_t index) +{ +(void)index; + +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanSetMode(uint32_t index, unsigned char can_op_mode, uint16_t can_command) +{ +(void)index; +(void)can_op_mode; +(void)can_command; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanSet(uint32_t index, uint16_t obj_index, uint16_t obj_sub_index, void *data, int32_t size) +{ +(void)index; +(void)obj_index; +(void)obj_sub_index; +(void)data; +(void)size; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanGet(uint32_t index, uint16_t obj_index, uint16_t obj_sub_index, void *data, int32_t size) +{ +(void)index; +(void)obj_index; +(void)obj_sub_index; +(void)data; +(void)size; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanTransmit(uint32_t index, struct TCanMsg *msg, int32_t count) +{ +(void)index; +(void)msg; +(void)count; + +DefDriverProcedure(1); +return(0); +} + + +void DRV_CALLBACK_TYPE DefCanTransmitClear(uint32_t index) +{ +(void)index; + +DefDriverProcedure(1); +} + + +uint32_t DRV_CALLBACK_TYPE DefCanTransmitGetCount(uint32_t index) +{ +(void)index; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanTransmitSet(uint32_t index, uint16_t cmd, uint32_t time) +{ +(void)index; +(void)cmd; +(void)time; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanReceive(uint32_t index, struct TCanMsg *msg, int32_t count) +{ +(void)index; +(void)msg; +(void)count; + +DefDriverProcedure(1); +return(0); +} + + +void DRV_CALLBACK_TYPE DefCanReceiveClear(uint32_t index) +{ +(void)index; + +DefDriverProcedure(1); +} + + +uint32_t DRV_CALLBACK_TYPE DefCanReceiveGetCount(uint32_t index) +{ +(void)index; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanSetSpeed(uint32_t index, uint16_t speed) +{ +(void)index; +(void)speed; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanSetSpeedUser(uint32_t index, uint32_t value) +{ +(void)index; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +char * DRV_CALLBACK_TYPE DefCanDrvInfo(void) +{ +DefDriverProcedure(1); +return(NULL); +} + + +char * DRV_CALLBACK_TYPE DefCanDrvHwInfo(uint32_t index) +{ +(void)index; + +DefDriverProcedure(1); +return(NULL); +} + + +int32_t DRV_CALLBACK_TYPE DefCanSetFilter(uint32_t index, struct TMsgFilter *msg_filter) +{ +(void)index; +(void)msg_filter; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanGetDeviceStatus(uint32_t index, struct TDeviceStatus *status) +{ +(void)index; +(void)status; + +status->CanStatus = CAN_STATUS_UNBEKANNT; +status->FifoStatus = FIFO_STATUS_UNBEKANNT; +status->DrvStatus = DRV_NOT_LOAD; +return(0); +} + + +void DRV_CALLBACK_TYPE DefCanSetPnPEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, int32_t status)) +{ +(void)event; + +DefDriverProcedure(1); +} + + +void DRV_CALLBACK_TYPE DefCanSetStatusEventCallback(void (DRV_CALLBACK_TYPE *event) + (uint32_t index, struct TDeviceStatus *device_status)) +{ +(void)event; + +DefDriverProcedure(1); +} + + +void DRV_CALLBACK_TYPE DefCanSetRxEventCallback(void (DRV_CALLBACK_TYPE *event)(uint32_t index, + struct TCanMsg *msg, int32_t count)) +{ +(void)event; + +DefDriverProcedure(1); +} + + +void DRV_CALLBACK_TYPE DefCanSetEvents(uint16_t events) +{ +(void)events; + +DefDriverProcedure(1); +} + + +uint32_t DRV_CALLBACK_TYPE DefCanEventStatus(void) +{ +DefDriverProcedure(1); +return(1); +} + + +// EX-Funktionen +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceCount(int32_t flags) +{ +(void)flags; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceList(struct TCanDevicesList **devices_list, int32_t flags) +{ +(void)devices_list; +(void)flags; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceListPerform(int32_t flags) +{ +(void)flags; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceListGet(struct TCanDevicesList *item) +{ +(void)item; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceInfo(uint32_t index, struct TCanDeviceInfo *device_info, + struct TCanInfoVar **hw_info, uint32_t *hw_info_size) +{ +(void)index; +(void)device_info; +(void)hw_info; +(void)hw_info_size; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceInfoPerform(uint32_t index, struct TCanDeviceInfo *device_info) +{ +(void)index; +(void)device_info; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetDeviceInfoGet(struct TCanInfoVar *item) +{ +(void)item; + +DefDriverProcedure(1); +return(0); +} + + +void DRV_CALLBACK_TYPE DefCanExDataFree(void **data) +{ +(void)data; + +DefDriverProcedure(1); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExCreateDevice(uint32_t *index, char *options) +{ +(void)index; +(void)options; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExDestroyDevice(uint32_t *index) +{ +(void)index; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExCreateFifo(uint32_t index, uint32_t size, TMhsEvent *event_obj, uint32_t event, uint32_t channels) +{ +(void)index; +(void)size; +(void)event_obj; +(void)event; +(void)channels; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExBindFifo(uint32_t fifo_index, uint32_t device_index, uint32_t bind) +{ +(void)fifo_index; +(void)device_index; +(void)bind; + +DefDriverProcedure(1); +return(0); +} + + +TMhsEvent * DRV_CALLBACK_TYPE DefCanExCreateEvent(void) +{ +DefDriverProcedure(1); +return(NULL); +} + + +int32_t DRV_DRV_CALLBACK_TYPE_TYPE DefCanExSetObjEvent(uint32_t index, uint32_t source, TMhsEvent *event_obj, uint32_t event) +{ +(void)index; +(void)source; +(void)event_obj; +(void)event; + +DefDriverProcedure(1); +return(0); +} + + +void DRV_CALLBACK_TYPE DefCanExSetEvent(TMhsEvent *event_obj, uint32_t event) +{ +(void)event_obj; +(void)event; + +DefDriverProcedure(1); +} + + +void DRV_CALLBACK_TYPE DefCanExSetEventAll(uint32_t event) +{ +(void)event; + +DefDriverProcedure(1); +} + + +void DRV_CALLBACK_TYPE DefCanExResetEvent(TMhsEvent *event_obj, uint32_t event) +{ +(void)event_obj; +(void)event; + +DefDriverProcedure(1); +} + + +uint32_t DRV_CALLBACK_TYPE DefCanExWaitForEvent(TMhsEvent *event_obj, uint32_t timeout) +{ +(void)event_obj; +(void)timeout; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExInitDriver(char *options) +{ +(void)options; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetOptions(uint32_t index, char *options) +{ +(void)index; +(void)options; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsByte(uint32_t index, char *name, char value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsWord(uint32_t index, char *name, int16_t value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsLong(uint32_t index, char *name, int32_t value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsUByte(uint32_t index, char *name, unsigned char value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsUWord(uint32_t index, char *name, uint16_t value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsULong(uint32_t index, char *name, uint32_t value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExSetAsString(uint32_t index, char *name, char *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsByte(uint32_t index, char *name, char *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsWord(uint32_t index, char *name, int16_t *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsLong(uint32_t index, char *name, int32_t *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsUByte(uint32_t index, char *name, unsigned char *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsUWord(uint32_t index, char *name, uint16_t *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsULong(uint32_t index, char *name, uint32_t *value) +{ +(void)index; +(void)name; +(void)value; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsString(uint32_t index, char *name, char **str) +{ +(void)index; +(void)name; +(void)str; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DRV_CALLBACK_TYPE DefCanExGetAsStringCopy(uint32_t index, char *name, char *dest, uint32_t *dest_size) +{ +(void)index; +(void)name; +(void)dest; +(void)dest_size; + +DefDriverProcedure(1); +return(0); +} + + +// **** CAN-FD +int32_t DefCanFdTransmit(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count) +{ +(void)index; +(void)fd_msg; +(void)count; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanFdReceive(uint32_t index, struct TCanFdMsg *fd_msg, int32_t count) +{ +(void)index; +(void)fd_msg; +(void)count; + +DefDriverProcedure(1); +return(0); +} + + +// **** <*> neu +int32_t DefCanExSetAsData(uint32_t index, char *name, void *data, uint32_t size); +{ +(void)index; +(void)name; +(void)data; +(void)size; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExSetDataPtr(uint32_t index, char *name, void *data_ptr, uint32_t size); +{ +(void)index; +(void)name; +(void)data_ptr; +(void)size; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExSetDataBlockCB(uint32_t index, TCanGetDataBlockCB func, void *user_data) +{ +(void)index; +(void)func; +(void)user_data; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExGetInfoList(uint32_t dev_idx, const char *name, struct TCanInfoVarLists *devices_info, int32_t flags) +{ +(void)dev_idx; +(void)name; +(void)devices_info; +(void)flags; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExGetInfoListPerform(uint32_t dev_idx, const char *name, int32_t flags) +{ +(void)dev_idx; +(void)name; +(void)flags; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExGetInfoListGet(uint32_t list_idx, struct TCanInfoVar *item) +{ +(void)list_idx; +(void)item; + +DefDriverProcedure(1); +return(0); +} + +int32_t DefMhsCanGetApiHandle(void **api_handle) +{ +(void)api_handle; + +DefDriverProcedure(1); +return(0); +} + +#ifdef ENABLE_EX_IO_SUPPORT // <*> neu +int32_t DefCanExIoOpen(uint32_t index, const char *name, uint32_t *io_id) +{ + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExIoClose(uint32_t io_id) +{ +(void)io_id; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExIoWrite(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout) +{ +(void)io_id; +(void)data; +(void)size; +(void)timeout; + +DefDriverProcedure(1); +return(0); +} + + +int32_t DefCanExIoRead(uint32_t io_id, void *data, uint32_t *size, uint32_t timeout) +{ +(void)io_id; +(void)data; +(void)size; +(void)timeout; + +DefDriverProcedure(1); +return(0); +} + +#endif + +#endif + + + +/***************************************************************/ +/* API Treiber Path ermitteln */ +/***************************************************************/ +#ifndef __WIN32__ // Linux + #define MAX_PATH_LEN 255 + + #define DIR_SEPARATOR '/' + #define DIR_SEPARATOR_STR "/" + +/**************************************************************************/ +/* C O N S T A N T E N - Linux */ +/**************************************************************************/ +static const char API_DRIVER_DLL[] = {"libmhstcan.so"}; + +static const char API_PATH_CFG_FILE[] = {"/etc/tiny_can/api.path"}; + +#define HAVE_API_DRV_DEFAULT_PATH +static const char API_DRV_DEFAULT_PATH[] = {"/opt/tiny_can/can_api"}; + +#ifdef __LP64__ +static const char API_DRIVER_X64_DIR[] = {"x64"}; +#else +static const char API_DRIVER_X32_DIR[] = {"x32"}; +#endif + +#else + #define MAX_PATH_LEN 255 + + #define DIR_SEPARATOR '\\' + #define DIR_SEPARATOR_STR "\\" + +/**************************************************************************/ +/* C O N S T A N T E N - Windows */ +/**************************************************************************/ +#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 API_DRIVER_DLL[] = {"mhstcan.dll"}; +#ifdef _WIN64 +static const char API_DRIVER_X64_DIR[] = {"x64"}; +#endif +//typedef char *(*TCanDrvInfoCB)(void); +#endif + +/**************************************************************************/ +/* F U N K T I O N E N */ +/**************************************************************************/ +#if defined(__WIN32__) || defined(LINUX_HAVE_GET_API_DRIVER_PATH) + +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 int32_t TestApi(const char *file_name) +{ +#ifdef __WIN32__ +HINSTANCE driver_handle; +#else +void *driver_handle; +#endif +TCanDrvInfo drv_info_cb; + +drv_info_cb = NULL; +#ifdef __WIN32__ +driver_handle = LoadLibraryA(file_name); +#else +driver_handle = dlopen(file_name, RTLD_LAZY); +#endif +if (driver_handle) + { + drv_info_cb = (TCanDrvInfo)MhsGetProcAddress(driver_handle, "CanDrvInfo"); +#ifdef __WIN32__ + FreeLibrary(driver_handle); +#else + dlclose(driver_handle); +#endif + } +#if defined(MHS_DRV_DEBUG_OUTPUT) && (!defined(__WIN32__)) +else + printf("Error load: %s\n\r, ", dlerror()); +#endif +if (drv_info_cb) + return(0); +else + return(-1); +} + + +#endif +#ifdef __WIN32__ + +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); +} + +/* <*> raus +static int32_t TestApi(const char *file_name) +{ +HINSTANCE driver_dll; +TCanDrvInfo drv_info_cb; + +drv_info_cb = NULL; +driver_dll = LoadLibraryA(file_name); +if (driver_dll) + { + drv_info_cb = (TCanDrvInfo)(void *)GetProcAddress(driver_dll, (LPCSTR)"CanDrvInfo"); + FreeLibrary(driver_dll); + } +if (drv_info_cb) + return(0); +else + return(-1); +} */ + + +static char *GetApiDriverWithPath(const char *driver_file) +{ +char *path, *file_name; +char app_file[MAX_PATH_LEN]; +char app_path[MAX_PATH_LEN]; +char *ptr; + +file_name = NULL; +if ((!driver_file ) || (!strlen(driver_file))) + driver_file = API_DRIVER_DLL; +if (strchr(driver_file, DIR_SEPARATOR)) + return(MhsStrDup(driver_file)); +if ((path = MhsRegReadStringEntry(REG_TINY_CAN_API, REG_TINY_CAN_API_PATH_ENTRY))) + { +#ifdef _WIN64 + file_name = MhsCreateFileName(path, API_DRIVER_X64_DIR, driver_file); +#else + file_name = MhsCreateFileName(path, NULL, driver_file); +#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, driver_file); + if (TestApi(file_name)) + MhsSafeFree(file_name); + } +return(file_name); +} + +#else + #ifdef LINUX_HAVE_GET_API_DRIVER_PATH + + +static char *GetAppPath(void) +{ +char buf[MAX_PATH_LEN]; +char *path, *ptr; +int fd; +size_t n; + +path = NULL; +SafeSprintf(buf, (MAX_PATH_LEN - 1), "/proc/%d/cmdline", getpid()); +fd = open(buf, O_RDONLY); +if (fd > -1) + { + if ((n = read(fd, buf, 200)) > 0) + { + buf[n] = '\0'; + path = (char *)malloc(PATH_MAX); + if (!realpath(buf, path)) + MhsSafeFree(path); + else + { + ptr = strrchr(path, DIR_SEPARATOR); + if (ptr) + *ptr = '\0'; + else + MhsSafeFree(path); + } + } + close(fd); + } +return(path); +} + + +static char *ReadPathFromCfgFile(void) +{ +char buf[MAX_PATH_LEN]; +char *path; +int fd; +size_t n; + +path = NULL; +fd = open(API_PATH_CFG_FILE, O_RDONLY); +if (fd > -1) + { + if ((n = read(fd, buf, 200)) > 0) + { + buf[n] = '\0'; + path = MhsStrDup(buf); + } + close(fd); + } +return(path); +} + + +static char *GetApiDriverWithPath(const char *driver_file) +{ +char *path, *file_name; + +file_name = NULL; +if ((!driver_file ) || (!strlen(driver_file))) + driver_file = API_DRIVER_DLL; +if (strchr(driver_file, DIR_SEPARATOR)) + return(MhsStrDup(driver_file)); +// **** 1. Pfad vom Konfig File +if ((path = ReadPathFromCfgFile())) + { +#ifdef MHS_DRV_DEBUG_OUTPUT + printf("driver path from config file: %s\n\r", path); +#endif +#ifdef __LP64__ + file_name = MhsCreateFileName(path, API_DRIVER_X64_DIR, driver_file); +#else + file_name = MhsCreateFileName(path, API_DRIVER_X32_DIR, driver_file); +#endif +#ifdef MHS_DRV_DEBUG_OUTPUT + printf("1. API driver with full path: %s\n\r", file_name); +#endif + if (TestApi(file_name)) + { + MhsSafeFree(file_name); + file_name = MhsCreateFileName(path, NULL, driver_file); + if (TestApi(file_name)) + MhsSafeFree(file_name); + } + free(path); + } +#ifdef HAVE_API_DRV_DEFAULT_PATH +// **** 2. Default API Pfad +if (!file_name) + { +#ifdef __LP64__ + file_name = MhsCreateFileName(API_DRV_DEFAULT_PATH, API_DRIVER_X64_DIR, driver_file); +#else + file_name = MhsCreateFileName(API_DRV_DEFAULT_PATH, API_DRIVER_X32_DIR, driver_file); +#endif +#ifdef MHS_DRV_DEBUG_OUTPUT + printf("2. API driver with full path: %s\n\r", file_name); +#endif + if (TestApi(file_name)) + MhsSafeFree(file_name); + } +if (!file_name) + { + file_name = MhsCreateFileName(API_DRV_DEFAULT_PATH, NULL, driver_file); + if (TestApi(file_name)) + MhsSafeFree(file_name); + } +#endif +// **** 3. Pfad gleich APP Pfad +if (!file_name) + { + if ((path = GetAppPath())) + { +#ifdef MHS_DRV_DEBUG_OUTPUT + printf("application path: %s\n\r", path); +#endif + file_name = MhsCreateFileName(path, NULL, driver_file); +#ifdef MHS_DRV_DEBUG_OUTPUT + printf("3. API driver with full path: %s\n\r", file_name); +#endif + if (TestApi(file_name)) + MhsSafeFree(file_name); + free(path); + } + } +if (!file_name) + file_name = MhsStrDup(driver_file); +return(file_name); +} + + #endif +#endif + + + diff --git a/lib/mhscanutil.c b/lib/mhscanutil.c new file mode 100644 index 0000000..2e93a14 --- /dev/null +++ b/lib/mhscanutil.c @@ -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 + #include + #include + #include +#else + #include + #include + #include + #include +#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 diff --git a/lib/mhscanutil.h b/lib/mhscanutil.h new file mode 100644 index 0000000..41ed923 --- /dev/null +++ b/lib/mhscanutil.h @@ -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 + + diff --git a/main.cpp b/main.cpp index ad07c10..e101082 100644 --- a/main.cpp +++ b/main.cpp @@ -97,7 +97,7 @@ int main(int argc, char *argv[]) QApplication app(argc, argv); - setApplicationStyleSheet( ":/BionxControl.qss"_L1 ); + //setApplicationStyleSheet( ":/BionxControl.qss"_L1 ); QMetaEnum metaEnum = QMetaEnum::fromType(); @@ -115,9 +115,6 @@ int main(int argc, char *argv[]) qDebug() << " schön: " << xxx << " -- " << uint8_t(xxx) << " : " << yyy; qDebug() << " nice: " << metaEnum.enumName() << " : " <className(); - //BCValueManager myMgr; - //myMgr.loadXml(); - BCMainWindow w; w.show();