From a93f4b3cbe55041fbf3295b9607615c59f5892fe Mon Sep 17 00:00:00 2001 From: Klaus Demlehner Date: Tue, 14 Apr 2026 22:49:24 +0200 Subject: [PATCH 01/13] Update .gitignore to include bin and obj directories --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 4abb374..df049d9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ .vs -deps* +bin +obj out build tmp From ba77da98fd5d5cab80fab7f630145b7998c325ad Mon Sep 17 00:00:00 2001 From: Klaus Demlehner Date: Tue, 14 Apr 2026 23:01:40 +0200 Subject: [PATCH 02/13] Add Tiny-CAN and CodeBlocks support --- include/CANvenient.h | 8 +++++ src/CANvenient.c | 19 +++++++++++ src/drivers/CANvenient_Ixxat.c | 46 ++++++++++++++++++++----- src/drivers/CANvenient_Ixxat.h | 24 ++++++++----- src/drivers/CANvenient_Kvaser.c | 43 ++++++++++++++++++----- src/drivers/CANvenient_Kvaser.h | 26 +++++++++----- src/drivers/CANvenient_PEAK.c | 55 ++++++++++++++++++++++-------- src/drivers/CANvenient_PEAK.h | 26 +++++++++----- src/drivers/CANvenient_SocketCAN.h | 24 ++++++++----- src/drivers/CANvenient_Softing.c | 46 ++++++++++++++++++++----- src/drivers/CANvenient_Softing.h | 26 +++++++++----- src/drivers/CANvenient_internal.h | 27 ++++++++++++--- src/drivers/CANvenient_template.h | 26 +++++++++----- 13 files changed, 298 insertions(+), 98 deletions(-) mode change 100644 => 100755 include/CANvenient.h mode change 100644 => 100755 src/CANvenient.c mode change 100644 => 100755 src/drivers/CANvenient_Ixxat.c mode change 100644 => 100755 src/drivers/CANvenient_Ixxat.h mode change 100644 => 100755 src/drivers/CANvenient_Kvaser.c mode change 100644 => 100755 src/drivers/CANvenient_Kvaser.h mode change 100644 => 100755 src/drivers/CANvenient_PEAK.c mode change 100644 => 100755 src/drivers/CANvenient_PEAK.h mode change 100644 => 100755 src/drivers/CANvenient_SocketCAN.h mode change 100644 => 100755 src/drivers/CANvenient_Softing.c mode change 100644 => 100755 src/drivers/CANvenient_Softing.h mode change 100644 => 100755 src/drivers/CANvenient_internal.h mode change 100644 => 100755 src/drivers/CANvenient_template.h diff --git a/include/CANvenient.h b/include/CANvenient.h old mode 100644 new mode 100755 index ab5515e..8040a4c --- a/include/CANvenient.h +++ b/include/CANvenient.h @@ -13,6 +13,10 @@ #include +#ifdef __cplusplus + extern "C" { +#endif + #define CAN_MAX_INTERFACES 64 #ifdef _WIN32 @@ -111,4 +115,8 @@ CANVENIENT_API int can_set_baudrate(int index, enum can_baudrate baud); CANVENIENT_API int can_send(int index, struct can_frame* frame); CANVENIENT_API int can_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif + #endif /* CANVENIENT_H */ diff --git a/src/CANvenient.c b/src/CANvenient.c old mode 100644 new mode 100755 index 564853e..aa43f6b --- a/src/CANvenient.c +++ b/src/CANvenient.c @@ -18,6 +18,7 @@ #include "drivers/CANvenient_SocketCAN.h" #include "drivers/CANvenient_Softing.h" #include "drivers/CANvenient_PEAK.h" +#include "drivers/CANvenient_TinyCan.h" struct can_iface can_interface[CAN_MAX_INTERFACES] = {0}; char can_error_reason[1024] = {0}; @@ -50,6 +51,11 @@ CANVENIENT_API int can_find_interfaces(void) return status; } + status = tinycan_find_interfaces(); + if (status < 0) + { + return status; + } return softing_find_interfaces(); } @@ -83,6 +89,8 @@ CANVENIENT_API int can_open(int index, enum can_baudrate baud) return socketcan_open(index); case CAN_VENDOR_SOFTING: return softing_open(index); + case CAN_VENDOR_MHS: + return tinycan_open(index); default: case CAN_VENDOR_NONE: set_error_reason("No CAN interface found at specified index."); @@ -116,6 +124,9 @@ CANVENIENT_API void can_close(int index) case CAN_VENDOR_SOFTING: softing_close(index); break; + case CAN_VENDOR_MHS: + tinycan_close(index); + break; default: case CAN_VENDOR_NONE: break; @@ -167,6 +178,8 @@ CANVENIENT_API int can_update(int index) break; case CAN_VENDOR_SOFTING: return softing_update(index); + case CAN_VENDOR_MHS: + return tinycan_update(index); default: case CAN_VENDOR_NONE: set_error_reason("No CAN interface found at specified index."); @@ -256,6 +269,8 @@ CANVENIENT_API int can_set_baudrate(int index, enum can_baudrate baud) return socketcan_set_baudrate(index, baud); case CAN_VENDOR_SOFTING: return softing_set_baudrate(index, baud); + case CAN_VENDOR_MHS: + return tinycan_set_baudrate(index, baud); default: case CAN_VENDOR_NONE: set_error_reason("No CAN interface found at specified index."); @@ -283,6 +298,8 @@ CANVENIENT_API int can_send(int index, struct can_frame* frame) return socketcan_send(index, frame); case CAN_VENDOR_SOFTING: return softing_send(index, frame); + case CAN_VENDOR_MHS: + return tinycan_send(index, frame); default: case CAN_VENDOR_NONE: set_error_reason("No CAN interface found at specified index."); @@ -310,6 +327,8 @@ CANVENIENT_API int can_recv(int index, struct can_frame* frame, u64* timestamp) return socketcan_recv(index, frame, timestamp); case CAN_VENDOR_SOFTING: return softing_recv(index, frame, timestamp); + case CAN_VENDOR_MHS: + return tinycan_recv(index, frame, timestamp); default: case CAN_VENDOR_NONE: set_error_reason("No CAN interface found at specified index."); diff --git a/src/drivers/CANvenient_Ixxat.c b/src/drivers/CANvenient_Ixxat.c old mode 100644 new mode 100755 index 895c81e..be381a4 --- a/src/drivers/CANvenient_Ixxat.c +++ b/src/drivers/CANvenient_Ixxat.c @@ -15,7 +15,11 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef _WIN32 +#ifdef VENIENT_IXXAT_DRV_DISABLED + #pragma message("!!!!!! WARNING: Ixxat driver is disabled. !!!!!!") +#endif + +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) #include #include #include @@ -36,7 +40,7 @@ static void ixxat_baudrate_to_btr(enum can_baudrate baud, u8* bt0, u8* bt1); int ixxat_find_interfaces(void) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) IVciDeviceManager* pDevMan = NULL; IVciEnumDevice* pEnum = NULL; @@ -145,7 +149,7 @@ int ixxat_find_interfaces(void) int ixxat_open(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) ixxat_ctx_t* ctx; IVciDeviceManager* pDevMan = NULL; @@ -241,7 +245,11 @@ int ixxat_open(int index) return 0; #else + #ifdef VENIENT_IXXAT_DRV_DISABLED + set_error_reason("Ixxat driver is disabled."); + #else set_error_reason("Ixxat driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -249,7 +257,7 @@ int ixxat_open(int index) void ixxat_close(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; if (ctx) @@ -273,14 +281,18 @@ void ixxat_close(int index) } #else + #ifdef VENIENT_IXXAT_DRV_DISABLED + set_error_reason("Ixxat driver is disabled."); + #else set_error_reason("Ixxat driver is only supported on Windows."); + #endif (void)index; #endif } int ixxat_update(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) ixxat_ctx_t* ctx; IVciDeviceManager* pDevMan = NULL; @@ -312,7 +324,11 @@ int ixxat_update(int index) return 0; #else + #ifdef VENIENT_IXXAT_DRV_DISABLED + set_error_reason("Ixxat driver is disabled."); + #else set_error_reason("Ixxat driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -320,7 +336,7 @@ int ixxat_update(int index) int ixxat_set_baudrate(int index, enum can_baudrate baud) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; IVciDeviceManager* pDevMan = NULL; @@ -462,7 +478,11 @@ int ixxat_set_baudrate(int index, enum can_baudrate baud) return 0; #else + #ifdef VENIENT_IXXAT_DRV_DISABLED + set_error_reason("Ixxat driver is disabled."); + #else set_error_reason("Ixxat driver is only supported on Windows."); + #endif (void)index; (void)baud; return -1; @@ -471,7 +491,7 @@ int ixxat_set_baudrate(int index, enum can_baudrate baud) int ixxat_send(int index, struct can_frame* frame) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; CANMSG msg = {0}; @@ -503,7 +523,11 @@ int ixxat_send(int index, struct can_frame* frame) return 0; #else + #ifdef VENIENT_IXXAT_DRV_DISABLED + set_error_reason("Ixxat driver is disabled."); + #else set_error_reason("Ixxat driver is only supported on Windows."); + #endif (void)index; (void)frame; return -1; @@ -512,7 +536,7 @@ int ixxat_send(int index, struct can_frame* frame) int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; CANMSG msg = {0}; @@ -550,7 +574,11 @@ int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) return 0; #else + #ifdef VENIENT_IXXAT_DRV_DISABLED + set_error_reason("Ixxat driver is disabled."); + #else set_error_reason("Ixxat driver is only supported on Windows."); + #endif (void)index; (void)frame; (void)timestamp; @@ -558,7 +586,7 @@ int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) #endif } -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) static void ixxat_baudrate_to_btr(enum can_baudrate baud, u8* bt0, u8* bt1) { switch (baud) diff --git a/src/drivers/CANvenient_Ixxat.h b/src/drivers/CANvenient_Ixxat.h old mode 100644 new mode 100755 index 6f618c6..2b865a0 --- a/src/drivers/CANvenient_Ixxat.h +++ b/src/drivers/CANvenient_Ixxat.h @@ -7,16 +7,24 @@ * SPDX-License-Identifier: MIT * **/ - +#include "global.h" #include "CANvenient.h" -int ixxat_find_interfaces(void); +#ifdef __cplusplus + extern "C" { +#endif + +int ixxat_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int ixxat_open(int index) ATTRIBUTE_INTERNAL; +void ixxat_close(int index) ATTRIBUTE_INTERNAL; +int ixxat_update(int index) ATTRIBUTE_INTERNAL; -int ixxat_open(int index); -void ixxat_close(int index); -int ixxat_update(int index); +int ixxat_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; -int ixxat_set_baudrate(int index, enum can_baudrate baud); +int ixxat_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; -int ixxat_send(int index, struct can_frame* frame); -int ixxat_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif \ No newline at end of file diff --git a/src/drivers/CANvenient_Kvaser.c b/src/drivers/CANvenient_Kvaser.c old mode 100644 new mode 100755 index 293a00f..0a748fc --- a/src/drivers/CANvenient_Kvaser.c +++ b/src/drivers/CANvenient_Kvaser.c @@ -16,7 +16,11 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef _WIN32 +#ifdef VENIENT_KVASER_DRV_DISABLED + #pragma message("!!!!!! WARNING: Kvaser driver is disabled. !!!!!!") +#endif + +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) #include #include @@ -33,7 +37,7 @@ static const char* get_canlib_error_text(canStatus status); int kvaser_find_interfaces(void) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) int channel_count = 0; canStatus status; @@ -118,7 +122,7 @@ int kvaser_find_interfaces(void) int kvaser_open(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; CanHandle hnd; @@ -152,7 +156,11 @@ int kvaser_open(int index) return 0; #else + #ifdef VENIENT_KVASER_DRV_DISABLED + set_error_reason("Kvaser driver is disabled."); + #else set_error_reason("Kvaser driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -160,7 +168,7 @@ int kvaser_open(int index) void kvaser_close(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; @@ -175,14 +183,18 @@ void kvaser_close(int index) can_interface[index].opened = 0; #else + #ifdef VENIENT_KVASER_DRV_DISABLED + set_error_reason("Kvaser driver is disabled."); + #else set_error_reason("Kvaser driver is only supported on Windows."); + #endif (void)index; #endif } int kvaser_update(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) kvaser_channel_info_t* ch_info; canStatus status; @@ -204,7 +216,11 @@ int kvaser_update(int index) return 0; #else + #ifdef VENIENT_KVASER_DRV_DISABLED + set_error_reason("Kvaser driver is disabled."); + #else set_error_reason("Kvaser driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -212,7 +228,7 @@ int kvaser_update(int index) int kvaser_set_baudrate(int index, enum can_baudrate baud) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) can_close(index); can_interface[index].baudrate = baud; @@ -228,7 +244,7 @@ int kvaser_set_baudrate(int index, enum can_baudrate baud) int kvaser_send(int index, struct can_frame* frame) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; canStatus status; @@ -243,7 +259,11 @@ int kvaser_send(int index, struct can_frame* frame) return 0; #else + #ifdef VENIENT_KVASER_DRV_DISABLED + set_error_reason("Kvaser driver is disabled."); + #else set_error_reason("Kvaser driver is only supported on Windows."); + #endif (void)index; (void)frame; return -1; @@ -252,7 +272,7 @@ int kvaser_send(int index, struct can_frame* frame) int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; canStatus status; @@ -278,7 +298,11 @@ int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) return 0; #else + #ifdef VENIENT_KVASER_DRV_DISABLED + set_error_reason("Kvaser driver is disabled."); + #else set_error_reason("Kvaser driver is only supported on Windows."); + #endif (void)index; (void)frame; (void)timestamp; @@ -286,7 +310,8 @@ int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) #endif } -#ifdef _WIN32 + +#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) static long baudrate_to_canlib(enum can_baudrate baud) { switch (baud) diff --git a/src/drivers/CANvenient_Kvaser.h b/src/drivers/CANvenient_Kvaser.h old mode 100644 new mode 100755 index 1dcd1e7..663e6ef --- a/src/drivers/CANvenient_Kvaser.h +++ b/src/drivers/CANvenient_Kvaser.h @@ -7,17 +7,25 @@ * SPDX-License-Identifier: MIT * **/ - +#include "global.h" #include "CANvenient.h" -int kvaser_find_interfaces(void); +#ifdef __cplusplus + extern "C" { +#endif + +int kvaser_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int kvaser_open(int index) ATTRIBUTE_INTERNAL; +int kvaser_open_fd(int index) ATTRIBUTE_INTERNAL; +void kvaser_close(int index) ATTRIBUTE_INTERNAL; +int kvaser_update(int index) ATTRIBUTE_INTERNAL; -int kvaser_open(int index); -int kvaser_open_fd(int index); -void kvaser_close(int index); -int kvaser_update(int index); +int kvaser_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; -int kvaser_set_baudrate(int index, enum can_baudrate baud); +int kvaser_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; -int kvaser_send(int index, struct can_frame* frame); -int kvaser_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif \ No newline at end of file diff --git a/src/drivers/CANvenient_PEAK.c b/src/drivers/CANvenient_PEAK.c old mode 100644 new mode 100755 index a851764..c681e42 --- a/src/drivers/CANvenient_PEAK.c +++ b/src/drivers/CANvenient_PEAK.c @@ -12,7 +12,14 @@ #include #include -#ifdef _WIN32 +#include "CANvenient.h" +#include "CANvenient_internal.h" + +#ifdef VENIENT_PEAK_DRV_DISABLED + #pragma message("!!!!!! WARNING: PEAK driver is disabled. !!!!!!") +#endif + +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) #include #include @@ -21,12 +28,9 @@ static char* lookup_error_string(TPCANStatus pcan_status); static TPCANBaudrate lookup_pcan_baudrate(enum can_baudrate baud); #endif -#include "CANvenient.h" -#include "CANvenient_internal.h" - int peak_find_interfaces(void) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) u32 ch_count = 0; TPCANChannelInformation* pcan_ch_info; @@ -126,7 +130,7 @@ int peak_find_interfaces(void) int peak_open(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) TPCANHandle pcan_ch = ((TPCANChannelInformation*)can_interface[index].internal)->channel_handle; TPCANStatus pcan_status; @@ -144,7 +148,11 @@ int peak_open(int index) } #else + #ifdef VENIENT_PEAK_DRV_DISABLED + set_error_reason("PEAK driver is disabled."); + #else set_error_reason("PEAK driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -152,7 +160,7 @@ int peak_open(int index) void peak_close(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) TPCANStatus pcan_status; @@ -163,14 +171,18 @@ void peak_close(int index) } #else + #ifdef VENIENT_PEAK_DRV_DISABLED + set_error_reason("PEAK driver is disabled."); + #else set_error_reason("PEAK driver is only supported on Windows."); + #endif (void)index; #endif } int peak_update(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) TPCANStatus pcan_status; @@ -191,8 +203,11 @@ int peak_update(int index) } #else - + #ifdef VENIENT_PEAK_DRV_DISABLED + set_error_reason("PEAK driver is disabled."); + #else set_error_reason("PEAK driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -200,14 +215,18 @@ int peak_update(int index) int peak_set_baudrate(int index, enum can_baudrate baud) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) can_close(index); can_interface[index].baudrate = baud; return can_open(index, baud); #else + #ifdef VENIENT_PEAK_DRV_DISABLED + set_error_reason("PEAK driver is disabled."); + #else set_error_reason("PEAK driver is only supported on Windows."); + #endif (void)index; (void)baud; return -1; @@ -216,7 +235,7 @@ int peak_set_baudrate(int index, enum can_baudrate baud) int peak_send(int index, struct can_frame* frame) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) TPCANHandle pcan_ch = ((TPCANChannelInformation*)can_interface[index].internal)->channel_handle; TPCANStatus pcan_status; @@ -242,7 +261,11 @@ int peak_send(int index, struct can_frame* frame) return 0; #else + #ifdef VENIENT_PEAK_DRV_DISABLED + set_error_reason("PEAK driver is disabled."); + #else set_error_reason("PEAK driver is only supported on Windows."); + #endif (void)index; (void)frame; return -1; @@ -251,7 +274,7 @@ int peak_send(int index, struct can_frame* frame) int peak_recv(int index, struct can_frame* frame, u64* timestamp) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) TPCANHandle pcan_ch = ((TPCANChannelInformation*)can_interface[index].internal)->channel_handle; TPCANStatus pcan_status; @@ -278,8 +301,11 @@ int peak_recv(int index, struct can_frame* frame, u64* timestamp) return 0; #else - + #ifdef VENIENT_PEAK_DRV_DISABLED + set_error_reason("PEAK driver is disabled."); + #else set_error_reason("PEAK driver is only supported on Windows."); + #endif (void)index; (void)frame; (void)timestamp; @@ -287,7 +313,8 @@ int peak_recv(int index, struct can_frame* frame, u64* timestamp) #endif } -#ifdef _WIN32 + +#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) static TPCANBaudrate lookup_pcan_baudrate(enum can_baudrate baud) { switch (baud) diff --git a/src/drivers/CANvenient_PEAK.h b/src/drivers/CANvenient_PEAK.h old mode 100644 new mode 100755 index 8e45f37..f381ebd --- a/src/drivers/CANvenient_PEAK.h +++ b/src/drivers/CANvenient_PEAK.h @@ -7,17 +7,25 @@ * SPDX-License-Identifier: MIT * **/ - +#include "global.h" #include "CANvenient.h" -int peak_find_interfaces(void); +#ifdef __cplusplus + extern "C" { +#endif + +int peak_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int peak_open(int index) ATTRIBUTE_INTERNAL; +int peak_open_fd(int index) ATTRIBUTE_INTERNAL; +void peak_close(int index) ATTRIBUTE_INTERNAL; +int peak_update(int index) ATTRIBUTE_INTERNAL; -int peak_open(int index); -int peak_open_fd(int index); -void peak_close(int index); -int peak_update(int index); +int peak_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; -int peak_set_baudrate(int index, enum can_baudrate baud); +int peak_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int peak_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; -int peak_send(int index, struct can_frame* frame); -int peak_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif \ No newline at end of file diff --git a/src/drivers/CANvenient_SocketCAN.h b/src/drivers/CANvenient_SocketCAN.h old mode 100644 new mode 100755 index d8209b6..450ef22 --- a/src/drivers/CANvenient_SocketCAN.h +++ b/src/drivers/CANvenient_SocketCAN.h @@ -7,16 +7,24 @@ * SPDX-License-Identifier: MIT * **/ - +#include "global.h" #include "CANvenient.h" -int socketcan_find_interfaces(void); +#ifdef __cplusplus + extern "C" { +#endif + +int socketcan_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int socketcan_open(int index) ATTRIBUTE_INTERNAL; +void socketcan_close(int index) ATTRIBUTE_INTERNAL; +int socketcan_update(int index) ATTRIBUTE_INTERNAL; -int socketcan_open(int index); -void socketcan_close(int index); -int socketcan_update(int index); +int socketcan_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; -int socketcan_set_baudrate(int index, enum can_baudrate baud); +int socketcan_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int socketcan_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; -int socketcan_send(int index, struct can_frame* frame); -int socketcan_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif diff --git a/src/drivers/CANvenient_Softing.c b/src/drivers/CANvenient_Softing.c old mode 100644 new mode 100755 index e80ed76..7dbf6a0 --- a/src/drivers/CANvenient_Softing.c +++ b/src/drivers/CANvenient_Softing.c @@ -16,7 +16,11 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef _WIN32 +#ifdef VENIENT_SOFTING_DRV_DISABLED + #pragma message("!!!!!! WARNING: Softing driver is disabled. !!!!!!") +#endif + +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) #include #include #include @@ -35,7 +39,7 @@ static double softing_baudrate_to_kbps(enum can_baudrate baud); int softing_find_interfaces(void) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) unsigned long buf_size_needed = 0; unsigned long num_channels = 0; @@ -127,7 +131,7 @@ int softing_find_interfaces(void) int softing_open(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; L2CONFIG cfg; @@ -205,7 +209,11 @@ int softing_open(int index) return 0; #else + #ifdef VENIENT_SOFTING_DRV_DISABLED + set_error_reason("Softing driver is disabled."); + #else set_error_reason("Softing driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -213,7 +221,7 @@ int softing_open(int index) void softing_close(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; @@ -231,14 +239,18 @@ void softing_close(int index) can_interface[index].opened = 0; #else + #ifdef VENIENT_SOFTING_DRV_DISABLED + set_error_reason("Softing driver is disabled."); + #else set_error_reason("Softing driver is only supported on Windows."); + #endif (void)index; #endif } int softing_update(int index) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) const softing_ctx_t* ctx; unsigned long buf_size_needed = 0; @@ -293,7 +305,11 @@ int softing_update(int index) return 0; #else + #ifdef VENIENT_SOFTING_DRV_DISABLED + set_error_reason("Softing driver is disabled."); + #else set_error_reason("Softing driver is only supported on Windows."); + #endif (void)index; return -1; #endif @@ -301,14 +317,18 @@ int softing_update(int index) int softing_set_baudrate(int index, enum can_baudrate baud) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) softing_close(index); can_interface[index].baudrate = baud; return softing_open(index); #else + #ifdef VENIENT_SOFTING_DRV_DISABLED + set_error_reason("Softing driver is disabled."); + #else set_error_reason("Softing driver is only supported on Windows."); + #endif (void)index; (void)baud; return -1; @@ -317,7 +337,7 @@ int softing_set_baudrate(int index, enum can_baudrate baud) int softing_send(int index, struct can_frame* frame) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; unsigned long ident; @@ -351,7 +371,11 @@ int softing_send(int index, struct can_frame* frame) return 0; #else + #ifdef VENIENT_SOFTING_DRV_DISABLED + set_error_reason("Softing driver is disabled."); + #else set_error_reason("Softing driver is only supported on Windows."); + #endif (void)index; (void)frame; return -1; @@ -360,7 +384,7 @@ int softing_send(int index, struct can_frame* frame) int softing_recv(int index, struct can_frame* frame, u64* timestamp) { -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; PARAM_STRUCT param; @@ -404,7 +428,11 @@ int softing_recv(int index, struct can_frame* frame, u64* timestamp) return -1; #else + #ifdef VENIENT_SOFTING_DRV_DISABLED + set_error_reason("Softing driver is disabled."); + #else set_error_reason("Softing driver is only supported on Windows."); + #endif (void)index; (void)frame; (void)timestamp; @@ -412,7 +440,7 @@ int softing_recv(int index, struct can_frame* frame, u64* timestamp) #endif } -#ifdef _WIN32 +#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) static double softing_baudrate_to_kbps(enum can_baudrate baud) { switch (baud) diff --git a/src/drivers/CANvenient_Softing.h b/src/drivers/CANvenient_Softing.h old mode 100644 new mode 100755 index 7df4d5b..4ea6693 --- a/src/drivers/CANvenient_Softing.h +++ b/src/drivers/CANvenient_Softing.h @@ -7,17 +7,25 @@ * SPDX-License-Identifier: MIT * **/ - +#include "global.h" #include "CANvenient.h" -int softing_find_interfaces(void); +#ifdef __cplusplus + extern "C" { +#endif + +int softing_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int softing_open(int index) ATTRIBUTE_INTERNAL; +int softing_open_fd(int index) ATTRIBUTE_INTERNAL; +void softing_close(int index) ATTRIBUTE_INTERNAL; +int softing_update(int index) ATTRIBUTE_INTERNAL; -int softing_open(int index); -int softing_open_fd(int index); -void softing_close(int index); -int softing_update(int index); +int softing_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; -int softing_set_baudrate(int index, enum can_baudrate baud); +int softing_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int softing_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; -int softing_send(int index, struct can_frame* frame); -int softing_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif \ No newline at end of file diff --git a/src/drivers/CANvenient_internal.h b/src/drivers/CANvenient_internal.h old mode 100644 new mode 100755 index 4665d24..9b117b0 --- a/src/drivers/CANvenient_internal.h +++ b/src/drivers/CANvenient_internal.h @@ -11,6 +11,18 @@ #ifndef CANVENIENT_INTERNAL_H #define CANVENIENT_INTERNAL_H +#include "global.h" + +#ifdef __cplusplus + extern "C" { +#endif + +#define VENIENT_SOFTING_DRV_DISABLED +#define VENIENT_IXXAT_DRV_DISABLED +#define VENIENT_KVASER_DRV_DISABLED +#define VENIENT_PEAK_DRV_DISABLED + + /* * CAN interface vendor enumeration. */ @@ -21,7 +33,8 @@ enum can_vendor CAN_VENDOR_KVASER, CAN_VENDOR_PEAK, CAN_VENDOR_SOCKETCAN, - CAN_VENDOR_SOFTING + CAN_VENDOR_SOFTING, + CAN_VENDOR_MHS }; /* @@ -36,10 +49,14 @@ struct can_iface void* internal; }; -extern struct can_iface can_interface[CAN_MAX_INTERFACES]; -extern char can_error_reason[1024]; +extern struct can_iface can_interface[CAN_MAX_INTERFACES] ATTRIBUTE_INTERNAL; +extern char can_error_reason[1024] ATTRIBUTE_INTERNAL; + +int find_free_interface_slot(u32* index) ATTRIBUTE_INTERNAL; +void set_error_reason(const char* reason) ATTRIBUTE_INTERNAL; -int find_free_interface_slot(u32* index); -void set_error_reason(const char* reason); +#ifdef __cplusplus + } +#endif #endif /* CANVENIENT_INTERNAL_H */ diff --git a/src/drivers/CANvenient_template.h b/src/drivers/CANvenient_template.h old mode 100644 new mode 100755 index c731294..6e593e2 --- a/src/drivers/CANvenient_template.h +++ b/src/drivers/CANvenient_template.h @@ -7,17 +7,25 @@ * SPDX-License-Identifier: MIT * **/ - +#include "global.h" #include "CANvenient.h" -int template_find_interfaces(void); +#ifdef __cplusplus + extern "C" { +#endif + +int template_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int template_open(int index) ATTRIBUTE_INTERNAL; +int template_open_fd(int index) ATTRIBUTE_INTERNAL; +void template_close(int index) ATTRIBUTE_INTERNAL; +int template_update(int index) ATTRIBUTE_INTERNAL; -int template_open(int index); -int template_open_fd(int index); -void template_close(int index); -int template_update(int index); +int template_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; -int template_set_baudrate(int index, enum can_baudrate baud); +int template_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int template_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; -int template_send(int index, struct can_frame* frame); -int template_recv(int index, struct can_frame* frame, u64* timestamp); +#ifdef __cplusplus + } +#endif \ No newline at end of file From dfd1abffc141b2f5d2ceb0a268f5067b6826bcf5 Mon Sep 17 00:00:00 2001 From: Klaus Demlehner Date: Tue, 14 Apr 2026 23:02:47 +0200 Subject: [PATCH 03/13] Add Tiny-CAN and CodeBlocks support --- CodeBlocks/CANvenient.cbp | 92 + CodeBlocks/CANvenient.depend | 321 ++ CodeBlocks/CANvenient.layout | 50 + CodeBlocks/CANvenient.workspace | 7 + CodeBlocks/CANvenient.workspace.layout | 6 + CodeBlocks/Test.cbp | 52 + CodeBlocks/Test.depend | 61 + CodeBlocks/Test.layout | 20 + CodeBlocks_Linux/CANvenient.cbp | 89 + CodeBlocks_Linux/CANvenient.depend | 321 ++ CodeBlocks_Linux/CANvenient.layout | 50 + CodeBlocks_Linux/CANvenient.workspace | 7 + CodeBlocks_Linux/CANvenient.workspace.layout | 6 + CodeBlocks_Linux/Test.cbp | 48 + CodeBlocks_Linux/Test.depend | 90 + CodeBlocks_Linux/Test.layout | 20 + deps/tiny_can/dev/lib/can_drv.h | 287 ++ deps/tiny_can/dev/lib/can_drv_config.h | 26 + deps/tiny_can/dev/lib/can_drv_ex.h | 488 +++ deps/tiny_can/dev/lib/can_types.h | 384 ++ deps/tiny_can/dev/lib/mhs_can_drv.c | 3269 ++++++++++++++++++ src/drivers/CANvenient_TinyCan.c | 391 +++ src/drivers/CANvenient_TinyCan.h | 32 + src/global.h | 31 + src/tests/linux_util.c | 93 + src/tests/linux_util.h | 20 + src/tests/rx_tx_example.c | 130 + 27 files changed, 6391 insertions(+) create mode 100755 CodeBlocks/CANvenient.cbp create mode 100755 CodeBlocks/CANvenient.depend create mode 100755 CodeBlocks/CANvenient.layout create mode 100755 CodeBlocks/CANvenient.workspace create mode 100755 CodeBlocks/CANvenient.workspace.layout create mode 100755 CodeBlocks/Test.cbp create mode 100755 CodeBlocks/Test.depend create mode 100755 CodeBlocks/Test.layout create mode 100755 CodeBlocks_Linux/CANvenient.cbp create mode 100755 CodeBlocks_Linux/CANvenient.depend create mode 100755 CodeBlocks_Linux/CANvenient.layout create mode 100755 CodeBlocks_Linux/CANvenient.workspace create mode 100755 CodeBlocks_Linux/CANvenient.workspace.layout create mode 100755 CodeBlocks_Linux/Test.cbp create mode 100755 CodeBlocks_Linux/Test.depend create mode 100755 CodeBlocks_Linux/Test.layout create mode 100755 deps/tiny_can/dev/lib/can_drv.h create mode 100755 deps/tiny_can/dev/lib/can_drv_config.h create mode 100755 deps/tiny_can/dev/lib/can_drv_ex.h create mode 100755 deps/tiny_can/dev/lib/can_types.h create mode 100755 deps/tiny_can/dev/lib/mhs_can_drv.c create mode 100755 src/drivers/CANvenient_TinyCan.c create mode 100755 src/drivers/CANvenient_TinyCan.h create mode 100755 src/global.h create mode 100755 src/tests/linux_util.c create mode 100755 src/tests/linux_util.h create mode 100755 src/tests/rx_tx_example.c diff --git a/CodeBlocks/CANvenient.cbp b/CodeBlocks/CANvenient.cbp new file mode 100755 index 0000000..11f7fa2 --- /dev/null +++ b/CodeBlocks/CANvenient.cbp @@ -0,0 +1,92 @@ + + + + + + diff --git a/CodeBlocks/CANvenient.depend b/CodeBlocks/CANvenient.depend new file mode 100755 index 0000000..5fc3cd0 --- /dev/null +++ b/CodeBlocks/CANvenient.depend @@ -0,0 +1,321 @@ +# depslib dependency file v1.0 +1683924000 source:x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\mhs_can_drv.c + "can_drv.h" + + + + + + + + + + + + + + + + +1775945270 + +1718834685 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv.h + "can_types.h" + "can_drv_config.h" + + + + + "can_drv_ex.h" + +1718834685 x.h" + +1681072468 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_types.h + + + + +1682157640 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_config.h + +1694268622 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_ex.h + +1776198155 source:x:\tiny_can\mhs\canopen\git\canvenient\src\canvenient.c + + + "CANvenient.h" + "drivers/CANvenient_internal.h" + "drivers/CANvenient_Ixxat.h" + "drivers/CANvenient_Kvaser.h" + "drivers/CANvenient_SocketCAN.h" + "drivers/CANvenient_Softing.h" + "drivers/CANvenient_PEAK.h" + "drivers/CANvenient_TinyCan.h" + +1775909477 ANvenient_TinyCan.h" + +1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h + + + + + +1775988415 .h> + +1776116619 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_internal.h + "global.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.h + "global.h" + "CANvenient.h" + +1775902876 t.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.h + "global.h" + "CANvenient.h" + +1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775846939 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.c + + + + + + + + + + + + + + + "CANvenient.h" + "CANvenient_internal.h" + +1775846940 t_internal.h" + +1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775988415 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775846940 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_template.c + "CANvenient.h" + "CANvenient_internal.h" + +1776198323 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.c + + + + "CANvenient.h" + "CANvenient_internal.h" + "can_drv.h" + +1775989972 " + +1683924000 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/mhs_can_drv.c + "can_drv.h" + + + + + + + + + + + + + + + + +1718834685 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv.h + "can_types.h" + "can_drv_config.h" + + + + + "can_drv_ex.h" + +1681072468 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_types.h + + + + +1682157640 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_config.h + +1694268622 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_ex.h + +1776116544 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/CANvenient.c + + + "CANvenient.h" + "drivers/CANvenient_internal.h" + "drivers/CANvenient_Ixxat.h" + "drivers/CANvenient_Kvaser.h" + "drivers/CANvenient_SocketCAN.h" + "drivers/CANvenient_Softing.h" + "drivers/CANvenient_PEAK.h" + "drivers/CANvenient_TinyCan.h" + +1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h + + + + + +1776116619 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_internal.h + "global.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.h + "global.h" + "CANvenient.h" + +1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775988415 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775846939 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.c + + + + + + + + + + + + + + + "CANvenient.h" + "CANvenient_internal.h" + +1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775846940 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_template.c + "CANvenient.h" + "CANvenient_internal.h" + +1776112109 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.c + + + + "CANvenient.h" + "CANvenient_internal.h" + "can_drv.h" + +1776184766 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/global.h + +1776184766 x:\tiny_can\mhs\canopen\git\canvenient\src\global.h + diff --git a/CodeBlocks/CANvenient.layout b/CodeBlocks/CANvenient.layout new file mode 100755 index 0000000..4213bb5 --- /dev/null +++ b/CodeBlocks/CANvenient.layout @@ -0,0 +1,50 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CodeBlocks/CANvenient.workspace b/CodeBlocks/CANvenient.workspace new file mode 100755 index 0000000..16d2340 --- /dev/null +++ b/CodeBlocks/CANvenient.workspace @@ -0,0 +1,7 @@ + + + + + + + diff --git a/CodeBlocks/CANvenient.workspace.layout b/CodeBlocks/CANvenient.workspace.layout new file mode 100755 index 0000000..12df4fe --- /dev/null +++ b/CodeBlocks/CANvenient.workspace.layout @@ -0,0 +1,6 @@ + + + + + + diff --git a/CodeBlocks/Test.cbp b/CodeBlocks/Test.cbp new file mode 100755 index 0000000..f2fe56a --- /dev/null +++ b/CodeBlocks/Test.cbp @@ -0,0 +1,52 @@ + + + + + + diff --git a/CodeBlocks/Test.depend b/CodeBlocks/Test.depend new file mode 100755 index 0000000..0c82845 --- /dev/null +++ b/CodeBlocks/Test.depend @@ -0,0 +1,61 @@ +# depslib dependency file v1.0 +1776025542 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.c + + + + + + + "linux_util.h" + +1776025542 l.h" + +1776117160 x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.h + +1776185211 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\rx_tx_example.c + + + + + + + "linux_util.h" + + +1776111075 + +1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h + + + + + +1775846938 .h> + +1776117130 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/rx_tx_example.c + + + + + + + "linux_util.h" + + +1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h + + + + + +1776117160 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.h + +1776025542 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.c + + + + + + + "linux_util.h" + diff --git a/CodeBlocks/Test.layout b/CodeBlocks/Test.layout new file mode 100755 index 0000000..4e4e5a4 --- /dev/null +++ b/CodeBlocks/Test.layout @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/CodeBlocks_Linux/CANvenient.cbp b/CodeBlocks_Linux/CANvenient.cbp new file mode 100755 index 0000000..b574855 --- /dev/null +++ b/CodeBlocks_Linux/CANvenient.cbp @@ -0,0 +1,89 @@ + + + + + + diff --git a/CodeBlocks_Linux/CANvenient.depend b/CodeBlocks_Linux/CANvenient.depend new file mode 100755 index 0000000..f082512 --- /dev/null +++ b/CodeBlocks_Linux/CANvenient.depend @@ -0,0 +1,321 @@ +# depslib dependency file v1.0 +1683924000 source:x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\mhs_can_drv.c + "can_drv.h" + + + + + + + + + + + + + + + + +1775945270 + +1718834685 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv.h + "can_types.h" + "can_drv_config.h" + + + + + "can_drv_ex.h" + +1718834685 x.h" + +1681072468 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_types.h + + + + +1682157640 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_config.h + +1694268622 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_ex.h + +1776116544 source:x:\tiny_can\mhs\canopen\git\canvenient\src\canvenient.c + + + "CANvenient.h" + "drivers/CANvenient_internal.h" + "drivers/CANvenient_Ixxat.h" + "drivers/CANvenient_Kvaser.h" + "drivers/CANvenient_SocketCAN.h" + "drivers/CANvenient_Softing.h" + "drivers/CANvenient_PEAK.h" + "drivers/CANvenient_TinyCan.h" + +1775909477 ANvenient_TinyCan.h" + +1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h + + + + + +1775988415 .h> + +1776116619 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_internal.h + "global.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.h + "global.h" + "CANvenient.h" + +1775902876 t.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.h + "global.h" + "CANvenient.h" + +1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.h + "global.h" + "CANvenient.h" + +1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775846939 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.c + + + + + + + + + + + + + + + "CANvenient.h" + "CANvenient_internal.h" + +1775846940 t_internal.h" + +1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775988415 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775846940 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_template.c + "CANvenient.h" + "CANvenient_internal.h" + +1776112109 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.c + + + + "CANvenient.h" + "CANvenient_internal.h" + "can_drv.h" + +1775989972 " + +1683924000 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/mhs_can_drv.c + "can_drv.h" + + + + + + + + + + + + + + + + +1718834685 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv.h + "can_types.h" + "can_drv_config.h" + + + + + "can_drv_ex.h" + +1681072468 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_types.h + + + + +1682157640 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_config.h + +1694268622 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_ex.h + +1776116544 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/CANvenient.c + + + "CANvenient.h" + "drivers/CANvenient_internal.h" + "drivers/CANvenient_Ixxat.h" + "drivers/CANvenient_Kvaser.h" + "drivers/CANvenient_SocketCAN.h" + "drivers/CANvenient_Softing.h" + "drivers/CANvenient_PEAK.h" + "drivers/CANvenient_TinyCan.h" + +1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h + + + + + +1776116619 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_internal.h + "global.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.h + "global.h" + "CANvenient.h" + +1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.h + "global.h" + "CANvenient.h" + +1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775988415 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.c + + + + "CANvenient.h" + "CANvenient_internal.h" + + + +1775846939 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.c + + + + + + + + + + + + + + + "CANvenient.h" + "CANvenient_internal.h" + +1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.c + + + + + "CANvenient.h" + "CANvenient_internal.h" + + + + +1775846940 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_template.c + "CANvenient.h" + "CANvenient_internal.h" + +1776112109 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.c + + + + "CANvenient.h" + "CANvenient_internal.h" + "can_drv.h" + +1776184766 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/global.h + +1776184766 x:\tiny_can\mhs\canopen\git\canvenient\src\global.h + diff --git a/CodeBlocks_Linux/CANvenient.layout b/CodeBlocks_Linux/CANvenient.layout new file mode 100755 index 0000000..277bad0 --- /dev/null +++ b/CodeBlocks_Linux/CANvenient.layout @@ -0,0 +1,50 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CodeBlocks_Linux/CANvenient.workspace b/CodeBlocks_Linux/CANvenient.workspace new file mode 100755 index 0000000..16d2340 --- /dev/null +++ b/CodeBlocks_Linux/CANvenient.workspace @@ -0,0 +1,7 @@ + + + + + + + diff --git a/CodeBlocks_Linux/CANvenient.workspace.layout b/CodeBlocks_Linux/CANvenient.workspace.layout new file mode 100755 index 0000000..12df4fe --- /dev/null +++ b/CodeBlocks_Linux/CANvenient.workspace.layout @@ -0,0 +1,6 @@ + + + + + + diff --git a/CodeBlocks_Linux/Test.cbp b/CodeBlocks_Linux/Test.cbp new file mode 100755 index 0000000..ec5d417 --- /dev/null +++ b/CodeBlocks_Linux/Test.cbp @@ -0,0 +1,48 @@ + + + + + + diff --git a/CodeBlocks_Linux/Test.depend b/CodeBlocks_Linux/Test.depend new file mode 100755 index 0000000..1a70086 --- /dev/null +++ b/CodeBlocks_Linux/Test.depend @@ -0,0 +1,90 @@ +# depslib dependency file v1.0 +1776025542 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.c + + + + + + + "linux_util.h" + +1776025542 l.h" + +1776117160 x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.h + +1776185211 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\rx_tx_example.c + + + + + + + "linux_util.h" + + +1776117130 + +1776111075 + +1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h + + + + + +1776112683 .h> + +1776117130 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/rx_tx_example.c + + + + + + + "linux_util.h" + + +1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h + + + + + +1776117160 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.h + +1776025542 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.c + + + + + + + "linux_util.h" + +1776025542 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.c + + + + + + + "linux_util.h" + +1776117160 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.h + +1776185211 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/rx_tx_example.c + + + + + + + "linux_util.h" + + +1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h + + + + + diff --git a/CodeBlocks_Linux/Test.layout b/CodeBlocks_Linux/Test.layout new file mode 100755 index 0000000..f3837c0 --- /dev/null +++ b/CodeBlocks_Linux/Test.layout @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/deps/tiny_can/dev/lib/can_drv.h b/deps/tiny_can/dev/lib/can_drv.h new file mode 100755 index 0000000..037772b --- /dev/null +++ b/deps/tiny_can/dev/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/deps/tiny_can/dev/lib/can_drv_config.h b/deps/tiny_can/dev/lib/can_drv_config.h new file mode 100755 index 0000000..456e05c --- /dev/null +++ b/deps/tiny_can/dev/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/deps/tiny_can/dev/lib/can_drv_ex.h b/deps/tiny_can/dev/lib/can_drv_ex.h new file mode 100755 index 0000000..50730d1 --- /dev/null +++ b/deps/tiny_can/dev/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/deps/tiny_can/dev/lib/can_types.h b/deps/tiny_can/dev/lib/can_types.h new file mode 100755 index 0000000..c5ecb18 --- /dev/null +++ b/deps/tiny_can/dev/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/deps/tiny_can/dev/lib/mhs_can_drv.c b/deps/tiny_can/dev/lib/mhs_can_drv.c new file mode 100755 index 0000000..8c59dd1 --- /dev/null +++ b/deps/tiny_can/dev/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/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c new file mode 100755 index 0000000..0f42352 --- /dev/null +++ b/src/drivers/CANvenient_TinyCan.c @@ -0,0 +1,391 @@ +/** @file CANvenient_TinyCan.c + * + * CANvenient is an abstraction layer for multiple CAN APIs on + * Windows and Linux. + * + * Copyright (c) 2026, MHS-Elektronik GmbH & Co. KG, Klaus Demlehner. + * Copyright (c) 2026, Michael Fitzmayer. + * All rights reserved. + * + * SPDX-License-Identifier: MIT + * + **/ +#include +#include +#include + +#include "CANvenient.h" +#include "CANvenient_internal.h" + +#include "can_drv.h" + +typedef struct _TTinyDevice TTinyDevice; + +struct _TTinyDevice + { + uint32_t DeviceIndex; + char Snr[20]; + }; + + +/* +#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 +#define TCAN_LOG_FLAG_DEBUG 0x08000000 +#define TCAN_LOG_FILE_HEADER 0x10000000 +#define TCAN_LOG_FILE_APPEND 0x20000000 +#define TCAN_LOG_FLAG_WITH_TIME 0x40000000 +#define TCAN_LOG_FLAG_DISABLE_SYNC 0x80000000 +*/ + +// TimeStampMode +// 0 = Disabled +// 1 = Software Time Stamps +// 2 = Hardware Time Stamps, UNIX-Format +// 3 = Hardware Time Stamps +// 4 = Hardware Time Stamp wenn verfügbar, ansonsten Software Time Stamps +#ifdef ENABLE_LOG + #pragma message("!!!!!! WARNING: CAN-API driver log is enabled !!!!!!") + + #define TREIBER_INIT_PARAM "logfile=tinycan.log;logflags=0x880000F3;FdMode=0;CanCallThread=0;TimeStampMode=4" +#else + #define TREIBER_INIT_PARAM "FdMode=0;CanCallThread=0;TimeStampMode=4" +#endif + +#define DEVICE_OPEN_PARAM "AutoStopCan=1" + +static uint32_t TinyCanDriverInit = 0; + + +struct TCanVenientToTCanBaudrate + { + enum can_baudrate CanVenientBaud; + uint16_t TCanBaudrate; + }; + +static const struct TCanVenientToTCanBaudrate CanVenientToTCanBaudrate[] = { + {CAN_BAUD_1M, CAN_1M_BIT}, + {CAN_BAUD_800K, CAN_800K_BIT}, + {CAN_BAUD_500K, CAN_500K_BIT}, + {CAN_BAUD_250K, CAN_250K_BIT}, + {CAN_BAUD_125K, CAN_125K_BIT}, + {CAN_BAUD_100K, CAN_100K_BIT}, + {CAN_BAUD_95K, 0xFFFF}, + {CAN_BAUD_83K, 0xFFFF}, + {CAN_BAUD_50K, CAN_50K_BIT}, + {CAN_BAUD_47K, 0xFFFF}, + {CAN_BAUD_33K, 0xFFFF}, + {CAN_BAUD_20K, CAN_20K_BIT}, + {CAN_BAUD_10K, CAN_10K_BIT}, + {CAN_BAUD_5K, 0xFFFF}, + {0, 0}}; + + +#define CAN_ERROR_TCAN -1 +#define CAN_ERROR_QXMTFULL -2 +#define CAN_ERROR_QRCVEMPTY -3 + +#define CAN_ERROR_QOVERRUN -4 +#define CAN_ERROR_BUSPASSIVE -5 +#define CAN_ERROR_BUSOFF -6 + +#define CAN_ERROR_NODRIVER -5 +#define CAN_ERROR_REGTEST -6 +#define CAN_ERROR_RESOURCE -7 + + +struct TCanVenientMhsError + { + int32_t CanError; + const char *ErrorMsg; + }; + + +static const struct TCanVenientMhsError CanVenientMhsError[] = { + {CAN_ERROR_TCAN, "Tiny-CAN API error."}, + {CAN_ERROR_QXMTFULL, "Transmit queue is full."}, + {CAN_ERROR_QRCVEMPTY, "Receive queue is empty."}, + + {CAN_ERROR_QOVERRUN, "Receive queue was read too late."}, + {CAN_ERROR_BUSPASSIVE, "Bus error: the CAN controller is error passive."}, + {CAN_ERROR_BUSOFF, "Bus error: the CAN controller is in bus-off state."}, + + {CAN_ERROR_NODRIVER, "Driver not loaded."}, + + {CAN_ERROR_REGTEST, "Test of the CAN controller hardware registers failed (no hardware found)."}, + + {CAN_ERROR_RESOURCE, "Resource (FIFO, Client, timeout) cannot be created."}, + {0, NULL}}; + + +static const char *lookup_error_string(int32_t can_error, int32_t tcan_error) +{ +const struct TCanVenientMhsError *err_list; +const char *error_str; +(void)tcan_error; + +if (can_error) + error_str = "No error. Success."; +else + { + for (err_list = CanVenientMhsError; (error_str = err_list->ErrorMsg); err_list++) + { + if (can_error == err_list->CanError) + break; + } + } +if (!error_str) + error_str = "Unknown error."; +return(error_str); +} + + +static char *mhs_strdup(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); +} + + +int tinycan_find_interfaces(void) +{ +int res; +uint32_t k, idx, already_registered; +struct TCanDevicesList *can_dev_list; +int32_t num_devs, i; +char dev_name[100]; +TTinyDevice *tiny_device; + +res = 0; +if (!TinyCanDriverInit) + { + if (LoadDriver(NULL) >= 0) + { + if (CanInitDriver(TREIBER_INIT_PARAM) >= 0) + TinyCanDriverInit = 1; + } + } +if ((num_devs = CanExGetDeviceList(&can_dev_list, 0)) <= 0) + { + set_error_reason("No Tiny-CAN hardwre found"); + return(-1); + } +for (i = 0; i < num_devs; i++) + { + snprintf(dev_name, sizeof(dev_name), "%s (S/N: %s)", can_dev_list[i].Description, can_dev_list[i].SerialNumber); + + already_registered = 0; + for (k = 0; k < CAN_MAX_INTERFACES; k++) + { + if (can_interface[k].name && strcmp(can_interface[k].name, dev_name) == 0) + { + already_registered = 1; + break; + } + } + if (already_registered) + continue; + + if (0 != find_free_interface_slot(&idx)) + break; /* No free slot available: stop. */ + + if (!(tiny_device = malloc(sizeof(TTinyDevice)))) + { + res = -1; + break; + } + can_interface[idx].internal = tiny_device; + if (!(can_interface[idx].name = mhs_strdup(dev_name))) + { + free(can_interface[idx].internal); + can_interface[idx].internal = NULL; + res = -1; + } + + tiny_device->DeviceIndex = INDEX_INVALID; + snprintf(tiny_device->Snr, 20, "%s", can_dev_list[i].SerialNumber); + + can_interface[idx].vendor = CAN_VENDOR_MHS; + can_interface[idx].opened = 0; + can_interface[idx].baudrate = CAN_BAUD_1M; + } +CanExDataFree((void **)&can_dev_list); +if (res < 0) + set_error_reason("Memory allocation failed."); +return(res); +} + + +int tinycan_open(int index) +{ +int32_t err; +TTinyDevice *tiny_device; +const struct TCanVenientToTCanBaudrate *b; +uint16_t tcan_baud; +//char dev_open_str[200]; <*> + +err = 0; +if (!(tiny_device = (TTinyDevice *)can_interface[index].internal)) + return(-1); +for (b = &CanVenientToTCanBaudrate[0]; (tcan_baud = b->TCanBaudrate); b++) + { + if (b->CanVenientBaud == can_interface[index].baudrate) + break; + } +if (!tcan_baud) + err = -1; +if (tcan_baud == 0xFFFF) + err = -1; +if ((!err) && (tiny_device->DeviceIndex == INDEX_INVALID)) + err = CanExCreateDevice(&tiny_device->DeviceIndex, "CanRxDFifoSize=16384"); +if (!err) + { + (void)CanExSetAsUWord(tiny_device->DeviceIndex, "CanSpeed1", tcan_baud); + (void)CanExSetAsString(tiny_device->DeviceIndex, "Snr", tiny_device->Snr); + } +//snprintf(dev_open_str, sizeof(dev_open_str), "%s;Snr=%s", DEVICE_OPEN_PARAM, tiny_device->Snr);<*> +if (!err) + err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); + //err = CanDeviceOpen(tiny_device->DeviceIndex, dev_open_str);<*> +if (!err) + err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); +if (err) + return(-1); +else + { + can_interface[index].opened = 1; + return(0); + } +} + + +void tinycan_close(int index) +{ +TTinyDevice *tiny_device; + +if (!(tiny_device = (TTinyDevice *)can_interface[index].internal)) + return; +(void)CanDeviceClose(tiny_device->DeviceIndex); +can_interface[index].opened = 0; // <*> +} + + +int tinycan_update(int index) +{ +uint32_t dev_idx; +struct TDeviceStatus status; +/*int32_t can_error; + +can_error = 0;*/ +dev_idx = ((TTinyDevice *)can_interface[index].internal)->DeviceIndex; +CanGetDeviceStatus(dev_idx, &status); +if (status.DrvStatus >= DRV_STATUS_CAN_OPEN) + { + /*if (status.FifoStatus & FIFO_HW_SW_OVERRUN) + can_error = CAN_ERROR_QOVERRUN; + if (status.CanStatus == CAN_STATUS_BUS_OFF) + can_error = CAN_ERROR_BUSOFF; + else if (status.CanStatus == CAN_STATUS_PASSIV) + can_error = CAN_ERROR_BUSPASSIVE;*/ + } +else + { + can_release(index); + return(-1); + } +return(0); +} + + +int tinycan_set_baudrate(int index, enum can_baudrate baud) +{ +can_close(index); +can_interface[index].baudrate = baud; +return can_open(index, baud); +} + + +int tinycan_send(int index, struct can_frame* frame) +{ +uint32_t dev_idx, len; +struct TCanMsg tcan_msg; +int32_t can_error, tcan_res; + +can_error = 0; +dev_idx = ((TTinyDevice *)can_interface[index].internal)->DeviceIndex; +len = frame->can_dlc; +tcan_msg.Flags.Long = len; +tcan_msg.Id = frame->can_id; +if (len) + memcpy(tcan_msg.MsgData, frame->data, len); +if ((tcan_res = CanTransmit(dev_idx, &tcan_msg, 1)) < 0) + can_error = CAN_ERROR_TCAN; +else if (tcan_res == 0) + can_error = CAN_ERROR_QXMTFULL; +if (can_error) + { + set_error_reason(lookup_error_string(can_error, tcan_res)); + return(-1); + } +return(0); +} + + +int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) +{ +uint32_t dev_idx, len; +struct TCanMsg tcan_msg; +int32_t can_error, tcan_res; + +can_error = 0; +dev_idx = ((TTinyDevice *)can_interface[index].internal)->DeviceIndex; +if ((tcan_res = CanReceive(dev_idx, &tcan_msg, 1)) == 1) + { + if (!tcan_msg.MsgRTR) + { + len = tcan_msg.MsgLen; + frame->can_id = tcan_msg.Id; + frame->can_dlc = len; + if (len) + memcpy(frame->data, tcan_msg.MsgData, len); + *timestamp = 0; // T.D. + } + else + can_error = CAN_ERROR_QRCVEMPTY; + } +else if (tcan_res == 0) + can_error = CAN_ERROR_QRCVEMPTY; +else + can_error = CAN_ERROR_TCAN; +if (can_error) + { + set_error_reason(lookup_error_string(can_error, tcan_res)); + return(-1); + } +return(0); +} + + diff --git a/src/drivers/CANvenient_TinyCan.h b/src/drivers/CANvenient_TinyCan.h new file mode 100755 index 0000000..b288aeb --- /dev/null +++ b/src/drivers/CANvenient_TinyCan.h @@ -0,0 +1,32 @@ +/** @file CANvenient_TinyCan.h + * + * CANvenient is an abstraction layer for multiple CAN APIs on + * Windows and Linux. + * + * Copyright (c) 2026, Michael Fitzmayer. All rights reserved. + * SPDX-License-Identifier: MIT + * + **/ +#include "global.h" +#include "CANvenient.h" + + +#ifdef __cplusplus + extern "C" { +#endif + +int tinycan_find_interfaces(void) ATTRIBUTE_INTERNAL; + +int tinycan_open(int index) ATTRIBUTE_INTERNAL; +int tinycan_open_fd(int index) ATTRIBUTE_INTERNAL; +void tinycan_close(int index) ATTRIBUTE_INTERNAL; +int tinycan_update(int index) ATTRIBUTE_INTERNAL; + +int tinycan_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; + +int tinycan_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; +int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; + +#ifdef __cplusplus + } +#endif diff --git a/src/global.h b/src/global.h new file mode 100755 index 0000000..f8a9b65 --- /dev/null +++ b/src/global.h @@ -0,0 +1,31 @@ +#ifndef __GLOBAL_H__ +#define __GLOBAL_H__ + +#ifdef __cplusplus + extern "C" { +#endif + +#if defined(WIN32) || defined(_WIN32) + #ifndef __WIN32__ + #define __WIN32__ + #endif +#endif + +#ifdef __WIN32__ + // ****** Windows + #define ATTRIBUTE_INTERNAL +#elif __APPLE__ + // ****** Apple + #define ATTRIBUTE_INTERNAL __attribute((visibility("hidden"))) +#else + // ****** Linux + #define ATTRIBUTE_INTERNAL + // replace -fvisibility=hidden + //#define ATTRIBUTE_INTERNAL __attribute((visibility("internal"))) +#endif + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/src/tests/linux_util.c b/src/tests/linux_util.c new file mode 100755 index 0000000..8b34d4f --- /dev/null +++ b/src/tests/linux_util.c @@ -0,0 +1,93 @@ +/******************************************************************************* + linux_util.c - description + ------------------- + begin : 12.04.2026 + last modify : 12.04.2026 + copyright : (C) 2026 by MHS-Elektronik GmbH & Co. KG, Germany + http://www.mhs-elektronik.de + author : Klaus Demlehner, klaus@mhs-elektronik.de + *******************************************************************************/ + +/*************************************************************************** + * * + * This program is free software, you can redistribute it and/or modify * + * it under the terms of the MIT License * + * * + ***************************************************************************/ +#ifndef _WIN32 + +#include +#include +#include +#include +#include +#include +#include "linux_util.h" + + + +#ifndef STDIN_FILENO + #define STDIN_FILENO 0 +#endif + + +static struct termios OldTermattr; + + +void UtilCleanup(void); + + +int UtilInit(void) +{ +struct termios termattr; + +if (tcgetattr(STDIN_FILENO, &OldTermattr) < 0) + return(-1); + +memcpy(&termattr, &OldTermattr, sizeof(struct termios)); + +termattr.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); +termattr.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); +termattr.c_cflag &= ~(CSIZE | PARENB); +termattr.c_cflag |= CS8; +termattr.c_oflag &= ~(OPOST); + +termattr.c_cc[VMIN] = 1; /* or 0 for some Unices; see note 1 */ +termattr.c_cc[VTIME] = 0; + +if (tcsetattr (STDIN_FILENO, TCSANOW, &termattr) < 0) + return(-1); +return(atexit(UtilCleanup)); +} + + +void UtilCleanup(void) +{ +tcsetattr(STDIN_FILENO, TCSAFLUSH, &OldTermattr); +} + + + +int KeyHit(void) +{ +int bytes_waiting; + +ioctl(STDIN_FILENO, FIONREAD, &bytes_waiting); +return(bytes_waiting); +} + + +/*char getch(void) +{ +char buf; + +if (read(STDIN_FILENO, &buf, 1) != 1) + return('\0'); +else + return(buf); +} */ + +#endif + + diff --git a/src/tests/linux_util.h b/src/tests/linux_util.h new file mode 100755 index 0000000..cf4acc8 --- /dev/null +++ b/src/tests/linux_util.h @@ -0,0 +1,20 @@ +#ifndef __LINUX_UTIL_H__ +#define __LINUX_UTIL_H__ + +#ifdef __cplusplus + extern "C" { +#endif + +#ifndef _WIN32 + +int UtilInit(void); +int KeyHit(void); +//char getch(void); + +#endif + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/src/tests/rx_tx_example.c b/src/tests/rx_tx_example.c new file mode 100755 index 0000000..9df48ba --- /dev/null +++ b/src/tests/rx_tx_example.c @@ -0,0 +1,130 @@ +/** @file example.c + * + * CANvenient is an abstraction layer for multiple CAN APIs on + * Windows and Linux. + * + * Copyright (c) 2026, Michael Fitzmayer. All rights reserved. + * SPDX-License-Identifier: MIT + * + **/ + +#include +#include +#include +#include +#include +#ifdef _WIN32 + #include +#else + #include "linux_util.h" +#endif + + +#ifdef _WIN32 + #define UtilInit() + #define KeyHit kbhit +#else + #include + #define getch getchar +#endif + + +static int OpenInterface(int *index) +{ +int res; + +res = 0; +if (!index) + return(-1); +if (!can_find_interfaces()) + { + for (int i = 0; i < CAN_MAX_INTERFACES; i++) + { + char name[256] = {0}; + can_get_name(i, name, sizeof(name)); + if (name[0] != '\0') + { + if (0 == can_open(i, CAN_BAUD_1M)) + { + printf("Opened CAN interface: %s\n\r", name); + res = 1; + *index = i; + break; + } + else + { + char error_reason[256] = {0}; + can_get_error(error_reason, sizeof(error_reason)); + printf("Failed to open CAN interface %s: %s\n\r", name, error_reason); + } + } + } + } +return(res); +} + + +static void PrintCanFrame(struct can_frame* frame, u64 timestamp) +{ +uint8_t i; +(void)timestamp; + +printf("id:%03X dlc:%0d data:", frame->can_id, frame->can_dlc); +if (frame->can_dlc) + { + for (i = 0; i < frame->can_dlc; i++) + printf("%02X ", frame->data[i]); + } +else + printf(" no data"); +printf("\n\r"); +} + + +static void TxStdFrame(int index, uint32_t id, uint8_t len, const uint8_t *data) +{ +struct can_frame frame; + +frame.can_id = id; +frame.can_dlc = len; +if ((len > 0) && (len <= 8)) + memcpy(frame.data, data, len); +(void)can_send(index, &frame); +} + + +int main() +{ +int index; +char ch; +struct can_frame rx_frame; +u64 timestamp; + +UtilInit(); +if (OpenInterface(&index) >= 1) + { + ch = '\0'; + printf("press \"t\" to send test message and \"q\" for quit\n\r\n\r"); + printf("received messages:\n\r"); + do + { + if (can_recv(index, &rx_frame, ×tamp) == 0) + PrintCanFrame(&rx_frame, timestamp); + if (KeyHit()) + { + ch = getch(); + switch (ch) + { + case 't' : { + TxStdFrame(index, 123, 8, (const uint8_t *)"*HALLO*"); + break; + } + } + } + } + while (ch != 'q'); + } +/* Implicitly calls can_close() for all opened interfaces. */ +can_release_interfaces(); +return(EXIT_SUCCESS); +} From 91b32c86e81012a5fff79e50a149305b3725f873 Mon Sep 17 00:00:00 2001 From: Klaus Demlehner Date: Tue, 14 Apr 2026 23:13:36 +0200 Subject: [PATCH 04/13] Add Tiny-CAN and CodeBlocks support --- README.md | 1 + 1 file changed, 1 insertion(+) mode change 100644 => 100755 README.md diff --git a/README.md b/README.md old mode 100644 new mode 100755 index 0bc1201..b54e8ac --- a/README.md +++ b/README.md @@ -21,3 +21,4 @@ The following back-ends are currently implemented: - PCAN-Basic - SocketCAN - Softing CAN Layer 2 +- MHS Elektronik - Tiny-CAN From f891fec71f7942b357b3ce4db7ff85150b18621b Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 18:25:53 +0200 Subject: [PATCH 05/13] Fully integrate support for @MHS-Elektronik Tiny-CAN --- .gitignore | 3 +- CMakeLists.txt | 1 + CMakeSettings.json | 24 - CodeBlocks/CANvenient.cbp | 92 - CodeBlocks/CANvenient.depend | 321 -- CodeBlocks/CANvenient.layout | 50 - CodeBlocks/CANvenient.workspace | 7 - CodeBlocks/CANvenient.workspace.layout | 6 - CodeBlocks/Test.cbp | 52 - CodeBlocks/Test.depend | 61 - CodeBlocks/Test.layout | 20 - CodeBlocks_Linux/CANvenient.cbp | 89 - CodeBlocks_Linux/CANvenient.depend | 321 -- CodeBlocks_Linux/CANvenient.layout | 50 - CodeBlocks_Linux/CANvenient.workspace | 7 - CodeBlocks_Linux/CANvenient.workspace.layout | 6 - CodeBlocks_Linux/Test.cbp | 48 - CodeBlocks_Linux/Test.depend | 90 - CodeBlocks_Linux/Test.layout | 20 - README.md | 2 +- cmake/dep_TinyCan.cmake | 13 + cmake/deps.cmake | 32 + deps/tiny_can/dev/lib/can_drv.h | 287 -- deps/tiny_can/dev/lib/can_drv_config.h | 26 - deps/tiny_can/dev/lib/can_drv_ex.h | 488 --- deps/tiny_can/dev/lib/can_types.h | 384 -- deps/tiny_can/dev/lib/mhs_can_drv.c | 3269 ------------------ include/CANvenient.h | 8 - src/CANvenient.c | 3 +- src/drivers/CANvenient_Ixxat.c | 46 +- src/drivers/CANvenient_Ixxat.h | 24 +- src/drivers/CANvenient_Kvaser.c | 43 +- src/drivers/CANvenient_Kvaser.h | 26 +- src/drivers/CANvenient_PEAK.c | 49 +- src/drivers/CANvenient_PEAK.h | 26 +- src/drivers/CANvenient_SocketCAN.h | 24 +- src/drivers/CANvenient_Softing.c | 46 +- src/drivers/CANvenient_Softing.h | 26 +- src/drivers/CANvenient_TinyCan.c | 609 ++-- src/drivers/CANvenient_TinyCan.h | 23 +- src/drivers/CANvenient_internal.h | 24 +- src/drivers/CANvenient_template.h | 26 +- src/global.h | 31 - 43 files changed, 469 insertions(+), 6334 deletions(-) delete mode 100755 CodeBlocks/CANvenient.cbp delete mode 100755 CodeBlocks/CANvenient.depend delete mode 100755 CodeBlocks/CANvenient.layout delete mode 100755 CodeBlocks/CANvenient.workspace delete mode 100755 CodeBlocks/CANvenient.workspace.layout delete mode 100755 CodeBlocks/Test.cbp delete mode 100755 CodeBlocks/Test.depend delete mode 100755 CodeBlocks/Test.layout delete mode 100755 CodeBlocks_Linux/CANvenient.cbp delete mode 100755 CodeBlocks_Linux/CANvenient.depend delete mode 100755 CodeBlocks_Linux/CANvenient.layout delete mode 100755 CodeBlocks_Linux/CANvenient.workspace delete mode 100755 CodeBlocks_Linux/CANvenient.workspace.layout delete mode 100755 CodeBlocks_Linux/Test.cbp delete mode 100755 CodeBlocks_Linux/Test.depend delete mode 100755 CodeBlocks_Linux/Test.layout create mode 100644 cmake/dep_TinyCan.cmake delete mode 100755 deps/tiny_can/dev/lib/can_drv.h delete mode 100755 deps/tiny_can/dev/lib/can_drv_config.h delete mode 100755 deps/tiny_can/dev/lib/can_drv_ex.h delete mode 100755 deps/tiny_can/dev/lib/can_types.h delete mode 100755 deps/tiny_can/dev/lib/mhs_can_drv.c mode change 100755 => 100644 include/CANvenient.h mode change 100755 => 100644 src/CANvenient.c mode change 100755 => 100644 src/drivers/CANvenient_Ixxat.c mode change 100755 => 100644 src/drivers/CANvenient_Ixxat.h mode change 100755 => 100644 src/drivers/CANvenient_Kvaser.c mode change 100755 => 100644 src/drivers/CANvenient_Kvaser.h mode change 100755 => 100644 src/drivers/CANvenient_PEAK.c mode change 100755 => 100644 src/drivers/CANvenient_PEAK.h mode change 100755 => 100644 src/drivers/CANvenient_SocketCAN.h mode change 100755 => 100644 src/drivers/CANvenient_Softing.c mode change 100755 => 100644 src/drivers/CANvenient_Softing.h mode change 100755 => 100644 src/drivers/CANvenient_internal.h mode change 100755 => 100644 src/drivers/CANvenient_template.h delete mode 100755 src/global.h diff --git a/.gitignore b/.gitignore index df049d9..4abb374 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ .vs -bin -obj +deps* out build tmp diff --git a/CMakeLists.txt b/CMakeLists.txt index ca21ecb..a08e5d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,7 @@ add_library( ${CMAKE_CURRENT_SOURCE_DIR}/src/drivers/CANvenient_PEAK.c ${CMAKE_CURRENT_SOURCE_DIR}/src/drivers/CANvenient_SocketCAN.c ${CMAKE_CURRENT_SOURCE_DIR}/src/drivers/CANvenient_Softing.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/drivers/CANvenient_TinyCan.c ) set_property(TARGET ${PROJECT_NAME} PROPERTY C_STANDARD 99) diff --git a/CMakeSettings.json b/CMakeSettings.json index 42c83b5..50415c8 100644 --- a/CMakeSettings.json +++ b/CMakeSettings.json @@ -28,30 +28,6 @@ "buildCommandArgs": "", "ctestCommandArgs": "", "inheritEnvironments": [ "msvc_x64_x64" ] - }, - { - "name": "x86-Debug", - "generator": "Ninja", - "configurationType": "Debug", - "buildRoot": "${projectDir}\\out\\build\\${name}", - "installRoot": "${projectDir}\\out\\install\\${name}", - "cmakeCommandArgs": "", - "buildCommandArgs": "", - "ctestCommandArgs": "", - "inheritEnvironments": [ "msvc_x86" ], - "variables": [] - }, - { - "name": "x86-Release", - "generator": "Ninja", - "configurationType": "RelWithDebInfo", - "buildRoot": "${projectDir}\\out\\build\\${name}", - "installRoot": "${projectDir}\\out\\install\\${name}", - "cmakeCommandArgs": "", - "buildCommandArgs": "", - "ctestCommandArgs": "", - "inheritEnvironments": [ "msvc_x86" ], - "variables": [] } ] } \ No newline at end of file diff --git a/CodeBlocks/CANvenient.cbp b/CodeBlocks/CANvenient.cbp deleted file mode 100755 index 11f7fa2..0000000 --- a/CodeBlocks/CANvenient.cbp +++ /dev/null @@ -1,92 +0,0 @@ - - - - - - diff --git a/CodeBlocks/CANvenient.depend b/CodeBlocks/CANvenient.depend deleted file mode 100755 index 5fc3cd0..0000000 --- a/CodeBlocks/CANvenient.depend +++ /dev/null @@ -1,321 +0,0 @@ -# depslib dependency file v1.0 -1683924000 source:x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\mhs_can_drv.c - "can_drv.h" - - - - - - - - - - - - - - - - -1775945270 - -1718834685 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv.h - "can_types.h" - "can_drv_config.h" - - - - - "can_drv_ex.h" - -1718834685 x.h" - -1681072468 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_types.h - - - - -1682157640 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_config.h - -1694268622 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_ex.h - -1776198155 source:x:\tiny_can\mhs\canopen\git\canvenient\src\canvenient.c - - - "CANvenient.h" - "drivers/CANvenient_internal.h" - "drivers/CANvenient_Ixxat.h" - "drivers/CANvenient_Kvaser.h" - "drivers/CANvenient_SocketCAN.h" - "drivers/CANvenient_Softing.h" - "drivers/CANvenient_PEAK.h" - "drivers/CANvenient_TinyCan.h" - -1775909477 ANvenient_TinyCan.h" - -1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h - - - - - -1775988415 .h> - -1776116619 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_internal.h - "global.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.h - "global.h" - "CANvenient.h" - -1775902876 t.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.h - "global.h" - "CANvenient.h" - -1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775846939 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.c - - - - - - - - - - - - - - - "CANvenient.h" - "CANvenient_internal.h" - -1775846940 t_internal.h" - -1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775988415 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775846940 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_template.c - "CANvenient.h" - "CANvenient_internal.h" - -1776198323 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.c - - - - "CANvenient.h" - "CANvenient_internal.h" - "can_drv.h" - -1775989972 " - -1683924000 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/mhs_can_drv.c - "can_drv.h" - - - - - - - - - - - - - - - - -1718834685 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv.h - "can_types.h" - "can_drv_config.h" - - - - - "can_drv_ex.h" - -1681072468 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_types.h - - - - -1682157640 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_config.h - -1694268622 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_ex.h - -1776116544 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/CANvenient.c - - - "CANvenient.h" - "drivers/CANvenient_internal.h" - "drivers/CANvenient_Ixxat.h" - "drivers/CANvenient_Kvaser.h" - "drivers/CANvenient_SocketCAN.h" - "drivers/CANvenient_Softing.h" - "drivers/CANvenient_PEAK.h" - "drivers/CANvenient_TinyCan.h" - -1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h - - - - - -1776116619 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_internal.h - "global.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.h - "global.h" - "CANvenient.h" - -1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775988415 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775846939 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.c - - - - - - - - - - - - - - - "CANvenient.h" - "CANvenient_internal.h" - -1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775846940 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_template.c - "CANvenient.h" - "CANvenient_internal.h" - -1776112109 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.c - - - - "CANvenient.h" - "CANvenient_internal.h" - "can_drv.h" - -1776184766 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/global.h - -1776184766 x:\tiny_can\mhs\canopen\git\canvenient\src\global.h - diff --git a/CodeBlocks/CANvenient.layout b/CodeBlocks/CANvenient.layout deleted file mode 100755 index 4213bb5..0000000 --- a/CodeBlocks/CANvenient.layout +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/CodeBlocks/CANvenient.workspace b/CodeBlocks/CANvenient.workspace deleted file mode 100755 index 16d2340..0000000 --- a/CodeBlocks/CANvenient.workspace +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/CodeBlocks/CANvenient.workspace.layout b/CodeBlocks/CANvenient.workspace.layout deleted file mode 100755 index 12df4fe..0000000 --- a/CodeBlocks/CANvenient.workspace.layout +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/CodeBlocks/Test.cbp b/CodeBlocks/Test.cbp deleted file mode 100755 index f2fe56a..0000000 --- a/CodeBlocks/Test.cbp +++ /dev/null @@ -1,52 +0,0 @@ - - - - - - diff --git a/CodeBlocks/Test.depend b/CodeBlocks/Test.depend deleted file mode 100755 index 0c82845..0000000 --- a/CodeBlocks/Test.depend +++ /dev/null @@ -1,61 +0,0 @@ -# depslib dependency file v1.0 -1776025542 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.c - - - - - - - "linux_util.h" - -1776025542 l.h" - -1776117160 x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.h - -1776185211 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\rx_tx_example.c - - - - - - - "linux_util.h" - - -1776111075 - -1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h - - - - - -1775846938 .h> - -1776117130 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/rx_tx_example.c - - - - - - - "linux_util.h" - - -1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h - - - - - -1776117160 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.h - -1776025542 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.c - - - - - - - "linux_util.h" - diff --git a/CodeBlocks/Test.layout b/CodeBlocks/Test.layout deleted file mode 100755 index 4e4e5a4..0000000 --- a/CodeBlocks/Test.layout +++ /dev/null @@ -1,20 +0,0 @@ - - - - - - - - - - - - - - - - - - - - diff --git a/CodeBlocks_Linux/CANvenient.cbp b/CodeBlocks_Linux/CANvenient.cbp deleted file mode 100755 index b574855..0000000 --- a/CodeBlocks_Linux/CANvenient.cbp +++ /dev/null @@ -1,89 +0,0 @@ - - - - - - diff --git a/CodeBlocks_Linux/CANvenient.depend b/CodeBlocks_Linux/CANvenient.depend deleted file mode 100755 index f082512..0000000 --- a/CodeBlocks_Linux/CANvenient.depend +++ /dev/null @@ -1,321 +0,0 @@ -# depslib dependency file v1.0 -1683924000 source:x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\mhs_can_drv.c - "can_drv.h" - - - - - - - - - - - - - - - - -1775945270 - -1718834685 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv.h - "can_types.h" - "can_drv_config.h" - - - - - "can_drv_ex.h" - -1718834685 x.h" - -1681072468 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_types.h - - - - -1682157640 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_config.h - -1694268622 x:\tiny_can\mhs\canopen\git\canvenient\deps\tiny_can\dev\lib\can_drv_ex.h - -1776116544 source:x:\tiny_can\mhs\canopen\git\canvenient\src\canvenient.c - - - "CANvenient.h" - "drivers/CANvenient_internal.h" - "drivers/CANvenient_Ixxat.h" - "drivers/CANvenient_Kvaser.h" - "drivers/CANvenient_SocketCAN.h" - "drivers/CANvenient_Softing.h" - "drivers/CANvenient_PEAK.h" - "drivers/CANvenient_TinyCan.h" - -1775909477 ANvenient_TinyCan.h" - -1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h - - - - - -1775988415 .h> - -1776116619 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_internal.h - "global.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.h - "global.h" - "CANvenient.h" - -1775902876 t.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.h - "global.h" - "CANvenient.h" - -1776116845 x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.h - "global.h" - "CANvenient.h" - -1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_ixxat.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_kvaser.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775846939 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_socketcan.c - - - - - - - - - - - - - - - "CANvenient.h" - "CANvenient_internal.h" - -1775846940 t_internal.h" - -1775945270 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_softing.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775988415 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_peak.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775846940 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_template.c - "CANvenient.h" - "CANvenient_internal.h" - -1776112109 source:x:\tiny_can\mhs\canopen\git\canvenient\src\drivers\canvenient_tinycan.c - - - - "CANvenient.h" - "CANvenient_internal.h" - "can_drv.h" - -1775989972 " - -1683924000 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/mhs_can_drv.c - "can_drv.h" - - - - - - - - - - - - - - - - -1718834685 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv.h - "can_types.h" - "can_drv_config.h" - - - - - "can_drv_ex.h" - -1681072468 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_types.h - - - - -1682157640 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_config.h - -1694268622 /data/tiny_can/mhs/CanOpen/git/CANvenient/deps/tiny_can/dev/lib/can_drv_ex.h - -1776116544 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/CANvenient.c - - - "CANvenient.h" - "drivers/CANvenient_internal.h" - "drivers/CANvenient_Ixxat.h" - "drivers/CANvenient_Kvaser.h" - "drivers/CANvenient_SocketCAN.h" - "drivers/CANvenient_Softing.h" - "drivers/CANvenient_PEAK.h" - "drivers/CANvenient_TinyCan.h" - -1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h - - - - - -1776116619 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_internal.h - "global.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.h - "global.h" - "CANvenient.h" - -1776116845 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.h - "global.h" - "CANvenient.h" - -1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Ixxat.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Kvaser.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775988415 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_PEAK.c - - - - "CANvenient.h" - "CANvenient_internal.h" - - - -1775846939 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_SocketCAN.c - - - - - - - - - - - - - - - "CANvenient.h" - "CANvenient_internal.h" - -1775945270 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_Softing.c - - - - - "CANvenient.h" - "CANvenient_internal.h" - - - - -1775846940 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_template.c - "CANvenient.h" - "CANvenient_internal.h" - -1776112109 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/drivers/CANvenient_TinyCan.c - - - - "CANvenient.h" - "CANvenient_internal.h" - "can_drv.h" - -1776184766 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/global.h - -1776184766 x:\tiny_can\mhs\canopen\git\canvenient\src\global.h - diff --git a/CodeBlocks_Linux/CANvenient.layout b/CodeBlocks_Linux/CANvenient.layout deleted file mode 100755 index 277bad0..0000000 --- a/CodeBlocks_Linux/CANvenient.layout +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/CodeBlocks_Linux/CANvenient.workspace b/CodeBlocks_Linux/CANvenient.workspace deleted file mode 100755 index 16d2340..0000000 --- a/CodeBlocks_Linux/CANvenient.workspace +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/CodeBlocks_Linux/CANvenient.workspace.layout b/CodeBlocks_Linux/CANvenient.workspace.layout deleted file mode 100755 index 12df4fe..0000000 --- a/CodeBlocks_Linux/CANvenient.workspace.layout +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/CodeBlocks_Linux/Test.cbp b/CodeBlocks_Linux/Test.cbp deleted file mode 100755 index ec5d417..0000000 --- a/CodeBlocks_Linux/Test.cbp +++ /dev/null @@ -1,48 +0,0 @@ - - - - - - diff --git a/CodeBlocks_Linux/Test.depend b/CodeBlocks_Linux/Test.depend deleted file mode 100755 index 1a70086..0000000 --- a/CodeBlocks_Linux/Test.depend +++ /dev/null @@ -1,90 +0,0 @@ -# depslib dependency file v1.0 -1776025542 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.c - - - - - - - "linux_util.h" - -1776025542 l.h" - -1776117160 x:\tiny_can\mhs\canopen\git\canvenient\src\tests\linux_util.h - -1776185211 source:x:\tiny_can\mhs\canopen\git\canvenient\src\tests\rx_tx_example.c - - - - - - - "linux_util.h" - - -1776117130 - -1776111075 - -1776112683 x:\tiny_can\mhs\canopen\git\canvenient\include\canvenient.h - - - - - -1776112683 .h> - -1776117130 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/rx_tx_example.c - - - - - - - "linux_util.h" - - -1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h - - - - - -1776117160 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.h - -1776025542 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.c - - - - - - - "linux_util.h" - -1776025542 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.c - - - - - - - "linux_util.h" - -1776117160 /data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/linux_util.h - -1776185211 source:/data/tiny_can/mhs/CanOpen/git/CANvenient/src/tests/rx_tx_example.c - - - - - - - "linux_util.h" - - -1776112683 /data/tiny_can/mhs/CanOpen/git/CANvenient/include/CANvenient.h - - - - - diff --git a/CodeBlocks_Linux/Test.layout b/CodeBlocks_Linux/Test.layout deleted file mode 100755 index f3837c0..0000000 --- a/CodeBlocks_Linux/Test.layout +++ /dev/null @@ -1,20 +0,0 @@ - - - - - - - - - - - - - - - - - - - - diff --git a/README.md b/README.md index b54e8ac..6885f78 100755 --- a/README.md +++ b/README.md @@ -21,4 +21,4 @@ The following back-ends are currently implemented: - PCAN-Basic - SocketCAN - Softing CAN Layer 2 -- MHS Elektronik - Tiny-CAN +- MHS Elektronik Tiny-CAN diff --git a/cmake/dep_TinyCan.cmake b/cmake/dep_TinyCan.cmake new file mode 100644 index 0000000..d25f3d4 --- /dev/null +++ b/cmake/dep_TinyCan.cmake @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.16) +project(TinyCan_devel C) + +add_library( + mhstcan + SHARED + ${CMAKE_CURRENT_SOURCE_DIR}/dev/lib/mhs_can_drv.c) + +set_target_properties(mhstcan PROPERTIES + WINDOWS_EXPORT_ALL_SYMBOLS ON + ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") \ No newline at end of file diff --git a/cmake/deps.cmake b/cmake/deps.cmake index ebe959e..62b4739 100644 --- a/cmake/deps.cmake +++ b/cmake/deps.cmake @@ -152,11 +152,40 @@ if(WIN32) set(SOFTING_INCLUDE_DIR "${SOFTING_PATH}/CAN/CAN Layer2/APIDLL") set(SOFTING_LIBRARY "${SOFTING_PATH}/CAN/CAN Layer2/APIDLL/${SOFTING_PLATFORM}/canL2${SOFTING_POSTFIX}.lib") + # Tiny-Can + set(TINYCAN_VERSION "8.12") + + set(TINYCAN_DEVEL_PKG TinyCan_v${TINYCAN_VERSION}.zip) + set(TINYCAN_DEVEL_URL https://canopenterm.de/mirror) + set(TINYCAN_DEVEL_HASH c047e901ccb34bc764fb5dc5f2359dad82ff55c4) + + ExternalProject_Add(TinyCan_devel + URL ${TINYCAN_DEVEL_URL}/${TINYCAN_DEVEL_PKG} + URL_HASH SHA1=${TINYCAN_DEVEL_HASH} + DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/deps + DOWNLOAD_NO_PROGRESS true + DOWNLOAD_EXTRACT_TIMESTAMP true + TLS_VERIFY true + SOURCE_DIR ${TINYCAN_PATH}/ + BUILD_BYPRODUCTS "${CMAKE_CURRENT_BINARY_DIR}/mhstcan.dll" + + INSTALL_COMMAND ${CMAKE_COMMAND} -E copy + "${CMAKE_CURRENT_BINARY_DIR}/TinyCan_devel-prefix/src/TinyCan_devel-build/mhstcan.dll" + ${CMAKE_CURRENT_BINARY_DIR}/ + + PATCH_COMMAND ${CMAKE_COMMAND} -E copy + "${CMAKE_CURRENT_SOURCE_DIR}/cmake/dep_TinyCan.cmake" ${TINYCAN_PATH}/CMakeLists.txt + ) + + set(TINYCAN_INCLUDE_DIR "${TINYCAN_PATH}/dev/lib") + set(TINYCAN_LIBRARY "${CMAKE_CURRENT_BINARY_DIR}/TinyCan_devel-prefix/src/TinyCan_devel-build/mhstcan.lib") + set(PLATFORM_DEPS Ixxat_devel Kvaser_devel PCAN_devel Softing_devel + TinyCan_devel ) set(PLATFORM_LIBS @@ -164,6 +193,7 @@ if(WIN32) ${KVASER_LIBRARY} ${PCAN_LIBRARY} ${SOFTING_LIBRARY} + ${TINYCAN_LIBRARY} ) include_directories( @@ -174,6 +204,7 @@ if(WIN32) SYSTEM ${PCAN_INCLUDE_DIR}/../src/pcan/driver SYSTEM ${PCAN_INCLUDE_DIR}/../src/pcan/lib SYSTEM ${SOFTING_INCLUDE_DIR} + SYSTEM ${TINYCAN_INCLUDE_DIR} ) add_dependencies( @@ -182,5 +213,6 @@ if(WIN32) Kvaser_devel PCAN_devel Softing_devel + TinyCan_devel ) endif() diff --git a/deps/tiny_can/dev/lib/can_drv.h b/deps/tiny_can/dev/lib/can_drv.h deleted file mode 100755 index 037772b..0000000 --- a/deps/tiny_can/dev/lib/can_drv.h +++ /dev/null @@ -1,287 +0,0 @@ -#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/deps/tiny_can/dev/lib/can_drv_config.h b/deps/tiny_can/dev/lib/can_drv_config.h deleted file mode 100755 index 456e05c..0000000 --- a/deps/tiny_can/dev/lib/can_drv_config.h +++ /dev/null @@ -1,26 +0,0 @@ -#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/deps/tiny_can/dev/lib/can_drv_ex.h b/deps/tiny_can/dev/lib/can_drv_ex.h deleted file mode 100755 index 50730d1..0000000 --- a/deps/tiny_can/dev/lib/can_drv_ex.h +++ /dev/null @@ -1,488 +0,0 @@ -#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/deps/tiny_can/dev/lib/can_types.h b/deps/tiny_can/dev/lib/can_types.h deleted file mode 100755 index c5ecb18..0000000 --- a/deps/tiny_can/dev/lib/can_types.h +++ /dev/null @@ -1,384 +0,0 @@ -#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/deps/tiny_can/dev/lib/mhs_can_drv.c b/deps/tiny_can/dev/lib/mhs_can_drv.c deleted file mode 100755 index 8c59dd1..0000000 --- a/deps/tiny_can/dev/lib/mhs_can_drv.c +++ /dev/null @@ -1,3269 +0,0 @@ -/*************************************************************************** - 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/include/CANvenient.h b/include/CANvenient.h old mode 100755 new mode 100644 index 8040a4c..ab5515e --- a/include/CANvenient.h +++ b/include/CANvenient.h @@ -13,10 +13,6 @@ #include -#ifdef __cplusplus - extern "C" { -#endif - #define CAN_MAX_INTERFACES 64 #ifdef _WIN32 @@ -115,8 +111,4 @@ CANVENIENT_API int can_set_baudrate(int index, enum can_baudrate baud); CANVENIENT_API int can_send(int index, struct can_frame* frame); CANVENIENT_API int can_recv(int index, struct can_frame* frame, u64* timestamp); -#ifdef __cplusplus - } -#endif - #endif /* CANVENIENT_H */ diff --git a/src/CANvenient.c b/src/CANvenient.c old mode 100755 new mode 100644 index aa43f6b..74b7b7b --- a/src/CANvenient.c +++ b/src/CANvenient.c @@ -56,6 +56,7 @@ CANVENIENT_API int can_find_interfaces(void) { return status; } + return softing_find_interfaces(); } @@ -194,7 +195,7 @@ CANVENIENT_API int can_get_baudrate(int index, enum can_baudrate* baud) set_error_reason("Channel index is out-of-range."); return -1; } - else if (!baud) + else if (! baud) { set_error_reason("Output parameter is NULL."); return -1; diff --git a/src/drivers/CANvenient_Ixxat.c b/src/drivers/CANvenient_Ixxat.c old mode 100755 new mode 100644 index be381a4..895c81e --- a/src/drivers/CANvenient_Ixxat.c +++ b/src/drivers/CANvenient_Ixxat.c @@ -15,11 +15,7 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef VENIENT_IXXAT_DRV_DISABLED - #pragma message("!!!!!! WARNING: Ixxat driver is disabled. !!!!!!") -#endif - -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 #include #include #include @@ -40,7 +36,7 @@ static void ixxat_baudrate_to_btr(enum can_baudrate baud, u8* bt0, u8* bt1); int ixxat_find_interfaces(void) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 IVciDeviceManager* pDevMan = NULL; IVciEnumDevice* pEnum = NULL; @@ -149,7 +145,7 @@ int ixxat_find_interfaces(void) int ixxat_open(int index) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 ixxat_ctx_t* ctx; IVciDeviceManager* pDevMan = NULL; @@ -245,11 +241,7 @@ int ixxat_open(int index) return 0; #else - #ifdef VENIENT_IXXAT_DRV_DISABLED - set_error_reason("Ixxat driver is disabled."); - #else set_error_reason("Ixxat driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -257,7 +249,7 @@ int ixxat_open(int index) void ixxat_close(int index) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; if (ctx) @@ -281,18 +273,14 @@ void ixxat_close(int index) } #else - #ifdef VENIENT_IXXAT_DRV_DISABLED - set_error_reason("Ixxat driver is disabled."); - #else set_error_reason("Ixxat driver is only supported on Windows."); - #endif (void)index; #endif } int ixxat_update(int index) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 ixxat_ctx_t* ctx; IVciDeviceManager* pDevMan = NULL; @@ -324,11 +312,7 @@ int ixxat_update(int index) return 0; #else - #ifdef VENIENT_IXXAT_DRV_DISABLED - set_error_reason("Ixxat driver is disabled."); - #else set_error_reason("Ixxat driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -336,7 +320,7 @@ int ixxat_update(int index) int ixxat_set_baudrate(int index, enum can_baudrate baud) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; IVciDeviceManager* pDevMan = NULL; @@ -478,11 +462,7 @@ int ixxat_set_baudrate(int index, enum can_baudrate baud) return 0; #else - #ifdef VENIENT_IXXAT_DRV_DISABLED - set_error_reason("Ixxat driver is disabled."); - #else set_error_reason("Ixxat driver is only supported on Windows."); - #endif (void)index; (void)baud; return -1; @@ -491,7 +471,7 @@ int ixxat_set_baudrate(int index, enum can_baudrate baud) int ixxat_send(int index, struct can_frame* frame) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; CANMSG msg = {0}; @@ -523,11 +503,7 @@ int ixxat_send(int index, struct can_frame* frame) return 0; #else - #ifdef VENIENT_IXXAT_DRV_DISABLED - set_error_reason("Ixxat driver is disabled."); - #else set_error_reason("Ixxat driver is only supported on Windows."); - #endif (void)index; (void)frame; return -1; @@ -536,7 +512,7 @@ int ixxat_send(int index, struct can_frame* frame) int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) { -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 ixxat_ctx_t* ctx = (ixxat_ctx_t*)can_interface[index].internal; CANMSG msg = {0}; @@ -574,11 +550,7 @@ int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) return 0; #else - #ifdef VENIENT_IXXAT_DRV_DISABLED - set_error_reason("Ixxat driver is disabled."); - #else set_error_reason("Ixxat driver is only supported on Windows."); - #endif (void)index; (void)frame; (void)timestamp; @@ -586,7 +558,7 @@ int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) #endif } -#if defined(_WIN32) && !defined(VENIENT_IXXAT_DRV_DISABLED) +#ifdef _WIN32 static void ixxat_baudrate_to_btr(enum can_baudrate baud, u8* bt0, u8* bt1) { switch (baud) diff --git a/src/drivers/CANvenient_Ixxat.h b/src/drivers/CANvenient_Ixxat.h old mode 100755 new mode 100644 index 2b865a0..6f618c6 --- a/src/drivers/CANvenient_Ixxat.h +++ b/src/drivers/CANvenient_Ixxat.h @@ -7,24 +7,16 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" - -#ifdef __cplusplus - extern "C" { -#endif -int ixxat_find_interfaces(void) ATTRIBUTE_INTERNAL; +#include "CANvenient.h" -int ixxat_open(int index) ATTRIBUTE_INTERNAL; -void ixxat_close(int index) ATTRIBUTE_INTERNAL; -int ixxat_update(int index) ATTRIBUTE_INTERNAL; +int ixxat_find_interfaces(void); -int ixxat_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; +int ixxat_open(int index); +void ixxat_close(int index); +int ixxat_update(int index); -int ixxat_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int ixxat_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; +int ixxat_set_baudrate(int index, enum can_baudrate baud); -#ifdef __cplusplus - } -#endif \ No newline at end of file +int ixxat_send(int index, struct can_frame* frame); +int ixxat_recv(int index, struct can_frame* frame, u64* timestamp); diff --git a/src/drivers/CANvenient_Kvaser.c b/src/drivers/CANvenient_Kvaser.c old mode 100755 new mode 100644 index 0a748fc..293a00f --- a/src/drivers/CANvenient_Kvaser.c +++ b/src/drivers/CANvenient_Kvaser.c @@ -16,11 +16,7 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef VENIENT_KVASER_DRV_DISABLED - #pragma message("!!!!!! WARNING: Kvaser driver is disabled. !!!!!!") -#endif - -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 #include #include @@ -37,7 +33,7 @@ static const char* get_canlib_error_text(canStatus status); int kvaser_find_interfaces(void) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 int channel_count = 0; canStatus status; @@ -122,7 +118,7 @@ int kvaser_find_interfaces(void) int kvaser_open(int index) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; CanHandle hnd; @@ -156,11 +152,7 @@ int kvaser_open(int index) return 0; #else - #ifdef VENIENT_KVASER_DRV_DISABLED - set_error_reason("Kvaser driver is disabled."); - #else set_error_reason("Kvaser driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -168,7 +160,7 @@ int kvaser_open(int index) void kvaser_close(int index) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; @@ -183,18 +175,14 @@ void kvaser_close(int index) can_interface[index].opened = 0; #else - #ifdef VENIENT_KVASER_DRV_DISABLED - set_error_reason("Kvaser driver is disabled."); - #else set_error_reason("Kvaser driver is only supported on Windows."); - #endif (void)index; #endif } int kvaser_update(int index) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 kvaser_channel_info_t* ch_info; canStatus status; @@ -216,11 +204,7 @@ int kvaser_update(int index) return 0; #else - #ifdef VENIENT_KVASER_DRV_DISABLED - set_error_reason("Kvaser driver is disabled."); - #else set_error_reason("Kvaser driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -228,7 +212,7 @@ int kvaser_update(int index) int kvaser_set_baudrate(int index, enum can_baudrate baud) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 can_close(index); can_interface[index].baudrate = baud; @@ -244,7 +228,7 @@ int kvaser_set_baudrate(int index, enum can_baudrate baud) int kvaser_send(int index, struct can_frame* frame) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; canStatus status; @@ -259,11 +243,7 @@ int kvaser_send(int index, struct can_frame* frame) return 0; #else - #ifdef VENIENT_KVASER_DRV_DISABLED - set_error_reason("Kvaser driver is disabled."); - #else set_error_reason("Kvaser driver is only supported on Windows."); - #endif (void)index; (void)frame; return -1; @@ -272,7 +252,7 @@ int kvaser_send(int index, struct can_frame* frame) int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) { -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 kvaser_channel_info_t* ch_info = (kvaser_channel_info_t*)can_interface[index].internal; canStatus status; @@ -298,11 +278,7 @@ int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) return 0; #else - #ifdef VENIENT_KVASER_DRV_DISABLED - set_error_reason("Kvaser driver is disabled."); - #else set_error_reason("Kvaser driver is only supported on Windows."); - #endif (void)index; (void)frame; (void)timestamp; @@ -310,8 +286,7 @@ int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) #endif } - -#if defined(_WIN32) && !defined(VENIENT_KVASER_DRV_DISABLED) +#ifdef _WIN32 static long baudrate_to_canlib(enum can_baudrate baud) { switch (baud) diff --git a/src/drivers/CANvenient_Kvaser.h b/src/drivers/CANvenient_Kvaser.h old mode 100755 new mode 100644 index 663e6ef..1dcd1e7 --- a/src/drivers/CANvenient_Kvaser.h +++ b/src/drivers/CANvenient_Kvaser.h @@ -7,25 +7,17 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" - -#ifdef __cplusplus - extern "C" { -#endif -int kvaser_find_interfaces(void) ATTRIBUTE_INTERNAL; +#include "CANvenient.h" -int kvaser_open(int index) ATTRIBUTE_INTERNAL; -int kvaser_open_fd(int index) ATTRIBUTE_INTERNAL; -void kvaser_close(int index) ATTRIBUTE_INTERNAL; -int kvaser_update(int index) ATTRIBUTE_INTERNAL; +int kvaser_find_interfaces(void); -int kvaser_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; +int kvaser_open(int index); +int kvaser_open_fd(int index); +void kvaser_close(int index); +int kvaser_update(int index); -int kvaser_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int kvaser_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; +int kvaser_set_baudrate(int index, enum can_baudrate baud); -#ifdef __cplusplus - } -#endif \ No newline at end of file +int kvaser_send(int index, struct can_frame* frame); +int kvaser_recv(int index, struct can_frame* frame, u64* timestamp); diff --git a/src/drivers/CANvenient_PEAK.c b/src/drivers/CANvenient_PEAK.c old mode 100755 new mode 100644 index c681e42..094ea93 --- a/src/drivers/CANvenient_PEAK.c +++ b/src/drivers/CANvenient_PEAK.c @@ -15,11 +15,7 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef VENIENT_PEAK_DRV_DISABLED - #pragma message("!!!!!! WARNING: PEAK driver is disabled. !!!!!!") -#endif - -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 #include #include @@ -30,7 +26,7 @@ static TPCANBaudrate lookup_pcan_baudrate(enum can_baudrate baud); int peak_find_interfaces(void) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 u32 ch_count = 0; TPCANChannelInformation* pcan_ch_info; @@ -130,7 +126,7 @@ int peak_find_interfaces(void) int peak_open(int index) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 TPCANHandle pcan_ch = ((TPCANChannelInformation*)can_interface[index].internal)->channel_handle; TPCANStatus pcan_status; @@ -148,11 +144,7 @@ int peak_open(int index) } #else - #ifdef VENIENT_PEAK_DRV_DISABLED - set_error_reason("PEAK driver is disabled."); - #else set_error_reason("PEAK driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -160,7 +152,7 @@ int peak_open(int index) void peak_close(int index) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 TPCANStatus pcan_status; @@ -171,18 +163,14 @@ void peak_close(int index) } #else - #ifdef VENIENT_PEAK_DRV_DISABLED - set_error_reason("PEAK driver is disabled."); - #else set_error_reason("PEAK driver is only supported on Windows."); - #endif (void)index; #endif } int peak_update(int index) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 TPCANStatus pcan_status; @@ -203,11 +191,8 @@ int peak_update(int index) } #else - #ifdef VENIENT_PEAK_DRV_DISABLED - set_error_reason("PEAK driver is disabled."); - #else + set_error_reason("PEAK driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -215,18 +200,14 @@ int peak_update(int index) int peak_set_baudrate(int index, enum can_baudrate baud) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 can_close(index); can_interface[index].baudrate = baud; return can_open(index, baud); #else - #ifdef VENIENT_PEAK_DRV_DISABLED - set_error_reason("PEAK driver is disabled."); - #else set_error_reason("PEAK driver is only supported on Windows."); - #endif (void)index; (void)baud; return -1; @@ -235,7 +216,7 @@ int peak_set_baudrate(int index, enum can_baudrate baud) int peak_send(int index, struct can_frame* frame) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 TPCANHandle pcan_ch = ((TPCANChannelInformation*)can_interface[index].internal)->channel_handle; TPCANStatus pcan_status; @@ -261,11 +242,7 @@ int peak_send(int index, struct can_frame* frame) return 0; #else - #ifdef VENIENT_PEAK_DRV_DISABLED - set_error_reason("PEAK driver is disabled."); - #else set_error_reason("PEAK driver is only supported on Windows."); - #endif (void)index; (void)frame; return -1; @@ -274,7 +251,7 @@ int peak_send(int index, struct can_frame* frame) int peak_recv(int index, struct can_frame* frame, u64* timestamp) { -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 TPCANHandle pcan_ch = ((TPCANChannelInformation*)can_interface[index].internal)->channel_handle; TPCANStatus pcan_status; @@ -301,11 +278,8 @@ int peak_recv(int index, struct can_frame* frame, u64* timestamp) return 0; #else - #ifdef VENIENT_PEAK_DRV_DISABLED - set_error_reason("PEAK driver is disabled."); - #else + set_error_reason("PEAK driver is only supported on Windows."); - #endif (void)index; (void)frame; (void)timestamp; @@ -313,8 +287,7 @@ int peak_recv(int index, struct can_frame* frame, u64* timestamp) #endif } - -#if defined(_WIN32) && !defined(VENIENT_PEAK_DRV_DISABLED) +#ifdef _WIN32 static TPCANBaudrate lookup_pcan_baudrate(enum can_baudrate baud) { switch (baud) diff --git a/src/drivers/CANvenient_PEAK.h b/src/drivers/CANvenient_PEAK.h old mode 100755 new mode 100644 index f381ebd..8e45f37 --- a/src/drivers/CANvenient_PEAK.h +++ b/src/drivers/CANvenient_PEAK.h @@ -7,25 +7,17 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" - -#ifdef __cplusplus - extern "C" { -#endif -int peak_find_interfaces(void) ATTRIBUTE_INTERNAL; +#include "CANvenient.h" -int peak_open(int index) ATTRIBUTE_INTERNAL; -int peak_open_fd(int index) ATTRIBUTE_INTERNAL; -void peak_close(int index) ATTRIBUTE_INTERNAL; -int peak_update(int index) ATTRIBUTE_INTERNAL; +int peak_find_interfaces(void); -int peak_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; +int peak_open(int index); +int peak_open_fd(int index); +void peak_close(int index); +int peak_update(int index); -int peak_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int peak_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; +int peak_set_baudrate(int index, enum can_baudrate baud); -#ifdef __cplusplus - } -#endif \ No newline at end of file +int peak_send(int index, struct can_frame* frame); +int peak_recv(int index, struct can_frame* frame, u64* timestamp); diff --git a/src/drivers/CANvenient_SocketCAN.h b/src/drivers/CANvenient_SocketCAN.h old mode 100755 new mode 100644 index 450ef22..d8209b6 --- a/src/drivers/CANvenient_SocketCAN.h +++ b/src/drivers/CANvenient_SocketCAN.h @@ -7,24 +7,16 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" - -#ifdef __cplusplus - extern "C" { -#endif -int socketcan_find_interfaces(void) ATTRIBUTE_INTERNAL; +#include "CANvenient.h" -int socketcan_open(int index) ATTRIBUTE_INTERNAL; -void socketcan_close(int index) ATTRIBUTE_INTERNAL; -int socketcan_update(int index) ATTRIBUTE_INTERNAL; +int socketcan_find_interfaces(void); -int socketcan_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; +int socketcan_open(int index); +void socketcan_close(int index); +int socketcan_update(int index); -int socketcan_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int socketcan_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; +int socketcan_set_baudrate(int index, enum can_baudrate baud); -#ifdef __cplusplus - } -#endif +int socketcan_send(int index, struct can_frame* frame); +int socketcan_recv(int index, struct can_frame* frame, u64* timestamp); diff --git a/src/drivers/CANvenient_Softing.c b/src/drivers/CANvenient_Softing.c old mode 100755 new mode 100644 index 7dbf6a0..e80ed76 --- a/src/drivers/CANvenient_Softing.c +++ b/src/drivers/CANvenient_Softing.c @@ -16,11 +16,7 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#ifdef VENIENT_SOFTING_DRV_DISABLED - #pragma message("!!!!!! WARNING: Softing driver is disabled. !!!!!!") -#endif - -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 #include #include #include @@ -39,7 +35,7 @@ static double softing_baudrate_to_kbps(enum can_baudrate baud); int softing_find_interfaces(void) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 unsigned long buf_size_needed = 0; unsigned long num_channels = 0; @@ -131,7 +127,7 @@ int softing_find_interfaces(void) int softing_open(int index) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; L2CONFIG cfg; @@ -209,11 +205,7 @@ int softing_open(int index) return 0; #else - #ifdef VENIENT_SOFTING_DRV_DISABLED - set_error_reason("Softing driver is disabled."); - #else set_error_reason("Softing driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -221,7 +213,7 @@ int softing_open(int index) void softing_close(int index) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; @@ -239,18 +231,14 @@ void softing_close(int index) can_interface[index].opened = 0; #else - #ifdef VENIENT_SOFTING_DRV_DISABLED - set_error_reason("Softing driver is disabled."); - #else set_error_reason("Softing driver is only supported on Windows."); - #endif (void)index; #endif } int softing_update(int index) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 const softing_ctx_t* ctx; unsigned long buf_size_needed = 0; @@ -305,11 +293,7 @@ int softing_update(int index) return 0; #else - #ifdef VENIENT_SOFTING_DRV_DISABLED - set_error_reason("Softing driver is disabled."); - #else set_error_reason("Softing driver is only supported on Windows."); - #endif (void)index; return -1; #endif @@ -317,18 +301,14 @@ int softing_update(int index) int softing_set_baudrate(int index, enum can_baudrate baud) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 softing_close(index); can_interface[index].baudrate = baud; return softing_open(index); #else - #ifdef VENIENT_SOFTING_DRV_DISABLED - set_error_reason("Softing driver is disabled."); - #else set_error_reason("Softing driver is only supported on Windows."); - #endif (void)index; (void)baud; return -1; @@ -337,7 +317,7 @@ int softing_set_baudrate(int index, enum can_baudrate baud) int softing_send(int index, struct can_frame* frame) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; unsigned long ident; @@ -371,11 +351,7 @@ int softing_send(int index, struct can_frame* frame) return 0; #else - #ifdef VENIENT_SOFTING_DRV_DISABLED - set_error_reason("Softing driver is disabled."); - #else set_error_reason("Softing driver is only supported on Windows."); - #endif (void)index; (void)frame; return -1; @@ -384,7 +360,7 @@ int softing_send(int index, struct can_frame* frame) int softing_recv(int index, struct can_frame* frame, u64* timestamp) { -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 softing_ctx_t* ctx = (softing_ctx_t*)can_interface[index].internal; PARAM_STRUCT param; @@ -428,11 +404,7 @@ int softing_recv(int index, struct can_frame* frame, u64* timestamp) return -1; #else - #ifdef VENIENT_SOFTING_DRV_DISABLED - set_error_reason("Softing driver is disabled."); - #else set_error_reason("Softing driver is only supported on Windows."); - #endif (void)index; (void)frame; (void)timestamp; @@ -440,7 +412,7 @@ int softing_recv(int index, struct can_frame* frame, u64* timestamp) #endif } -#if defined(_WIN32) && !defined(VENIENT_SOFTING_DRV_DISABLED) +#ifdef _WIN32 static double softing_baudrate_to_kbps(enum can_baudrate baud) { switch (baud) diff --git a/src/drivers/CANvenient_Softing.h b/src/drivers/CANvenient_Softing.h old mode 100755 new mode 100644 index 4ea6693..7df4d5b --- a/src/drivers/CANvenient_Softing.h +++ b/src/drivers/CANvenient_Softing.h @@ -7,25 +7,17 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" - -#ifdef __cplusplus - extern "C" { -#endif -int softing_find_interfaces(void) ATTRIBUTE_INTERNAL; +#include "CANvenient.h" -int softing_open(int index) ATTRIBUTE_INTERNAL; -int softing_open_fd(int index) ATTRIBUTE_INTERNAL; -void softing_close(int index) ATTRIBUTE_INTERNAL; -int softing_update(int index) ATTRIBUTE_INTERNAL; +int softing_find_interfaces(void); -int softing_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; +int softing_open(int index); +int softing_open_fd(int index); +void softing_close(int index); +int softing_update(int index); -int softing_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int softing_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; +int softing_set_baudrate(int index, enum can_baudrate baud); -#ifdef __cplusplus - } -#endif \ No newline at end of file +int softing_send(int index, struct can_frame* frame); +int softing_recv(int index, struct can_frame* frame, u64* timestamp); diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index 0f42352..76b9fcb 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -10,6 +10,10 @@ * SPDX-License-Identifier: MIT * **/ + +#include +#include + #include #include #include @@ -17,37 +21,13 @@ #include "CANvenient.h" #include "CANvenient_internal.h" -#include "can_drv.h" - typedef struct _TTinyDevice TTinyDevice; struct _TTinyDevice - { - uint32_t DeviceIndex; - char Snr[20]; - }; - - -/* -#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 -#define TCAN_LOG_FLAG_DEBUG 0x08000000 -#define TCAN_LOG_FILE_HEADER 0x10000000 -#define TCAN_LOG_FILE_APPEND 0x20000000 -#define TCAN_LOG_FLAG_WITH_TIME 0x40000000 -#define TCAN_LOG_FLAG_DISABLE_SYNC 0x80000000 -*/ +{ + uint32_t DeviceIndex; + char Snr[20]; +}; // TimeStampMode // 0 = Disabled @@ -56,336 +36,375 @@ struct _TTinyDevice // 3 = Hardware Time Stamps // 4 = Hardware Time Stamp wenn verfügbar, ansonsten Software Time Stamps #ifdef ENABLE_LOG - #pragma message("!!!!!! WARNING: CAN-API driver log is enabled !!!!!!") +#pragma message("!!!!!! WARNING: CAN-API driver log is enabled !!!!!!") - #define TREIBER_INIT_PARAM "logfile=tinycan.log;logflags=0x880000F3;FdMode=0;CanCallThread=0;TimeStampMode=4" +#define TREIBER_INIT_PARAM "logfile=tinycan.log;logflags=0x880000F3;FdMode=0;CanCallThread=0;TimeStampMode=4" #else - #define TREIBER_INIT_PARAM "FdMode=0;CanCallThread=0;TimeStampMode=4" +#define TREIBER_INIT_PARAM "FdMode=0;CanCallThread=0;TimeStampMode=4" #endif #define DEVICE_OPEN_PARAM "AutoStopCan=1" static uint32_t TinyCanDriverInit = 0; - struct TCanVenientToTCanBaudrate - { - enum can_baudrate CanVenientBaud; - uint16_t TCanBaudrate; - }; +{ + enum can_baudrate CanVenientBaud; + uint16_t TCanBaudrate; +}; static const struct TCanVenientToTCanBaudrate CanVenientToTCanBaudrate[] = { - {CAN_BAUD_1M, CAN_1M_BIT}, - {CAN_BAUD_800K, CAN_800K_BIT}, - {CAN_BAUD_500K, CAN_500K_BIT}, - {CAN_BAUD_250K, CAN_250K_BIT}, - {CAN_BAUD_125K, CAN_125K_BIT}, - {CAN_BAUD_100K, CAN_100K_BIT}, - {CAN_BAUD_95K, 0xFFFF}, - {CAN_BAUD_83K, 0xFFFF}, - {CAN_BAUD_50K, CAN_50K_BIT}, - {CAN_BAUD_47K, 0xFFFF}, - {CAN_BAUD_33K, 0xFFFF}, - {CAN_BAUD_20K, CAN_20K_BIT}, - {CAN_BAUD_10K, CAN_10K_BIT}, - {CAN_BAUD_5K, 0xFFFF}, - {0, 0}}; - - -#define CAN_ERROR_TCAN -1 -#define CAN_ERROR_QXMTFULL -2 -#define CAN_ERROR_QRCVEMPTY -3 - -#define CAN_ERROR_QOVERRUN -4 -#define CAN_ERROR_BUSPASSIVE -5 -#define CAN_ERROR_BUSOFF -6 - -#define CAN_ERROR_NODRIVER -5 -#define CAN_ERROR_REGTEST -6 -#define CAN_ERROR_RESOURCE -7 - + {CAN_BAUD_1M, CAN_1M_BIT}, + {CAN_BAUD_800K, CAN_800K_BIT}, + {CAN_BAUD_500K, CAN_500K_BIT}, + {CAN_BAUD_250K, CAN_250K_BIT}, + {CAN_BAUD_125K, CAN_125K_BIT}, + {CAN_BAUD_100K, CAN_100K_BIT}, + {CAN_BAUD_95K, 0xFFFF}, + {CAN_BAUD_83K, 0xFFFF}, + {CAN_BAUD_50K, CAN_50K_BIT}, + {CAN_BAUD_47K, 0xFFFF}, + {CAN_BAUD_33K, 0xFFFF}, + {CAN_BAUD_20K, CAN_20K_BIT}, + {CAN_BAUD_10K, CAN_10K_BIT}, + {CAN_BAUD_5K, 0xFFFF}, + {0, 0}}; + +#define CAN_ERROR_TCAN -1 +#define CAN_ERROR_QXMTFULL -2 +#define CAN_ERROR_QRCVEMPTY -3 + +#define CAN_ERROR_QOVERRUN -4 +#define CAN_ERROR_BUSPASSIVE -5 +#define CAN_ERROR_BUSOFF -6 + +#define CAN_ERROR_NODRIVER -5 +#define CAN_ERROR_REGTEST -6 +#define CAN_ERROR_RESOURCE -7 struct TCanVenientMhsError - { - int32_t CanError; - const char *ErrorMsg; - }; - +{ + int32_t CanError; + const char* ErrorMsg; +}; static const struct TCanVenientMhsError CanVenientMhsError[] = { - {CAN_ERROR_TCAN, "Tiny-CAN API error."}, - {CAN_ERROR_QXMTFULL, "Transmit queue is full."}, - {CAN_ERROR_QRCVEMPTY, "Receive queue is empty."}, - - {CAN_ERROR_QOVERRUN, "Receive queue was read too late."}, - {CAN_ERROR_BUSPASSIVE, "Bus error: the CAN controller is error passive."}, - {CAN_ERROR_BUSOFF, "Bus error: the CAN controller is in bus-off state."}, + {CAN_ERROR_TCAN, "Tiny-CAN API error."}, + {CAN_ERROR_QXMTFULL, "Transmit queue is full."}, + {CAN_ERROR_QRCVEMPTY, "Receive queue is empty."}, - {CAN_ERROR_NODRIVER, "Driver not loaded."}, + {CAN_ERROR_QOVERRUN, "Receive queue was read too late."}, + {CAN_ERROR_BUSPASSIVE, "Bus error: the CAN controller is error passive."}, + {CAN_ERROR_BUSOFF, "Bus error: the CAN controller is in bus-off state."}, - {CAN_ERROR_REGTEST, "Test of the CAN controller hardware registers failed (no hardware found)."}, + {CAN_ERROR_NODRIVER, "Driver not loaded."}, - {CAN_ERROR_RESOURCE, "Resource (FIFO, Client, timeout) cannot be created."}, - {0, NULL}}; + {CAN_ERROR_REGTEST, "Test of the CAN controller hardware registers failed (no hardware found)."}, + {CAN_ERROR_RESOURCE, "Resource (FIFO, Client, timeout) cannot be created."}, + {0, NULL}}; -static const char *lookup_error_string(int32_t can_error, int32_t tcan_error) +static const char* lookup_error_string(int32_t can_error, int32_t tcan_error) { -const struct TCanVenientMhsError *err_list; -const char *error_str; -(void)tcan_error; - -if (can_error) - error_str = "No error. Success."; -else - { - for (err_list = CanVenientMhsError; (error_str = err_list->ErrorMsg); err_list++) + const struct TCanVenientMhsError* err_list; + const char* error_str; + (void)tcan_error; + + if (can_error) + { + error_str = "No error. Success."; + } + else + { + for (err_list = CanVenientMhsError; (error_str = err_list->ErrorMsg); err_list++) + { + if (can_error == err_list->CanError) + { + break; + } + } + } + if (! error_str) { - if (can_error == err_list->CanError) - break; + error_str = "Unknown error."; } - } -if (!error_str) - error_str = "Unknown error."; -return(error_str); + return (error_str); } - -static char *mhs_strdup(const char *str) +static char* mhs_strdup(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); -} + 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); + } +} int tinycan_find_interfaces(void) { -int res; -uint32_t k, idx, already_registered; -struct TCanDevicesList *can_dev_list; -int32_t num_devs, i; -char dev_name[100]; -TTinyDevice *tiny_device; - -res = 0; -if (!TinyCanDriverInit) - { - if (LoadDriver(NULL) >= 0) + int res; + uint32_t k, idx, already_registered; + struct TCanDevicesList* can_dev_list; + int32_t num_devs, i; + char dev_name[100]; + TTinyDevice* tiny_device; + + res = 0; + if (! TinyCanDriverInit) { - if (CanInitDriver(TREIBER_INIT_PARAM) >= 0) - TinyCanDriverInit = 1; + if (LoadDriver(NULL) >= 0) + { + if (CanInitDriver(TREIBER_INIT_PARAM) >= 0) + { + TinyCanDriverInit = 1; + } + } } - } -if ((num_devs = CanExGetDeviceList(&can_dev_list, 0)) <= 0) - { - set_error_reason("No Tiny-CAN hardwre found"); - return(-1); - } -for (i = 0; i < num_devs; i++) - { - snprintf(dev_name, sizeof(dev_name), "%s (S/N: %s)", can_dev_list[i].Description, can_dev_list[i].SerialNumber); - - already_registered = 0; - for (k = 0; k < CAN_MAX_INTERFACES; k++) + if ((num_devs = CanExGetDeviceList(&can_dev_list, 0)) <= 0) { - if (can_interface[k].name && strcmp(can_interface[k].name, dev_name) == 0) - { - already_registered = 1; - break; - } + set_error_reason("No Tiny-CAN hardwre found"); + return (-1); } - if (already_registered) - continue; - - if (0 != find_free_interface_slot(&idx)) - break; /* No free slot available: stop. */ - - if (!(tiny_device = malloc(sizeof(TTinyDevice)))) + for (i = 0; i < num_devs; i++) { - res = -1; - break; + snprintf(dev_name, sizeof(dev_name), "%s (S/N: %s)", can_dev_list[i].Description, can_dev_list[i].SerialNumber); + + already_registered = 0; + for (k = 0; k < CAN_MAX_INTERFACES; k++) + { + if (can_interface[k].name && strcmp(can_interface[k].name, dev_name) == 0) + { + already_registered = 1; + break; + } + } + if (already_registered) + { + continue; + } + + if (0 != find_free_interface_slot(&idx)) + { + break; /* No free slot available: stop. */ + } + + if (! (tiny_device = malloc(sizeof(TTinyDevice)))) + { + res = -1; + break; + } + can_interface[idx].internal = tiny_device; + if (! (can_interface[idx].name = mhs_strdup(dev_name))) + { + free(can_interface[idx].internal); + can_interface[idx].internal = NULL; + res = -1; + } + + tiny_device->DeviceIndex = INDEX_INVALID; + snprintf(tiny_device->Snr, 20, "%s", can_dev_list[i].SerialNumber); + + can_interface[idx].vendor = CAN_VENDOR_MHS; + can_interface[idx].opened = 0; + can_interface[idx].baudrate = CAN_BAUD_1M; } - can_interface[idx].internal = tiny_device; - if (!(can_interface[idx].name = mhs_strdup(dev_name))) + CanExDataFree((void**)&can_dev_list); + if (res < 0) { - free(can_interface[idx].internal); - can_interface[idx].internal = NULL; - res = -1; + set_error_reason("Memory allocation failed."); } - - tiny_device->DeviceIndex = INDEX_INVALID; - snprintf(tiny_device->Snr, 20, "%s", can_dev_list[i].SerialNumber); - - can_interface[idx].vendor = CAN_VENDOR_MHS; - can_interface[idx].opened = 0; - can_interface[idx].baudrate = CAN_BAUD_1M; - } -CanExDataFree((void **)&can_dev_list); -if (res < 0) - set_error_reason("Memory allocation failed."); -return(res); + return (res); } - int tinycan_open(int index) { -int32_t err; -TTinyDevice *tiny_device; -const struct TCanVenientToTCanBaudrate *b; -uint16_t tcan_baud; -//char dev_open_str[200]; <*> - -err = 0; -if (!(tiny_device = (TTinyDevice *)can_interface[index].internal)) - return(-1); -for (b = &CanVenientToTCanBaudrate[0]; (tcan_baud = b->TCanBaudrate); b++) - { - if (b->CanVenientBaud == can_interface[index].baudrate) - break; - } -if (!tcan_baud) - err = -1; -if (tcan_baud == 0xFFFF) - err = -1; -if ((!err) && (tiny_device->DeviceIndex == INDEX_INVALID)) - err = CanExCreateDevice(&tiny_device->DeviceIndex, "CanRxDFifoSize=16384"); -if (!err) - { - (void)CanExSetAsUWord(tiny_device->DeviceIndex, "CanSpeed1", tcan_baud); - (void)CanExSetAsString(tiny_device->DeviceIndex, "Snr", tiny_device->Snr); - } -//snprintf(dev_open_str, sizeof(dev_open_str), "%s;Snr=%s", DEVICE_OPEN_PARAM, tiny_device->Snr);<*> -if (!err) - err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); - //err = CanDeviceOpen(tiny_device->DeviceIndex, dev_open_str);<*> -if (!err) - err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); -if (err) - return(-1); -else - { - can_interface[index].opened = 1; - return(0); - } -} + int32_t err; + TTinyDevice* tiny_device; + const struct TCanVenientToTCanBaudrate* b; + uint16_t tcan_baud; + err = 0; + if (! (tiny_device = (TTinyDevice*)can_interface[index].internal)) + { + return (-1); + } + for (b = &CanVenientToTCanBaudrate[0]; (tcan_baud = b->TCanBaudrate); b++) + { + if (b->CanVenientBaud == can_interface[index].baudrate) + { + break; + } + } + if (! tcan_baud) + { + err = -1; + } + if (tcan_baud == 0xFFFF) + { + err = -1; + } + if ((! err) && (tiny_device->DeviceIndex == INDEX_INVALID)) + { + err = CanExCreateDevice(&tiny_device->DeviceIndex, "CanRxDFifoSize=16384"); + } + if (! err) + { + (void)CanExSetAsUWord(tiny_device->DeviceIndex, "CanSpeed1", tcan_baud); + (void)CanExSetAsString(tiny_device->DeviceIndex, "Snr", tiny_device->Snr); + } + if (! err) + { + err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); + } + if (! err) + { + err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); + } + if (err) + { + return (-1); + } + else + { + can_interface[index].opened = 1; + return (0); + } +} void tinycan_close(int index) { -TTinyDevice *tiny_device; + TTinyDevice* tiny_device; -if (!(tiny_device = (TTinyDevice *)can_interface[index].internal)) - return; -(void)CanDeviceClose(tiny_device->DeviceIndex); -can_interface[index].opened = 0; // <*> + if (! (tiny_device = (TTinyDevice*)can_interface[index].internal)) + { + return; + } + (void)CanDeviceClose(tiny_device->DeviceIndex); + can_interface[index].opened = 0; // <*> } - int tinycan_update(int index) { -uint32_t dev_idx; -struct TDeviceStatus status; -/*int32_t can_error; - -can_error = 0;*/ -dev_idx = ((TTinyDevice *)can_interface[index].internal)->DeviceIndex; -CanGetDeviceStatus(dev_idx, &status); -if (status.DrvStatus >= DRV_STATUS_CAN_OPEN) - { - /*if (status.FifoStatus & FIFO_HW_SW_OVERRUN) - can_error = CAN_ERROR_QOVERRUN; - if (status.CanStatus == CAN_STATUS_BUS_OFF) - can_error = CAN_ERROR_BUSOFF; - else if (status.CanStatus == CAN_STATUS_PASSIV) - can_error = CAN_ERROR_BUSPASSIVE;*/ - } -else - { - can_release(index); - return(-1); - } -return(0); -} + uint32_t dev_idx; + struct TDeviceStatus status; + dev_idx = ((TTinyDevice*)can_interface[index].internal)->DeviceIndex; + CanGetDeviceStatus(dev_idx, &status); + if (status.DrvStatus >= DRV_STATUS_CAN_OPEN) + { + /* + if (status.FifoStatus & FIFO_HW_SW_OVERRUN) + { + can_error = CAN_ERROR_QOVERRUN; + } + if (status.CanStatus == CAN_STATUS_BUS_OFF) + { + can_error = CAN_ERROR_BUSOFF; + } + else if (status.CanStatus == CAN_STATUS_PASSIV) + { + can_error = CAN_ERROR_BUSPASSIVE; + } + */ + } + else + { + can_release(index); + return (-1); + } + return (0); +} int tinycan_set_baudrate(int index, enum can_baudrate baud) { -can_close(index); -can_interface[index].baudrate = baud; -return can_open(index, baud); + can_close(index); + can_interface[index].baudrate = baud; + return can_open(index, baud); } - int tinycan_send(int index, struct can_frame* frame) { -uint32_t dev_idx, len; -struct TCanMsg tcan_msg; -int32_t can_error, tcan_res; - -can_error = 0; -dev_idx = ((TTinyDevice *)can_interface[index].internal)->DeviceIndex; -len = frame->can_dlc; -tcan_msg.Flags.Long = len; -tcan_msg.Id = frame->can_id; -if (len) - memcpy(tcan_msg.MsgData, frame->data, len); -if ((tcan_res = CanTransmit(dev_idx, &tcan_msg, 1)) < 0) - can_error = CAN_ERROR_TCAN; -else if (tcan_res == 0) - can_error = CAN_ERROR_QXMTFULL; -if (can_error) - { - set_error_reason(lookup_error_string(can_error, tcan_res)); - return(-1); - } -return(0); + uint32_t dev_idx, len; + struct TCanMsg tcan_msg; + int32_t can_error, tcan_res; + + can_error = 0; + dev_idx = ((TTinyDevice*)can_interface[index].internal)->DeviceIndex; + len = frame->can_dlc; + tcan_msg.Flags.Long = len; + tcan_msg.Id = frame->can_id; + if (len) + { + memcpy(tcan_msg.MsgData, frame->data, len); + } + if ((tcan_res = CanTransmit(dev_idx, &tcan_msg, 1)) < 0) + { + can_error = CAN_ERROR_TCAN; + } + else if (tcan_res == 0) + { + can_error = CAN_ERROR_QXMTFULL; + } + if (can_error) + { + set_error_reason(lookup_error_string(can_error, tcan_res)); + return (-1); + } + return (0); } - int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) { -uint32_t dev_idx, len; -struct TCanMsg tcan_msg; -int32_t can_error, tcan_res; - -can_error = 0; -dev_idx = ((TTinyDevice *)can_interface[index].internal)->DeviceIndex; -if ((tcan_res = CanReceive(dev_idx, &tcan_msg, 1)) == 1) - { - if (!tcan_msg.MsgRTR) + uint8_t len; + uint32_t dev_idx; + struct TCanMsg tcan_msg; + int32_t can_error, tcan_res; + + can_error = 0; + dev_idx = ((TTinyDevice*)can_interface[index].internal)->DeviceIndex; + if ((tcan_res = CanReceive(dev_idx, &tcan_msg, 1)) == 1) { - len = tcan_msg.MsgLen; - frame->can_id = tcan_msg.Id; - frame->can_dlc = len; - if (len) - memcpy(frame->data, tcan_msg.MsgData, len); - *timestamp = 0; // T.D. + if (! tcan_msg.MsgRTR) + { + len = (uint8_t)tcan_msg.MsgLen; + frame->can_id = tcan_msg.Id; + frame->can_dlc = len; + if (len) + { + memcpy(frame->data, tcan_msg.MsgData, len); + } + *timestamp = 0; // T.D. + } + else + { + can_error = CAN_ERROR_QRCVEMPTY; + } + } + else if (tcan_res == 0) + { + can_error = CAN_ERROR_QRCVEMPTY; + } + else + { + can_error = CAN_ERROR_TCAN; } - else - can_error = CAN_ERROR_QRCVEMPTY; - } -else if (tcan_res == 0) - can_error = CAN_ERROR_QRCVEMPTY; -else - can_error = CAN_ERROR_TCAN; -if (can_error) - { - set_error_reason(lookup_error_string(can_error, tcan_res)); - return(-1); - } -return(0); + if (can_error) + { + set_error_reason(lookup_error_string(can_error, tcan_res)); + return (-1); + } + return (0); } - - diff --git a/src/drivers/CANvenient_TinyCan.h b/src/drivers/CANvenient_TinyCan.h index b288aeb..90f594a 100755 --- a/src/drivers/CANvenient_TinyCan.h +++ b/src/drivers/CANvenient_TinyCan.h @@ -7,26 +7,25 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" +#include "CANvenient.h" #ifdef __cplusplus - extern "C" { +extern "C" +{ #endif -int tinycan_find_interfaces(void) ATTRIBUTE_INTERNAL; + int tinycan_find_interfaces(void); -int tinycan_open(int index) ATTRIBUTE_INTERNAL; -int tinycan_open_fd(int index) ATTRIBUTE_INTERNAL; -void tinycan_close(int index) ATTRIBUTE_INTERNAL; -int tinycan_update(int index) ATTRIBUTE_INTERNAL; + int tinycan_open(int index); + void tinycan_close(int index); + int tinycan_update(int index); -int tinycan_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; + int tinycan_set_baudrate(int index, enum can_baudrate baud); -int tinycan_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; + int tinycan_send(int index, struct can_frame* frame); + int tinycan_recv(int index, struct can_frame* frame, u64* timestamp); #ifdef __cplusplus - } +} #endif diff --git a/src/drivers/CANvenient_internal.h b/src/drivers/CANvenient_internal.h old mode 100755 new mode 100644 index 9b117b0..bb33364 --- a/src/drivers/CANvenient_internal.h +++ b/src/drivers/CANvenient_internal.h @@ -11,18 +11,6 @@ #ifndef CANVENIENT_INTERNAL_H #define CANVENIENT_INTERNAL_H -#include "global.h" - -#ifdef __cplusplus - extern "C" { -#endif - -#define VENIENT_SOFTING_DRV_DISABLED -#define VENIENT_IXXAT_DRV_DISABLED -#define VENIENT_KVASER_DRV_DISABLED -#define VENIENT_PEAK_DRV_DISABLED - - /* * CAN interface vendor enumeration. */ @@ -49,14 +37,10 @@ struct can_iface void* internal; }; -extern struct can_iface can_interface[CAN_MAX_INTERFACES] ATTRIBUTE_INTERNAL; -extern char can_error_reason[1024] ATTRIBUTE_INTERNAL; - -int find_free_interface_slot(u32* index) ATTRIBUTE_INTERNAL; -void set_error_reason(const char* reason) ATTRIBUTE_INTERNAL; +extern struct can_iface can_interface[CAN_MAX_INTERFACES]; +extern char can_error_reason[1024]; -#ifdef __cplusplus - } -#endif +int find_free_interface_slot(u32* index); +void set_error_reason(const char* reason); #endif /* CANVENIENT_INTERNAL_H */ diff --git a/src/drivers/CANvenient_template.h b/src/drivers/CANvenient_template.h old mode 100755 new mode 100644 index 6e593e2..c731294 --- a/src/drivers/CANvenient_template.h +++ b/src/drivers/CANvenient_template.h @@ -7,25 +7,17 @@ * SPDX-License-Identifier: MIT * **/ -#include "global.h" -#include "CANvenient.h" - -#ifdef __cplusplus - extern "C" { -#endif -int template_find_interfaces(void) ATTRIBUTE_INTERNAL; +#include "CANvenient.h" -int template_open(int index) ATTRIBUTE_INTERNAL; -int template_open_fd(int index) ATTRIBUTE_INTERNAL; -void template_close(int index) ATTRIBUTE_INTERNAL; -int template_update(int index) ATTRIBUTE_INTERNAL; +int template_find_interfaces(void); -int template_set_baudrate(int index, enum can_baudrate baud) ATTRIBUTE_INTERNAL; +int template_open(int index); +int template_open_fd(int index); +void template_close(int index); +int template_update(int index); -int template_send(int index, struct can_frame* frame) ATTRIBUTE_INTERNAL; -int template_recv(int index, struct can_frame* frame, u64* timestamp) ATTRIBUTE_INTERNAL; +int template_set_baudrate(int index, enum can_baudrate baud); -#ifdef __cplusplus - } -#endif \ No newline at end of file +int template_send(int index, struct can_frame* frame); +int template_recv(int index, struct can_frame* frame, u64* timestamp); diff --git a/src/global.h b/src/global.h deleted file mode 100755 index f8a9b65..0000000 --- a/src/global.h +++ /dev/null @@ -1,31 +0,0 @@ -#ifndef __GLOBAL_H__ -#define __GLOBAL_H__ - -#ifdef __cplusplus - extern "C" { -#endif - -#if defined(WIN32) || defined(_WIN32) - #ifndef __WIN32__ - #define __WIN32__ - #endif -#endif - -#ifdef __WIN32__ - // ****** Windows - #define ATTRIBUTE_INTERNAL -#elif __APPLE__ - // ****** Apple - #define ATTRIBUTE_INTERNAL __attribute((visibility("hidden"))) -#else - // ****** Linux - #define ATTRIBUTE_INTERNAL - // replace -fvisibility=hidden - //#define ATTRIBUTE_INTERNAL __attribute((visibility("internal"))) -#endif - -#ifdef __cplusplus - } -#endif - -#endif From 31bf87f13f3fcde5289b144280238c1bbf3194fb Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 18:46:41 +0200 Subject: [PATCH 06/13] Address issues as reported by Codacy. --- src/drivers/CANvenient_TinyCan.c | 12 +-- src/tests/linux_util.c | 93 ---------------------- src/tests/linux_util.h | 20 ----- src/tests/rx_tx_example.c | 130 ------------------------------- 4 files changed, 6 insertions(+), 249 deletions(-) delete mode 100755 src/tests/linux_util.c delete mode 100755 src/tests/linux_util.h delete mode 100755 src/tests/rx_tx_example.c diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index 76b9fcb..d8905b5 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -134,11 +134,11 @@ static const char* lookup_error_string(int32_t can_error, int32_t tcan_error) static char* mhs_strdup(const char* str) { size_t len; - char* new_str; if (str) { - len = strlen(str) + 1; + char* new_str; + len = strnlen(str, 100); new_str = (char*)malloc(len); if (! new_str) { @@ -156,7 +156,7 @@ static char* mhs_strdup(const char* str) int tinycan_find_interfaces(void) { int res; - uint32_t k, idx, already_registered; + uint32_t k, idx; struct TCanDevicesList* can_dev_list; int32_t num_devs, i; char dev_name[100]; @@ -180,9 +180,10 @@ int tinycan_find_interfaces(void) } for (i = 0; i < num_devs; i++) { + uint32_t already_registered = 0; + snprintf(dev_name, sizeof(dev_name), "%s (S/N: %s)", can_dev_list[i].Description, can_dev_list[i].SerialNumber); - already_registered = 0; for (k = 0; k < CAN_MAX_INTERFACES; k++) { if (can_interface[k].name && strcmp(can_interface[k].name, dev_name) == 0) @@ -368,7 +369,6 @@ int tinycan_send(int index, struct can_frame* frame) int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) { - uint8_t len; uint32_t dev_idx; struct TCanMsg tcan_msg; int32_t can_error, tcan_res; @@ -379,7 +379,7 @@ int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) { if (! tcan_msg.MsgRTR) { - len = (uint8_t)tcan_msg.MsgLen; + uint8_t len = (uint8_t)tcan_msg.MsgLen; frame->can_id = tcan_msg.Id; frame->can_dlc = len; if (len) diff --git a/src/tests/linux_util.c b/src/tests/linux_util.c deleted file mode 100755 index 8b34d4f..0000000 --- a/src/tests/linux_util.c +++ /dev/null @@ -1,93 +0,0 @@ -/******************************************************************************* - linux_util.c - description - ------------------- - begin : 12.04.2026 - last modify : 12.04.2026 - copyright : (C) 2026 by MHS-Elektronik GmbH & Co. KG, Germany - http://www.mhs-elektronik.de - author : Klaus Demlehner, klaus@mhs-elektronik.de - *******************************************************************************/ - -/*************************************************************************** - * * - * This program is free software, you can redistribute it and/or modify * - * it under the terms of the MIT License * - * * - ***************************************************************************/ -#ifndef _WIN32 - -#include -#include -#include -#include -#include -#include -#include "linux_util.h" - - - -#ifndef STDIN_FILENO - #define STDIN_FILENO 0 -#endif - - -static struct termios OldTermattr; - - -void UtilCleanup(void); - - -int UtilInit(void) -{ -struct termios termattr; - -if (tcgetattr(STDIN_FILENO, &OldTermattr) < 0) - return(-1); - -memcpy(&termattr, &OldTermattr, sizeof(struct termios)); - -termattr.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); -termattr.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); -termattr.c_cflag &= ~(CSIZE | PARENB); -termattr.c_cflag |= CS8; -termattr.c_oflag &= ~(OPOST); - -termattr.c_cc[VMIN] = 1; /* or 0 for some Unices; see note 1 */ -termattr.c_cc[VTIME] = 0; - -if (tcsetattr (STDIN_FILENO, TCSANOW, &termattr) < 0) - return(-1); -return(atexit(UtilCleanup)); -} - - -void UtilCleanup(void) -{ -tcsetattr(STDIN_FILENO, TCSAFLUSH, &OldTermattr); -} - - - -int KeyHit(void) -{ -int bytes_waiting; - -ioctl(STDIN_FILENO, FIONREAD, &bytes_waiting); -return(bytes_waiting); -} - - -/*char getch(void) -{ -char buf; - -if (read(STDIN_FILENO, &buf, 1) != 1) - return('\0'); -else - return(buf); -} */ - -#endif - - diff --git a/src/tests/linux_util.h b/src/tests/linux_util.h deleted file mode 100755 index cf4acc8..0000000 --- a/src/tests/linux_util.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef __LINUX_UTIL_H__ -#define __LINUX_UTIL_H__ - -#ifdef __cplusplus - extern "C" { -#endif - -#ifndef _WIN32 - -int UtilInit(void); -int KeyHit(void); -//char getch(void); - -#endif - -#ifdef __cplusplus - } -#endif - -#endif diff --git a/src/tests/rx_tx_example.c b/src/tests/rx_tx_example.c deleted file mode 100755 index 9df48ba..0000000 --- a/src/tests/rx_tx_example.c +++ /dev/null @@ -1,130 +0,0 @@ -/** @file example.c - * - * CANvenient is an abstraction layer for multiple CAN APIs on - * Windows and Linux. - * - * Copyright (c) 2026, Michael Fitzmayer. All rights reserved. - * SPDX-License-Identifier: MIT - * - **/ - -#include -#include -#include -#include -#include -#ifdef _WIN32 - #include -#else - #include "linux_util.h" -#endif - - -#ifdef _WIN32 - #define UtilInit() - #define KeyHit kbhit -#else - #include - #define getch getchar -#endif - - -static int OpenInterface(int *index) -{ -int res; - -res = 0; -if (!index) - return(-1); -if (!can_find_interfaces()) - { - for (int i = 0; i < CAN_MAX_INTERFACES; i++) - { - char name[256] = {0}; - can_get_name(i, name, sizeof(name)); - if (name[0] != '\0') - { - if (0 == can_open(i, CAN_BAUD_1M)) - { - printf("Opened CAN interface: %s\n\r", name); - res = 1; - *index = i; - break; - } - else - { - char error_reason[256] = {0}; - can_get_error(error_reason, sizeof(error_reason)); - printf("Failed to open CAN interface %s: %s\n\r", name, error_reason); - } - } - } - } -return(res); -} - - -static void PrintCanFrame(struct can_frame* frame, u64 timestamp) -{ -uint8_t i; -(void)timestamp; - -printf("id:%03X dlc:%0d data:", frame->can_id, frame->can_dlc); -if (frame->can_dlc) - { - for (i = 0; i < frame->can_dlc; i++) - printf("%02X ", frame->data[i]); - } -else - printf(" no data"); -printf("\n\r"); -} - - -static void TxStdFrame(int index, uint32_t id, uint8_t len, const uint8_t *data) -{ -struct can_frame frame; - -frame.can_id = id; -frame.can_dlc = len; -if ((len > 0) && (len <= 8)) - memcpy(frame.data, data, len); -(void)can_send(index, &frame); -} - - -int main() -{ -int index; -char ch; -struct can_frame rx_frame; -u64 timestamp; - -UtilInit(); -if (OpenInterface(&index) >= 1) - { - ch = '\0'; - printf("press \"t\" to send test message and \"q\" for quit\n\r\n\r"); - printf("received messages:\n\r"); - do - { - if (can_recv(index, &rx_frame, ×tamp) == 0) - PrintCanFrame(&rx_frame, timestamp); - if (KeyHit()) - { - ch = getch(); - switch (ch) - { - case 't' : { - TxStdFrame(index, 123, 8, (const uint8_t *)"*HALLO*"); - break; - } - } - } - } - while (ch != 'q'); - } -/* Implicitly calls can_close() for all opened interfaces. */ -can_release_interfaces(); -return(EXIT_SUCCESS); -} From 5b15ab07424bcce7747c0ed05e928861dc088a34 Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 18:55:33 +0200 Subject: [PATCH 07/13] Add compile guards; let's test it on Windows first. --- src/drivers/CANvenient_TinyCan.c | 61 ++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index d8905b5..e41ec29 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -11,16 +11,19 @@ * **/ +#ifdef _WIN32 #include #include #include #include #include +#endif #include "CANvenient.h" #include "CANvenient_internal.h" +#ifdef _WIN32 typedef struct _TTinyDevice TTinyDevice; struct _TTinyDevice @@ -152,17 +155,18 @@ static char* mhs_strdup(const char* str) return (NULL); } } +#endif int tinycan_find_interfaces(void) { - int res; + int res = 0; +#ifdef _WIN32 uint32_t k, idx; struct TCanDevicesList* can_dev_list; int32_t num_devs, i; char dev_name[100]; TTinyDevice* tiny_device; - res = 0; if (! TinyCanDriverInit) { if (LoadDriver(NULL) >= 0) @@ -227,11 +231,13 @@ int tinycan_find_interfaces(void) { set_error_reason("Memory allocation failed."); } +#endif return (res); } int tinycan_open(int index) { +#ifdef _WIN32 int32_t err; TTinyDevice* tiny_device; const struct TCanVenientToTCanBaudrate* b; @@ -283,10 +289,18 @@ int tinycan_open(int index) can_interface[index].opened = 1; return (0); } + +#else + set_error_reason("Tiny-Can driver is currently only supported on Windows."); + (void)index; + return -1; +#endif } void tinycan_close(int index) { +#ifdef _WIN32 + TTinyDevice* tiny_device; if (! (tiny_device = (TTinyDevice*)can_interface[index].internal)) @@ -295,10 +309,17 @@ void tinycan_close(int index) } (void)CanDeviceClose(tiny_device->DeviceIndex); can_interface[index].opened = 0; // <*> + +#else + set_error_reason("Tiny-Can driver is currently only supported on Windows."); + (void)index; +#endif } int tinycan_update(int index) { +#ifdef _WIN32 + uint32_t dev_idx; struct TDeviceStatus status; @@ -327,17 +348,35 @@ int tinycan_update(int index) return (-1); } return (0); + +#else + + set_error_reason("Tiny-Can driver is currently only supported on Windows."); + (void)index; + return -1; +#endif } int tinycan_set_baudrate(int index, enum can_baudrate baud) { +#ifdef _WIN32 + can_close(index); can_interface[index].baudrate = baud; return can_open(index, baud); + +#else + set_error_reason("Tiny-Can driver is currently only supported on Windows."); + (void)index; + (void)baud; + return -1; +#endif } int tinycan_send(int index, struct can_frame* frame) { +#ifdef _WIN32 + uint32_t dev_idx, len; struct TCanMsg tcan_msg; int32_t can_error, tcan_res; @@ -365,10 +404,19 @@ int tinycan_send(int index, struct can_frame* frame) return (-1); } return (0); + +#else + set_error_reason("Tiny-CAN driver is currently only supported on Windows."); + (void)index; + (void)frame; + return -1; +#endif } int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) { +#ifdef _WIN32 + uint32_t dev_idx; struct TCanMsg tcan_msg; int32_t can_error, tcan_res; @@ -407,4 +455,13 @@ int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) return (-1); } return (0); + +#else + + set_error_reason("Tiny-CAN driver is currently only supported on Windows."); + (void)index; + (void)frame; + (void)timestamp; + return -1; +#endif } From 45d41e88847ca38f626dfc200740b7f78e4c8037 Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 19:05:18 +0200 Subject: [PATCH 08/13] Address warnings as reported by cppcheck --- src/drivers/CANvenient_TinyCan.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index e41ec29..13abf98 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -275,14 +275,14 @@ int tinycan_open(int index) if (! err) { err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); - } - if (! err) - { - err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); - } - if (err) - { - return (-1); + if (! err) + { + err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); + if (err) + { + return (-1); + } + } } else { @@ -291,7 +291,7 @@ int tinycan_open(int index) } #else - set_error_reason("Tiny-Can driver is currently only supported on Windows."); + set_error_reason("Tiny-Can driver is only supported on Windows."); (void)index; return -1; #endif @@ -311,7 +311,7 @@ void tinycan_close(int index) can_interface[index].opened = 0; // <*> #else - set_error_reason("Tiny-Can driver is currently only supported on Windows."); + set_error_reason("Tiny-Can driver is only supported on Windows."); (void)index; #endif } @@ -351,7 +351,7 @@ int tinycan_update(int index) #else - set_error_reason("Tiny-Can driver is currently only supported on Windows."); + set_error_reason("Tiny-Can driver is only supported on Windows."); (void)index; return -1; #endif @@ -366,7 +366,7 @@ int tinycan_set_baudrate(int index, enum can_baudrate baud) return can_open(index, baud); #else - set_error_reason("Tiny-Can driver is currently only supported on Windows."); + set_error_reason("Tiny-Can driver is only supported on Windows."); (void)index; (void)baud; return -1; @@ -406,7 +406,7 @@ int tinycan_send(int index, struct can_frame* frame) return (0); #else - set_error_reason("Tiny-CAN driver is currently only supported on Windows."); + set_error_reason("Tiny-CAN driver is only supported on Windows."); (void)index; (void)frame; return -1; @@ -458,7 +458,7 @@ int tinycan_recv(int index, struct can_frame* frame, u64* timestamp) #else - set_error_reason("Tiny-CAN driver is currently only supported on Windows."); + set_error_reason("Tiny-CAN driver is only supported on Windows."); (void)index; (void)frame; (void)timestamp; From e7c97b71502cfc569674fce538bc419636ce32bf Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 19:08:09 +0200 Subject: [PATCH 09/13] Add missing return path. --- src/drivers/CANvenient_TinyCan.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index 13abf98..b09e609 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -283,6 +283,7 @@ int tinycan_open(int index) return (-1); } } + return (0); } else { From b8e3732bef14213cbe0e4a2f0fea439320e235ee Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 19:11:21 +0200 Subject: [PATCH 10/13] Clean-up error handling. --- src/drivers/CANvenient_TinyCan.c | 56 ++++++++++++++++---------------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index b09e609..cb7c405 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -243,53 +243,53 @@ int tinycan_open(int index) const struct TCanVenientToTCanBaudrate* b; uint16_t tcan_baud; - err = 0; if (! (tiny_device = (TTinyDevice*)can_interface[index].internal)) { return (-1); } - for (b = &CanVenientToTCanBaudrate[0]; (tcan_baud = b->TCanBaudrate); b++) + + // Find matching baudrate + tcan_baud = 0; + for (b = &CanVenientToTCanBaudrate[0]; b->TCanBaudrate; b++) { if (b->CanVenientBaud == can_interface[index].baudrate) { + tcan_baud = b->TCanBaudrate; break; } } - if (! tcan_baud) + + if (!tcan_baud || tcan_baud == 0xFFFF) { - err = -1; - } - if (tcan_baud == 0xFFFF) - { - err = -1; + return (-1); } - if ((! err) && (tiny_device->DeviceIndex == INDEX_INVALID)) + + if (tiny_device->DeviceIndex == INDEX_INVALID) { err = CanExCreateDevice(&tiny_device->DeviceIndex, "CanRxDFifoSize=16384"); - } - if (! err) - { - (void)CanExSetAsUWord(tiny_device->DeviceIndex, "CanSpeed1", tcan_baud); - (void)CanExSetAsString(tiny_device->DeviceIndex, "Snr", tiny_device->Snr); - } - if (! err) - { - err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); - if (! err) + if (err) { - err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); - if (err) - { - return (-1); - } + return (-1); } - return (0); } - else + + (void)CanExSetAsUWord(tiny_device->DeviceIndex, "CanSpeed1", tcan_baud); + (void)CanExSetAsString(tiny_device->DeviceIndex, "Snr", tiny_device->Snr); + + err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); + if (err) { - can_interface[index].opened = 1; - return (0); + return (-1); } + + err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); + if (err) + { + return (-1); + } + + can_interface[index].opened = 1; + return (0); #else set_error_reason("Tiny-Can driver is only supported on Windows."); From 2d60930b8a4cd4d1d7c1bf4c776ee4f0939ef577 Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 19:13:47 +0200 Subject: [PATCH 11/13] Reduce variable scope. --- src/drivers/CANvenient_TinyCan.c | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index cb7c405..5c2eeed 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -136,12 +136,10 @@ static const char* lookup_error_string(int32_t can_error, int32_t tcan_error) static char* mhs_strdup(const char* str) { - size_t len; - if (str) { char* new_str; - len = strnlen(str, 100); + size_t len = strnlen(str, 100); new_str = (char*)malloc(len); if (! new_str) { @@ -247,7 +245,7 @@ int tinycan_open(int index) { return (-1); } - + // Find matching baudrate tcan_baud = 0; for (b = &CanVenientToTCanBaudrate[0]; b->TCanBaudrate; b++) @@ -258,12 +256,12 @@ int tinycan_open(int index) break; } } - - if (!tcan_baud || tcan_baud == 0xFFFF) + + if (! tcan_baud || tcan_baud == 0xFFFF) { return (-1); } - + if (tiny_device->DeviceIndex == INDEX_INVALID) { err = CanExCreateDevice(&tiny_device->DeviceIndex, "CanRxDFifoSize=16384"); @@ -272,22 +270,22 @@ int tinycan_open(int index) return (-1); } } - + (void)CanExSetAsUWord(tiny_device->DeviceIndex, "CanSpeed1", tcan_baud); (void)CanExSetAsString(tiny_device->DeviceIndex, "Snr", tiny_device->Snr); - + err = CanDeviceOpen(tiny_device->DeviceIndex, DEVICE_OPEN_PARAM); if (err) { return (-1); } - + err = CanSetMode(tiny_device->DeviceIndex, OP_CAN_START, CAN_CMD_ALL_CLEAR); if (err) { return (-1); } - + can_interface[index].opened = 1; return (0); From 993923b62709a4f040d5420c98f9278ea66a5b56 Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 19:16:28 +0200 Subject: [PATCH 12/13] Address cppcheck warning. --- src/drivers/CANvenient_TinyCan.c | 2 +- src/drivers/CANvenient_TinyCan.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/drivers/CANvenient_TinyCan.c b/src/drivers/CANvenient_TinyCan.c index 5c2eeed..80bccf7 100755 --- a/src/drivers/CANvenient_TinyCan.c +++ b/src/drivers/CANvenient_TinyCan.c @@ -372,7 +372,7 @@ int tinycan_set_baudrate(int index, enum can_baudrate baud) #endif } -int tinycan_send(int index, struct can_frame* frame) +int tinycan_send(int index, const struct can_frame* frame) { #ifdef _WIN32 diff --git a/src/drivers/CANvenient_TinyCan.h b/src/drivers/CANvenient_TinyCan.h index 90f594a..ba81fbf 100755 --- a/src/drivers/CANvenient_TinyCan.h +++ b/src/drivers/CANvenient_TinyCan.h @@ -23,7 +23,7 @@ extern "C" int tinycan_set_baudrate(int index, enum can_baudrate baud); - int tinycan_send(int index, struct can_frame* frame); + int tinycan_send(int index, const struct can_frame* frame); int tinycan_recv(int index, struct can_frame* frame, u64* timestamp); #ifdef __cplusplus From 6be90d8d9e641214e7c8fdc7fce9d3ad172f354d Mon Sep 17 00:00:00 2001 From: Michael Fitzmayer Date: Fri, 17 Apr 2026 19:25:07 +0200 Subject: [PATCH 13/13] Set proper build dir for Tiny-Can --- cmake/deps.cmake | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/cmake/deps.cmake b/cmake/deps.cmake index 62b4739..063b07e 100644 --- a/cmake/deps.cmake +++ b/cmake/deps.cmake @@ -155,6 +155,9 @@ if(WIN32) # Tiny-Can set(TINYCAN_VERSION "8.12") + set(TINYCAN_PATH "${CMAKE_CURRENT_SOURCE_DIR}/deps/TinyCan") + set(TINYCAN_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/TinyCan_devel-prefix/src/TinyCan_devel-build") + set(TINYCAN_DEVEL_PKG TinyCan_v${TINYCAN_VERSION}.zip) set(TINYCAN_DEVEL_URL https://canopenterm.de/mirror) set(TINYCAN_DEVEL_HASH c047e901ccb34bc764fb5dc5f2359dad82ff55c4) @@ -167,10 +170,10 @@ if(WIN32) DOWNLOAD_EXTRACT_TIMESTAMP true TLS_VERIFY true SOURCE_DIR ${TINYCAN_PATH}/ - BUILD_BYPRODUCTS "${CMAKE_CURRENT_BINARY_DIR}/mhstcan.dll" + BUILD_BYPRODUCTS ${TINYCAN_BUILD_DIR}/mhstcan.lib INSTALL_COMMAND ${CMAKE_COMMAND} -E copy - "${CMAKE_CURRENT_BINARY_DIR}/TinyCan_devel-prefix/src/TinyCan_devel-build/mhstcan.dll" + ${TINYCAN_BUILD_DIR}/mhstcan.dll ${CMAKE_CURRENT_BINARY_DIR}/ PATCH_COMMAND ${CMAKE_COMMAND} -E copy @@ -178,7 +181,7 @@ if(WIN32) ) set(TINYCAN_INCLUDE_DIR "${TINYCAN_PATH}/dev/lib") - set(TINYCAN_LIBRARY "${CMAKE_CURRENT_BINARY_DIR}/TinyCan_devel-prefix/src/TinyCan_devel-build/mhstcan.lib") + set(TINYCAN_LIBRARY ${TINYCAN_BUILD_DIR}/mhstcan.lib) set(PLATFORM_DEPS Ixxat_devel