1.0.0

Prefer Npcap over WinPcap and TCP

.gitlab-ci.yml

@@ -4,7 +4,6 @@ variables:
 stages:
   - build
   - unit_test
-  - hardware_test
   - deploy
 
 #-------------------------------------------------------------------------------
@@ -21,7 +20,7 @@ build windows/x64:
       - build
     expire_in: 3 days
   tags:
-    - icsneo-windows
+    - libicsneo-win-x64
 
 unit_test windows/x64:
   stage: unit_test
@@ -32,7 +31,7 @@ unit_test windows/x64:
   needs:
     - build windows/x64
   tags:
-    - icsneo-windows
+    - libicsneo-win-x64
   timeout: 5m
 
 build windows/x86:
@@ -45,7 +44,7 @@ build windows/x86:
       - build
     expire_in: 3 days
   tags:
-    - icsneo-windows
+    - libicsneo-win-x64
 
 unit_test windows/x86:
   stage: unit_test
@@ -56,7 +55,7 @@ unit_test windows/x86:
   needs:
     - build windows/x86
   tags:
-    - icsneo-windows
+    - libicsneo-win-x64
   timeout: 5m
 
 #-------------------------------------------------------------------------------
@@ -235,54 +234,6 @@ unit_test linux/ubuntu/2204/amd64/clang:
     - linux-build
   timeout: 5m
 
-build linux/fedora/37/amd64/gcc:
-  <<: *build_linux_fedora_gcc
-  image: fedora:37
-
-unit_test linux/fedora/37/amd64/gcc:
-  <<: *test_linux_fedora_gcc
-  image: fedora:37
-  dependencies:
-    - build linux/fedora/37/amd64/gcc
-  needs:
-    - build linux/fedora/37/amd64/gcc
-
-build linux/fedora/37/amd64/clang:
-  <<: *build_linux_fedora_clang
-  image: fedora:37
-
-unit_test linux/fedora/37/amd64/clang:
-  <<: *test_linux_fedora_clang
-  image: fedora:37
-  dependencies:
-    - build linux/fedora/37/amd64/clang
-  needs:
-    - build linux/fedora/37/amd64/clang
-
-build linux/fedora/38/amd64/gcc:
-  <<: *build_linux_fedora_gcc
-  image: fedora:38
-
-unit_test linux/fedora/38/amd64/gcc:
-  <<: *test_linux_fedora_gcc
-  image: fedora:38
-  dependencies:
-    - build linux/fedora/38/amd64/gcc
-  needs:
-    - build linux/fedora/38/amd64/gcc
-
-build linux/fedora/38/amd64/clang:
-  <<: *build_linux_fedora_clang
-  image: fedora:38
-
-unit_test linux/fedora/38/amd64/clang:
-  <<: *test_linux_fedora_clang
-  image: fedora:38
-  dependencies:
-    - build linux/fedora/38/amd64/clang
-  needs:
-    - build linux/fedora/38/amd64/clang
-
 build linux/fedora/39/amd64/gcc:
   <<: *build_linux_fedora_gcc
   image: fedora:39
@@ -307,118 +258,53 @@ unit_test linux/fedora/39/amd64/clang:
   needs:
     - build linux/fedora/39/amd64/clang
 
-.hw_test: &hw_test
+build linux/fedora/40/amd64/gcc:
-  stage: hardware_test
+  <<: *build_linux_fedora_gcc
-  tags:
+  image: fedora:40
-    - libicsneo_hil
-  timeout: 5m
-  script:
-    - echo $GUEST_OS_TAG
-    - echo $DEVICE_PORT
-    - /opt/libvirt-driver/prepare.sh
-    - /opt/libvirt-driver/run.sh
-  after_script:
-    - /opt/libvirt-driver/cleanup.sh
-  allow_failure: true
 
-.fedora38_needs: &fedora38_needs
+unit_test linux/fedora/40/amd64/gcc:
+  <<: *test_linux_fedora_gcc
+  image: fedora:40
+  dependencies:
+    - build linux/fedora/40/amd64/gcc
   needs:
-    - job: build linux/fedora/38/amd64/clang
+    - build linux/fedora/40/amd64/gcc
-      artifacts: true
 
-hardware_test fedora38-red2:
+build linux/fedora/40/amd64/clang:
-  <<: *hw_test
+  <<: *build_linux_fedora_clang
-  <<: *fedora38_needs
+  image: fedora:40
-  variables:
-    GUEST_OS_TAG: fedora38
-    DEVICE_PORT: ETH_A
 
-hardware_test fedora38-vcan42:
+unit_test linux/fedora/40/amd64/clang:
-  <<: *hw_test
+  <<: *test_linux_fedora_clang
-  <<: *fedora38_needs
+  image: fedora:40
-  variables:
+  dependencies:
-    GUEST_OS_TAG: fedora38
+    - build linux/fedora/40/amd64/clang
-    DEVICE_PORT: USB_D
-
-hardware_test fedora38-fire3:
-  <<: *hw_test
-  <<: *fedora38_needs
-  variables:
-    GUEST_OS_TAG: fedora38
-    DEVICE_PORT: ETH_B
-
-hardware_test fedora38-vcan42-EL:
-  <<: *hw_test
-  <<: *fedora38_needs
-  variables:
-    GUEST_OS_TAG: fedora38
-    DEVICE_PORT: USB_C
-
-.ubuntu2204_needs: &ubuntu2204_needs
   needs:
-    - job: build linux/ubuntu/2204/amd64/clang
+    - build linux/fedora/40/amd64/clang
-      artifacts: true
 
-hardware_test ubuntu2204-red2:
+build linux/fedora/41/amd64/gcc:
-  <<: *hw_test
+  <<: *build_linux_fedora_gcc
-  <<: *ubuntu2204_needs
+  image: fedora:41
-  variables:
-    GUEST_OS_TAG: ubuntu22.04
-    DEVICE_PORT: ETH_A
 
-hardware_test ubuntu2204-vcan42:
+unit_test linux/fedora/41/amd64/gcc:
-  <<: *hw_test
+  <<: *test_linux_fedora_gcc
-  <<: *ubuntu2204_needs
+  image: fedora:41
-  variables:
+  dependencies:
-    GUEST_OS_TAG: ubuntu22.04
+    - build linux/fedora/41/amd64/gcc
-    DEVICE_PORT: USB_D
-
-hardware_test ubuntu2204-fire3:
-  <<: *hw_test
-  <<: *ubuntu2204_needs
-  variables:
-    GUEST_OS_TAG: ubuntu22.04
-    DEVICE_PORT: ETH_B
-
-hardware_test ubuntu2204-vcan42-EL:
-  <<: *hw_test
-  <<: *ubuntu2204_needs
-  variables:
-    GUEST_OS_TAG: ubuntu22.04
-    DEVICE_PORT: USB_C
-
-.win10_needs: &win10_needs
   needs:
-    - job: build windows/x64
+    - build linux/fedora/41/amd64/gcc
-      artifacts: true
 
-hardware_test win10-red2:
+build linux/fedora/41/amd64/clang:
-  <<: *hw_test
+  <<: *build_linux_fedora_clang
-  <<: *win10_needs
+  image: fedora:41
-  variables:
-    GUEST_OS_TAG: win10
-    DEVICE_PORT: ETH_A
 
-hardware_test win10-vcan42:
+unit_test linux/fedora/41/amd64/clang:
-  <<: *hw_test
+  <<: *test_linux_fedora_clang
-  <<: *win10_needs
+  image: fedora:41
-  variables:
+  dependencies:
-    GUEST_OS_TAG: win10
+    - build linux/fedora/41/amd64/clang
-    DEVICE_PORT: USB_D
+  needs:
-
+    - build linux/fedora/41/amd64/clang
-hardware_test win10-fire3:
-  <<: *hw_test
-  <<: *win10_needs
-  variables:
-    GUEST_OS_TAG: win10
-    DEVICE_PORT: ETH_B
-
-hardware_test win10-vcan42-EL:
-  <<: *hw_test
-  <<: *win10_needs
-  variables:
-    GUEST_OS_TAG: win10
-    DEVICE_PORT: USB_C
 
 #-------------------------------------------------------------------------------
 # Python Module
@@ -522,6 +408,8 @@ push github:
   image: alpine:latest
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+      when: delayed
+      start_in: 10 minutes
   dependencies:
     - deploy python/pypi
   needs:

CMakeLists.txt

@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.16)
-project(libicsneo VERSION 0.3.0)
+project(libicsneo VERSION 1.0.0)
 
 cmake_policy(SET CMP0074 NEW)
 if(POLICY CMP0135)
@@ -7,7 +7,6 @@ if(POLICY CMP0135)
 endif()
 
 option(LIBICSNEO_BUILD_UNIT_TESTS "Build unit tests." OFF)
-option(LIBICSNEO_BUILD_SYSTEM_TESTS "Build system tests." OFF)
 option(LIBICSNEO_BUILD_DOCS "Build documentation. Don't use in Visual Studio." OFF)
 option(LIBICSNEO_BUILD_EXAMPLES "Build examples." ON)
 option(LIBICSNEO_BUILD_ICSNEOC "Build dynamic C library" ON)
@@ -110,7 +109,9 @@ if(LIBICSNEO_BUILD_DOCS)
 endif()
 
 if(WIN32)
+	add_definitions(-DWIN32_LEAN_AND_MEAN -DNOMINMAX -D_CRT_SECURE_NO_WARNINGS)
 	set(PLATFORM_SRC
+		platform/windows/strings.cpp
 		platform/windows/registry.cpp
 	)
 
@@ -245,7 +246,11 @@ set(SRC_FILES
 	communication/message/ethphymessage.cpp
 	communication/message/linmessage.cpp
 	communication/message/livedatamessage.cpp
+	communication/message/logdatamessage.cpp
 	communication/message/tc10statusmessage.cpp
+	communication/message/gptpstatusmessage.cpp
+	communication/message/ethernetstatusmessage.cpp
+	communication/message/macsecmessage.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp
@@ -273,6 +278,7 @@ set(SRC_FILES
 	communication/driver.cpp
 	communication/livedata.cpp
 	communication/ringbuffer.cpp
+	communication/crc32.cpp
 	device/extensions/flexray/extension.cpp
 	device/extensions/flexray/controller.cpp
 	device/idevicesettings.cpp
@@ -302,6 +308,7 @@ set(SRC_FILES
 	disk/vsa/vsa0f.cpp
 	disk/vsa/vsa6a.cpp
 	disk/vsa/vsaparser.cpp
+	platform/servd.cpp
 	${PLATFORM_SRC}
 )
 
@@ -362,7 +369,7 @@ target_include_directories(icsneocpp
 		${CMAKE_CURRENT_SOURCE_DIR}/include
 		${LIBICSNEO_EXTENSION_INCLUDE_PATHS}
 )
-target_link_libraries(icsneocpp PUBLIC Threads::Threads)
+target_link_libraries(icsneocpp PUBLIC Threads::Threads $<$<BOOL:${WIN32}>:ws2_32 iphlpapi>)
 set_property(TARGET icsneocpp PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_compile_features(icsneocpp PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 message("Loaded extensions: " ${LIBICSNEO_EXTENSION_TARGETS})
@@ -420,10 +427,9 @@ if(LIBICSNEO_ENABLE_RAW_ETHERNET)
 	if(WIN32)
 		if(LIBICSNEO_NPCAP_INCLUDE_DIR STREQUAL "")
 			target_include_directories(icsneocpp PUBLIC AFTER third-party/winpcap/include)
-			add_definitions(-DWPCAP -DHAVE_REMOTE -DWIN32_LEAN_AND_MEAN)
+			add_definitions(-DWPCAP -DHAVE_REMOTE)
 		else()
 			target_include_directories(icsneocpp PUBLIC AFTER ${LIBICSNEO_NPCAP_INCLUDE_DIR})
-			add_definitions(-DNPCAP -DWIN32_LEAN_AND_MEAN)
 		endif()
 	else()
 		find_package(PCAP REQUIRED)
@@ -525,6 +531,7 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 		test/unit/livedataencoderdecodertest.cpp
 		test/unit/ringbuffertest.cpp
 		test/unit/apperrordecodertest.cpp
+		test/unit/windowsstrings.cpp
 	)
 
 	target_link_libraries(libicsneo-unit-tests gtest gtest_main)
@@ -537,22 +544,6 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 	add_test(NAME libicsneo-unit-test-suite COMMAND libicsneo-unit-tests)
 endif()
 
-if(LIBICSNEO_BUILD_SYSTEM_TESTS)
-	if(DEFINED ENV{LIBICSNEO_SYSTEM_TESTS})
-		include(FetchContent)
-		file(MAKE_DIRECTORY test/system)
-		FetchContent_Declare(
-			SystemTests
-			GIT_REPOSITORY $ENV{LIBICSNEO_SYSTEM_TESTS}
-			GIT_TAG main
-			SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/test/system
-		)
-		FetchContent_MakeAvailable(SystemTests)
-	else()
-		message("System test repo not defined!")
-	endif()
-endif()
-
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
 include(CPack)

LICENSE

@@ -1,13 +1,29 @@
-Copyright 2018-2024 Intrepid Control Systems, Inc.
+Copyright (c) 2018-2025 Intrepid Control Systems, Inc.
 
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
 
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
 
-3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
 
-4. It is forbidden to use this library or derivatives to interface with vehicle networking hardware not produced by Intrepid Control Systems, Inc.
+4. It is forbidden to use this library or derivatives to interface with vehicle
+   networking hardware not produced by Intrepid Control Systems, Inc.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -23,6 +23,8 @@ each of the respective APIs.
 - RAD-A2B
 - RAD-Comet 2
 - RAD-Comet 3
+- RAD-Epsilon
+- RAD-EpsilonXL
 - RAD-Galaxy
 - RAD-Galaxy 2
 - RAD-Gigastar

api/icsneoc/version.rc.template

@@ -29,7 +29,7 @@ BEGIN
             VALUE "FileDescription",  "Intrepid Control Systems Open Device Communication C API"
             VALUE "FileVersion",      VER_FILEVERSION_STR
             VALUE "InternalName",     "icsneoc.dll"
-            VALUE "LegalCopyright",   "Intrepid Control Systems, Inc. (C) 2018-2024"
+            VALUE "LegalCopyright",   "Intrepid Control Systems, Inc. (C) 2018-2025"
             VALUE "OriginalFilename", "icsneoc.dll"
             VALUE "ProductName",      "libicsneo"
             VALUE "ProductVersion",   VER_PRODUCTVERSION_STR

api/icsneocpp/event.cpp

@@ -120,6 +120,8 @@ static constexpr const char* DISK_NOT_CONNECTED = "The program tried to access a
 static constexpr const char* UNEXPECTED_RESPONSE = "Received an unexpected or invalid response from the device.";
 static constexpr const char* LIN_SETTINGS_NOT_AVAILABLE = "LIN settings are not available for this device.";
 static constexpr const char* MODE_NOT_FOUND = "The mode was not found.";
+static constexpr const char* GPTP_NOT_SUPPORTED = "GPTP clock synchronization is not supported on this device.";
+static constexpr const char* SETTING_NOT_AVAILABLE = "Requested a setting that is not available on this device";
 
 // Transport Errors
 static constexpr const char* FAILED_TO_READ = "A read operation failed.";
@@ -182,9 +184,23 @@ static constexpr const char* VSA_BYTE_PARSE_FAILURE = "Failure to parse record b
 static constexpr const char* VSA_EXTENDED_MESSAGE_ERROR = "Failure to parse extended message record sequence";
 static constexpr const char* VSA_OTHER_ERROR = "Unknown error in VSA read API.";
 
+// Servd
+static constexpr const char* SERVD_BIND_ERROR = "Error binding socket for Servd communication";
+static constexpr const char* SERVD_NONBLOCK_ERROR = "Error setting non-blocking mode for Servd socket";
+static constexpr const char* SERVD_TRANSCEIVE_ERROR = "Error while sending to or receiving from Servd";
+static constexpr const char* SERVD_OUTDATED_ERROR = "Servd version is lower than client (libicsneo) version, update Servd";
+static constexpr const char* SERVD_INVALID_RESPONSE_ERROR = "Unexpected response from Servd";
+static constexpr const char* SERVD_LOCK_ERROR = "Error locking Servd mutex";
+static constexpr const char* SERVD_SEND_ERROR = "Error sending to Servd";
+static constexpr const char* SERVD_RECV_ERROR = "Error receiving from Servd";
+static constexpr const char* SERVD_POLL_ERROR = "Error polling on Servd socket";
+static constexpr const char* SERVD_NODATA_ERROR = "No data received from Servd";
+static constexpr const char* SERVD_JOIN_MULTICAST_ERROR = "Error joining Servd multicast group";
+
 static constexpr const char* TOO_MANY_EVENTS = "Too many events have occurred. The list has been truncated.";
 static constexpr const char* UNKNOWN = "An unknown internal error occurred.";
 static constexpr const char* INVALID = "An invalid internal error occurred.";
+
 const char* APIEvent::DescriptionForType(Type type) {
 	switch(type) {
 		// API Errors
@@ -314,6 +330,8 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return LIN_SETTINGS_NOT_AVAILABLE;
 		case Type::ModeNotFound:
 			return MODE_NOT_FOUND;
+		case Type::SettingNotAvaiableDevice:
+			return SETTING_NOT_AVAILABLE;
 		// Transport Errors
 		case Type::FailedToRead:
 			return FAILED_TO_READ;
@@ -345,6 +363,8 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return GETIFADDRS_ERROR;
 		case Type::SendToError:
 			return SEND_TO_ERROR;
+		case Type::GPTPNotSupported:
+			return GPTP_NOT_SUPPORTED;
 	
 		// FTD3XX
 		case Type::FTOK:
@@ -430,6 +450,30 @@ const char* APIEvent::DescriptionForType(Type type) {
 		case Type::VSAOtherError:
 			return VSA_OTHER_ERROR;
 
+		// Servd
+		case Type::ServdBindError:
+			return SERVD_BIND_ERROR;
+		case Type::ServdNonblockError:
+			return SERVD_NONBLOCK_ERROR;
+		case Type::ServdTransceiveError:
+			return SERVD_TRANSCEIVE_ERROR;
+		case Type::ServdOutdatedError:
+			return SERVD_OUTDATED_ERROR;
+		case Type::ServdInvalidResponseError:
+			return SERVD_INVALID_RESPONSE_ERROR;
+		case Type::ServdLockError:
+			return SERVD_LOCK_ERROR;
+		case Type::ServdSendError:
+			return SERVD_SEND_ERROR;
+		case Type::ServdRecvError:
+			return SERVD_RECV_ERROR;
+		case Type::ServdPollError:
+			return SERVD_POLL_ERROR;
+		case Type::ServdNoDataError:
+			return SERVD_NODATA_ERROR;
+		case Type::ServdJoinMulticastError:
+			return SERVD_JOIN_MULTICAST_ERROR;
+
 		// Other Errors
 		case Type::TooManyEvents:
 			return TOO_MANY_EVENTS;

api/icsneolegacy/icsneolegacy.cpp

@@ -2,8 +2,6 @@
 #error "icsneolegacy.cpp must be compiled with a C++ compiler!"
 #endif
 
-#define NOMINMAX
-
 #define ICSNEOC_MAKEDLL
 #include "icsneo/icsneolegacy.h"
 #include "icsneo/J2534.h"
@@ -29,25 +27,25 @@ static std::map<legacymaphandle_t, neodevice_t> neodevices;
 static std::map<neodevice_t*, NeoDeviceEx*> openneodevices;
 
 static const std::map<size_t, size_t> mp_netIDToVnetOffSet = {
-	{NETID_HSCAN, 1},
+	{NETID_DWCAN_01, 1},
-	{NETID_MSCAN, 2},
+	{NETID_DWCAN_08, 2},
-	{NETID_HSCAN2, 18},
+	{NETID_DWCAN_02, 18},
-	{NETID_HSCAN3, 19},
+	{NETID_DWCAN_03, 19},
-	{NETID_HSCAN4, 32},
+	{NETID_DWCAN_04, 32},
-	{NETID_HSCAN5, 33},
+	{NETID_DWCAN_05, 33},
-	{NETID_HSCAN6, 47},
+	{NETID_DWCAN_06, 47},
-	{NETID_HSCAN7, 48},
+	{NETID_DWCAN_07, 48},
 };
 
 static const std::map<size_t, size_t> mp_HWnetIDToCMnetID = {
-	{NETID_HSCAN, 0},
+	{NETID_DWCAN_01, 0},
-	{NETID_MSCAN, 1},
+	{NETID_DWCAN_08, 1},
-	{NETID_HSCAN2, 5},
+	{NETID_DWCAN_02, 5},
-	{NETID_HSCAN3, 8},
+	{NETID_DWCAN_03, 8},
-	{NETID_HSCAN4, 14},
+	{NETID_DWCAN_04, 14},
-	{NETID_HSCAN5, 15},
+	{NETID_DWCAN_05, 15},
-	{NETID_HSCAN6, 32},
+	{NETID_DWCAN_06, 32},
-	{NETID_HSCAN7, 33},
+	{NETID_DWCAN_07, 33},
 };
 
 static unsigned long vnet_table[] = {0, PLASMA_SLAVE1_OFFSET, PLASMA_SLAVE2_OFFSET};

bindings/python/CMakeLists.txt

@@ -1,7 +1,18 @@
 cmake_minimum_required(VERSION 3.20)
 
 set(PYBIND11_FINDPYTHON ON)
-find_package(pybind11 CONFIG REQUIRED)
+
+if(PYBIND11_ROOT)
+    find_package(pybind11 CONFIG REQUIRED)
+else()
+    include(FetchContent)
+    FetchContent_Declare(
+        pybind11
+        GIT_REPOSITORY https://github.com/pybind/pybind11.git
+        GIT_TAG v2.13.6
+    )
+    FetchContent_MakeAvailable(pybind11)
+endif()
 
 pybind11_add_module(icsneopy
     icsneopy/api/event.cpp
@@ -10,17 +21,34 @@ pybind11_add_module(icsneopy
     icsneopy/api/version.cpp
     icsneopy/device/devicetype.cpp
     icsneopy/communication/network.cpp
+    icsneopy/communication/io.cpp
     icsneopy/communication/message/message.cpp
     icsneopy/communication/message/canmessage.cpp
+    icsneopy/communication/message/canerrormessage.cpp
     icsneopy/communication/message/ethernetmessage.cpp
     icsneopy/communication/message/linmessage.cpp
     icsneopy/communication/message/tc10statusmessage.cpp
     icsneopy/communication/message/mdiomessage.cpp
+    icsneopy/communication/message/gptpstatusmessage.cpp
+    icsneopy/communication/message/ethernetstatusmessage.cpp
+    icsneopy/communication/message/macsecmessage.cpp
+    icsneopy/communication/message/scriptstatusmessage.cpp
     icsneopy/communication/message/callback/messagecallback.cpp
     icsneopy/communication/message/filter/messagefilter.cpp
+    icsneopy/communication/message/flexray/flexraymessage.cpp
+    icsneopy/disk/diskdriver.cpp
     icsneopy/device/device.cpp
+    icsneopy/device/idevicesettings.cpp
     icsneopy/icsneocpp.cpp
 )
 target_link_libraries(icsneopy PRIVATE icsneocpp)
 
-install(TARGETS icsneopy LIBRARY DESTINATION .)
+install(TARGETS icsneopy LIBRARY DESTINATION icsneopy)
+
+find_program(STUBGEN_EXE stubgen)
+if(STUBGEN_EXE)
+    add_custom_command(TARGET icsneopy POST_BUILD COMMAND stubgen -v -p icsneopy -o .)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi py.typed DESTINATION icsneopy)
+endif()
+
+install(FILES __init__.py DESTINATION icsneopy)

bindings/python/__init__.py

@@ -0,0 +1 @@
+from .icsneopy import *

bindings/python/icsneopy/communication/io.cpp

@@ -0,0 +1,19 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/io.h"
+
+namespace icsneo {
+
+void init_io(pybind11::module_& m) {
+	pybind11::enum_<IO>(m, "IO")
+		.value("EthernetActivation", IO::EthernetActivation)
+		.value("USBHostPower", IO::USBHostPower)
+		.value("BackupPowerEnabled", IO::BackupPowerEnabled)
+		.value("BackupPowerGood", IO::BackupPowerGood)
+		.value("Misc", IO::Misc)
+		.value("EMisc", IO::EMisc);
+}
+
+} // namespace icsneo

bindings/python/icsneopy/communication/message/canerrormessage.cpp

@@ -0,0 +1,38 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/canerrormessage.h"
+
+namespace icsneo {
+
+void init_errorcodes(pybind11::module_& m) {
+	pybind11::enum_<CANErrorCode>(m, "CANErrorCode")
+		.value("NoError", CANErrorCode::NoError)
+		.value("StuffError", CANErrorCode::StuffError)
+		.value("FormError", CANErrorCode::FormError)
+		.value("AckError", CANErrorCode::AckError)
+		.value("Bit1Error", CANErrorCode::Bit1Error)
+		.value("Bit0Error", CANErrorCode::Bit0Error)
+		.value("CRCError", CANErrorCode::CRCError)
+		.value("NoChange", CANErrorCode::NoChange);
+}
+
+void init_canerrormessage(pybind11::module_& m) {
+	init_errorcodes(m);
+	pybind11::class_<CANErrorMessage, std::shared_ptr<CANErrorMessage>, Message>(m, "CANErrorMessage")
+		.def_readonly("network", &CANErrorMessage::network)
+		.def_readonly("transmitErrorCount", &CANErrorMessage::transmitErrorCount)
+		.def_readonly("receiveErrorCount", &CANErrorMessage::receiveErrorCount)
+		.def_readonly("busOff", &CANErrorMessage::busOff)
+		.def_readonly("errorPassive", &CANErrorMessage::errorPassive)
+		.def_readonly("errorWarn", &CANErrorMessage::errorWarn)
+		.def_readonly("dataErrorCode", &CANErrorMessage::dataErrorCode)
+		.def_readonly("errorCode", &CANErrorMessage::errorCode);
+	
+
+	m.attr("CANErrorCountMessage") = m.attr("CANErrorMessage");
+}
+
+} // namespace icsneo 
+

bindings/python/icsneopy/communication/message/ethernetstatusmessage.cpp

@@ -0,0 +1,35 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/ethernetstatusmessage.h"
+
+namespace icsneo {
+
+void init_ethernetstatusmessage(pybind11::module_& m) {
+	pybind11::class_<EthernetStatusMessage, std::shared_ptr<EthernetStatusMessage>, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
+
+	pybind11::enum_<EthernetStatusMessage::LinkSpeed>(ethernetStatusMessage, "LinkSpeed")
+		.value("LinkSpeedAuto", EthernetStatusMessage::LinkSpeed::LinkSpeedAuto)
+		.value("LinkSpeed10", EthernetStatusMessage::LinkSpeed::LinkSpeed10)
+		.value("LinkSpeed100", EthernetStatusMessage::LinkSpeed::LinkSpeed100)
+		.value("LinkSpeed1000", EthernetStatusMessage::LinkSpeed::LinkSpeed1000)
+		.value("LinkSpeed2500", EthernetStatusMessage::LinkSpeed::LinkSpeed2500)
+		.value("LinkSpeed5000", EthernetStatusMessage::LinkSpeed::LinkSpeed5000)
+		.value("LinkSpeed10000", EthernetStatusMessage::LinkSpeed::LinkSpeed10000);
+
+	pybind11::enum_<EthernetStatusMessage::LinkMode>(ethernetStatusMessage, "LinkMode")
+		.value("LinkModeAuto", EthernetStatusMessage::LinkMode::LinkModeAuto)
+		.value("LinkModeMaster", EthernetStatusMessage::LinkMode::LinkModeMaster)
+		.value("LinkModeSlave", EthernetStatusMessage::LinkMode::LinkModeSlave)
+		.value("LinkModeInvalid", EthernetStatusMessage::LinkMode::LinkModeInvalid);
+
+	ethernetStatusMessage
+		.def_readonly("network", &EthernetStatusMessage::network)
+		.def_readonly("state", &EthernetStatusMessage::state)
+		.def_readonly("speed", &EthernetStatusMessage::speed)
+		.def_readonly("duplex", &EthernetStatusMessage::duplex)
+		.def_readonly("mode", &EthernetStatusMessage::mode);
+}
+
+} // namespace icsneo

bindings/python/icsneopy/communication/message/filter/messagefilter.cpp

@@ -9,6 +9,7 @@ namespace icsneo {
 void init_messagefilter(pybind11::module_& m) {
 	pybind11::class_<MessageFilter, std::shared_ptr<MessageFilter>>(m, "MessageFilter")
 		.def(pybind11::init())
+		.def(pybind11::init<Message::Type>())
 		.def(pybind11::init<Network::NetID>());
 }
 

bindings/python/icsneopy/communication/message/flexray/flexraymessage.cpp

@@ -0,0 +1,57 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/flexray/flexraymessage.h"
+#include "icsneo/device/extensions/flexray/symbol.h"
+#include "icsneo/device/extensions/flexray/channel.h"
+#include "icsneo/device/extensions/flexray/crcstatus.h"
+
+namespace icsneo {
+
+struct FlexRayNamespace {
+    using Symbol = icsneo::FlexRay::Symbol;
+    using CRCStatus = icsneo::FlexRay::CRCStatus;
+    using Channel = icsneo::FlexRay::Channel;
+};
+
+void init_flexraymessage(pybind11::module_& m) {
+    // dummy class to hold the enums
+    pybind11::class_<FlexRayNamespace> flexray(m, "FlexRay");
+    // enumerations
+    pybind11::enum_<FlexRayNamespace::Symbol>(flexray, "Symbol")
+        .value("None", FlexRayNamespace::Symbol::None)
+        .value("Unknown", FlexRayNamespace::Symbol::Unknown)
+        .value("Wakeup", FlexRayNamespace::Symbol::Wakeup)
+        .value("CAS", FlexRayNamespace::Symbol::CAS);
+    pybind11::enum_<FlexRayNamespace::CRCStatus>(flexray, "CRCStatus")
+        .value("OK", FlexRayNamespace::CRCStatus::OK)
+        .value("Error", FlexRayNamespace::CRCStatus::Error)
+        .value("NoCRC", FlexRayNamespace::CRCStatus::NoCRC);
+    pybind11::enum_<FlexRayNamespace::Channel>(flexray, "Channel")
+	    .value("None", FlexRayNamespace::Channel::None)
+	    .value("A", FlexRayNamespace::Channel::A)
+	    .value("B", FlexRayNamespace::Channel::B)
+	    .value("AB", FlexRayNamespace::Channel::AB);
+    // read-only until transmit is supported
+	pybind11::class_<FlexRayMessage, std::shared_ptr<FlexRayMessage>, Frame>(m, "FlexRayMessage")
+		.def(pybind11::init())
+		.def_readonly("slotid", &FlexRayMessage::slotid)
+		.def_readonly("tsslen", &FlexRayMessage::tsslen)
+        .def_readonly("framelen", &FlexRayMessage::framelen)
+		.def_readonly("symbol", &FlexRayMessage::symbol)
+		.def_readonly("header_crc_status", &FlexRayMessage::headerCRCStatus)
+		.def_readonly("header_crc", &FlexRayMessage::headerCRC)
+		.def_readonly("frame_crc_status", &FlexRayMessage::crcStatus)
+		.def_readonly("frame_crc", &FlexRayMessage::frameCRC)
+		.def_readonly("channel", &FlexRayMessage::channel)
+        .def_readonly("null_frame", &FlexRayMessage::nullFrame)
+        .def_readonly("payload_preamble", &FlexRayMessage::payloadPreamble)
+        .def_readonly("sync_frame", &FlexRayMessage::sync)
+        .def_readonly("startup_frame", &FlexRayMessage::startup)
+        .def_readonly("dynamic_frame", &FlexRayMessage::dynamic)
+        .def_readonly("cycle", &FlexRayMessage::cycle);
+}
+
+} // namespace icsneo 
+

bindings/python/icsneopy/communication/message/gptpstatusmessage.cpp

@@ -0,0 +1,79 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/gptpstatusmessage.h"
+
+namespace icsneo {
+
+void init_gptpstatusmessage(pybind11::module_& m) {
+	pybind11::class_<GPTPStatus, std::shared_ptr<GPTPStatus>, Message> gptpStatus(m, "GPTPStatus");
+	
+	pybind11::class_<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
+		.def_readonly("seconds", &GPTPStatus::Timestamp::seconds)
+		.def_readonly("nanoseconds", &GPTPStatus::Timestamp::nanoseconds)
+		.def("to_seconds", &GPTPStatus::Timestamp::toSeconds, pybind11::call_guard<pybind11::gil_scoped_release>());
+	
+	pybind11::class_<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
+		.def_readonly("nanosecondsMSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
+		.def_readonly("nanosecondsLSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
+		.def_readonly("fractionalNanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
+	
+	pybind11::class_<GPTPStatus::PortID>(gptpStatus, "PortID")
+		.def_readonly("clockIdentity", &GPTPStatus::PortID::clockIdentity)
+		.def_readonly("portNumber", &GPTPStatus::PortID::portNumber);
+	
+	pybind11::class_<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
+		.def_readonly("clockClass", &GPTPStatus::ClockQuality::clockClass)
+		.def_readonly("clockAccuracy", &GPTPStatus::ClockQuality::clockAccuracy)
+		.def_readonly("offsetScaledLogVariance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
+	
+	pybind11::class_<GPTPStatus::SystemID>(gptpStatus, "SystemID")
+		.def_readonly("priority1", &GPTPStatus::SystemID::priority1)
+		.def_readonly("clockQuality", &GPTPStatus::SystemID::clockQuality)
+		.def_readonly("priority2", &GPTPStatus::SystemID::priority2)
+		.def_readonly("clockID", &GPTPStatus::SystemID::clockID);
+	
+	pybind11::class_<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
+		.def_readonly("sysID", &GPTPStatus::PriorityVector::sysID)
+		.def_readonly("stepsRemoved", &GPTPStatus::PriorityVector::stepsRemoved)
+		.def_readonly("portID", &GPTPStatus::PriorityVector::portID)
+		.def_readonly("portNumber", &GPTPStatus::PriorityVector::portNumber);
+	
+	pybind11::class_<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
+		.def_readonly("parentPortIdentity", &GPTPStatus::ParentDS::parentPortIdentity)
+		.def_readonly("cumulativeRateRatio", &GPTPStatus::ParentDS::cumulativeRateRatio)
+		.def_readonly("grandmasterIdentity", &GPTPStatus::ParentDS::grandmasterIdentity)
+		.def_readonly("gmClockQualityClockClass", &GPTPStatus::ParentDS::gmClockQualityClockClass)
+		.def_readonly("gmClockQualityClockAccuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
+		.def_readonly("gmClockQualityOffsetScaledLogVariance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
+		.def_readonly("gmPriority1", &GPTPStatus::ParentDS::gmPriority1)
+		.def_readonly("gmPriority2", &GPTPStatus::ParentDS::gmPriority2);
+
+	pybind11::class_<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
+		.def_readonly("stepsRemoved", &GPTPStatus::CurrentDS::stepsRemoved)
+		.def_readonly("offsetFromMaster", &GPTPStatus::CurrentDS::offsetFromMaster)
+		.def_readonly("lastgmPhaseChange", &GPTPStatus::CurrentDS::lastgmPhaseChange)
+		.def_readonly("lastgmFreqChange", &GPTPStatus::CurrentDS::lastgmFreqChange)
+		.def_readonly("gmTimeBaseIndicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
+		.def_readonly("gmChangeCount", &GPTPStatus::CurrentDS::gmChangeCount)
+		.def_readonly("timeOfLastgmChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
+		.def_readonly("timeOfLastgmPhaseChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
+		.def_readonly("timeOfLastgmFreqChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
+
+	gptpStatus.def_readonly("currentTime", &GPTPStatus::currentTime)
+		.def_readonly("gmPriority", &GPTPStatus::gmPriority)
+		.def_readonly("msOffsetNs", &GPTPStatus::msOffsetNs)
+		.def_readonly("isSync", &GPTPStatus::isSync)
+		.def_readonly("linkStatus", &GPTPStatus::linkStatus)
+		.def_readonly("linkDelayNS", &GPTPStatus::linkDelayNS)
+		.def_readonly("selectedRole", &GPTPStatus::selectedRole)
+		.def_readonly("asCapable", &GPTPStatus::asCapable)
+		.def_readonly("isSyntonized", &GPTPStatus::isSyntonized)
+		.def_readonly("lastRXSyncTS", &GPTPStatus::lastRXSyncTS)
+		.def_readonly("currentDS", &GPTPStatus::currentDS)
+		.def_readonly("parentDS", &GPTPStatus::parentDS);
+
+}
+
+} // namespace icsneo

bindings/python/icsneopy/communication/message/macsecmessage.cpp

@@ -0,0 +1,160 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/macsecmessage.h"
+
+namespace icsneo {
+
+void init_macsecmessage(pybind11::module_ & m)
+{
+	pybind11::enum_<MACsecPacketType>(m, "MACsecPacketType")
+		.value("NoVLAN_OrMPLS", MACsecPacketType::NoVLANOrMPLS)
+		.value("SingleVLAN", MACsecPacketType::SingleVLAN)
+		.value("DualVLAN", MACsecPacketType::DualVLAN)
+		.value("MPLS", MACsecPacketType::MPLS)
+		.value("SingleVLAN_FollowByMPLS", MACsecPacketType::SingleVLANFollowedByMPLS)
+		.value("DualVLAN_FollowByMPLS", MACsecPacketType::DualVLANFollowedByMPLS)
+		.value("Unsupported", MACsecPacketType::Unsupported);
+
+	pybind11::enum_<MACsecValidateFrameType>(m, "MACsecValidateFrameType")
+		.value("Disabled", MACsecValidateFrameType::Disabled)
+		.value("Check", MACsecValidateFrameType::Check)
+		.value("Strict", MACsecValidateFrameType::Strict)
+		.value("NA", MACsecValidateFrameType::NA);
+
+	pybind11::enum_<MACsecSecTagIcvStripType>(m, "MACsecSecTagIcvStripType")
+		.value("StripBoth", MACsecSecTagIcvStripType::StripBoth)
+		.value("StripSecTagPreserveICV", MACsecSecTagIcvStripType::StripSecTagPreserveICV)
+		.value("PreserveSecTagStripICV", MACsecSecTagIcvStripType::PreserveSecTagStripICV)
+		.value("PreserveBoth", MACsecSecTagIcvStripType::PreserveBoth);
+
+	pybind11::enum_<MACsecCipherSuiteType>(m, "MACsecCipherSuiteType")
+		.value("AES_128", MACsecCipherSuiteType::GcmAes128)
+		.value("AES_256", MACsecCipherSuiteType::GcmAes256)
+		.value("AES_128_XPN", MACsecCipherSuiteType::GcmAes128Xpn)
+		.value("AES_256_XPN", MACsecCipherSuiteType::GcmAes256Xpn);
+
+	pybind11::class_<MACsecVLANTag, std::shared_ptr<MACsecVLANTag>>(m, "MACsecVLANTag")
+		.def(pybind11::init())
+		.def_readwrite("vid", &MACsecVLANTag::vid)
+		.def_readwrite("pri_cfi", &MACsecVLANTag::priCfi);
+
+	pybind11::class_<MACsecMPLSOuter, std::shared_ptr<MACsecMPLSOuter>>(m, "MACsecMPLSOuter")
+		.def(pybind11::init())
+		.def_readwrite("mpls_label", &MACsecMPLSOuter::mplsLabel)
+		.def_readwrite("exp", &MACsecMPLSOuter::exp);
+
+	pybind11::class_<MACsecRule, std::shared_ptr<MACsecRule>>(m, "MACsecRule")
+		.def(pybind11::init())
+		.def_readwrite("index", &MACsecRule::index)
+		.def_readwrite("keyMacDa", &MACsecRule::keyMacDa)
+		.def_readwrite("maskMacDa", &MACsecRule::maskMacDa)
+		.def_readwrite("keyMacSa", &MACsecRule::keyMacSa)
+		.def_readwrite("maskMacSa", &MACsecRule::maskMacSa)
+		.def_readwrite("keyEthertype", &MACsecRule::keyEthertype)
+		.def_readwrite("maskEthertype", &MACsecRule::maskEthertype)
+		.def_readwrite("keyVlanTagOuter1", &MACsecRule::keyVlanTagOuter1)
+		.def_readwrite("keyMplsOuter1", &MACsecRule::keyMplsOuter1)
+		.def_readwrite("maskVlanTagOuter1", &MACsecRule::maskVlanTagOuter1)
+		.def_readwrite("maskMplsOuter1", &MACsecRule::maskMplsOuter1)
+		.def_readwrite("keyVlanTagOuter2", &MACsecRule::keyVlanTagOuter2)
+		.def_readwrite("keyMplsOuter2", &MACsecRule::keyMplsOuter2)
+		.def_readwrite("maskVlanTagOuter2", &MACsecRule::maskVlanTagOuter2)
+		.def_readwrite("maskMplsOuter2", &MACsecRule::maskMplsOuter2)
+		.def_readwrite("keyBonusData", &MACsecRule::keyBonusData)
+		.def_readwrite("maskBonusData", &MACsecRule::maskBonusData)
+		.def_readwrite("keyTagMatchBitmap", &MACsecRule::keyTagMatchBitmap)
+		.def_readwrite("maskTagMatchBitmap", &MACsecRule::maskTagMatchBitmap)
+		.def_readwrite("keyPacketType", &MACsecRule::keyPacketType)
+		.def_readwrite("maskPacketType", &MACsecRule::maskPacketType)
+		.def_readwrite("keyInnerVlanType", &MACsecRule::keyInnerVlanType)
+		.def_readwrite("maskInnerVlanType", &MACsecRule::maskInnerVlanType)
+		.def_readwrite("keyOuterVlanType", &MACsecRule::keyOuterVlanType)
+		.def_readwrite("maskOuterVlanType", &MACsecRule::maskOuterVlanType)
+		.def_readwrite("keyNumTags", &MACsecRule::keyNumTags)
+		.def_readwrite("maskNumTags", &MACsecRule::maskNumTags)
+		.def_readwrite("keyExpress", &MACsecRule::keyExpress)
+		.def_readwrite("maskExpress", &MACsecRule::maskExpress)
+		.def_readwrite("isMpls", &MACsecRule::isMpls)
+		.def_readwrite("enable", &MACsecRule::enable);
+
+	pybind11::class_<MACsecMap, std::shared_ptr<MACsecMap>>(m, "MACsecMap")
+		.def(pybind11::init())
+		.def_readwrite("index", &MACsecMap::index)
+		.def_readwrite("secTagSci", &MACsecMap::secTagSci)
+		.def_readwrite("secYIndex", &MACsecMap::secYIndex)
+		.def_readwrite("isControlPacket", &MACsecMap::isControlPacket)
+		.def_readwrite("scIndex", &MACsecMap::scIndex)
+		.def_readwrite("auxiliaryPlcy", &MACsecMap::auxiliaryPlcy)
+		.def_readwrite("ruleId", &MACsecMap::ruleId)
+		.def_readwrite("enable", &MACsecMap::enable);
+
+	pybind11::class_<MACsecSecY, std::shared_ptr<MACsecSecY>>(m, "MACsecSecY")
+		.def(pybind11::init())
+		.def_readwrite("index", &MACsecSecY::index)
+		.def_readwrite("controlledPortEnabled", &MACsecSecY::controlledPortEnabled)
+		.def_readwrite("frameValidationType", &MACsecSecY::frameValidationType)
+		.def_readwrite("secTagIcvStripType", &MACsecSecY::secTagIcvStripType)
+		.def_readwrite("cipher", &MACsecSecY::cipher)
+		.def_readwrite("confidentialOffset", &MACsecSecY::confidentialOffset)
+		.def_readwrite("icvIncludesDaSa", &MACsecSecY::icvIncludesDaSa)
+		.def_readwrite("replayProtect", &MACsecSecY::replayProtect)
+		.def_readwrite("replayWindow", &MACsecSecY::replayWindow)
+		.def_readwrite("protectFrames", &MACsecSecY::protectFrames)
+		.def_readwrite("secTagOffset", &MACsecSecY::secTagOffset)
+		.def_readwrite("secTagTci", &MACsecSecY::secTagTci)
+		.def_readwrite("mtu", &MACsecSecY::mtu)
+		.def_readwrite("enable", &MACsecSecY::enable);
+
+	pybind11::class_<MACsecSc, std::shared_ptr<MACsecSc>>(m, "MACsecSc")
+		.def(pybind11::init())
+		.def_readwrite("index", &MACsecSc::index)
+		.def_readwrite("secYIndex", &MACsecSc::secYIndex)
+		.def_readwrite("sci", &MACsecSc::sci)
+		.def_readwrite("saIndex0", &MACsecSc::saIndex0)
+		.def_readwrite("saIndex1", &MACsecSc::saIndex1)
+		.def_readwrite("saIndex0InUse", &MACsecSc::saIndex0InUse)
+		.def_readwrite("saIndex1InUse", &MACsecSc::saIndex1InUse)
+		.def_readwrite("enableAutoRekey", &MACsecSc::enableAutoRekey)
+		.def_readwrite("isActiveSa1", &MACsecSc::isActiveSa1)
+		.def_readwrite("enable", &MACsecSc::enable);
+
+	pybind11::class_<MACsecSa, std::shared_ptr<MACsecSa>>(m, "MACsecSa")
+		.def(pybind11::init())
+		.def_readwrite("index", &MACsecSa::index)
+		.def_readwrite("sak", &MACsecSa::sak)
+		.def_readwrite("hashKey", &MACsecSa::hashKey)
+		.def_readwrite("salt", &MACsecSa::salt)
+		.def_readwrite("ssci", &MACsecSa::ssci)
+		.def_readwrite("an", &MACsecSa::an)
+		.def_readwrite("nextPn", &MACsecSa::nextPn)
+		.def_readwrite("enable", &MACsecSa::enable);
+
+	pybind11::class_<MACSecFlags, std::shared_ptr<MACSecFlags>>(m, "MACSecFlags")
+		.def(pybind11::init())
+		.def_readwrite("en", &MACSecFlags::en);
+
+	pybind11::class_<MACsecConfig, std::shared_ptr<MACsecConfig>>(m, "MACsecConfig")
+		.def(pybind11::init())
+		.def_readwrite("flags", &MACsecConfig::flags)
+		.def_readwrite("rule", &MACsecConfig::rule)
+		.def_readwrite("map", &MACsecConfig::map)
+		.def_readwrite("secy", &MACsecConfig::secy)
+		.def_readwrite("sc", &MACsecConfig::sc)
+		.def_readwrite("sa", &MACsecConfig::sa);
+
+	pybind11::class_<MACSecGlobalFlags, std::shared_ptr<MACSecGlobalFlags>>(m, "MACSecGlobalFlags")
+		.def(pybind11::init())
+		.def_readwrite("en", &MACSecGlobalFlags::en)
+		.def_readwrite("nvm", &MACSecGlobalFlags::nvm);
+
+	pybind11::class_<MACsecMessage, std::shared_ptr<MACsecMessage>>(m, "MACsecMessage")
+		.def(pybind11::init())
+		.def_readwrite("flags", &MACsecMessage::flags)
+		.def_readwrite("rx", &MACsecMessage::rx)
+		.def_readwrite("tx", &MACsecMessage::tx);
+}
+
+} // namespace icsneo 
+

bindings/python/icsneopy/communication/message/message.cpp

@@ -11,6 +11,7 @@ void init_message(pybind11::module_& m) {
 	pybind11::enum_<Message::Type>(message, "Type")
 		.value("Frame", Message::Type::Frame)
 		.value("CANErrorCount", Message::Type::CANErrorCount)
+		.value("CANError", Message::Type::CANError)
 		.value("LINHeaderOnly", Message::Type::LINHeaderOnly)
 		.value("LINBreak", Message::Type::LINBreak)
 		.value("Invalid", Message::Type::Invalid)
@@ -31,7 +32,9 @@ void init_message(pybind11::module_& m) {
 		.value("LiveData", Message::Type::LiveData)
 		.value("HardwareInfo", Message::Type::HardwareInfo)
 		.value("TC10Status", Message::Type::TC10Status)
-		.value("AppError", Message::Type::AppError);
+		.value("AppError", Message::Type::AppError)
+		.value("GPTPStatus", Message::Type::GPTPStatus)
+		.value("EthernetStatus", Message::Type::EthernetStatus);
 
 	message.def(pybind11::init<Message::Type>());
 	message.def_readonly("type", &Message::type);

bindings/python/icsneopy/communication/message/scriptstatusmessage.cpp

@@ -0,0 +1,30 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/scriptstatusmessage.h"
+
+namespace icsneo {
+
+void init_scriptstatusmessage(pybind11::module_& m) {
+	pybind11::class_<ScriptStatusMessage, std::shared_ptr<ScriptStatusMessage>, Message>(m, "ScriptStatusMessage")
+        .def_readonly("isEncrypted", &ScriptStatusMessage::isEncrypted)
+        .def_readonly("isCoreminiRunning", &ScriptStatusMessage::isCoreminiRunning)
+        .def_readonly("sectorOverflows", &ScriptStatusMessage::sectorOverflows)
+        .def_readonly("numRemainingSectorBuffers", &ScriptStatusMessage::numRemainingSectorBuffers)
+        .def_readonly("lastSector", &ScriptStatusMessage::lastSector)
+        .def_readonly("readBinSize", &ScriptStatusMessage::readBinSize)
+        .def_readonly("minSector", &ScriptStatusMessage::minSector)
+        .def_readonly("maxSector", &ScriptStatusMessage::maxSector)
+        .def_readonly("currentSector", &ScriptStatusMessage::currentSector)
+        .def_readonly("coreminiCreateTime", &ScriptStatusMessage::coreminiCreateTime)
+        .def_readonly("fileChecksum", &ScriptStatusMessage::fileChecksum)
+        .def_readonly("coreminiVersion", &ScriptStatusMessage::coreminiVersion)
+        .def_readonly("coreminiHeaderSize", &ScriptStatusMessage::coreminiHeaderSize)
+        .def_readonly("diagnosticErrorCode", &ScriptStatusMessage::diagnosticErrorCode)
+        .def_readonly("diagnosticErrorCodeCount", &ScriptStatusMessage::diagnosticErrorCodeCount)
+        .def_readonly("maxCoreminiSizeKB", &ScriptStatusMessage::maxCoreminiSizeKB);
+}
+
+} // namespace icsneo 
+

bindings/python/icsneopy/communication/network.cpp

@@ -11,25 +11,25 @@ void init_network(pybind11::module_& m) {
 
 	pybind11::enum_<Network::NetID>(network, "NetID")
 		.value("Device", Network::NetID::Device)
-		.value("HSCAN", Network::NetID::HSCAN)
+		.value("DWCAN_01", Network::NetID::DWCAN_01)
-		.value("MSCAN", Network::NetID::MSCAN)
+		.value("DWCAN_08", Network::NetID::DWCAN_08)
-		.value("SWCAN", Network::NetID::SWCAN)
+		.value("SWCAN_01", Network::NetID::SWCAN_01)
-		.value("LSFTCAN", Network::NetID::LSFTCAN)
+		.value("LSFTCAN_01", Network::NetID::LSFTCAN_01)
 		.value("FordSCP", Network::NetID::FordSCP)
 		.value("J1708", Network::NetID::J1708)
 		.value("Aux", Network::NetID::Aux)
 		.value("J1850VPW", Network::NetID::J1850VPW)
-		.value("ISO9141", Network::NetID::ISO9141)
+		.value("ISO9141_01", Network::NetID::ISO9141_01)
 		.value("DiskData", Network::NetID::DiskData)
 		.value("Main51", Network::NetID::Main51)
 		.value("RED", Network::NetID::RED)
 		.value("SCI", Network::NetID::SCI)
-		.value("ISO9141_2", Network::NetID::ISO9141_2)
+		.value("ISO9141_02", Network::NetID::ISO9141_02)
 		.value("ISO14230", Network::NetID::ISO14230)
-		.value("LIN", Network::NetID::LIN)
+		.value("LIN_01", Network::NetID::LIN_01)
-		.value("OP_Ethernet1", Network::NetID::OP_Ethernet1)
+		.value("AE_01", Network::NetID::AE_01)
-		.value("OP_Ethernet2", Network::NetID::OP_Ethernet2)
+		.value("AE_02", Network::NetID::AE_02)
-		.value("OP_Ethernet3", Network::NetID::OP_Ethernet3)
+		.value("AE_03", Network::NetID::AE_03)
 		.value("RED_EXT_MEMORYREAD", Network::NetID::RED_EXT_MEMORYREAD)
 		.value("RED_INT_MEMORYREAD", Network::NetID::RED_INT_MEMORYREAD)
 		.value("RED_DFLASH_READ", Network::NetID::RED_DFLASH_READ)
@@ -51,15 +51,15 @@ void init_network(pybind11::module_& m) {
 		.value("RED_SCOPE_CAPTURE", Network::NetID::RED_SCOPE_CAPTURE)
 		.value("RED_HARDWARE_EXCEP", Network::NetID::RED_HARDWARE_EXCEP)
 		.value("RED_GET_RTC", Network::NetID::RED_GET_RTC)
-		.value("ISO9141_3", Network::NetID::ISO9141_3)
+		.value("ISO9141_03", Network::NetID::ISO9141_03)
-		.value("HSCAN2", Network::NetID::HSCAN2)
+		.value("DWCAN_02", Network::NetID::DWCAN_02)
-		.value("HSCAN3", Network::NetID::HSCAN3)
+		.value("DWCAN_03", Network::NetID::DWCAN_03)
-		.value("OP_Ethernet4", Network::NetID::OP_Ethernet4)
+		.value("AE_04", Network::NetID::AE_04)
-		.value("OP_Ethernet5", Network::NetID::OP_Ethernet5)
+		.value("AE_05", Network::NetID::AE_05)
-		.value("ISO9141_4", Network::NetID::ISO9141_4)
+		.value("ISO9141_04", Network::NetID::ISO9141_04)
-		.value("LIN2", Network::NetID::LIN2)
+		.value("LIN_02", Network::NetID::LIN_02)
-		.value("LIN3", Network::NetID::LIN3)
+		.value("LIN_03", Network::NetID::LIN_03)
-		.value("LIN4", Network::NetID::LIN4)
+		.value("LIN_04", Network::NetID::LIN_04)
 		.value("RED_App_Error", Network::NetID::RED_App_Error)
 		.value("CGI", Network::NetID::CGI)
 		.value("Reset_Status", Network::NetID::Reset_Status)
@@ -69,44 +69,44 @@ void init_network(pybind11::module_& m) {
 		.value("Read_Datalink_Cm_Rx_Msg", Network::NetID::Read_Datalink_Cm_Rx_Msg)
 		.value("Logging_Overflow", Network::NetID::Logging_Overflow)
 		.value("ReadSettings", Network::NetID::ReadSettings)
-		.value("HSCAN4", Network::NetID::HSCAN4)
+		.value("DWCAN_04", Network::NetID::DWCAN_04)
-		.value("HSCAN5", Network::NetID::HSCAN5)
+		.value("DWCAN_05", Network::NetID::DWCAN_05)
 		.value("RS232", Network::NetID::RS232)
-		.value("UART", Network::NetID::UART)
+		.value("UART_01", Network::NetID::UART_01)
-		.value("UART2", Network::NetID::UART2)
+		.value("UART_02", Network::NetID::UART_02)
-		.value("UART3", Network::NetID::UART3)
+		.value("UART_03", Network::NetID::UART_03)
-		.value("UART4", Network::NetID::UART4)
+		.value("UART_04", Network::NetID::UART_04)
-		.value("SWCAN2", Network::NetID::SWCAN2)
+		.value("SWCAN_02", Network::NetID::SWCAN_02)
-		.value("Ethernet_DAQ", Network::NetID::Ethernet_DAQ)
+		.value("ETHERNET_DAQ", Network::NetID::ETHERNET_DAQ)
 		.value("Data_To_Host", Network::NetID::Data_To_Host)
 		.value("TextAPI_To_Host", Network::NetID::TextAPI_To_Host)
-		.value("SPI1", Network::NetID::SPI1)
+		.value("SPI_01", Network::NetID::SPI_01)
-		.value("OP_Ethernet6", Network::NetID::OP_Ethernet6)
+		.value("AE_06", Network::NetID::AE_06)
 		.value("Red_VBat", Network::NetID::Red_VBat)
-		.value("OP_Ethernet7", Network::NetID::OP_Ethernet7)
+		.value("AE_07", Network::NetID::AE_07)
-		.value("OP_Ethernet8", Network::NetID::OP_Ethernet8)
+		.value("AE_08", Network::NetID::AE_08)
-		.value("OP_Ethernet9", Network::NetID::OP_Ethernet9)
+		.value("AE_09", Network::NetID::AE_09)
-		.value("OP_Ethernet10", Network::NetID::OP_Ethernet10)
+		.value("AE_10", Network::NetID::AE_10)
-		.value("OP_Ethernet11", Network::NetID::OP_Ethernet11)
+		.value("AE_11", Network::NetID::AE_11)
-		.value("FlexRay1a", Network::NetID::FlexRay1a)
+		.value("FLEXRAY_01A", Network::NetID::FLEXRAY_01A)
-		.value("FlexRay1b", Network::NetID::FlexRay1b)
+		.value("FLEXRAY_01B", Network::NetID::FLEXRAY_01B)
-		.value("FlexRay2a", Network::NetID::FlexRay2a)
+		.value("FLEXRAY_02A", Network::NetID::FLEXRAY_02A)
-		.value("FlexRay2b", Network::NetID::FlexRay2b)
+		.value("FLEXRAY_02B", Network::NetID::FLEXRAY_02B)
-		.value("LIN5", Network::NetID::LIN5)
+		.value("LIN_05", Network::NetID::LIN_05)
-		.value("FlexRay", Network::NetID::FlexRay)
+		.value("FLEXRAY_01", Network::NetID::FLEXRAY_01)
-		.value("FlexRay2", Network::NetID::FlexRay2)
+		.value("FLEXRAY_02", Network::NetID::FLEXRAY_02)
-		.value("OP_Ethernet12", Network::NetID::OP_Ethernet12)
+		.value("AE_12", Network::NetID::AE_12)
-		.value("I2C", Network::NetID::I2C)
+		.value("I2C_01", Network::NetID::I2C_01)
-		.value("MOST25", Network::NetID::MOST25)
+		.value("MOST_25", Network::NetID::MOST_25)
-		.value("MOST50", Network::NetID::MOST50)
+		.value("MOST_50", Network::NetID::MOST_50)
-		.value("MOST150", Network::NetID::MOST150)
+		.value("MOST_150", Network::NetID::MOST_150)
-		.value("Ethernet", Network::NetID::Ethernet)
+		.value("ETHERNET_01", Network::NetID::ETHERNET_01)
 		.value("GMFSA", Network::NetID::GMFSA)
 		.value("TCP", Network::NetID::TCP)
-		.value("HSCAN6", Network::NetID::HSCAN6)
+		.value("DWCAN_06", Network::NetID::DWCAN_06)
-		.value("HSCAN7", Network::NetID::HSCAN7)
+		.value("DWCAN_07", Network::NetID::DWCAN_07)
-		.value("LIN6", Network::NetID::LIN6)
+		.value("LIN_06", Network::NetID::LIN_06)
-		.value("LSFTCAN2", Network::NetID::LSFTCAN2)
+		.value("LSFTCAN_02", Network::NetID::LSFTCAN_02)
 		.value("LogicalDiskInfo", Network::NetID::LogicalDiskInfo)
 		.value("WiVICommand", Network::NetID::WiVICommand)
 		.value("ScriptStatus", Network::NetID::ScriptStatus)
@@ -119,51 +119,51 @@ void init_network(pybind11::module_& m) {
 		.value("DeviceStatus", Network::NetID::DeviceStatus)
 		.value("UDP", Network::NetID::UDP)
 		.value("ForwardedMessage", Network::NetID::ForwardedMessage)
-		.value("I2C2", Network::NetID::I2C2)
+		.value("I2C_02", Network::NetID::I2C_02)
-		.value("I2C3", Network::NetID::I2C3)
+		.value("I2C_03", Network::NetID::I2C_03)
-		.value("I2C4", Network::NetID::I2C4)
+		.value("I2C_04", Network::NetID::I2C_04)
-		.value("Ethernet2", Network::NetID::Ethernet2)
+		.value("ETHERNET_02", Network::NetID::ETHERNET_02)
-		.value("A2B1", Network::NetID::A2B1)
+		.value("A2B_01", Network::NetID::A2B_01)
-		.value("A2B2", Network::NetID::A2B2)
+		.value("A2B_02", Network::NetID::A2B_02)
-		.value("Ethernet3", Network::NetID::Ethernet3)
+		.value("ETHERNET_03", Network::NetID::ETHERNET_03)
-		.value("WBMS", Network::NetID::WBMS)
+		.value("WBMS_01", Network::NetID::WBMS_01)
-		.value("DWCAN9", Network::NetID::DWCAN9)
+		.value("DWCAN_09", Network::NetID::DWCAN_09)
-		.value("DWCAN10", Network::NetID::DWCAN10)
+		.value("DWCAN_10", Network::NetID::DWCAN_10)
-		.value("DWCAN11", Network::NetID::DWCAN11)
+		.value("DWCAN_11", Network::NetID::DWCAN_11)
-		.value("DWCAN12", Network::NetID::DWCAN12)
+		.value("DWCAN_12", Network::NetID::DWCAN_12)
-		.value("DWCAN13", Network::NetID::DWCAN13)
+		.value("DWCAN_13", Network::NetID::DWCAN_13)
-		.value("DWCAN14", Network::NetID::DWCAN14)
+		.value("DWCAN_14", Network::NetID::DWCAN_14)
-		.value("DWCAN15", Network::NetID::DWCAN15)
+		.value("DWCAN_15", Network::NetID::DWCAN_15)
-		.value("DWCAN16", Network::NetID::DWCAN16)
+		.value("DWCAN_16", Network::NetID::DWCAN_16)
-		.value("LIN7", Network::NetID::LIN7)
+		.value("LIN_07", Network::NetID::LIN_07)
-		.value("LIN8", Network::NetID::LIN8)
+		.value("LIN_08", Network::NetID::LIN_08)
-		.value("SPI2", Network::NetID::SPI2)
+		.value("SPI_02", Network::NetID::SPI_02)
-		.value("MDIO1", Network::NetID::MDIO1)
+		.value("MDIO_01", Network::NetID::MDIO_01)
-		.value("MDIO2", Network::NetID::MDIO2)
+		.value("MDIO_02", Network::NetID::MDIO_02)
-		.value("MDIO3", Network::NetID::MDIO3)
+		.value("MDIO_03", Network::NetID::MDIO_03)
-		.value("MDIO4", Network::NetID::MDIO4)
+		.value("MDIO_04", Network::NetID::MDIO_04)
-		.value("MDIO5", Network::NetID::MDIO5)
+		.value("MDIO_05", Network::NetID::MDIO_05)
-		.value("MDIO6", Network::NetID::MDIO6)
+		.value("MDIO_06", Network::NetID::MDIO_06)
-		.value("MDIO7", Network::NetID::MDIO7)
+		.value("MDIO_07", Network::NetID::MDIO_07)
-		.value("MDIO8", Network::NetID::MDIO8)
+		.value("MDIO_08", Network::NetID::MDIO_08)
-		.value("OP_Ethernet13", Network::NetID::OP_Ethernet13)
+		.value("AE_13", Network::NetID::AE_13)
-		.value("OP_Ethernet14", Network::NetID::OP_Ethernet14)
+		.value("AE_14", Network::NetID::AE_14)
-		.value("OP_Ethernet15", Network::NetID::OP_Ethernet15)
+		.value("AE_15", Network::NetID::AE_15)
-		.value("OP_Ethernet16", Network::NetID::OP_Ethernet16)
+		.value("AE_16", Network::NetID::AE_16)
-		.value("SPI3", Network::NetID::SPI3)
+		.value("SPI_03", Network::NetID::SPI_03)
-		.value("SPI4", Network::NetID::SPI4)
+		.value("SPI_04", Network::NetID::SPI_04)
-		.value("SPI5", Network::NetID::SPI5)
+		.value("SPI_05", Network::NetID::SPI_05)
-		.value("SPI6", Network::NetID::SPI6)
+		.value("SPI_06", Network::NetID::SPI_06)
-		.value("SPI7", Network::NetID::SPI7)
+		.value("SPI_07", Network::NetID::SPI_07)
-		.value("SPI8", Network::NetID::SPI8)
+		.value("SPI_08", Network::NetID::SPI_08)
-		.value("LIN9", Network::NetID::LIN9)
+		.value("LIN_09", Network::NetID::LIN_09)
-		.value("LIN10", Network::NetID::LIN10)
+		.value("LIN_10", Network::NetID::LIN_10)
-		.value("LIN11", Network::NetID::LIN11)
+		.value("LIN_11", Network::NetID::LIN_11)
-		.value("LIN12", Network::NetID::LIN12)
+		.value("LIN_12", Network::NetID::LIN_12)
-		.value("LIN13", Network::NetID::LIN13)
+		.value("LIN_13", Network::NetID::LIN_13)
-		.value("LIN14", Network::NetID::LIN14)
+		.value("LIN_14", Network::NetID::LIN_14)
-		.value("LIN15", Network::NetID::LIN15)
+		.value("LIN_15", Network::NetID::LIN_15)
-		.value("LIN16", Network::NetID::LIN16)
+		.value("LIN_16", Network::NetID::LIN_16)
 		.value("Any", Network::NetID::Any)
 		.value("Invalid", Network::NetID::Invalid);
 	
@@ -178,7 +178,7 @@ void init_network(pybind11::module_& m) {
 		.value("LSFTCAN", Network::Type::LSFTCAN)
 		.value("SWCAN", Network::Type::SWCAN)
 		.value("ISO9141", Network::Type::ISO9141)
-		.value("I2C", Network::Type::I2C)
+		.value("I2C_01", Network::Type::I2C)
 		.value("A2B", Network::Type::A2B)
 		.value("SPI", Network::Type::SPI)
 		.value("MDIO", Network::Type::MDIO)

bindings/python/icsneopy/device/device.cpp

@@ -5,41 +5,54 @@
 
 #include "icsneo/device/device.h"
 
+#include <fstream>
+
 namespace icsneo {
 
 void init_device(pybind11::module_& m) {
 	pybind11::class_<Device, std::shared_ptr<Device>>(m, "Device")
-		.def("get_type", &Device::getType)
+		.def("__repr__", &Device::describe)
-		.def("get_serial", &Device::getSerial)
-		.def("get_serial_number", &Device::getSerialNumber)
-		.def("get_product_name", &Device::getProductName)
-		.def("open", [](Device& device) { return device.open(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("close", &Device::close, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("is_open", &Device::isOpen)
-		.def("go_online", &Device::goOnline, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("go_offline", &Device::goOffline, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("is_online", &Device::isOnline)
-		.def("enable_message_polling", &Device::enableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("disable_message_polling", &Device::disableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("is_message_polling_enabled", &Device::isMessagePollingEnabled)
-		.def("get_messages", [](Device& device) { return device.getMessages(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_current_message_count", &Device::getCurrentMessageCount)
-		.def("get_polling_message_limit", &Device::getPollingMessageLimit)
-		.def("set_polling_message_limit", &Device::setPollingMessageLimit)
 		.def("add_message_callback", &Device::addMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("remove_message_callback", &Device::removeMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("clear_script", &Device::clearScript, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("close", &Device::close, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("describe", &Device::describe)
+		.def("disable_message_polling", &Device::disableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("enable_message_polling", &Device::enableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_current_message_count", &Device::getCurrentMessageCount)
+		.def("get_digital_io", &Device::getDigitalIO, pybind11::arg("type"), pybind11::arg("number"), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_gptp_status", &Device::getGPTPStatus, pybind11::arg("timeout") = std::chrono::milliseconds(100), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_messages", [](Device& device) { return device.getMessages(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_polling_message_limit", &Device::getPollingMessageLimit)
+		.def("get_product_name", &Device::getProductName)
+		.def("get_rtc", &Device::getRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_script_status", &Device::getScriptStatus, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_serial_number", &Device::getSerialNumber)
+		.def("get_serial", &Device::getSerial)
 		.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
 		.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
-		.def("get_rtc", &Device::getRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_rtc", &Device::setRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("describe", &Device::describe)
-		.def("is_online_supported", &Device::isOnlineSupported)
-		.def("supports_tc10", &Device::supportsTC10)
-		.def("request_tc10_wake", &Device::requestTC10Wake, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("request_tc10_sleep", &Device::requestTC10Sleep, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("__repr__", &Device::describe);
+		.def("get_type", &Device::getType)
+		.def("go_offline", &Device::goOffline, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("go_online", &Device::goOnline, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("is_message_polling_enabled", &Device::isMessagePollingEnabled)
+		.def("is_online_supported", &Device::isOnlineSupported)
+		.def("is_online", &Device::isOnline)
+		.def("is_open", &Device::isOpen)
+		.def("open", [](Device& device) { return device.open(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("prepare_script_load", &Device::prepareScriptLoad, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("remove_message_callback", &Device::removeMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("request_tc10_sleep", &Device::requestTC10Sleep, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("request_tc10_wake", &Device::requestTC10Wake, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_digital_io", pybind11::overload_cast<IO, size_t, bool>(&Device::setDigitalIO), pybind11::arg("type"), pybind11::arg("number"), pybind11::arg("value"), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_polling_message_limit", &Device::setPollingMessageLimit)
+		.def("set_rtc", &Device::setRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("start_script", &Device::startScript, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("stop_script", &Device::stopScript, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("supports_tc10", &Device::supportsTC10)
+		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("upload_coremini", [](Device& device, std::string& path, Disk::MemoryType memType) { std::ifstream ifs(path, std::ios::binary); return device.uploadCoremini(ifs, memType); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("write_macsec_config", &Device::writeMACsecConfig, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def_readonly("settings", &Device::settings);
 }
 
 } // namespace icsneo

bindings/python/icsneopy/device/devicetype.cpp

@@ -33,6 +33,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("EtherBADGE", DeviceType::Enum::EtherBADGE)
 		.value("RAD_A2B", DeviceType::Enum::RAD_A2B)
 		.value("RADEpsilon", DeviceType::Enum::RADEpsilon)
+		.value("RADEpsilonXL", DeviceType::Enum::RADEpsilonXL)
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
 		.value("RADComet", DeviceType::Enum::RADComet)

bindings/python/icsneopy/device/idevicesettings.cpp

@@ -0,0 +1,47 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/stl_bind.h>
+#include <pybind11/functional.h>
+#include <pybind11/chrono.h>
+
+#include "icsneo/device/idevicesettings.h"
+
+#include <fstream>
+
+namespace icsneo {
+
+struct DeviceSettingsNamespace {
+    using EthLinkMode = AELinkMode;
+    using LinkSpeed = EthLinkSpeed;
+};
+
+void init_idevicesettings(pybind11::module_& m) {
+    pybind11::class_<DeviceSettingsNamespace> settings(m, "Settings");
+
+    pybind11::enum_<DeviceSettingsNamespace::EthLinkMode>(settings, "EthernetLinkMode")
+        .value("Auto", DeviceSettingsNamespace::EthLinkMode::AE_LINK_AUTO)
+        .value("Slave", DeviceSettingsNamespace::EthLinkMode::AE_LINK_SLAVE)
+        .value("Master", DeviceSettingsNamespace::EthLinkMode::AE_LINK_MASTER);
+
+    pybind11::enum_<DeviceSettingsNamespace::LinkSpeed>(settings, "EthernetLinkSpeed")
+        .value("Speed10M", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10)
+        .value("Speed100M", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_100)
+        .value("Speed1G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_1000)
+        .value("Speed2_5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_2500)
+        .value("Speed5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_5000)
+        .value("Speed10G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10000);
+
+    pybind11::class_<IDeviceSettings, std::shared_ptr<IDeviceSettings>>(m, "IDeviceSettings")
+        .def("apply", &IDeviceSettings::apply, pybind11::arg("temporary") = 0, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("apply_defaults", &IDeviceSettings::applyDefaults, pybind11::arg("temporary") = 0, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("get_phy_enable", &IDeviceSettings::getPhyEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("get_phy_mode", &IDeviceSettings::getPhyMode, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("get_phy_speed", &IDeviceSettings::getPhySpeed, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_phy_enable", &IDeviceSettings::setPhyEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_phy_mode", &IDeviceSettings::setPhyMode, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_phy_speed", &IDeviceSettings::setPhySpeed, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("refresh", &IDeviceSettings::refresh, pybind11::arg("ignoreChecksum") = 0, pybind11::call_guard<pybind11::gil_scoped_release>());
+}
+
+} // namespace icsneo
+

bindings/python/icsneopy/disk/diskdriver.cpp

@@ -0,0 +1,26 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/disk/diskdriver.h"
+
+namespace icsneo {
+
+// binding namespace workaround to avoid submodules
+struct DiskNamespace {
+	using Access = icsneo::Disk::Access;
+	using MemoryType = icsneo::Disk::MemoryType;
+};
+
+void init_diskdriver(pybind11::module_& m) {
+	pybind11::class_<DiskNamespace> disk(m, "Disk");
+	pybind11::enum_<Disk::Access>(disk, "Access")
+		.value("None", Disk::Access::None)
+		.value("EntireCard", Disk::Access::EntireCard)
+		.value("VSA", Disk::Access::VSA);
+	pybind11::enum_<Disk::MemoryType>(disk, "MemoryType")
+		.value("Flash", Disk::MemoryType::Flash)
+		.value("SD", Disk::MemoryType::SD);
+}
+
+} // namespace icsneo 

bindings/python/icsneopy/icsneocpp.cpp

@@ -10,19 +10,30 @@ void init_event(pybind11::module_&);
 void init_eventcallback(pybind11::module_&);
 void init_eventmanager(pybind11::module_&);
 void init_network(pybind11::module_&);
+void init_io(pybind11::module_&);
 void init_devicetype(pybind11::module_&);
 void init_message(pybind11::module_&);
 void init_canmessage(pybind11::module_&);
+void init_canerrormessage(pybind11::module_&);
 void init_ethernetmessage(pybind11::module_&);
 void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
+void init_gptpstatusmessage(pybind11::module_&);
 void init_mdiomessage(pybind11::module_&);
+void init_ethernetstatusmessage(pybind11::module_&);
+void init_macsecmessage(pybind11::module_&);
+void init_scriptstatusmessage(pybind11::module_&);
+void init_diskdriver(pybind11::module_&);
 void init_device(pybind11::module_&);
 void init_messagefilter(pybind11::module_&);
 void init_messagecallback(pybind11::module_&);
 void init_version(pybind11::module_&);
+void init_flexraymessage(pybind11::module_& m);
+void init_idevicesettings(pybind11::module_&);
 
 PYBIND11_MODULE(icsneopy, m) {
+	pybind11::options options;
+	options.disable_enum_members_docstring();
 	m.doc() = "libicsneo Python module";
 
 	init_event(m);
@@ -31,15 +42,24 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_version(m);
 	init_devicetype(m);
 	init_network(m);
+	init_io(m);
 	init_message(m);
 	init_canmessage(m);
+	init_canerrormessage(m);
 	init_ethernetmessage(m);
 	init_linmessage(m);
 	init_tc10statusmessage(m);
+	init_gptpstatusmessage(m);
 	init_mdiomessage(m);
+	init_ethernetstatusmessage(m);
+	init_macsecmessage(m);
+	init_scriptstatusmessage(m);
 	init_messagefilter(m);
 	init_messagecallback(m);
+	init_diskdriver(m);
 	init_device(m);
+	init_flexraymessage(m);
+	init_idevicesettings(m);
 
 	m.def("find_all_devices", &FindAllDevices);
 	m.def("get_supported_devices", &GetSupportedDevices);

ci/build-posix.sh

@@ -1,7 +1,8 @@
 #!/bin/sh
-
+export CFLAGS="-Wall -Werror"
+export CXXFLAGS="-Wall -Werror"
 cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON \
-	-DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_BUILD_SYSTEM_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
+	-DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
 
 cmake --build build || exit 1
 

ci/build-windows.bat

@@ -4,9 +4,9 @@ mkdir build
 
 REM build
 cd build
-set CFLAGS=/WX
+set CFLAGS=/WX /W4 /wd4127
-set CXXFLAGS=/WX
+set CXXFLAGS=/WX /W4 /wd4127
-cmake -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_BUILD_SYSTEM_TESTS=ON -DLIBICSNEO_ENABLE_TCP=ON ..
+cmake -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=ON ..
 if %errorlevel% neq 0 exit /b %errorlevel%
 cmake --build .
 if %errorlevel% neq 0 exit /b %errorlevel%

ci/build-windows32.bat

@@ -1,2 +1,2 @@
-call "%VCVARS32%"
+call "%VCVARS32_2022%"
 call "ci\build-windows.bat"

ci/build-windows64.bat

@@ -1,2 +1,2 @@
-call "%VCVARS64%"
+call "%VCVARS64_2022%"
 call "ci\build-windows.bat"

communication/communication.cpp

@@ -37,29 +37,28 @@ bool Communication::open() {
 }
 
 void Communication::spawnThreads() {
+	closing = false;
 	readTaskThread = std::thread(&Communication::readTask, this);
 }
 
 void Communication::joinThreads() {
-	closing = true;
-
 	if(pauseReadTask) {
 		resumeReads();
 	}
 
+	closing = true;
 	if(readTaskThread.joinable())
 		readTaskThread.join();
-	closing = false;
 }
 
 bool Communication::close() {
-	joinThreads();
-
 	if(!isOpen() && !isDisconnected()) {
 		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
 		return false;
 	}
 
+	joinThreads();
+
 	return driver->close();
 }
 

communication/crc32.cpp

@@ -0,0 +1,70 @@
+/*
+ * crc32.c
+ *
+ *  Created on: Jun 22, 2020
+ *      Author: BJones
+ */
+#include "icsneo/communication/crc32.h"
+#include <stddef.h>
+
+static const unsigned long crc32_table[256] = { 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
+	0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
+	0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F,
+	0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+	0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180,
+	0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11,
+	0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2,
+	0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+	0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
+	0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC,
+	0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525,
+	0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+	0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E,
+	0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+	0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
+	0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+	0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9,
+	0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226,
+	0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
+	0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+	0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354,
+	0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
+	0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E,
+	0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D };
+
+uint32_t crc32(uint32_t crc, const unsigned char* buf, uint32_t len)
+{
+	unsigned char octet;
+	const unsigned char* p = buf;
+
+	crc = ~crc;
+	while (len--)
+	{
+		octet = *p++; /* Cast to unsigned octet. */
+		crc = (crc >> 8) ^ crc32_table[(crc & 0xff) ^ octet];
+	}
+	return ~crc;
+}
+
+static unsigned char rev_crc32_table[256];
+
+static void revgen(void)
+{
+	size_t k;
+
+	for (k = 0; k < 256; k++)
+		rev_crc32_table[crc32_table[k] >> 24] = (uint8_t)k;
+}
+
+uint32_t revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len)
+{
+	unsigned char k;
+	revgen();
+	crc = ~crc;
+	while (len--)
+	{
+		k = rev_crc32_table[crc >> 24];
+		crc = ((crc ^ crc32_table[k]) << 8) | (k ^ buf[len]);
+	}
+	return ~crc;
+}

communication/decoder.cpp

@@ -3,7 +3,7 @@
 #include "icsneo/communication/message/serialnumbermessage.h"
 #include "icsneo/communication/message/resetstatusmessage.h"
 #include "icsneo/communication/message/readsettingsmessage.h"
-#include "icsneo/communication/message/canerrorcountmessage.h"
+#include "icsneo/communication/message/canerrormessage.h"
 #include "icsneo/communication/message/neoreadmemorysdmessage.h"
 #include "icsneo/communication/message/flashmemorymessage.h"
 #include "icsneo/communication/message/extendedresponsemessage.h"
@@ -16,10 +16,13 @@
 #include "icsneo/communication/message/mdiomessage.h"
 #include "icsneo/communication/message/extendeddatamessage.h"
 #include "icsneo/communication/message/livedatamessage.h"
+#include "icsneo/communication/message/logdatamessage.h"
 #include "icsneo/communication/message/diskdatamessage.h"
 #include "icsneo/communication/message/hardwareinfo.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
+#include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/apperrormessage.h"
+#include "icsneo/communication/message/ethernetstatusmessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -93,7 +96,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 					break;
 				}
 				case Message::Type::CANErrorCount: {
-					CANErrorCountMessage& can = *static_cast<CANErrorCountMessage*>(result.get());
+					CANErrorMessage& can = *static_cast<CANErrorMessage*>(result.get());
 					can.network = packet->network;
 					break;
 				}
@@ -237,21 +240,26 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						return true;
 					}
 
-					result = HardwareCANPacket::DecodeToMessage(packet->data);
+					const auto can = std::dynamic_pointer_cast<CANMessage>(HardwareCANPacket::DecodeToMessage(packet->data));
-					if(!result) {
+					if(!can) {
 						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-						return false; // A nullptr was returned, the packet was malformed
+						return false;
+					}
+					
+					if(can->arbid == 0x162) {
+						result = EthernetStatusMessage::DecodeToMessage(can->data);
+
+						if(!result) {
+							report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+							return false;
+						}
+					} else {
+						// TODO: move more handleNeoVIMessage handling here, the Decoder layer will parse the message and the Device layer can cache the values
+						can->network = packet->network;
+						result = can;
 					}
 
-					// Timestamps are in (resolution) ns increments since 1/1/2007 GMT 00:00:00.0000
+					result->timestamp *= timestampResolution;
-					// The resolution depends on the device
-					auto* raw = dynamic_cast<RawMessage*>(result.get());
-					if(raw == nullptr) {
-						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-						return false; // A nullptr was returned, the packet was malformed
-					}
-					raw->timestamp *= timestampResolution;
-					raw->network = packet->network;
 					return true;
 				}
 				case Network::NetID::DeviceStatus: {
@@ -285,11 +293,11 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 				}
 				case Network::NetID::ExtendedCommand: {
 
-					if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
+					if(packet->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
 						break; // Handle as a raw message, might not be a generic response
 
-					const auto& resp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
+					const auto& resp = *reinterpret_cast<ExtendedResponseMessage::ResponseHeader*>(packet->data.data());
-					switch(resp.header.command) {
+					switch(resp.command) {
 						case ExtendedCommand::GetComponentVersions:
 							result = ComponentVersionPacket::DecodeToMessage(packet->data);
 							return true;
@@ -299,15 +307,23 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::GenericBinaryInfo:
 							result = GenericBinaryStatusPacket::DecodeToMessage(packet->data);
 							return true;
-						case ExtendedCommand::GenericReturn:
+						case ExtendedCommand::GenericReturn: {
-							result = std::make_shared<ExtendedResponseMessage>(resp.command, resp.returnCode);
+							if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
+								break;
+							const auto& packedResp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
+							result = std::make_shared<ExtendedResponseMessage>(packedResp.command, packedResp.returnCode);
 							return true;
+						}
 						case ExtendedCommand::LiveData:
 							result = HardwareLiveDataPacket::DecodeToMessage(packet->data, report);
 							return true;
 						case ExtendedCommand::GetTC10Status:
 							result = TC10StatusMessage::DecodeToMessage(packet->data);
 							return true;
+						case ExtendedCommand::GetGPTPStatus: {
+							result = GPTPStatus::DecodeToMessage(packet->data, report);
+							return true;
+						}
 						default:
 							// No defined handler, treat this as a RawMessage
 							break;
@@ -476,7 +492,16 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 					result = std::make_shared<DiskDataMessage>(std::move(packet->data));
 					return true;
 				}
+				case Network::NetID::Data_To_Host: {
+					result = LogDataMessage::DecodeToMessage(packet->data);
+					if(!result) {
+						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::EventWarning);
+						return false;
+					}
+					return true;
+				}
 				default:
+		
 					break;
 			}
 			break;

communication/encoder.cpp

@@ -265,6 +265,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			case Command::GetMainVersion:
 			case Command::GetSecondaryVersions:
 			case Command::NeoReadMemory:
+			case Command::ClearCoreMini:
+			case Command::LoadCoreMini:
 				// There is a firmware handling idiosyncrasy with these commands
 				// They must be encoded in the short format
 				m51msg->forceShortFormat = true;

communication/message/ethernetstatusmessage.cpp

@@ -0,0 +1,57 @@
+#include "icsneo/communication/message/ethernetstatusmessage.h"
+
+using namespace icsneo;
+
+#pragma pack(push, 1)
+enum LinkSpeed {
+	ethSpeed10,
+	ethSpeed100,
+	ethSpeed1000,
+	ethSpeedAutoNeg,
+	ethSpeed2500,
+	ethSpeed5000,
+	ethSpeed10000,
+};
+
+enum LinkMode {
+	AE_LINK_AUTO,
+	AE_LINK_MASTER,
+	AE_LINK_SLAVE,
+	AE_LINK_INVALID = 255,
+};
+
+struct Packet {
+	uint8_t state;
+	uint8_t speed;
+	uint8_t duplex;
+	uint16_t network;
+	uint8_t mode;
+};
+#pragma pack(pop)
+
+std::shared_ptr<Message> EthernetStatusMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	if(bytestream.size() < sizeof(Packet)) {
+		return nullptr;
+	}
+	Packet* packet = (Packet*)bytestream.data();
+	LinkSpeed speed;
+	switch(packet->speed) {
+		case ethSpeed10: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed10; break;
+		case ethSpeed100: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed100; break;
+		case ethSpeed1000: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed1000; break;
+		case ethSpeedAutoNeg: speed = EthernetStatusMessage::LinkSpeed::LinkSpeedAuto; break;
+		case ethSpeed2500: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed2500; break;
+		case ethSpeed5000: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed5000; break;
+		case ethSpeed10000: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed10000; break;
+		default: return nullptr;
+	}
+	LinkMode mode;
+	switch(packet->mode) {
+		case AE_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
+		case AE_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
+		case AE_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
+		case AE_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
+		default: return nullptr;
+	}
+	return std::make_shared<EthernetStatusMessage>(packet->network, packet->state, speed, packet->duplex, mode);
+}

communication/message/flexray/control/flexraycontrolmessage.cpp

@@ -7,8 +7,7 @@
 using namespace icsneo;
 
 std::vector<uint8_t> FlexRayControlMessage::BuildBaseControlArgs(uint8_t controller, FlexRay::Opcode op, const std::vector<uint8_t>& args) {
-	std::vector<uint8_t> ret;
+	std::vector<uint8_t> ret(args.size() + 4);
-	ret.reserve(args.size() + 4);
 	ret.push_back(controller);
 	const uint16_t size = uint16_t((std::min)(args.size() + 1, size_t(std::numeric_limits<uint16_t>::max()))); // Add 1 for the opcode
 	ret.push_back(uint8_t(size));

communication/message/gptpstatusmessage.cpp

@@ -0,0 +1,219 @@
+#include <icsneo/communication/message/gptpstatusmessage.h>
+#include <icsneo/communication/message/extendedresponsemessage.h>
+#include <cstring>
+
+namespace icsneo {
+typedef double float64;
+typedef int64_t time_interval;
+typedef uint64_t _clock_identity;
+
+
+#pragma pack(push, 1)
+
+struct port_identity {
+	_clock_identity clock_identity;
+	uint16_t port_number;
+};
+
+struct _scaled_ns {
+	int16_t nanoseconds_msb;
+	int64_t nanoseconds_lsb;
+	int16_t fractional_nanoseconds;
+};
+
+struct _clock_quality {
+	uint8_t clock_class;
+	uint8_t clock_accuracy;
+	uint16_t offset_scaled_log_variance;
+};
+
+struct system_identity {
+	uint8_t priority_1;
+	struct _clock_quality clock_quality;
+	uint8_t priority_2;
+	_clock_identity clock_identity;
+};
+
+struct _timestamp {
+	uint16_t seconds_msb;
+	uint32_t seconds_lsb;
+	uint32_t nanoseconds;
+};
+
+struct priority_vector {
+	struct system_identity sysid;
+	uint16_t steps_removed;
+	struct port_identity portid;
+	uint16_t port_number;
+};
+
+
+// IEEE 802.1AS-2020 14.3
+// This is a read-only data structure
+struct _current_ds {
+	uint16_t steps_removed;
+	time_interval offset_from_master;
+	struct _scaled_ns last_gm_phase_change;
+	float64 last_gm_freq_change;
+	uint16_t gm_time_base_indicator;
+	uint32_t gm_change_count;
+	uint32_t time_of_last_gm_change_event;
+	uint32_t time_of_last_gm_phase_change_event;
+	uint32_t time_of_last_gm_freq_change_event;
+};
+
+// IEEE 802.1AS-2020 14.4
+// This is a read-only data structure
+struct _parent_ds {
+	struct port_identity parent_port_identity;
+	int32_t cumulative_rate_ratio;
+	_clock_identity grandmaster_identity;
+	uint8_t gm_clock_quality_clock_class;
+	uint8_t gm_clock_quality_clock_accuracy;
+	uint16_t gm_clock_quality_offset_scaled_log_variance;
+	uint8_t gm_priority1;
+	uint8_t gm_priority2;
+};
+
+struct _GPTPStatus
+{
+	struct _timestamp current_time;
+	struct priority_vector gm_priority;
+	int64_t ms_offset_ns;
+	uint8_t is_sync;
+	uint8_t link_status;
+	int64_t link_delay_ns;
+	uint8_t selected_role;
+	uint8_t as_capable;
+	uint8_t is_syntonized;
+	struct _timestamp last_rx_sync_ts; // t2 in IEEE 1588-2019 Figure-16
+	struct _current_ds current_ds;
+	struct _parent_ds parent_ds;
+};
+
+#pragma pack(pop)
+
+static void SetField(GPTPStatus::Timestamp& output, const _timestamp& input) {
+	output.seconds = ((uint64_t)(input.seconds_msb) << 32) | ((uint64_t)input.seconds_lsb);
+	output.nanoseconds = input.nanoseconds;
+}
+
+static void SetField(GPTPStatus::PortID& output, const port_identity& input) {
+	output.clockIdentity = input.clock_identity;
+	output.portNumber = input.port_number;	
+}
+static void SetField(GPTPStatus::ClockQuality& output, const _clock_quality& input) {
+	output.clockClass = input.clock_class;
+	output.clockAccuracy = input.clock_accuracy;
+	output.offsetScaledLogVariance = input.offset_scaled_log_variance;
+}
+
+static void SetField(GPTPStatus::SystemID& output, const system_identity& input) {
+	output.priority1 = input.priority_1;
+	SetField(output.clockQuality, input.clock_quality);
+	output.priority2 = input.priority_2;
+	output.clockID = input.clock_identity;
+}
+
+static void SetField(GPTPStatus::ScaledNanoSeconds& output, const _scaled_ns& input) {
+	output.nanosecondsMSB = input.nanoseconds_msb;
+	output.nanosecondsLSB = input.nanoseconds_lsb;
+	output.fractionalNanoseconds = input.fractional_nanoseconds;
+}
+
+static void SetField(GPTPStatus::PriorityVector& output, const priority_vector& input) {
+	SetField(output.sysID, input.sysid);
+	output.stepsRemoved = input.steps_removed;
+	SetField(output.portID, input.portid);
+	output.portNumber = input.port_number;
+}
+
+static void SetField(GPTPStatus::CurrentDS& output, const _current_ds& input) {
+	output.stepsRemoved = input.steps_removed;
+	output.offsetFromMaster = input.offset_from_master;
+	SetField(output.lastgmPhaseChange, input.last_gm_phase_change);
+	output.lastgmFreqChange = input.last_gm_freq_change;	
+	output.gmTimeBaseIndicator = input.gm_time_base_indicator;
+	output.gmChangeCount = input.gm_change_count;
+	output.timeOfLastgmChangeEvent = input.time_of_last_gm_change_event;
+	output.timeOfLastgmPhaseChangeEvent = input.time_of_last_gm_phase_change_event;
+	output.timeOfLastgmFreqChangeEvent = input.time_of_last_gm_freq_change_event;
+}
+
+static void SetField(GPTPStatus::ParentDS& output, const _parent_ds& input) {
+	SetField(output.parentPortIdentity, input.parent_port_identity);
+	output.cumulativeRateRatio = input.cumulative_rate_ratio;
+	output.grandmasterIdentity = input.grandmaster_identity;
+	output.gmClockQualityClockClass = input.gm_clock_quality_clock_class;
+	output.gmClockQualityClockAccuracy = input.gm_clock_quality_clock_accuracy;
+	output.gmClockQualityOffsetScaledLogVariance = input.gm_clock_quality_offset_scaled_log_variance;
+	output.gmPriority1 = input.gm_priority1;
+	output.gmPriority2 = input.gm_priority2;
+}
+
+[[maybe_unused]] static void SetField(uint8_t& output, const uint8_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint16_t& output, const uint16_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint32_t& output, const uint32_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint64_t& output, const uint64_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int8_t& output, const int8_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int16_t& output, const int16_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int32_t& output, const int32_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int64_t& output, const int64_t& input) {
+	output = input;
+}
+
+std::shared_ptr<GPTPStatus> GPTPStatus::DecodeToMessage(std::vector<uint8_t>& bytes, const device_eventhandler_t&) {
+
+	// The following does not lead to overflow since we only call this function if it has at least ResponseHeader length bytes
+	std::shared_ptr<GPTPStatus> res = std::make_shared<GPTPStatus>();
+	auto* header = reinterpret_cast<ExtendedResponseMessage::ResponseHeader*>(bytes.data());
+	uint16_t length = header->length;
+	_GPTPStatus* input = reinterpret_cast<_GPTPStatus*>(bytes.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
+
+#define CheckLengthAndSet(output, input) if(length >= sizeof(decltype(input))) { \
+		SetField(output, input); \
+		length -= sizeof(decltype(input)); \
+	} else {\
+		memset(&output, 0, sizeof(decltype(output))); \
+		length = 0; \
+		res->shortFormat = true; \
+	}
+
+	CheckLengthAndSet(res->currentTime, input->current_time);
+	CheckLengthAndSet(res->gmPriority, input->gm_priority);
+	CheckLengthAndSet(res->msOffsetNs, input->ms_offset_ns);
+	CheckLengthAndSet(res->isSync, input->is_sync);
+	CheckLengthAndSet(res->linkStatus, input->link_status);
+	CheckLengthAndSet(res->linkDelayNS, input->link_delay_ns);
+	CheckLengthAndSet(res->selectedRole, input->selected_role);
+	CheckLengthAndSet(res->asCapable, input->as_capable);
+	CheckLengthAndSet(res->isSyntonized, input->is_syntonized);
+	CheckLengthAndSet(res->lastRXSyncTS, input->last_rx_sync_ts);
+	CheckLengthAndSet(res->currentDS, input->current_ds);
+	CheckLengthAndSet(res->parentDS, input->parent_ds);
+
+	return res;
+}
+
+}

communication/message/logdatamessage.cpp

@@ -0,0 +1,12 @@
+#include "icsneo/communication/message/logdatamessage.h"
+#include <iostream>
+
+using namespace icsneo;
+
+std::shared_ptr<LogDataMessage> LogDataMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+    if(bytestream.size() % 2 != 0)
+        return nullptr;
+    const auto* begin = (char16_t*)bytestream.data();
+    const auto* end = begin + (bytestream.size() / sizeof(char16_t));
+    return std::make_shared<LogDataMessage>(std::wstring(begin,end));
+}

communication/message/macsecmessage.cpp

@@ -0,0 +1,531 @@
+#include "icsneo/communication/message/macsecmessage.h"
+
+#include "icsneo/communication/crc32.h"
+#include <memory>
+#include <cstdint>
+#include <iostream>
+#include <cstring>
+
+namespace icsneo
+{
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4201) // nameless struct/union
+#endif
+
+#pragma pack(push, 1)
+/* MACsec Rule */
+/**
+ * @brief Structure of Vlan tag
+ *
+ */
+typedef struct
+{
+	uint16_t vid; /*!< 12 bits */
+	uint8_t priCfi; /*!< PRI - 3 bits, CFI - 1bit */
+} MACSEC_VLANTAG_t;
+/**
+ * @brief Structure of MPLS
+ *
+ */
+typedef struct
+{
+	uint32_t mplsLabel; /*!< 20 bits */
+	uint8_t exp; /*!< 3 bits */
+} MACSEC_MPLS_OUTER_t;
+/**
+ * @brief Define Encoded Packet Type from the parser
+ *
+ */
+static constexpr int MACSEC_SETTINGS_RULE_SIZE = 88;
+typedef union _MACSecRule
+{
+	struct
+	{
+		uint8_t index;
+		uint8_t keyMacDa[6]; /*!< MAC DA field extracted from the packet */
+		uint8_t maskMacDa[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t keyMacSa[6]; /*!< MAC SA field extracted from the packet */
+		uint8_t maskMacSa[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint16_t keyEthertype; /*!< First E-Type found in the packet that doesn't match one of the preconfigured custom tag. */
+		uint16_t maskEthertype; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACSEC_VLANTAG_t keyVlanTagOuter1; /*!< outermost/1st VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
+		MACSEC_MPLS_OUTER_t keyMplsOuter1;
+		MACSEC_VLANTAG_t maskVlanTagOuter1; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACSEC_MPLS_OUTER_t maskMplsOuter1;
+		MACSEC_VLANTAG_t keyVlanTagOuter2; /*!< 2nd outermost VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
+		MACSEC_MPLS_OUTER_t keyMplsOuter2;
+		MACSEC_VLANTAG_t maskVlanTagOuter2; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		MACSEC_MPLS_OUTER_t maskMplsOuter2;
+		uint16_t keyBonusData; /*!< 2 bytes of additional bonus data extracted from one of the custom tags. */
+		uint16_t maskBonusData; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t
+			keyTagMatchBitmap; /*!< 8 bits total. Maps 1 to 1 bitwise with the set of custom tags. (set bit[N]=1 if check Nth custom tag) */
+		uint8_t maskTagMatchBitmap; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t keyPacketType; /*!< Encoded Packet Type, see MACSEC_PACKET_TYPE */
+		uint8_t maskPacketType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint16_t
+			keyInnerVlanType; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the second outermost VLAN Tag. */
+		uint16_t maskInnerVlanType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint16_t keyOuterVlanType; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the outermost VLAN Tag. */
+		uint16_t maskOuterVlanType; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t
+			keyNumTags; /*!< 7 bits total. Number of VLAN/custom tags or MPLS lables detected. Ingress: before SecTag; Egress: total detected. Exclude MCS header tags. i.e. Bit 2: 2 tags/labels before SecTAG...Bit 6: 6 or more tags/labels before SecTAG. */
+		uint8_t maskNumTags; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t keyExpress; /*!< 1 bits. Express packet. */
+		uint8_t maskExpress; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
+		uint8_t isMpls;
+		uint8_t rsvd[5];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_RULE_SIZE];
+} MACSecRule_t;
+/* MACsec Map */
+static constexpr int MACSEC_SETTINGS_MAP_SIZE = 20;
+typedef union _MACSecMap
+{
+	struct
+	{
+		uint8_t index;
+		uint64_t secTagSci; /*!< Identifies the SecTAG SCI for this Flow. */
+		uint8_t secYIndex; /*!< index for entry in Egress secY Policy */
+		uint8_t isControlPacket; /*!< Identifies all packets matching this index lookup as control packets. */
+		uint8_t scIndex; /*!< Identifies the SC for this Flow. */
+		uint8_t auxiliaryPlcy; /*!< Auxiliary policy bits. */
+		uint8_t ruleId; /*!< Identifies the Rule for this Flow. */
+		uint8_t rsvd[5];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_MAP_SIZE];
+} MACSecMap_t;
+/* MACsec SecY */
+/**
+ * @brief Define the permit police for frames as defined in 802.1ae
+ *
+ */
+static constexpr int MACSEC_SETTINGS_SECY_SIZE = 24;
+typedef union _MACSecSecY
+{
+	struct
+	{
+		uint8_t index; /*!< Identifies the SecY for this Flow. */
+		uint8_t controlledPortEnabled; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
+		uint8_t frameValidationType; /*!< see MACSEC_VALIDATEFRAME */
+		uint8_t secTagIcvStripType; /*!< see MACSEC_STRIP_SECTAG_ICV */
+		uint8_t cipher; /*!< Define the cipher suite to use for this SecY see MACSEC_CIPHER_SUITE */
+		uint8_t confidentialOffset; /*!< Define the number of bytes that are unencrypted following the SecTag. */
+		uint8_t icvIncludesDaSa; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
+		uint8_t replayProtect; /*!< Enables Anti-Replay protection */
+		uint32_t replayWindow; /*!< Unsigned value indicating the size of the anti-replay window. */
+		uint8_t
+			protectFrames; /*!< 0 = do not encrypt or authenticate this packet; 1 = always Authenticate frame and if SecTag.TCI.E = 1 encrypt the packet as well. */
+		uint8_t
+			secTagOffset; /*!< Define the offset in bytes from either the start of the packet or a matching Etype depending on SecTag_Insertion_Mode. */
+		uint8_t secTagTci; /*!< Tag Control Information excluding the AN field which originates from the SA Policy table */
+		uint16_t mtu; /*!< Specifies the outgoing MTU for this SecY */
+		uint8_t rsvd[6];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SECY_SIZE];
+} MACSecSecY_t;
+/* MACsec SC */
+static constexpr int MACSEC_SETTINGS_SC_SIZE = 24;
+typedef union _MACSecSc
+{
+	struct
+	{
+		uint8_t index; /*!< SC index. */
+		uint8_t secYIndex; /*!< SecY associated with this packet. */
+		uint64_t sci; /*!< The Secure Channel Identifier. */
+		uint8_t saIndex0; /*!< Define the 1st SA to use */
+		uint8_t saIndex1; /*!< Define the 2nd SA to use */
+		uint8_t saIndex0InUse; /*!< Specifies whether 1st SA is in use or not. */
+		uint8_t saIndex1InUse; /*!< Specifies whether 2nd SA is in use or not.  */
+		uint8_t enableAutoRekey; /*!< If enabled, then once the pn_threshold is reached, auto rekey will happen. */
+		uint8_t
+			isActiveSa1; /*!< If set, then sa_index1 is the currently active SA index. If cleared, the sa_index0 is the currently active SA index). */
+		uint8_t rsvd[7];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SC_SIZE];
+} MACSecSc_t;
+/* MACsec SA */
+static constexpr int MACSEC_SETTINGS_SA_SIZE = 80;
+typedef union _MACSecSa
+{
+	struct
+	{
+		uint8_t index; /*!< SA index */
+		uint8_t
+			sak[32]; /*!< 256b SAK: Define the encryption key to be used to encrypte this packet. The lower 128 bits are used for 128-bit ciphers. */
+		uint8_t hashKey[16]; /*!< 128b Hash Key: Key used for authentication. */
+		uint8_t salt[12]; /*!< 96b Salt value: Salt value used in XPN ciphers. */
+		uint32_t ssci; /*!< 32b SSCI value: Short Secure Channel Identifier, used in XPN ciphers. */
+		uint8_t an; /*!< 2b SecTag Association Number (AN) */
+		uint64_t nextPn; /*!< 64b next_pn value: Next packet number to insert into outgoing packet on a particular SA. */
+		uint8_t rsvd[5];
+		uint8_t enable;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SA_SIZE];
+} MACSecSa_t;
+/* MACsec Flags */
+typedef union _MACSecFlags
+{
+	struct
+	{
+		uint32_t en : 1; // '1' = enable; '0' = disable
+		uint32_t reserved : 31;
+	};
+	uint32_t flags_32b;
+} MACSecFlags_t;
+#define MACSEC_SETTINGS_FLAGS_SIZE (4)
+/* MACSec Settings for 1 port/phy */
+typedef struct MACSEC_CONFIG_t
+{
+	MACSecFlags_t flags;
+	MACSecRule_t rule[MACsecConfig::NumRules];
+	MACSecMap_t map[MACsecConfig::NumMaps];
+	MACSecSecY_t secy[MACsecConfig::NumSecY];
+	MACSecSc_t sc[MACsecConfig::NumSc];
+	MACSecSa_t sa[MACsecConfig::NumSa];
+} MACSEC_CONFIG;
+typedef union _MACSecGlobalFlags
+{
+	struct
+	{
+		uint32_t en : 1; // '1' = enable; '0' = disable
+		uint32_t nvm : 1; // store macsec config in non-volatile memory
+		uint32_t reserved : 30;
+	};
+	uint32_t flags_32b;
+} MACSecGlobalFlags_t;
+#define MACSEC_SETTINGS_SIZE (2040) // leave space for expansion and keep nicely aligned for flashing
+typedef union _MACSEC_SETTINGS
+{
+	struct
+	{
+		MACSecGlobalFlags_t flags;
+		MACSEC_CONFIG rx;
+		MACSEC_CONFIG tx;
+	};
+	uint8_t byte[MACSEC_SETTINGS_SIZE];
+} MACSEC_SETTINGS;
+
+#define MACSEC_SETTINGS_VERSION 1
+struct MACSEC_SETTINGS_W_HDR
+{
+	uint16_t version;
+	uint16_t len;
+	uint32_t crc32;
+	MACSEC_SETTINGS macsec;
+};
+
+#pragma pack(pop)
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+std::shared_ptr<MACsecMessage> MACsecMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream, const device_eventhandler_t& report)
+{
+	if (bytestream.empty() || (bytestream.size() < sizeof(MACSEC_SETTINGS_W_HDR)))
+	{
+		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+		return nullptr;
+	}
+
+	MACSEC_SETTINGS_W_HDR* macsecArgs = (MACSEC_SETTINGS_W_HDR*)bytestream.data();
+	if (macsecArgs->version != MACSEC_SETTINGS_VERSION)
+	{
+		report(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
+		return nullptr;
+	}
+	if (macsecArgs->len != sizeof(MACSEC_SETTINGS))
+	{
+		report(APIEvent::Type::SettingsLengthError, APIEvent::Severity::Error);
+		return nullptr;
+	}
+	const auto crcCalculted = crc32(0, (uint8_t*)&macsecArgs->macsec, macsecArgs->len);
+	if (macsecArgs->crc32 != crcCalculted)
+	{
+		report(APIEvent::Type::SettingsChecksumError, APIEvent::Severity::Error);
+		return nullptr;
+	}
+
+	auto msg = std::make_shared<MACsecMessage>();
+
+	const auto& copyConfig = [](const MACSEC_CONFIG& source, MACsecConfig& dest)
+	{
+		dest.flags.en = source.flags.en;
+		for (int index = 0; index < MACsecConfig::NumRules; index++)
+		{
+			if(!source.rule[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.rule[index].___name__ = (decltype(dest.rule[index].___name__))source.rule[index].___name__
+#undef __COPY_ARR
+#define __COPY_ARR(___name__) (void)memcpy(dest.rule[index].___name__.data(), source.rule[index].___name__, dest.rule[index].___name__.size())
+			__COPY_ITEM(index);
+			__COPY_ARR(keyMacDa);
+			__COPY_ARR(maskMacDa);
+			__COPY_ARR(keyMacSa);
+			__COPY_ARR(maskMacSa);
+			__COPY_ITEM(keyVlanTagOuter1.vid);
+			__COPY_ITEM(keyVlanTagOuter1.priCfi);
+			__COPY_ITEM(keyMplsOuter1.mplsLabel);
+			__COPY_ITEM(keyMplsOuter1.exp);
+			__COPY_ITEM(maskVlanTagOuter1.vid);
+			__COPY_ITEM(maskVlanTagOuter1.priCfi);
+			__COPY_ITEM(maskMplsOuter1.mplsLabel);
+			__COPY_ITEM(maskMplsOuter1.exp);
+			__COPY_ITEM(keyVlanTagOuter2.vid);
+			__COPY_ITEM(keyVlanTagOuter2.priCfi);
+			__COPY_ITEM(keyMplsOuter2.mplsLabel);
+			__COPY_ITEM(keyMplsOuter2.exp);
+			__COPY_ITEM(maskVlanTagOuter2.vid);
+			__COPY_ITEM(maskVlanTagOuter2.priCfi);
+			__COPY_ITEM(maskMplsOuter2.mplsLabel);
+			__COPY_ITEM(maskMplsOuter2.exp);
+			__COPY_ITEM(keyEthertype);
+			__COPY_ITEM(maskEthertype);
+			__COPY_ITEM(keyBonusData);
+			__COPY_ITEM(maskBonusData);
+			__COPY_ITEM(keyTagMatchBitmap);
+			__COPY_ITEM(maskTagMatchBitmap);
+			__COPY_ITEM(keyPacketType);
+			__COPY_ITEM(maskPacketType);
+			__COPY_ITEM(keyInnerVlanType);
+			__COPY_ITEM(maskInnerVlanType);
+			__COPY_ITEM(keyOuterVlanType);
+			__COPY_ITEM(maskOuterVlanType);
+			__COPY_ITEM(keyNumTags);
+			__COPY_ITEM(maskNumTags);
+			__COPY_ITEM(keyExpress);
+			__COPY_ITEM(maskExpress);
+			__COPY_ITEM(isMpls);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumMaps; index++)
+		{
+			if(!source.map[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.map[index].___name__ = source.map[index].___name__
+			__COPY_ITEM(index);
+			__COPY_ITEM(secTagSci);
+			__COPY_ITEM(secYIndex);
+			__COPY_ITEM(isControlPacket);
+			__COPY_ITEM(scIndex);
+			__COPY_ITEM(auxiliaryPlcy);
+			__COPY_ITEM(ruleId);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumSecY; index++)
+		{
+			if(!source.secy[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.secy[index].___name__ = (decltype(dest.secy[index].___name__))source.secy[index].___name__
+			__COPY_ITEM(index);
+			__COPY_ITEM(controlledPortEnabled);
+			__COPY_ITEM(frameValidationType);
+			__COPY_ITEM(secTagIcvStripType);
+			__COPY_ITEM(cipher);
+			__COPY_ITEM(confidentialOffset);
+			__COPY_ITEM(icvIncludesDaSa);
+			__COPY_ITEM(replayProtect);
+			__COPY_ITEM(replayWindow);
+			__COPY_ITEM(protectFrames);
+			__COPY_ITEM(secTagOffset);
+			__COPY_ITEM(secTagTci);
+			__COPY_ITEM(mtu);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumSc; index++)
+		{
+			if(!source.sc[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.sc[index].___name__ = source.sc[index].___name__
+			__COPY_ITEM(index);
+			__COPY_ITEM(secYIndex);
+			__COPY_ITEM(sci);
+			__COPY_ITEM(saIndex0);
+			__COPY_ITEM(saIndex1);
+			__COPY_ITEM(saIndex0InUse);
+			__COPY_ITEM(saIndex1InUse);
+			__COPY_ITEM(enableAutoRekey);
+			__COPY_ITEM(isActiveSa1);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumSa; index++)
+		{
+			if(!source.sa[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.sa[index].___name__ = source.sa[index].___name__
+#undef __COPY_ARR
+#define __COPY_ARR(___name__) (void)memcpy(dest.sa[index].___name__.data(), source.sa[index].___name__, dest.sa[index].___name__.size())
+			__COPY_ITEM(index);
+			__COPY_ARR(sak);
+			__COPY_ARR(hashKey);
+			__COPY_ARR(salt);
+			__COPY_ITEM(ssci);
+			__COPY_ITEM(an);
+			__COPY_ITEM(nextPn);
+			__COPY_ITEM(enable);
+		}
+	};
+
+	msg->flags.en = macsecArgs->macsec.flags.en;
+	copyConfig(macsecArgs->macsec.rx, msg->rx);
+	copyConfig(macsecArgs->macsec.tx, msg->tx);
+
+	return msg;
+}
+
+bool MACsecMessage::EncodeFromMessage(std::vector<uint8_t>& bytestream, const device_eventhandler_t& report) const
+{
+	MACSEC_SETTINGS_W_HDR* macsecArgs;
+
+	bytestream.resize(sizeof(MACSEC_SETTINGS_W_HDR), 0);
+	macsecArgs = (MACSEC_SETTINGS_W_HDR*)bytestream.data();
+
+	macsecArgs->version = MACSEC_SETTINGS_VERSION;
+	macsecArgs->len = sizeof(MACSEC_SETTINGS_W_HDR);
+
+	const auto& copyConfig = [](const MACsecConfig& source, MACSEC_CONFIG& dest)
+	{
+		dest.flags.en = (uint8_t)source.flags.en;
+		for (int index = 0; index < MACsecConfig::NumRules; index++)
+		{
+			if(!source.rule[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.rule[index].___name__ = (decltype(dest.rule[index].___name__))source.rule[index].___name__
+#undef __COPY_ARR
+#define __COPY_ARR(___name__) (void)memcpy(dest.rule[index].___name__, source.rule[index].___name__.data(), source.rule[index].___name__.size())
+			__COPY_ITEM(index);
+			__COPY_ARR(keyMacDa);
+			__COPY_ARR(maskMacDa);
+			__COPY_ARR(keyMacSa);
+			__COPY_ARR(maskMacSa);
+			__COPY_ITEM(keyVlanTagOuter1.vid);
+			__COPY_ITEM(keyVlanTagOuter1.priCfi);
+			__COPY_ITEM(keyMplsOuter1.mplsLabel);
+			__COPY_ITEM(keyMplsOuter1.exp);
+			__COPY_ITEM(maskVlanTagOuter1.vid);
+			__COPY_ITEM(maskVlanTagOuter1.priCfi);
+			__COPY_ITEM(maskMplsOuter1.mplsLabel);
+			__COPY_ITEM(maskMplsOuter1.exp);
+			__COPY_ITEM(keyVlanTagOuter2.vid);
+			__COPY_ITEM(keyVlanTagOuter2.priCfi);
+			__COPY_ITEM(keyMplsOuter2.mplsLabel);
+			__COPY_ITEM(keyMplsOuter2.exp);
+			__COPY_ITEM(maskVlanTagOuter2.vid);
+			__COPY_ITEM(maskVlanTagOuter2.priCfi);
+			__COPY_ITEM(maskMplsOuter2.mplsLabel);
+			__COPY_ITEM(maskMplsOuter2.exp);
+			__COPY_ITEM(keyEthertype);
+			__COPY_ITEM(maskEthertype);
+			__COPY_ITEM(keyBonusData);
+			__COPY_ITEM(maskBonusData);
+			__COPY_ITEM(keyTagMatchBitmap);
+			__COPY_ITEM(maskTagMatchBitmap);
+			__COPY_ITEM(keyPacketType);
+			__COPY_ITEM(maskPacketType);
+			__COPY_ITEM(keyInnerVlanType);
+			__COPY_ITEM(maskInnerVlanType);
+			__COPY_ITEM(keyOuterVlanType);
+			__COPY_ITEM(maskOuterVlanType);
+			__COPY_ITEM(keyNumTags);
+			__COPY_ITEM(maskNumTags);
+			__COPY_ITEM(keyExpress);
+			__COPY_ITEM(maskExpress);
+			__COPY_ITEM(isMpls);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumMaps; index++)
+		{
+			if(!source.map[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.map[index].___name__ = source.map[index].___name__
+			__COPY_ITEM(index);
+			__COPY_ITEM(secTagSci);
+			__COPY_ITEM(secYIndex);
+			__COPY_ITEM(isControlPacket);
+			__COPY_ITEM(scIndex);
+			__COPY_ITEM(auxiliaryPlcy);
+			__COPY_ITEM(ruleId);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumSecY; index++)
+		{
+			if(!source.secy[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.secy[index].___name__ = (decltype(dest.secy[index].___name__))source.secy[index].___name__
+			__COPY_ITEM(index);
+			__COPY_ITEM(controlledPortEnabled);
+			__COPY_ITEM(frameValidationType);
+			__COPY_ITEM(secTagIcvStripType);
+			__COPY_ITEM(cipher);
+			__COPY_ITEM(confidentialOffset);
+			__COPY_ITEM(icvIncludesDaSa);
+			__COPY_ITEM(replayProtect);
+			__COPY_ITEM(replayWindow);
+			__COPY_ITEM(protectFrames);
+			__COPY_ITEM(secTagOffset);
+			__COPY_ITEM(secTagTci);
+			__COPY_ITEM(mtu);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumSc; index++)
+		{
+			if(!source.sc[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.sc[index].___name__ = source.sc[index].___name__
+			__COPY_ITEM(index);
+			__COPY_ITEM(secYIndex);
+			__COPY_ITEM(sci);
+			__COPY_ITEM(saIndex0);
+			__COPY_ITEM(saIndex1);
+			__COPY_ITEM(saIndex0InUse);
+			__COPY_ITEM(saIndex1InUse);
+			__COPY_ITEM(enableAutoRekey);
+			__COPY_ITEM(isActiveSa1);
+			__COPY_ITEM(enable);
+		}
+
+		for (int index = 0; index < MACsecConfig::NumSa; index++)
+		{
+			if(!source.sa[index].enable) continue;
+#undef __COPY_ITEM
+#define __COPY_ITEM(___name__) dest.sa[index].___name__ = source.sa[index].___name__
+#undef __COPY_ARR
+#define __COPY_ARR(___name__) (void)memcpy(dest.sa[index].___name__, source.sa[index].___name__.data(), source.sa[index].___name__.size())
+			__COPY_ITEM(index);
+			__COPY_ARR(sak);
+			__COPY_ARR(hashKey);
+			__COPY_ARR(salt);
+			__COPY_ITEM(ssci);
+			__COPY_ITEM(an);
+			__COPY_ITEM(nextPn);
+			__COPY_ITEM(enable);
+		}
+	};
+	macsecArgs->macsec.flags.en = this->flags.en;
+	macsecArgs->macsec.flags.nvm = this->flags.nvm;
+
+	copyConfig(this->rx, macsecArgs->macsec.rx);
+	copyConfig(this->tx, macsecArgs->macsec.tx);
+
+	macsecArgs->crc32 = crc32(0, (uint8_t*)&macsecArgs->macsec, sizeof(MACSEC_SETTINGS));
+
+	(void)report;
+
+	return true;
+}
+
+} // namespace icsneo

communication/message/neomessage.cpp

@@ -1,7 +1,7 @@
 #include "icsneo/communication/message/neomessage.h"
 #include "icsneo/communication/message/canmessage.h"
 #include "icsneo/communication/message/ethernetmessage.h"
-#include "icsneo/communication/message/canerrorcountmessage.h"
+#include "icsneo/communication/message/canerrormessage.h"
 #include "icsneo/communication/message/linmessage.h"
 
 using namespace icsneo;
@@ -75,13 +75,15 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 					lin.length = 1;
 				
 				lin.linStatus = {
-					linmsg->statusFlags.TxChecksumEnhanced,
+					linmsg->statusFlags.TxChecksumEnhanced, // .txChecksumEnhanced
-					linmsg->statusFlags.TxCommander,
+					linmsg->statusFlags.TxCommander, // .txCommander
-					linmsg->statusFlags.TxResponder,
+					linmsg->statusFlags.TxResponder, // .txResponder
-					linmsg->statusFlags.UpdateResponderOnce,
+					0, // .txAborted
-					linmsg->statusFlags.HasUpdatedResponderOnce,
+					linmsg->statusFlags.UpdateResponderOnce, // .updateResponderOnce
-					linmsg->statusFlags.BusRecovered,
+					linmsg->statusFlags.HasUpdatedResponderOnce, // .hasUpdatedResponderOnce
-					linmsg->statusFlags.BreakOnly
+					linmsg->statusFlags.BusRecovered, // .busRecovered
+					linmsg->statusFlags.BreakOnly // .breakOnly
+					
 				};
 
 				lin.status.linJustBreakSync = linmsg->errFlags.ErrRxBreakSyncOnly;
@@ -104,7 +106,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 	}
 	case Message::Type::CANErrorCount: {
 		neomessage_can_error_t& canerror = *(neomessage_can_error_t*)&neomsg;
-		auto canerrormsg = std::static_pointer_cast<CANErrorCountMessage>(message);
+		auto canerrormsg = std::static_pointer_cast<CANErrorMessage>(message);
 		canerror.transmitErrorCount = canerrormsg->transmitErrorCount;
 		canerror.receiveErrorCount = canerrormsg->receiveErrorCount;
 		canerror.status.canBusOff = canerrormsg->busOff;

communication/packet/canpacket.cpp

@@ -1,5 +1,5 @@
 #include "icsneo/communication/packet/canpacket.h"
-#include "icsneo/communication/message/canerrorcountmessage.h"
+#include "icsneo/communication/message/canerrormessage.h"
 
 using namespace icsneo;
 
@@ -53,16 +53,18 @@ static std::optional<uint8_t> CAN_LengthToDLC(size_t dataLength, bool fd)
 
 	return std::nullopt;
 }
-
 std::shared_ptr<Message> HardwareCANPacket::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
 	const HardwareCANPacket* data = (const HardwareCANPacket*)bytestream.data();
-
+	const HardwareCANErrorPacket* errPacket = (const HardwareCANErrorPacket*)bytestream.data();
-	if(data->dlc.RB1) { // Change counts reporting
+	if(errPacket->ERROR_INDICATOR) {
-
+		auto msg = std::make_shared<CANErrorMessage>();
-		const bool busOff = data->data[0] & 0b00100000;
+		msg->receiveErrorCount = errPacket->REC;
-
+		msg->transmitErrorCount = errPacket->TEC;
-		auto msg = std::make_shared<CANErrorCountMessage>(data->data[2], data->data[1], busOff);
+		msg->errorWarn = HardwareCANErrorPacket::GetErrorWarn(errPacket->flags);
-
+		msg->errorPassive = HardwareCANErrorPacket::GetErrorPassive(errPacket->flags);
+		msg->busOff = HardwareCANErrorPacket::GetBusOff(errPacket->flags);
+		msg->errorCode = (CANErrorCode)errPacket->error_code;
+		msg->dataErrorCode = (CANErrorCode)errPacket->brs_data_error_code;
 		// This timestamp is raw off the device (in timestampResolution increments)
 		// Decoder will fix as it has information about the timestampResolution increments
 		msg->timestamp = data->timestamp.TS;

communication/packet/componentversionpacket.cpp

@@ -31,7 +31,7 @@ std::shared_ptr<ComponentVersionsMessage> ComponentVersionPacket::DecodeToMessag
 	// Get a reference to the payload to fully validate the length
 	const auto& response = *reinterpret_cast<const ComponentVersionsResponse*>(bytes.data());
 	// Expected size is the header, numVersions field, and numVersions ComponentVersion objects.
-	auto expectedSize = sizeof(ExtendedResponseMessage::ResponseHeader) + 2 + (response.numVersions * sizeof(ComponentVersion));
+	auto expectedSize = sizeof(ExtendedResponseMessage::ResponseHeader) + 2 + (response.numVersions * sizeof(PackedComponentVersion));
 	// If the response is malformed (too small), return an empty message.
 	if(bytes.size() < expectedSize) {
 		return msg; // Empty
@@ -39,7 +39,14 @@ std::shared_ptr<ComponentVersionsMessage> ComponentVersionPacket::DecodeToMessag
 	// Unpack into the portable class
 	for(unsigned int i = 0; i < response.numVersions; ++i) {
 		const auto& packedVersion = response.versions[i];
-		msg->versions.emplace_back(packedVersion.valid, packedVersion.componentInfo, packedVersion.identifier, packedVersion.dotVersion, packedVersion.commitHash);
+		msg->versions.emplace_back(
+			packedVersion.valid,
+			packedVersion.componentInfo,
+			packedVersion.identifier,
+			packedVersion.dotVersion,
+			packedVersion.commitHash,
+			packedVersion.expansionSlot
+		);
 	}
 	return msg;
 }

communication/packet/linpacket.cpp

@@ -31,7 +31,7 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 	auto isChecksumInvalid = [&]() -> bool {
 		/* messages with no data have no checksum (e.g. header only) */
 		if(!msg->data.size())
-			return true;
+			return false;
 
 		uint8_t checkSum = (8 > numDataBytes) ? *(dataStart + numDataBytes) : packet->CoreMiniBitsLIN.LINByte9;
 		LINMessage::calcChecksum(*msg);

device/device.cpp

@@ -88,6 +88,10 @@ Device::~Device() {
 		disableMessagePolling();
 	if(isOpen())
 		close();
+	if(heartbeatThread.joinable()) {
+		stopHeartbeatThread = true;		
+		heartbeatThread.join();
+	}
 }
 
 uint16_t Device::getTimestampResolution() const {
@@ -130,6 +134,18 @@ std::pair<std::vector<std::shared_ptr<Message>>, bool> Device::getMessages() {
 	return std::make_pair(ret, retBool);
 }
 
+std::shared_ptr<DeviceExtension> Device::getExtension(const std::string& name) const {
+	std::shared_ptr<DeviceExtension> ret;
+	std::lock_guard<std::mutex> lk(extensionsLock);
+	for(auto& ext : extensions) {
+		if((ext->getName() == name)) {
+			ret = ext;
+			break;
+		}
+	}
+	return ret;
+}
+
 bool Device::getMessages(std::vector<std::shared_ptr<Message>>& container, size_t limit, std::chrono::milliseconds timeout) {
 	if(!isOpen()) {
 		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
@@ -176,6 +192,14 @@ void Device::enforcePollingMessageLimit() {
 	}
 }
 
+bool Device::refreshComponentVersions() {
+	if(auto compVersions = com->getComponentVersionsSync()) {
+		componentVersions = std::move(*compVersions);
+		return true;
+	}
+	return false;
+}
+
 bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	if(!com) {
 		report(APIEvent::Type::Unknown, APIEvent::Severity::Error);
@@ -195,6 +219,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 				tryAgain = true;
 			return true;
 		});
+
 		if(!tryAgain) {
 			com->close();
 			report(attemptErr, APIEvent::Severity::Error);
@@ -218,16 +243,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	if(block) // Extensions say no
 		return false;
 
-	// Get component versions *after* the extension "onDeviceOpen" hooks (e.g. device reflashes)
+	refreshComponentVersions();
-	
-	if(supportsComponentVersions()) {
-		if(auto compVersions = com->getComponentVersionsSync())
-			componentVersions = std::move(*compVersions);
-		else
-			// It's possible the device is on older firmware so don't return false here
-			report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::EventWarning);
-	}
-
 	if(!settings->disabled) {
 		// Since we will not fail the open if a settings read fails,
 		// downgrade any errors to warnings. Otherwise the error will
@@ -246,6 +262,12 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 		handleInternalMessage(message);
 	}));
 
+	// Clear the previous heartbeat thread, in case open() was called on this instance more than once
+	if(heartbeatThread.joinable())
+		heartbeatThread.join();
+
+	stopHeartbeatThread = false;
+
 	heartbeatThread = std::thread([this]() {
 		EventManager::GetInstance().downgradeErrorsOnCurrentThread();
 
@@ -271,12 +293,12 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 		}
 
 		while(!stopHeartbeatThread) {
-			// Wait for 110ms for a possible heartbeat
-			std::this_thread::sleep_for(std::chrono::milliseconds(110));
 			std::unique_lock<std::mutex> recvLk(receivedMessageMutex);
-			if(receivedMessage) {
+			// Wait for 110ms for a possible heartbeat
+			if(heartbeatCV.wait_for(recvLk, std::chrono::milliseconds(110), [&]() { return receivedMessage; })) {
 				receivedMessage = false;
-			} else {
+			} else if(!stopHeartbeatThread) { // Add this condition here in case the thread was stopped while waiting for the last message
+
 				// Some communication, such as the bootloader and extractor interfaces, must
 				// redirect the input stream from the device as it will no longer be in the
 				// packet format we expect here. As a result, status updates will not reach
@@ -285,9 +307,8 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 				// otherwise quiet stream. This lock makes sure suppressDisconnects() will
 				// block until we've either gotten our status update or disconnected from
 				// the device.
-				std::lock_guard<std::mutex> lk(heartbeatMutex);
+				std::unique_lock<std::mutex> lk(heartbeatMutex);
-				if(heartbeatSuppressed())
+				if(heartbeatSuppressed()) continue;
-					continue;
 
 				// No heartbeat received, request a status
 				com->sendCommand(Command::RequestStatusUpdate);
@@ -297,8 +318,8 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 					receivedMessage = false;
 				} else {
 					if(!stopHeartbeatThread && !isDisconnected()) {
+						close();
 						report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
-						com->driver->close();
 					}
 					break;
 				}
@@ -324,7 +345,7 @@ APIEvent::Type Device::attemptToBeginCommunication() {
 		return getCommunicationNotEstablishedError();
 	}
 
-	if(!com->sendCommand(Command::EnableNetworkCommunication, false))
+	if(!enableNetworkCommunication(false))
 		return getCommunicationNotEstablishedError();
 	std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
@@ -335,6 +356,7 @@ APIEvent::Type Device::attemptToBeginCommunication() {
 		if(i++ > 5)
 			break;
 	}
+
 	if(!serial) // "Communication could not be established with the device. Perhaps it is not powered with 12 volts?"
 		return getCommunicationNotEstablishedError();
 
@@ -348,6 +370,14 @@ APIEvent::Type Device::attemptToBeginCommunication() {
 	else
 		versions = std::move(*maybeVersions);
 
+	// Get component versions before the extension "onDeviceOpen" hooks so that we can properly check verisons
+	if(supportsComponentVersions()) {
+		if(auto compVersions = com->getComponentVersionsSync())
+			componentVersions = std::move(*compVersions);
+		else
+			report(APIEvent::Type::NotSupported, APIEvent::Severity::EventWarning); // outdated firmware
+	}
+
 	return APIEvent::Type::NoErrorFound;
 }
 
@@ -371,16 +401,20 @@ bool Device::close() {
 
 	internalHandlerCallbackID = 0;
 
-	if(heartbeatThread.joinable())
-		heartbeatThread.join();
-	stopHeartbeatThread = false;
-
 	forEachExtension([](const std::shared_ptr<DeviceExtension>& ext) { ext->onDeviceClose(); return true; });
 	return com->close();
 }
 
+bool Device::enableLogData() {
+	return com->sendCommand(Command::EnableLogData, true);
+}
+
+bool Device::disableLogData() {
+	return com->sendCommand(Command::EnableLogData, false);
+}
+
 bool Device::goOnline() {
-	if(!com->sendCommand(Command::EnableNetworkCommunication, true))
+	if(!enableNetworkCommunication(true))
 		return false;
 
 	auto startTime = std::chrono::system_clock::now();
@@ -423,29 +457,13 @@ bool Device::goOffline() {
 		return true;
 	}
 
-	if(!com->sendCommand(Command::EnableNetworkCommunication, false))
+	if(!enableNetworkCommunication(false))
 		return false;
 
-	auto startTime = std::chrono::system_clock::now();
-
 	ledState = (latestResetStatus && latestResetStatus->cmRunning) ? LEDState::CoreMiniRunning : LEDState::Offline;
 
 	updateLEDState();
 
-	std::shared_ptr<MessageFilter> filter = std::make_shared<MessageFilter>(Network::NetID::Reset_Status);
-	filter->includeInternalInAny = true;
-
-	// Wait until communication is disabled or 5 seconds, whichever comes first
-	while((std::chrono::system_clock::now() - startTime) < std::chrono::seconds(5)) {
-		if(latestResetStatus && !latestResetStatus->comEnabled)
-			break;
-
-		if(!com->sendCommand(Command::RequestStatusUpdate))
-			return false;
-
-		com->waitForMessageSync(filter, std::chrono::milliseconds(100));
-	}
-
 	online = false;
 
 	return true;
@@ -806,12 +824,6 @@ std::shared_ptr<HardwareInfo> Device::getHardwareInfo(std::chrono::milliseconds
 		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
 		return nullptr;
 	}
-
-	if(!isOnline()) {
-		report(APIEvent::Type::DeviceCurrentlyOffline, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
 	auto filter = std::make_shared<MessageFilter>(Message::Type::HardwareInfo);
 
 	auto response = com->waitForMessageSync([this]() {
@@ -1691,7 +1703,10 @@ void Device::stopScriptStatusThreadIfNecessary(std::unique_lock<std::mutex> lk)
 Lifetime Device::suppressDisconnects() {
 	std::lock_guard<std::mutex> lk(heartbeatMutex);
 	heartbeatSuppressedByUser++;
-	return Lifetime([this] { std::lock_guard<std::mutex> lk2(heartbeatMutex); heartbeatSuppressedByUser--; });
+	return Lifetime([this] { 
+		std::lock_guard<std::mutex> lk2(heartbeatMutex);
+		heartbeatSuppressedByUser--;
+	});
 }
 
 void Device::addExtension(std::shared_ptr<DeviceExtension>&& extension) {
@@ -1721,15 +1736,6 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 		case Message::Type::RawMessage: {
 			auto rawMessage = std::static_pointer_cast<RawMessage>(message);
 			switch(rawMessage->network.getNetID()) {
-				case Network::NetID::Device: {
-					// Device is not guaranteed to be a CANMessage, it might be a RawMessage
-					// if it couldn't be decoded to a CANMessage. We only care about the
-					// CANMessage decoding right now.
-					auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
-					if(canmsg)
-						handleNeoVIMessage(std::move(canmsg));
-					break;
-				}
 				case Network::NetID::DeviceStatus:
 					// Device Status format is unique per device, so the devices need to decode it themselves
 					handleDeviceStatus(rawMessage);
@@ -1739,6 +1745,15 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 			}
 			break;
 		}
+		case Message::Type::Frame: {
+			// Device is not guaranteed to be a CANMessage, it might be a RawMessage
+			// if it couldn't be decoded to a CANMessage. We only care about the
+			// CANMessage decoding right now.
+			auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
+			if(canmsg)
+				handleNeoVIMessage(std::move(canmsg));
+			break;
+		}
 		default: break;
 	}
 	forEachExtension([&](const std::shared_ptr<DeviceExtension>& ext) {
@@ -1984,11 +1999,6 @@ std::optional<size_t> Device::getGenericBinarySize(uint16_t binaryIndex) {
 		return std::nullopt;
 	}
 
-	if(!isOnline()) {
-		report(APIEvent::Type::DeviceCurrentlyOffline, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
 	std::vector<uint8_t> args = GenericBinaryStatusPacket::EncodeArguments(binaryIndex);
 	
 	std::shared_ptr<Message> response = com->waitForMessageSync(
@@ -2051,6 +2061,40 @@ bool Device::readBinaryFile(std::ostream& stream, uint16_t binaryIndex) {
 	return true;
 }
 
+bool Device::writeBinaryFile(const std::vector<uint8_t>& in, uint16_t binaryIndex)
+{
+	auto timeout = std::chrono::milliseconds(100);
+
+	auto size = in.size();
+
+	std::vector<uint8_t> arguments(sizeof(ExtendedDataMessage::ExtendedDataHeader) + ExtendedDataMessage::MaxExtendedDataBufferSize);
+	ExtendedDataMessage::ExtendedDataHeader& parameters = *reinterpret_cast<ExtendedDataMessage::ExtendedDataHeader*>(arguments.data());
+
+	auto filter = std::make_shared<MessageFilter>(Network::NetID::ExtendedData);
+
+	for (size_t offset = 0; offset < size; offset += ExtendedDataMessage::MaxExtendedDataBufferSize)
+	{
+		parameters.subCommand = ExtendedDataSubCommand::GenericBinaryWrite;
+		parameters.userValue = static_cast<uint32_t>(binaryIndex);
+		parameters.offset = static_cast<uint32_t>(offset);
+		parameters.length = static_cast<uint32_t>(std::min(ExtendedDataMessage::MaxExtendedDataBufferSize, size - offset));
+		(void)memcpy(&arguments[sizeof(ExtendedDataMessage::ExtendedDataHeader)], &in[offset], parameters.length);
+
+		std::shared_ptr<Message> response = com->waitForMessageSync(
+			[this, arguments]() {
+				return com->sendCommand(Command::ExtendedData, arguments);
+			},
+			filter,
+			timeout
+		);
+		if (!response) {
+			report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+			return false;
+		}
+	}
+	return true;
+}
+
 bool Device::subscribeLiveData(std::shared_ptr<LiveDataCommandMessage> message) {
 	if(!supportsLiveData()) {
 		report(APIEvent::Type::LiveDataNotSupported, APIEvent::Severity::Error);
@@ -3335,3 +3379,56 @@ std::optional<TC10StatusMessage> Device::getTC10Status(Network::NetID network) {
 
 	return *typed;
 }
+
+std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeout) {
+	if(!supportsGPTP()) {
+		report(APIEvent::Type::GPTPNotSupported, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	if(!isOpen()) {
+		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this](){ 
+			return com->sendCommand(ExtendedCommand::GetGPTPStatus, {}); 
+		},
+		std::make_shared<MessageFilter>(Message::Type::GPTPStatus),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	auto retMsg = std::static_pointer_cast<GPTPStatus>(response);
+	if(!retMsg) {
+		return std::nullopt;
+	}
+
+	return *retMsg;
+}
+
+bool Device::writeMACsecConfig(const MACsecMessage& message, uint16_t binaryIndex)
+{
+	std::vector<uint8_t> raw;
+
+	message.EncodeFromMessage(raw, report);
+
+	return writeBinaryFile(raw, binaryIndex);
+}
+
+bool Device::enableNetworkCommunication(bool enable) {
+	bool sendMsg = false;
+	if(!com->driver->enableCommunication(enable, sendMsg)) {
+		return false;
+	}
+	if(sendMsg) {
+		if(!com->sendCommand(Command::EnableNetworkCommunication, enable)) {
+			return false;
+		}
+	}
+	return true;
+}

device/devicefinder.cpp

@@ -2,6 +2,7 @@
 #include "icsneo/platform/devices.h"
 #include "icsneo/device/founddevice.h"
 #include "generated/extensions/builtin.h"
+#include "icsneo/platform/servd.h"
 
 #ifdef ICSNEO_ENABLE_FIRMIO
 #include "icsneo/platform/firmio.h"
@@ -63,29 +64,33 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 	static std::vector<FoundDevice> newDriverFoundDevices;
 	newDriverFoundDevices.clear();
 
-	#ifdef ICSNEO_ENABLE_FIRMIO
+	if(Servd::Enabled()) {
-	FirmIO::Find(newDriverFoundDevices);
+		Servd::Find(newDriverFoundDevices);
-	#endif
+	} else {
-
+		#ifdef ICSNEO_ENABLE_FIRMIO
-	#ifdef ICSNEO_ENABLE_TCP
+		FirmIO::Find(newDriverFoundDevices);
-	TCP::Find(newDriverFoundDevices);
+		#endif
-	#endif
+	
-
+		#ifdef ICSNEO_ENABLE_TCP
-	#ifdef ICSNEO_ENABLE_RAW_ETHERNET
+		TCP::Find(newDriverFoundDevices);
-	PCAP::Find(newDriverFoundDevices);
+		#endif
-	#endif
+	
-
+		#ifdef ICSNEO_ENABLE_RAW_ETHERNET
-	#ifdef ICSNEO_ENABLE_CDCACM
+		PCAP::Find(newDriverFoundDevices);
-	CDCACM::Find(newDriverFoundDevices);
+		#endif
-	#endif
+	
-
+		#ifdef ICSNEO_ENABLE_CDCACM
-	#ifdef ICSNEO_ENABLE_FTDI
+		CDCACM::Find(newDriverFoundDevices);
-	FTDI::Find(newDriverFoundDevices);
+		#endif
-	#endif
+	
-
+		#ifdef ICSNEO_ENABLE_FTDI
-	#ifdef ICSNEO_ENABLE_FTD3XX
+		FTDI::Find(newDriverFoundDevices);
-	FTD3XX::Find(newDriverFoundDevices);
+		#endif
-	#endif
+	
+		#ifdef ICSNEO_ENABLE_FTD3XX
+		FTD3XX::Find(newDriverFoundDevices);
+		#endif
+	}
 
 	// Weak because we don't want to keep devices open if they go out of scope elsewhere
 	static std::vector<std::weak_ptr<Device>> foundDevices;
@@ -193,6 +198,10 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADEpsilon>(dev, newFoundDevices);
 		#endif
 
+		#ifdef __RADEPSILONXL_H_
+		makeIfSerialMatches<RADEpsilonXL>(dev, newFoundDevices);
+		#endif
+
 		#ifdef __RADGALAXY_H_
 		makeIfSerialMatches<RADGalaxy>(dev, newFoundDevices);
 		#endif
@@ -352,6 +361,10 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADEpsilon::DEVICE_TYPE,
 		#endif
 
+		#ifdef __RADEPSILONXL_H_
+		RADEpsilonXL::DEVICE_TYPE,
+		#endif
+
 		#ifdef __RADGALAXY_H_
 		RADGalaxy::DEVICE_TYPE,
 		#endif

docs/conf.py

@@ -12,7 +12,7 @@ subprocess.call('cd ..; doxygen docs/icsneoc/Doxyfile', shell=True)
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = 'libicsneo'
-copyright = '2024, Intrepid Control Systems, Inc.'
+copyright = '2024-2025, Intrepid Control Systems, Inc.'
 author = 'Intrepid Control Systems, Inc.'
 
 # -- General configuration ---------------------------------------------------

docs/icsneopy/api.rst

@@ -6,4 +6,5 @@ Python API
    :members:
    :undoc-members:
    :show-inheritance:
+   :imported-members:
    :special-members: __init__

docs/icsneopy/examples.rst

@@ -2,7 +2,7 @@
 Python Examples
 ===============
 
-Transmit CAN frames on HSCAN
+Transmit CAN frames on DW CAN 01
 ============================
 
 .. code-block:: python
@@ -15,7 +15,7 @@ Transmit CAN frames on HSCAN
    device: icsneopy.Device = devices[0]
 
    message = icsneopy.CANMessage()
-   message.network = icsneopy.Network(icsneopy.Network.NetID.HSCAN)
+   message.network = icsneopy.Network(icsneopy.Network.NetID.DWCAN_01)
    message.arbid = 0x56
    message.data = (0x11, 0x22, 0x33)
 
@@ -25,7 +25,7 @@ Transmit CAN frames on HSCAN
 
    device.transmit(message)
      
-Receive CAN frames on HSCAN
+Receive CAN frames on DW CAN 01
 ===========================
 
 .. code-block:: python
@@ -40,7 +40,7 @@ Receive CAN frames on HSCAN
 
    def on_message(message: icsneopy.CANMessage):
        print(message.arbid, message.data)
-   message_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.HSCAN)
+   message_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.DWCAN_01)
    callback = icsneopy.MessageCallback(on_message, message_filter)
 
    device.add_message_callback(callback)
@@ -50,3 +50,114 @@ Receive CAN frames on HSCAN
 
    # rx for 10s
    time.sleep(10)
+
+
+Monitor Ethernet Status
+=======================
+
+.. code-block:: python
+
+   import icsneopy
+   import time
+
+   def main():
+      devices = icsneopy.find_all_devices()
+      if len(devices) == 0:
+         print("error: no devices found")
+         return False
+
+      device = devices[0]
+      print(f"info: monitoring Ethernet status on {device}")
+
+      def on_message(message):
+         print(f"info: network: {message.network}, state: {message.state}, speed: {message.speed}, duplex: {message.duplex}, mode: {message.mode}")
+
+      filter = icsneopy.MessageFilter(icsneopy.Message.Type.EthernetStatus)
+      callback = icsneopy.MessageCallback(on_message, filter)
+      device.add_message_callback(callback)
+
+      if not device.open():
+         print("error: unable to open device")
+         return False
+
+      if not device.go_online():
+         print("error: unable to go online")
+         return False
+
+      while True:
+         time.sleep(1)
+
+   main()
+
+TC10
+====
+
+.. code-block:: python
+
+   import icsneopy
+   import time
+
+   devices: list[icsneopy.Device] = icsneopy.find_all_devices()
+
+   device: icsneopy.Device = devices[0]
+
+   print(f"using {device} for TC10")
+
+   device.open()
+
+   netid = icsneopy.Network.NetID.AE_01
+
+   if device.supports_tc10():
+      # initial
+      status = device.get_tc10_status(netid)
+      print(f"initial status: wake: {status.wakeStatus}, sleep: {status.sleepStatus}")
+      time.sleep(1)
+
+      # sleep
+      device.request_tc10_sleep(netid)
+      print("waiting 1s for sleep to occur")
+      time.sleep(1)
+      status = device.get_tc10_status(netid)
+      print(f"post sleep status: wake: {status.wakeStatus}, sleep: {status.sleepStatus}")
+      
+      # wake
+      device.request_tc10_wake(netid)
+      print("waiting 1s for wake to occur")
+      time.sleep(1)
+      status = device.get_tc10_status(netid)
+      print(f"post wake status: wake: {status.wakeStatus}, sleep: {status.sleepStatus}")
+   else:
+      print(f"{device} does not support TC10")
+
+DoIP Ethernet Activation
+========================
+
+.. code-block:: python
+
+   import icsneopy
+   import time
+
+   devs = icsneopy.find_all_devices()
+
+   dev = devs[0]
+
+   dev.open()
+
+   # the device must be online for digital I/O
+   dev.go_online()
+
+   print(f"initial state: {dev.get_digital_io(icsneopy.IO.EthernetActivation, 1)}")
+
+   dev.set_digital_io(icsneopy.IO.EthernetActivation, 1, True)
+
+   print(f"after setting to true: {dev.get_digital_io(icsneopy.IO.EthernetActivation, 1)}")
+
+   # allow for observing the change
+   time.sleep(2)
+
+   dev.set_digital_io(icsneopy.IO.EthernetActivation, 1, False)
+
+   print(f"after setting to false: {dev.get_digital_io(icsneopy.IO.EthernetActivation, 1)}")
+
+   # allow for observing the change
+   time.sleep(2)

docs/icsneopy/index.rst

@@ -7,3 +7,4 @@ icsneopy
 
    examples
    api
+   radepsilon

docs/icsneopy/radepsilon.rst

@@ -0,0 +1,137 @@
+=======================================
+Python Examples for RAD-Epsilon Devices
+=======================================
+
+
+
+Working with PHY Settings
+=========================
+
+.. code-block:: python
+
+    import sys
+    import icsneopy
+
+
+    class PhyStaticInfo:
+
+        def __init__(self, index, type, switch_port):
+            self.index = index
+            self.type = type
+            self.switch_port = switch_port
+
+        def __repr__(self):
+            return f"{self.switch_port}: Type {self.type} / Index {self.index}"
+
+
+    # Switch Port name to PHY index and PHY type
+    RAD_EPSILON_PHY_INFO = {
+        "1": PhyStaticInfo(0, "88Q2112", "1"),
+        "2": PhyStaticInfo(1, "88Q2112", "2"),
+        "3": PhyStaticInfo(2, "88Q2112", "3"),
+        "4": PhyStaticInfo(3, "88Q2112", "4"),
+        "5": PhyStaticInfo(4, "88Q2112", "5"),
+        "6": PhyStaticInfo(5, "88Q2112", "6"),
+        "9": PhyStaticInfo(6, "88Q2112", "9"),
+        "10": PhyStaticInfo(7, "88Q2112", "10")
+    }
+
+    RAD_EPSILON_XL_PHY_INFO = {
+        "A1": PhyStaticInfo(0, "88Q222x", "A1"),
+        "A2": PhyStaticInfo(1, "88Q222x", "A2"),
+        "A3": PhyStaticInfo(2, "88Q222x", "A3"),
+        "A4": PhyStaticInfo(3, "88Q222x", "A4"),
+        "A5": PhyStaticInfo(4, "88Q222x", "A5"),
+        "A6": PhyStaticInfo(5, "88Q222x", "A6"),
+        "A11": PhyStaticInfo(6, "88Q222x", "A11"),
+        "A8": PhyStaticInfo(7, "88Q222x", "A8"),
+        "B1": PhyStaticInfo(8, "88Q222x", "B1"),
+        "B2": PhyStaticInfo(9, "88Q222x", "B2"),
+        "B3": PhyStaticInfo(10, "88Q222x", "B3"),
+        "B4": PhyStaticInfo(11, "88Q222x", "B4"),
+        "B5": PhyStaticInfo(12, "88Q222x", "B5"),
+        "B6": PhyStaticInfo(13, "88Q222x", "B6"),
+        "B7": PhyStaticInfo(14, "88Q222x", "B7"),
+        "B8": PhyStaticInfo(15, "88Q222x", "B8"),
+        "A9": PhyStaticInfo(16, "88X3310", "A9"),
+        "B9": PhyStaticInfo(17, "88X3310", "B9"),
+    }
+
+
+    def find_specific_device(type: icsneopy.DeviceType.Enum, serial: str | None = None) -> icsneopy.Device | None:
+        devices = icsneopy.find_all_devices()
+        for device in devices:
+            device_type = device.get_type().get_device_type()
+            if serial: # always find by serial if specified
+                if device.get_serial() == serial:
+                    return device
+            elif device_type == type:
+                return device
+        return None
+
+
+    def find_rad_epsilonxl(serial: str | None = None) -> icsneopy.Device | None:
+        return find_specific_device(icsneopy.DeviceType.Enum.RADEpsilonXL, serial)
+
+
+    def find_rad_epsilon(serial: str | None = None) -> icsneopy.Device | None:
+        return find_specific_device(icsneopy.DeviceType.Enum.RADEpsilon, serial)
+
+
+    def report_phy_settings(device: icsneopy.Device, phy: PhyStaticInfo) -> bool:
+        phy_enable = device.settings.get_phy_enable(phy.index)
+        phy_mode = device.settings.get_phy_mode(phy.index)
+        phy_speed = device.settings.get_phy_speed(phy.index)
+        if phy_enable is None or phy_mode is None or phy_speed is None:
+            print(f"failed to get settings for PHY{phy.index} on port {phy.switch_port}")
+        print(f"PHY {phy.index} ({phy.type})")
+        print(f"\tPort: {phy.switch_port}")
+        print(f"\tEnabled: {'TRUE' if phy_enable else 'FALSE'}")
+        print(f"\tMode: {phy_mode}")
+        print(f"\tSpeed: {phy_speed}")
+        return True
+
+    def configure_phy(device: icsneopy.Device, phy: PhyStaticInfo, enable: bool, mode: int, speed: int) -> bool:
+        if not device.settings.set_phy_enable(phy.index, enable):
+            print(f"failed to set enable for PHY{phy.index} at port {phy.switch_port}")
+            return False
+        if not device.settings.set_phy_mode(phy.index, mode):
+            print(f"failed to set mode for PHY{phy.index} at port {phy.switch_port}")
+            return False
+        if not device.settings.set_phy_speed(phy.index, speed):
+            print(f"failed to set speed for PHY{phy.index} at port {phy.switch_port}")
+            return False
+        if not device.settings.apply(True):
+            print(f"failed to apply settings")
+            print(icsneopy.get_last_error())
+            return False
+        print(f"Successfully set settings for PHY{phy.index} at port {phy.switch_port}")
+        return True
+
+
+    # find the first RAD-EpsilonXL
+    device = find_rad_epsilonxl()
+    if not device:
+        print("failed to find a RAD-EpsilonXL to open")
+        sys.exit(-1)
+    if not device.open():
+        print(f"Failed to open {device.describe()}")
+        print(icsneopy.get_last_error())
+        sys.exit(-1)
+    print(f"Opened {device.describe()}")
+    print("Applying default settings")
+    if not device.settings.apply_defaults():
+        print(icsneopy.get_last_error())
+        sys.exit(-1)
+    print("Reporting PHY settings")
+    for phy in RAD_EPSILON_XL_PHY_INFO.values():
+        report_phy_settings(device, phy)
+    # Setting Port A1 to Master mode, enabled, 1G speed
+    phy = RAD_EPSILON_XL_PHY_INFO["A1"]
+    if configure_phy(device, phy, True, icsneopy.Settings.EthernetLinkMode.Master, icsneopy.Settings.EthernetLinkSpeed.Speed1G) and device.settings.refresh(True):
+        report_phy_settings(device, phy) # report them back
+    else:
+        print(icsneopy.get_last_error())
+        sys.exit(-1)
+    device.close()
+

examples/CMakeLists.txt

@@ -11,10 +11,6 @@ option(LIBICSNEO_BUILD_CPP_MDIO_EXAMPLE "Build the MDIO example." ON)
 option(LIBICSNEO_BUILD_CPP_VSA_EXAMPLE "Build the VSA example." ON)
 option(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE "Build the app error example." ON)
 
-# Disabled until we properly build these in-tree
-# option(LIBICSNEO_BUILD_CSHARP_INTERACTIVE_EXAMPLE "Build the command-line interactive C# example." OFF)
-# option(LIBICSNEO_BUILD_JAVA_INTERACTIVE_EXAMPLE "Build the command-line interactive Java example." OFF)
-
 if(LIBICSNEO_BUILD_C_INTERACTIVE_EXAMPLE)
 	add_subdirectory(c/interactive)
 endif()
@@ -62,11 +58,3 @@ endif()
 if(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE)
 	add_subdirectory(cpp/apperror)
 endif()
-
-# if(LIBICSNEO_BUILD_CSHARP_INTERACTIVE_EXAMPLE)
-# 	add_subdirectory(csharp)
-# endif()
-
-# if(LIBICSNEO_BUILD_JAVA_INTERACTIVE_EXAMPLE)
-# 	add_subdirectory(java)
-# endif()

examples/c/interactive/src/main.c

@@ -128,7 +128,7 @@ void printAPIEvents() {
 void printDeviceEvents(neodevice_t* device) {
 	neoevent_t events[99];
 	size_t eventCount = 99;
-	if(icsneo_getDeviceEvents(selectedDevice, events, &eventCount)) {
+	if(icsneo_getDeviceEvents(device, events, &eventCount)) {
 		if(eventCount == 1) {
 			printf("1 device event found!\n");
 			printf("Event 0x%x: %s\n", events[0].eventNumber, events[0].description);
@@ -160,7 +160,7 @@ char getCharInput(int numArgs, ...) {
 
 	char* list = (char*) calloc(numArgs, sizeof(char));
 	for(int i = 0; i < numArgs; ++i) {
-		*(list + i) = va_arg(vaList, int);
+		*(list + i) = (char)va_arg(vaList, int);
 	}
 
 	va_end(vaList);
@@ -285,10 +285,10 @@ int main() {
 			printf("Would you like to open or close %s?\n", productDescription);
 			printf("[1] Open\n[2] Close\n[3] Cancel\n\n");
 
-			char input = getCharInput(3, '1', '2', '3');
+			char userSelection = getCharInput(3, '1', '2', '3');
 			printf("\n");
 
-			switch(input) {
+			switch(userSelection) {
 			case '1':
 				// Attempt to open the selected device
 				if(icsneo_openDevice(selectedDevice)) {
@@ -346,10 +346,10 @@ int main() {
 			printf("Would you like to have %s go online or offline?\n", productDescription);
 			printf("[1] Online\n[2] Offline\n[3] Cancel\n\n");
 
-			char input = getCharInput(3, '1', '2', '3');
+			char userSelection = getCharInput(3, '1', '2', '3');
 			printf("\n");
 
-			switch(input) {
+			switch(userSelection) {
 			case '1':
 				// Attempt to go online
 				if(icsneo_goOnline(selectedDevice)) {
@@ -394,10 +394,10 @@ int main() {
 			printf("Would you like to enable or disable message polling for %s?\n", productDescription);
 			printf("[1] Enable\n[2] Disable\n[3] Cancel\n\n");
 
-			char input = getCharInput(3, '1', '2', '3');
+			char userSelection = getCharInput(3, '1', '2', '3');
 			printf("\n");
 
-			switch(input) {
+			switch(userSelection) {
 			case '1':
 				// Attempt to enable message polling
 				if(icsneo_enableMessagePolling(selectedDevice)) {
@@ -481,8 +481,8 @@ int main() {
 							case ICSNEO_NETWORK_TYPE_CAN: {
 								neomessage_can_t* canMsg = (neomessage_can_t*)frame;
 								printf("\t0x%03x [%zu] ", canMsg->arbid, canMsg->length);
-								for(size_t i = 0; i < canMsg->length; i++) {
+								for(size_t j = 0; j < canMsg->length; j++) {
-									printf("%02x ", canMsg->data[i]);
+									printf("%02x ", canMsg->data[j]);
 								}
 								if(canMsg->status.transmitMessage)
 									printf("TX%s %04x ", canMsg->status.globalError ? " ERR" : "", canMsg->description);
@@ -495,18 +495,18 @@ int main() {
 								size_t dataLen = (frameLen > 2) ? (frameLen - 2) : 0;
 								size_t numberBytesHeader = (dataLen > 1) ? 3 : 1;
 								size_t numberBytesData = frameLen - numberBytesHeader;
-								if(linMsg->netid == ICSNEO_NETID_LIN) {
+								if(linMsg->netid == ICSNEO_NETID_LIN_01) {
 									printf("LIN 1 | ID: 0x%02x [%zu] ", linMsg->header[0], dataLen);
 								}
-								else if (linMsg->netid == ICSNEO_NETID_LIN2) {
+								else if (linMsg->netid == ICSNEO_NETID_LIN_02) {
 									printf("LIN 2 | ID: 0x%02x [%zu] ", linMsg->header[0], dataLen);
 								}
 
-								for(size_t i = 0; i < dataLen; ++i) {
+								for(size_t j = 0; j < dataLen; ++j) {
-									if (i < 2) {
+									if (j < 2) {
-										printf("%02x ", linMsg->header[i+1]);
+										printf("%02x ", linMsg->header[j+1]);
 									} else {
-										printf("%02x ", linMsg->data[i-2]);
+										printf("%02x ", linMsg->data[j-2]);
 									}
 								}
 								if(numberBytesData > 0)
@@ -562,7 +562,7 @@ int main() {
 			neomessage_can_t msg = {0};
 			msg.arbid = 0x120;
 			msg.length = 6;
-			msg.netid = ICSNEO_NETID_HSCAN;
+			msg.netid = ICSNEO_NETID_DWCAN_01;
 			msg.data = sendMessageData;
 			msg.description = 0x1c5; // Random description to match the receipt
 			msg.status.canfdFDF = false;
@@ -606,7 +606,7 @@ int main() {
 			icsneo_describeDevice(selectedDevice, productDescription, &descriptionLength);
 
 			// Attempt to set baudrate and apply settings
-			if(icsneo_setBaudrate(selectedDevice, ICSNEO_NETID_HSCAN, 250000) && icsneo_settingsApply(selectedDevice)) {
+			if(icsneo_setBaudrate(selectedDevice, ICSNEO_NETID_DWCAN_01, 250000) && icsneo_settingsApply(selectedDevice)) {
 				printf("Successfully set HS CAN baudrate for %s to 250k!\n\n", productDescription);
 			} else {
 				printf("Failed to set HS CAN for %s to 250k!\n\n", productDescription);
@@ -632,7 +632,7 @@ int main() {
 			icsneo_describeDevice(selectedDevice, productDescription, &descriptionLength);
 
 			// Attempt to set baudrate and apply settings
-			if(icsneo_setBaudrate(selectedDevice, ICSNEO_NETID_HSCAN, 500000) && icsneo_settingsApply(selectedDevice)) {
+			if(icsneo_setBaudrate(selectedDevice, ICSNEO_NETID_DWCAN_01, 500000) && icsneo_settingsApply(selectedDevice)) {
 				printf("Successfully set HS CAN baudrate for %s to 500k!\n\n", productDescription);
 			} else {
 				printf("Failed to set HS CAN for %s to 500k!\n\n", productDescription);
@@ -725,7 +725,7 @@ int main() {
 			}
 
 			const bool set = selection2 == '1';
-			neoio_t type;
+			neoio_t type = ICSNEO_IO_ETH_ACTIVATION;
 			switch (selection)
 			{
 			case '1': type = ICSNEO_IO_ETH_ACTIVATION; break;
@@ -758,7 +758,7 @@ int main() {
 			icsneo_describeDevice(selectedDevice, productDescription, &descriptionLength);
 
 			printf("Termination is ");
-			const bool val = icsneo_isTerminationEnabledFor(selectedDevice, ICSNEO_NETID_HSCAN);
+			const bool val = icsneo_isTerminationEnabledFor(selectedDevice, ICSNEO_NETID_DWCAN_01);
 			neoevent_t err = { 0 };
 			if(icsneo_getLastError(&err)) {
 				printf("not available at this time: %s\n\n", err.description);
@@ -776,7 +776,7 @@ int main() {
 			}
 
 			// Attempt to set baudrate and apply settings
-			if(icsneo_setTerminationFor(selectedDevice, ICSNEO_NETID_HSCAN, selection2 == '1') && icsneo_settingsApply(selectedDevice)) {
+			if(icsneo_setTerminationFor(selectedDevice, ICSNEO_NETID_DWCAN_01, selection2 == '1') && icsneo_settingsApply(selectedDevice)) {
 				printf("Successfully set HS CAN termination for %s!\n\n", productDescription);
 			} else {
 				printf("Failed to set HS CAN termination for %s!\n\n", productDescription);

examples/c/legacy/deviceSettings/main.c

@@ -11,7 +11,7 @@ e.g. pSettings.Settings.red2 -> pSettings.Settings.fire3
 #include <stdbool.h>
 
 #if defined _WIN32
-	#include "icsneo/platform/windows.h"
+	#include <windows.h>
 	#define SLEEP(msecs) Sleep(msecs)
 #elif defined (__unix__) || (defined (__APPLE__) && defined (__MACH__))
 	#include <time.h>

examples/c/legacy/lin/main.c

@@ -5,7 +5,7 @@
 #include <stdbool.h>
 
 #if defined _WIN32
-	#include "icsneo/platform/windows.h"
+	#include <windows.h>
 	#define SLEEP(msecs) Sleep(msecs)
 #elif defined (__unix__) || (defined (__APPLE__) && defined (__MACH__))
 	#include <time.h>
@@ -58,7 +58,7 @@ int main() {
 		msg1.Protocol = SPY_PROTOCOL_LIN;
 		msg1.StatusBitField = 0;
 		msg1.StatusBitField2 = 0;
-		lNetworkID = NETID_LIN2;
+		lNetworkID = NETID_LIN_02;
 		msg1.Header[0] = 0x11; //protected ID
 		msg1.Header[1] = 0xaa;
 		msg1.Header[2] = 0xbb;
@@ -80,7 +80,7 @@ int main() {
 		icsSpyMessageJ1850 msg2 = {0};
 		msg2.Protocol = SPY_PROTOCOL_LIN;
 		msg2.StatusBitField = SPY_STATUS_INIT_MESSAGE;
-		lNetworkID = NETID_LIN;
+		lNetworkID = NETID_LIN_01;
 		msg2.Header[0] = 0x11; //protected ID
 		msg2.NumberBytesData = 0;
 		msg2.NumberBytesHeader = 1;
@@ -96,7 +96,7 @@ int main() {
 		msg3.Protocol = SPY_PROTOCOL_LIN;
 		msg3.StatusBitField = SPY_STATUS_INIT_MESSAGE;
 		msg3.StatusBitField2 = 0;
-		lNetworkID = NETID_LIN;
+		lNetworkID = NETID_LIN_01;
 		msg3.Header[0] = 0xe2; //protected ID
 		msg3.Header[1] = 0x44;
 		msg3.Header[2] = 0x33;
@@ -131,10 +131,10 @@ int main() {
 					const icsSpyMessageJ1850* linMsg = (icsSpyMessageJ1850*)&rxMsg[idx];
 					size_t frameLen = (linMsg->NumberBytesHeader + linMsg->NumberBytesData);
 					size_t dataLen = (frameLen > 2) ? (frameLen - 2) : 0;
-					if(linMsg->NetworkID == NETID_LIN) {
+					if(linMsg->NetworkID == NETID_LIN_01) {
 						printf("LIN 1 | ID: 0x%02x [%zu] ", linMsg->Header[0], dataLen);
 					}
-					else if (linMsg->NetworkID == NETID_LIN2) {
+					else if (linMsg->NetworkID == NETID_LIN_02) {
 						printf("LIN 2 | ID: 0x%02x [%zu] ", linMsg->Header[0], dataLen);
 					}
 

examples/c/simple/lin/main.c

@@ -123,7 +123,7 @@ void printAPIEvents() {
 void printDeviceEvents(neodevice_t* device) {
 	neoevent_t events[99];
 	size_t eventCount = 99;
-	if(icsneo_getDeviceEvents(selectedDevice, events, &eventCount)) {
+	if(icsneo_getDeviceEvents(device, events, &eventCount)) {
 		if(eventCount == 1) {
 			printf("1 device event found!\n");
 			printf("Event 0x%x: %s\n", events[0].eventNumber, events[0].description);
@@ -155,7 +155,7 @@ char getCharInput(int numArgs, ...) {
 
 	char* list = (char*) calloc(numArgs, sizeof(char));
 	for(int i = 0; i < numArgs; ++i) {
-		*(list + i) = va_arg(vaList, int);
+		*(list + i) = (char)va_arg(vaList, int);
 	}
 
 	va_end(vaList);
@@ -285,7 +285,7 @@ int main() {
 		msg.header[1] = 0x11;
 		msg.header[2] = 0x22;
 		msg.length = 10;
-		msg.netid = ICSNEO_NETID_LIN;
+		msg.netid = ICSNEO_NETID_LIN_01;
 		msg.data = sendMessageData;
 		msg.linStatus.txCommander = 1;
 		msg.linStatus.txChecksumEnhanced = 1;
@@ -335,8 +335,8 @@ int main() {
 						case ICSNEO_NETWORK_TYPE_CAN: {
 							neomessage_can_t* canMsg = (neomessage_can_t*)frame;
 							printf("\t0x%03x [%zu] ", canMsg->arbid, canMsg->length);
-							for(size_t i = 0; i < canMsg->length; i++) {
+							for(size_t j = 0; i < canMsg->length; j++) {
-								printf("%02x ", canMsg->data[i]);
+								printf("%02x ", canMsg->data[j]);
 							}
 							if(canMsg->status.transmitMessage)
 								printf("TX%s %04x ", canMsg->status.globalError ? " ERR" : "", canMsg->description);
@@ -347,20 +347,18 @@ int main() {
 							neomessage_lin_t* linMsg = (neomessage_lin_t*)frame;
 							size_t frameLen = linMsg->length;
 							size_t dataLen = (frameLen > 2) ? (frameLen - 2) : 0;
-							size_t numberBytesHeader = (dataLen > 1) ? 3 : 1;
+							if(linMsg->netid == ICSNEO_NETID_LIN_01) {
-							size_t numberBytesData = frameLen - numberBytesHeader;
-							if(linMsg->netid == ICSNEO_NETID_LIN) {
 								printf("LIN 1 | ID: 0x%02x [%zu] ", linMsg->header[0], dataLen);
 							}
-							else if (linMsg->netid == ICSNEO_NETID_LIN2) {
+							else if (linMsg->netid == ICSNEO_NETID_LIN_02) {
 								printf("LIN 2 | ID: 0x%02x [%zu] ", linMsg->header[0], dataLen);
 							}
 
-							for(size_t i = 0; i < dataLen; ++i) {
+							for(size_t j = 0; j < dataLen; ++j) {
-								if (i < 2) {
+								if (j < 2) {
-									printf("%02x ", linMsg->header[i+1]);
+									printf("%02x ", linMsg->header[j+1]);
 								} else {
-									printf("%02x ", linMsg->data[i-2]);
+									printf("%02x ", linMsg->data[j-2]);
 								}
 							}
 							printf("| Checksum: 0x%02x\n", linMsg->checksum);

examples/cpp/a2b/src/a2b.cpp

@@ -79,7 +79,7 @@ void example0(const std::shared_ptr<icsneo::Device>& rada2b) {
 				true /* true if we want 16 bit channels in the message, false for 32 bit. This should match the RAD-A2B device setting */
 			);
 			msg->txmsg = true;
-			msg->network = icsneo::Network(icsneo::Network::NetID::A2B2);
+			msg->network = icsneo::Network(icsneo::Network::NetID::A2B_02);
 
 			// Load the WAV audio data into the desired channel, break if we fail to load
 			if(!msg->loadAudioBuffer(wavStream, channelMap)) {
@@ -192,7 +192,7 @@ void example3(const std::shared_ptr<icsneo::Device>& rada2b) {
 		std::shared_ptr<icsneo::A2BMessage> a2bmsgPtr = std::make_shared<icsneo::A2BMessage>(numFrames, icsneo::A2BMessage::TDMMode::TDM4, true);
 
 		icsneo::A2BMessage& a2bmsg = *a2bmsgPtr.get();
-		a2bmsg.network = icsneo::Network(icsneo::Network::NetID::A2B2);
+		a2bmsg.network = icsneo::Network(icsneo::Network::NetID::A2B_02);
 		a2bmsg.txmsg = true;
 
 		for(size_t frame = 0; frame < a2bmsg.getNumFrames(); frame++) {
@@ -241,13 +241,13 @@ void example3(const std::shared_ptr<icsneo::Device>& rada2b) {
 }
 
 /**
- * Example 4: Retrieving A2B bus status using I2C messaages.
+ * Example 4: Retrieving A2B bus status using I2C messages.
 */
 void example4(const std::shared_ptr<icsneo::Device>& rada2b) {
 	std::shared_ptr<icsneo::I2CMessage> msg = std::make_shared<icsneo::I2CMessage>();
-	std::shared_ptr<icsneo::MessageFilter> msgFilter = std::make_shared<icsneo::MessageFilter>(icsneo::Network::NetID::I2C2);
+	std::shared_ptr<icsneo::MessageFilter> msgFilter = std::make_shared<icsneo::MessageFilter>(icsneo::Network::NetID::I2C_02);
 
-	msg->network = icsneo::Network(icsneo::Network::NetID::I2C2);
+	msg->network = icsneo::Network(icsneo::Network::NetID::I2C_02);
 	msg->controlBytes.resize(1);
 	msg->controlBytes[0] = static_cast<uint8_t>(0x17u); // Register address for A2B INTTYPE
 	msg->dataBytes.resize(1, 0);
@@ -261,7 +261,7 @@ void example4(const std::shared_ptr<icsneo::Device>& rada2b) {
 
 			if(newMsg->type == icsneo::Message::Type::Frame) {
 				const auto& frame = std::dynamic_pointer_cast<icsneo::Frame>(newMsg);
-				if(frame && frame->network.getNetID() == icsneo::Network::NetID::I2C2) {
+				if(frame && frame->network.getNetID() == icsneo::Network::NetID::I2C_02) {
 					const auto& i2cMessage = std::dynamic_pointer_cast<icsneo::I2CMessage>(frame);
 
 					if(!i2cMessage) {

examples/cpp/apperror/src/AppErrorExample.cpp

@@ -8,7 +8,7 @@
 #include "icsneo/communication/message/message.h"
 /*
  * App errors are responses from the device indicating internal runtime errors
- * NOTE: To trigger the app error in this example, disable the HSCAN network on the device 
+ * NOTE: To trigger the app error in this example, disable the DW CAN 01 network on the device 
  * (e.g. with neoVI Explorer)
  */
 int main() {
@@ -58,14 +58,14 @@ int main() {
 		// Prepare a CAN message
 		std::cout << std::endl << "Transmitting a CAN frame... ";
 		auto txMessage = std::make_shared<icsneo::CANMessage>();
-		txMessage->network = icsneo::Network::NetID::HSCAN;
+		txMessage->network = icsneo::Network::NetID::DWCAN_01;
 		txMessage->arbid = 0x22;
 		txMessage->data.insert(txMessage->data.end(), {0xaa, 0xbb, 0xcc});
 		// The DLC will come from the length of the data vector
 		txMessage->isExtended = false;
 		txMessage->isCANFD = false;
 
-		// Transmit a CAN message on HSCAN, even though HSCAN is disabled on the device!
+		// Transmit a CAN message on DW CAN 01, even though DW CAN 01 is disabled on the device!
 		// Expect to see an app error caught in the callback defined above
 		ret = device->transmit(txMessage); 
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;

examples/cpp/interactive/src/InteractiveExample.cpp

@@ -267,7 +267,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
 		} // end of icsneo::Message::Type::Frame
 		case icsneo::Message::Type::CANErrorCount: {
 			// A message of type CANErrorCount is guaranteed to be a CANErrorCount, so we can static cast safely
-			auto cec = std::static_pointer_cast<icsneo::CANErrorCountMessage>(message);
+			auto cec = std::static_pointer_cast<icsneo::CANErrorMessage>(message);
 			std::cout << "\t\t" << cec->network << " error counts changed, REC=" << cec->receiveErrorCount
 				<< " TEC=" << cec->transmitErrorCount << " (" << (cec->busOff ? "" : "Not ") << "Bus Off)" << std::endl;
 			break;
@@ -508,7 +508,7 @@ int main() {
 
 			std::cout << "Transmitting a normal CAN frame..." << std::endl;
 			auto msg = std::make_shared<icsneo::CANMessage>();
-			msg->network = icsneo::Network::NetID::HSCAN;
+			msg->network = icsneo::Network::NetID::DWCAN_01;
 			msg->arbid = 0x120;
 			msg->data.insert(msg->data.end(), {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff});
 			msg->isExtended = false;
@@ -525,7 +525,7 @@ int main() {
 			/** Example of CAN FD
 			std::cout << "Transmitting an extended CAN FD frame... " << std::endl;
 			auto txMessage = std::make_shared<icsneo::CANMessage>();
-			txMessage->network = icsneo::Network::NetID::HSCAN;
+			txMessage->network = icsneo::Network::NetID::DWCAN_01;
 			txMessage->arbid = 0x1C5001C5;
 			txMessage->data.insert(txMessage->data.end(), {0xaa, 0xbb, 0xcc});
 			// The DLC will come from the length of the data vector
@@ -565,7 +565,7 @@ int main() {
 			selectedDevice = selectDevice(devices);
 
 			// Attempt to set baudrate and apply settings
-			if(selectedDevice->settings->setBaudrateFor(icsneo::Network::NetID::HSCAN, 250000) && selectedDevice->settings->apply()) {
+			if(selectedDevice->settings->setBaudrateFor(icsneo::Network::NetID::DWCAN_01, 250000) && selectedDevice->settings->apply()) {
 				std::cout << "Successfully set HS CAN baudrate for " << selectedDevice->describe() << " to 250k!" << std::endl;
 			} else {
 				std::cout << "Failed to set HS CAN baudrate for " << selectedDevice->describe() << " to 250k!" << std::endl << std::endl;
@@ -586,7 +586,7 @@ int main() {
 			selectedDevice = selectDevice(devices);
 
 			// Attempt to set baudrate and apply settings
-			if(selectedDevice->settings->setBaudrateFor(icsneo::Network::NetID::LSFTCAN, 250000) && selectedDevice->settings->apply()) {
+			if(selectedDevice->settings->setBaudrateFor(icsneo::Network::NetID::LSFTCAN_01, 250000) && selectedDevice->settings->apply()) {
 				std::cout << "Successfully set LSFT CAN baudrate for " << selectedDevice->describe() << " to 250k!" << std::endl;
 			} else {
 				std::cout << "Failed to set LSFT CAN baudrate for " << selectedDevice->describe() << " to 250k!" << std::endl << std::endl;
@@ -790,7 +790,7 @@ int main() {
 			selectedDevice = selectDevice(devices);
 
 			std::cout << "Termination is ";
-			const auto val = selectedDevice->settings->isTerminationEnabledFor(icsneo::Network::NetID::HSCAN);
+			const auto val = selectedDevice->settings->isTerminationEnabledFor(icsneo::Network::NetID::DWCAN_01);
 			if(!val.has_value()) {
 				std::cout << "not available at this time: " << icsneo::GetLastError() << std::endl << std::endl;
 				break;
@@ -807,7 +807,7 @@ int main() {
 			}
 
 			// Attempt to set termination and apply settings
-			if(selectedDevice->settings->setTerminationFor(icsneo::Network::NetID::HSCAN, selection2 == '1') && selectedDevice->settings->apply()) {
+			if(selectedDevice->settings->setTerminationFor(icsneo::Network::NetID::DWCAN_01, selection2 == '1') && selectedDevice->settings->apply()) {
 				std::cout << "Successfully set HS CAN termination for " << selectedDevice->describe() << std::endl;
 			} else {
 				std::cout << "Failed to set HS CAN termination for " << selectedDevice->describe() << std::endl;

examples/cpp/lin/src/LINExample.cpp

@@ -32,28 +32,28 @@ int main() {
 
 		int64_t baud = 19200;
 
-		std::cout << "Enable LIN commander resistor... ";
+		std::cout << "Enable LIN 01 commander resistor... ";
-		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN, true);
+		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN_01, true);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Disable LIN2 commander resistor... ";
+		std::cout << "Disable LIN 02 commander resistor... ";
-		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN2, false);
+		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN_02, false);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Setting LIN to operate at " << baud << "bit/s... ";
+		std::cout << "Setting LIN 01 to operate at " << baud << "bit/s... ";
-		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN, baud);
+		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN_01, baud);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Setting LIN2 to operate at " << baud << "bit/s... ";
+		std::cout << "Setting LIN 02 to operate at " << baud << "bit/s... ";
-		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN2, baud);
+		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN_02, baud);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Setting LIN mode to NORMAL... ";
+		std::cout << "Setting LIN 01 mode to NORMAL... ";
-		ret = device->settings->setLINModeFor(icsneo::Network::NetID::LIN, NORMAL_MODE);
+		ret = device->settings->setLINModeFor(icsneo::Network::NetID::LIN_01, NORMAL_MODE);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Setting LIN2 mode to NORMAL... ";
+		std::cout << "Setting LIN 02 mode to NORMAL... ";
-		ret = device->settings->setLINModeFor(icsneo::Network::NetID::LIN2, NORMAL_MODE);
+		ret = device->settings->setLINModeFor(icsneo::Network::NetID::LIN_02, NORMAL_MODE);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
 		std::cout << "Applying settings... ";
@@ -61,14 +61,14 @@ int main() {
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
 		std::cout << "Getting LIN Baudrate... ";
-		int64_t readBaud = device->settings->getBaudrateFor(icsneo::Network::NetID::LIN);
+		int64_t readBaud = device->settings->getBaudrateFor(icsneo::Network::NetID::LIN_01);
 		if(readBaud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
 			std::cout << "OK, " << (readBaud) << "bit/s" << std::endl;
 
-		std::cout << "Getting LIN2 Baudrate... ";
+		std::cout << "Getting LIN 02 Baudrate... ";
-		readBaud = device->settings->getBaudrateFor(icsneo::Network::NetID::LIN2);
+		readBaud = device->settings->getBaudrateFor(icsneo::Network::NetID::LIN_02);
 		if(readBaud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
@@ -113,18 +113,18 @@ int main() {
 		}));
 
 		// We can transmit messages
-		std::cout << "Transmitting a LIN responder data frame... ";
+		std::cout << "Transmitting a LIN 02 responder data frame... ";
 		auto lin_r = std::make_shared<icsneo::LINMessage>();
-		lin_r->network = icsneo::Network::NetID::LIN2;
+		lin_r->network = icsneo::Network::NetID::LIN_02;
 		lin_r->ID = 0x11;
 		lin_r->linMsgType = icsneo::LINMessage::Type::LIN_UPDATE_RESPONDER;
 		lin_r->data = {0xaa, 0xbb, 0xcc, 0xdd, 0x11, 0x22, 0x33, 0x44};
 		ret = device->transmit(lin_r); // This will return false if the device does not support LIN
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Transmitting a LIN commander header... ";
+		std::cout << "Transmitting a LIN 01 commander header... ";
 		auto lin_c = std::make_shared<icsneo::LINMessage>();
-		lin_c->network = icsneo::Network::NetID::LIN;
+		lin_c->network = icsneo::Network::NetID::LIN_01;
 		lin_c->ID = 0x11;
 		lin_c->linMsgType = icsneo::LINMessage::Type::LIN_HEADER_ONLY;
 		ret = device->transmit(lin_c);
@@ -132,9 +132,9 @@ int main() {
 
 		std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
-		std::cout << "Transmitting a LIN commander frame with responder data... ";
+		std::cout << "Transmitting a LIN 01 commander frame with responder data... ";
 		auto lin_d = std::make_shared<icsneo::LINMessage>();
-		lin_d->network = icsneo::Network::NetID::LIN;
+		lin_d->network = icsneo::Network::NetID::LIN_01;
 		lin_d->ID = 0x22;
 		lin_d->isEnhancedChecksum = true;
 		lin_d->linMsgType = icsneo::LINMessage::Type::LIN_COMMANDER_MSG;

examples/cpp/mdio/src/MDIOExample.cpp

@@ -117,7 +117,7 @@ int main()
 		// We can transmit messages to read the PHY ID of BCM89810 PHY
 		std::cout << "\tTransmitting a MDIO request to read ID on BCM89810...\n";
 		auto mdio_r = std::make_shared<icsneo::MDIOMessage>();
-		mdio_r->network = icsneo::Network::NetID::MDIO1;
+		mdio_r->network = icsneo::Network::NetID::MDIO_01;
 		mdio_r->phyAddress = 0x00u;
 		mdio_r->regAddress = 0x02u;
 		mdio_r->direction = icsneo::MDIOMessage::Direction::Read;
@@ -128,7 +128,7 @@ int main()
 		// We can transmit messages to write to arbitrary register
 		std::cout << "\tTransmitting a MDIO request to write register on BCM89810...\n";
 		mdio_r = std::make_shared<icsneo::MDIOMessage>();
-		mdio_r->network = icsneo::Network::NetID::MDIO1;
+		mdio_r->network = icsneo::Network::NetID::MDIO_01;
 		mdio_r->phyAddress = 0x00u;
 		mdio_r->regAddress = 0x1Bu;
 		mdio_r->data = {0xAA, 0xAF};
@@ -140,7 +140,7 @@ int main()
 		// We can transmit messages to read back to arbitrary register
 		std::cout << "\tTransmitting a MDIO request to read register on BCM89810...\n";
 		mdio_r = std::make_shared<icsneo::MDIOMessage>();
-		mdio_r->network = icsneo::Network::NetID::MDIO1;
+		mdio_r->network = icsneo::Network::NetID::MDIO_01;
 		mdio_r->phyAddress = 0x00u;
 		mdio_r->regAddress = 0x1Bu;
 		mdio_r->direction = icsneo::MDIOMessage::Direction::Read;
@@ -154,7 +154,7 @@ int main()
 		// We can transmit messages to read the PHY ID of BCM89810 PHY
 		std::cout << "\tTransmitting a MDIO request to read ID on 88Q2112...\n";
 		mdio_r = std::make_shared<icsneo::MDIOMessage>();
-		mdio_r->network = icsneo::Network::NetID::MDIO1;
+		mdio_r->network = icsneo::Network::NetID::MDIO_01;
 		mdio_r->phyAddress = 0x06u;
 		mdio_r->devAddress = 0x01u;
 		mdio_r->regAddress = 0x0002u;
@@ -166,7 +166,7 @@ int main()
 		// We can transmit messages to write to arbitrary register
 		std::cout << "\tTransmitting a MDIO request to write register on 88Q2112...\n";
 		mdio_r = std::make_shared<icsneo::MDIOMessage>();
-		mdio_r->network = icsneo::Network::NetID::MDIO1;
+		mdio_r->network = icsneo::Network::NetID::MDIO_01;
 		mdio_r->phyAddress = 0x06u;
 		mdio_r->devAddress = 0x01u;
 		mdio_r->regAddress = 0x0902u;
@@ -179,7 +179,7 @@ int main()
 		// We can transmit messages to read back to arbitrary register
 		std::cout << "\tTransmitting a MDIO request to read register on 88Q2112...\n";
 		mdio_r = std::make_shared<icsneo::MDIOMessage>();
-		mdio_r->network = icsneo::Network::NetID::MDIO1;
+		mdio_r->network = icsneo::Network::NetID::MDIO_01;
 		mdio_r->phyAddress = 0x06u;
 		mdio_r->devAddress = 0x01u;
 		mdio_r->regAddress = 0x0902u;

examples/cpp/simple/src/SimpleExample.cpp

@@ -37,39 +37,39 @@ int main() {
 		}
 		std::cout << "OK" << std::endl;
 
-		std::cout << "\tGetting HSCAN Baudrate... ";
+		std::cout << "\tGetting DW CAN 01 Baudrate... ";
-		int64_t baud = device->settings->getBaudrateFor(icsneo::Network::NetID::HSCAN);
+		int64_t baud = device->settings->getBaudrateFor(icsneo::Network::NetID::DWCAN_01);
 		if(baud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
 			std::cout << "OK, " << (baud/1000) << "kbit/s" << std::endl;
 
-		std::cout << "\tSetting HSCAN to operate at 125kbit/s... ";
+		std::cout << "\tSetting DW CAN 01 to operate at 125kbit/s... ";
-		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::HSCAN, 125000);
+		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::DWCAN_01, 125000);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
 		// Changes to the settings do not take affect until you call settings->apply()!
 		// When you get the baudrate here, you're reading what the device is currently operating on
-		std::cout << "\tGetting HSCAN Baudrate... (expected to be unchanged) ";
+		std::cout << "\tGetting DW CAN 01 Baudrate... (expected to be unchanged) ";
-		baud = device->settings->getBaudrateFor(icsneo::Network::NetID::HSCAN);
+		baud = device->settings->getBaudrateFor(icsneo::Network::NetID::DWCAN_01);
 		if(baud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
 			std::cout << "OK, " << (baud/1000) << "kbit/s" << std::endl;
 
-		std::cout << "\tGetting HSCANFD Baudrate... ";
+		std::cout << "\tGetting DW CAN 01 FD Baudrate... ";
-		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::HSCAN);
+		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::DWCAN_01);
 		if(baud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
 			std::cout << "OK, " << (baud/1000) << "kbit/s" << std::endl;
 
-		std::cout << "\tSetting HSCANFD to operate at 8Mbit/s... ";
+		std::cout << "\tSetting DW CAN 01 FD to operate at 8Mbit/s... ";
-		ret = device->settings->setFDBaudrateFor(icsneo::Network::NetID::HSCAN, 8000000);
+		ret = device->settings->setFDBaudrateFor(icsneo::Network::NetID::DWCAN_01, 8000000);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "\tGetting HSCANFD Baudrate... (expected to be unchanged) ";
+		std::cout << "\tGetting DW CAN 01 FD Baudrate... (expected to be unchanged) ";
-		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::HSCAN);
+		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::DWCAN_01);
 		if(baud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
@@ -83,15 +83,15 @@ int main() {
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
 		// Now that we have applied, we expect that our operating baudrates have changed
-		std::cout << "\tGetting HSCAN Baudrate... ";
+		std::cout << "\tGetting DW CAN 01 Baudrate... ";
-		baud = device->settings->getBaudrateFor(icsneo::Network::NetID::HSCAN);
+		baud = device->settings->getBaudrateFor(icsneo::Network::NetID::DWCAN_01);
 		if(baud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
 			std::cout << "OK, " << (baud/1000) << "kbit/s" << std::endl;
 
-		std::cout << "\tGetting HSCANFD Baudrate... ";
+		std::cout << "\tGetting DW CAN 01 (FD) Baudrate... ";
-		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::HSCAN);
+		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::DWCAN_01);
 		if(baud < 0)
 			std::cout << "FAIL" << std::endl;
 		else
@@ -155,13 +155,13 @@ int main() {
 		// We can transmit messages
 		std::cout << "\n\tTransmitting an extended CAN FD frame... ";
 		auto txMessage5 = std::make_shared<icsneo::CANMessage>();
-		txMessage5->network = icsneo::Network::NetID::HSCAN;
+		txMessage5->network = icsneo::Network::NetID::DWCAN_01;
 		txMessage5->arbid = 0x1C5001C5;
 		txMessage5->data.insert(txMessage5->data.end(), {0xaa, 0xbb, 0xcc});
 		// The DLC will come from the length of the data vector
 		txMessage5->isExtended = true;
 		txMessage5->isCANFD = true;
-		ret = device->transmit(txMessage5); // This will return false if the device does not support CAN FD, or does not have HSCAN
+		ret = device->transmit(txMessage5); // This will return false if the device does not support CAN FD, or does not have DWCAN_01
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
 		// We can also register a handler
@@ -252,7 +252,7 @@ int main() {
 				} // end of icsneo::Message::Type::Frame
 				case icsneo::Message::Type::CANErrorCount: {
 					// A message of type CANErrorCount is guaranteed to be a CANErrorCount, so we can static cast safely
-					auto cec = std::static_pointer_cast<icsneo::CANErrorCountMessage>(message);
+					auto cec = std::static_pointer_cast<icsneo::CANErrorMessage>(message);
 
 					// Print the error counts
 					std::cout << "\t\t" << cec->network << " error counts changed, REC=" << std::to_string(cec->receiveErrorCount)
@@ -290,25 +290,25 @@ int main() {
 		// We can transmit messages
 		std::cout << "\tTransmitting an extended CAN FD frame... ";
 		auto txMessage = std::make_shared<icsneo::CANMessage>();
-		txMessage->network = icsneo::Network::NetID::HSCAN;
+		txMessage->network = icsneo::Network::NetID::DWCAN_01;
 		txMessage->arbid = 0x1C5001C5;
 		txMessage->data.insert(txMessage->data.end(), {0xaa, 0xbb, 0xcc});
 		// The DLC will come from the length of the data vector
 		txMessage->isExtended = true;
 		txMessage->isCANFD = true;
-		ret = device->transmit(txMessage); // This will return false if the device does not support CAN FD, or does not have HSCAN
+		ret = device->transmit(txMessage); // This will return false if the device does not support CAN FD, or does not have DWCAN_01
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "\tTransmitting an ethernet frame on OP (BR) Ethernet 2... ";
+		std::cout << "\tTransmitting an ethernet frame on AE 02... ";
 		auto ethTxMessage = std::make_shared<icsneo::EthernetMessage>();
-		ethTxMessage->network = icsneo::Network::NetID::OP_Ethernet2;
+		ethTxMessage->network = icsneo::Network::NetID::AE_02;
 		ethTxMessage->data.insert(ethTxMessage->data.end(), {
 			0x00, 0xFC, 0x70, 0x00, 0x01, 0x02, /* Destination MAC */
 			0x00, 0xFC, 0x70, 0x00, 0x01, 0x01, /* Source MAC */
 			0x00, 0x00, /* Ether Type */
 			0x01, 0xC5, 0x01, 0xC5 /* Payload (will automatically be padded on transmit unless you set `ethTxMessage->noPadding`) */
 		});
-		ret = device->transmit(ethTxMessage); // This will return false if the device does not support OP (BR) Ethernet 2
+		ret = device->transmit(ethTxMessage); // This will return false if the device does not support AE 02
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
 		std::vector<icsneo::MiscIO> emisc = device->getEMiscIO();

examples/cpp/vsa/src/VSAExample.cpp

@@ -36,7 +36,7 @@ std::vector<std::shared_ptr<icsneo::Frame>> constructRandomFrames(size_t frameCo
 				// Short Ethernet
 				{
 					auto frame = std::make_shared<icsneo::EthernetMessage>();
-					frame->network = icsneo::Network::NetID::Ethernet;
+					frame->network = icsneo::Network::NetID::ETHERNET_01;
 					frames.push_back(frame);
 					frame->data.resize(ShortEthSize);
 					std::generate(frame->data.begin(), frame->data.end(), randByteGen);
@@ -46,7 +46,7 @@ std::vector<std::shared_ptr<icsneo::Frame>> constructRandomFrames(size_t frameCo
 				// Long Ethernet
 				{
 					auto frame = std::make_shared<icsneo::EthernetMessage>();
-					frame->network = icsneo::Network::NetID::Ethernet;
+					frame->network = icsneo::Network::NetID::ETHERNET_01;
 					frames.push_back(frame);
 					frame->data.resize(LongEthSize);
 					std::generate(frame->data.begin(), frame->data.end(), randByteGen);
@@ -56,7 +56,7 @@ std::vector<std::shared_ptr<icsneo::Frame>> constructRandomFrames(size_t frameCo
 				// Classic CAN
 				{
 					auto frame = std::make_shared<icsneo::CANMessage>();
-					frame->network = icsneo::Network::NetID::HSCAN2;
+					frame->network = icsneo::Network::NetID::DWCAN_02;
 					frames.push_back(frame);
 					frame->data.resize(ClassicCANSize);
 
@@ -67,7 +67,7 @@ std::vector<std::shared_ptr<icsneo::Frame>> constructRandomFrames(size_t frameCo
 				// CAN FD
 				{
 					auto frame = std::make_shared<icsneo::CANMessage>();
-					frame->network = icsneo::Network::NetID::HSCAN3;
+					frame->network = icsneo::Network::NetID::DWCAN_03;
 					frames.push_back(frame);
 					frame->data.resize(CANFDSize);
 					std::generate(frame->data.begin(), frame->data.end(), randByteGen);

examples/csharp/CMakeLists.txt

@@ -1,26 +0,0 @@
-cmake_minimum_required(VERSION 3.2)
-project(icsneocsharp VERSION 0.2.0)
-
-set(CMAKE_CXX_STANDARD 11)
-
-include(GNUInstallDirs)
-
-# Add an include directory like so if desired
-#include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
-
-# Enable Warnings
-if(MSVC)
-	# Force to always compile with W4
-	if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-		string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-	else()
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
-	endif()
-else() #if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-switch -Wno-unknown-pragmas")
-endif()
-
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../third-party/libicsneo ${CMAKE_CURRENT_BINARY_DIR}/third-party/libicsneo)
-
-add_library(icsneocsharp SHARED ${CMAKE_CURRENT_SOURCE_DIR}/csharp_wrap.c)
-target_link_libraries(icsneocsharp icsneoc)

examples/csharp/InteractiveExample.cs

@@ -1,520 +0,0 @@
-using System.Collections.Generic;
-
-namespace libicsneocsharp_example {
-    class InteractiveExample {
-
-        private uint msgLimit = 50000;
-        private neodevice_t selectedDevice;
-        private List<neodevice_t> devices = new List<neodevice_t>();
-        private uint numDevices = 0;
-
-        private void PrintAllDevices() {
-            if(numDevices == 0) {
-                System.Console.WriteLine("No devices found! Please scan for new devices.");
-            }
-
-            for(int i = 0; i < numDevices; i++) {
-                System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                if(icsneocsharp.icsneo_describeDevice(devices[i], description, ref maxLength)) {
-                    System.Console.Write("[" + (i + 1) + "] " + description.ToString() + "\tConnected: ");
-
-                    if(icsneocsharp.icsneo_isOpen(devices[i])) {
-                        System.Console.Write("Yes\t");
-                    } else System.Console.Write("No\t");
-
-                    System.Console.Write("Online: ");
-                    if(icsneocsharp.icsneo_isOnline(devices[i])) {
-                        System.Console.Write("Yes\t");
-                    } else System.Console.Write("No\t");
-
-                    System.Console.Write("Msg Polling: ");
-                    if(icsneocsharp.icsneo_isMessagePollingEnabled(devices[i])) {
-                        System.Console.Write("On\n");
-                    } else System.Console.Write("Off\n");
-                } else {
-                    System.Console.WriteLine("Description for device " + (i + 1) + " not available!");
-                }
-            }
-        }
-
-        private uint ScanNewDevices() {
-            neodevice_t newDevices = icsneocsharp.new_neodevice_t_array(99);
-
-            int count = 10;
-
-            icsneocsharp.icsneo_findAllDevices(newDevices, ref count);
-
-            numDevices += (uint) count;
-
-            for(int i = 0; i < numDevices; i++) {
-                devices.Add(icsneocsharp.neodevice_t_array_getitem(newDevices, i));
-            }
-            icsneocsharp.delete_neodevice_t_array(newDevices);
-            return (uint) count;
-        }
-
-        private void PrintMainMenu() {
-            System.Console.WriteLine("Press the letter next to the function you want to use:");
-            System.Console.WriteLine("A - List all devices");
-            System.Console.WriteLine("B - Scan for new devices");
-            System.Console.WriteLine("C - Open/close");
-            System.Console.WriteLine("D - Go online/offline");
-            System.Console.WriteLine("E - Enable/disable message polling");
-            System.Console.WriteLine("F - Get messages");
-            System.Console.WriteLine("G - Send message");
-            System.Console.WriteLine("H - Get events");
-            System.Console.WriteLine("I - Set HS CAN to 250K");
-            System.Console.WriteLine("J - Set HS CAN to 500K");
-            System.Console.WriteLine("X - Exit");
-        }
-
-        void PrintLastError() {
-            neoevent_t error = new neoevent_t();
-            if(icsneocsharp.icsneo_getLastError(error))
-                System.Console.WriteLine("Error 0x" + error.eventNumber + ": " + error.description);
-            else
-                System.Console.WriteLine("No errors found!");
-        }
-
-        void PrintAPIEvents() {
-            neoevent_t events = icsneocsharp.new_neoevent_t_array(99);
-            int eventCount = 99;
-            if(icsneocsharp.icsneo_getEvents(events, ref eventCount)) {
-                if(eventCount == 1) {
-                    neoevent_t evt = icsneocsharp.neoevent_t_array_getitem(events, 0);
-                    System.Console.WriteLine("1 API event found!");
-                    System.Console.WriteLine("Event 0x" + evt.eventNumber + ": " + evt.description);
-                } else {
-                    System.Console.WriteLine(eventCount + " API events found!");
-                    for(var i = 0; i < eventCount; ++i) {
-                        neoevent_t evt = icsneocsharp.neoevent_t_array_getitem(events, i);
-                        System.Console.WriteLine("Event 0x" + evt.eventNumber + ": " + evt.description);
-                    }
-                }
-            } else {
-                System.Console.WriteLine("Failed to get API events!");
-            }
-            icsneocsharp.delete_neoevent_t_array(events);
-        }
-
-        void PrintDeviceEvents(neodevice_t device) {
-            neoevent_t events = icsneocsharp.new_neoevent_t_array(99);
-            int eventCount = 99;
-            if(icsneocsharp.icsneo_getDeviceEvents(device, events, ref eventCount)) {
-                if(eventCount == 1) {
-                    neoevent_t evt = icsneocsharp.neoevent_t_array_getitem(events, 0);
-                    System.Console.WriteLine("1 device event found!");
-                    System.Console.WriteLine("Event 0x" + evt.eventNumber + ": " + evt.description);
-                } else {
-                    System.Console.WriteLine(eventCount + " device events found!");
-                    for(var i = 0; i < eventCount; ++i) {
-                        neoevent_t evt = icsneocsharp.neoevent_t_array_getitem(events, i);
-                        System.Console.WriteLine("Event 0x" + evt.eventNumber + ": " + evt.description);
-                    }
-                }
-            } else {
-                System.Console.WriteLine("Failed to get API events!");
-            }
-            icsneocsharp.delete_neoevent_t_array(events);
-        }
-
-        private char GetCharInput(List<char> allowed) {
-            bool found = false;
-            char key = '0';
-            while(!found) {
-                key = System.Console.ReadKey().KeyChar;
-                System.Console.WriteLine();
-                foreach(char compare in allowed) {
-                    if(compare == key) {
-                        found = true;
-                        break;
-                    }
-                }
-
-                if(!found) {
-                    System.Console.WriteLine("Input did not match expected options. Please try again.");
-                }
-            }
-            return key;
-        }
-
-        neodevice_t SelectDevice() {
-            System.Console.WriteLine("Please select a device:");
-            PrintAllDevices();
-            System.Console.WriteLine();
-
-            int selectedDeviceNum = 10;
-            while(selectedDeviceNum > numDevices) {
-                char deviceSelection = GetCharInput(new List<char> { '1', '2', '3', '4', '5', '6', '7', '8', '9' });
-                selectedDeviceNum = (int)char.GetNumericValue(deviceSelection);
-                if(selectedDeviceNum > numDevices) {
-                    System.Console.WriteLine("Selected device out of range!");
-                }
-            }
-
-            System.Console.WriteLine();
-
-            return devices[selectedDeviceNum - 1];
-        }
-
-        public void Run() {
-            neoversion_t version = icsneocsharp.icsneo_getVersion();
-            System.Console.WriteLine("ICS icsneocsharp.dll version " + version.major + "." + version.minor + "." + version.patch);
-            System.Console.WriteLine();
-
-            while(true) {
-                PrintMainMenu();
-                System.Console.WriteLine();
-                char input = GetCharInput(new List<char> { 'A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'X', 'x' });
-                System.Console.WriteLine();
-                switch(input) {
-                // List current devices
-                case 'A':
-                    goto case 'a';
-                case 'a':
-                    PrintAllDevices();
-                    System.Console.WriteLine();
-                    break;
-                // Scan for new devices
-                case 'B':
-                    goto case 'b';
-                case 'b': {
-                    var numNewDevices = ScanNewDevices();
-                    if(numNewDevices == 1) {
-                        System.Console.WriteLine("1 new device found!");
-                    } else {
-                        System.Console.WriteLine(numNewDevices + " new devices found!");
-                    }
-                    PrintAllDevices();
-                    System.Console.WriteLine();
-                    break;
-                }
-                // Open/close a device
-                case 'C':
-                    goto case 'c';
-                case 'c': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    System.Console.WriteLine("Would you like to open or close " + description + "?");
-                    System.Console.WriteLine("[1] Open\n[2] Close\n[3] Cancel\n");
-
-                    char option = GetCharInput(new List<char> { '1', '2', '3' });
-                    System.Console.WriteLine();
-
-                    switch(option) {
-                    case '1':
-                        // Attempt to open the selected device
-                        if(icsneocsharp.icsneo_openDevice(selectedDevice)) {
-                            System.Console.WriteLine(description + " successfully opened!\n");
-                        } else {
-                            System.Console.WriteLine(description + " failed to open!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-                        break;
-                    case '2':
-                        // Attempt to close the device
-                        if(icsneocsharp.icsneo_closeDevice(selectedDevice)) {
-                            numDevices--;
-                            System.Console.WriteLine("Successfully closed " + description + "!\n");
-                            devices.Remove(selectedDevice);
-                            selectedDevice = null;
-                        } else {
-                            System.Console.WriteLine("Failed to close " + description.ToString() + "!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-                        break;
-                    default:
-                        System.Console.WriteLine("Canceling!\n");
-                        break;
-                    }
-                    break;
-                }
-                // Go online/offline
-                case 'D':
-                    goto case 'd';
-                case 'd': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    System.Console.WriteLine("Would you like to have " + description.ToString() + " go online or offline?");
-                    System.Console.WriteLine("[1] Online\n[2] Offline\n[3] Cancel\n");
-
-                    char option = GetCharInput(new List<char> { '1', '2', '3' });
-                    System.Console.WriteLine();
-
-                    switch(option) {
-                    case '1':
-                        // Attempt to go online
-                        if(icsneocsharp.icsneo_goOnline(selectedDevice)) {
-                            System.Console.WriteLine(description + " successfully went online!\n");
-                        } else {
-                            System.Console.WriteLine(description + " failed to go online!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-                        break;
-                    case '2':
-                        // Attempt to go offline
-                        if(icsneocsharp.icsneo_goOffline(selectedDevice)) {
-                            System.Console.WriteLine(description + " successfully went offline!\n");
-                        } else {
-                            System.Console.WriteLine(description + " failed to go offline!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-                        break;
-                    default:
-                        System.Console.WriteLine("Canceling!\n");
-                        break;
-                    }
-                    break;
-                }
-                // Enable/disable message polling
-                case 'E':
-                    goto case 'e';
-                case 'e': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    System.Console.WriteLine("Would you like to enable or disable message polling for " + description.ToString() + "?");
-                    System.Console.WriteLine("[1] Enable\n[2] Disable\n[3] Cancel\n");
-
-                    char option = GetCharInput(new List<char> { '1', '2', '3' });
-                    System.Console.WriteLine();
-
-                    switch(option) {
-                    case '1':
-                        // Attempt to enable message polling
-                        if(icsneocsharp.icsneo_enableMessagePolling(selectedDevice)) {
-                            System.Console.WriteLine("Successfully enabled message polling for " + description.ToString() + "!\n");
-                        } else {
-                            System.Console.WriteLine("Failed to enable message polling for " + description.ToString() + "!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-
-                        // Manually setting the polling message limit as done below is optional
-                        // It will default to 20k if not set
-                        // Attempt to set the polling message limit
-                        if(icsneocsharp.icsneo_setPollingMessageLimit(selectedDevice, msgLimit)) {
-                            System.Console.WriteLine("Successfully set message polling limit for " + description.ToString() + "!\n");
-                        } else {
-                            System.Console.WriteLine("Failed to set polling message limit for " + description.ToString() + "!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-                        break;
-                    case '2':
-                        // Attempt to disable message polling
-                        if(icsneocsharp.icsneo_disableMessagePolling(selectedDevice)) {
-                            System.Console.WriteLine("Successfully disabled message polling for " + description.ToString() + "!\n");
-                        } else {
-                            System.Console.WriteLine("Failed to disable message polling for " + description.ToString() + "!\n");
-                            PrintLastError();
-                            System.Console.WriteLine();
-                        }
-                        break;
-                    default:
-                        System.Console.WriteLine("Canceling!\n");
-                        break;
-                    }
-                }
-                break;
-                case 'F':
-                    goto case 'f';
-                case 'f': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    // Prepare the neomessage_t array and size for reading in the messages
-                    neomessage_t msgs = icsneocsharp.new_neomessage_t_array((int)msgLimit);
-                    int msgCount = (int)msgLimit;
-
-                    if(!icsneocsharp.icsneo_getMessages(selectedDevice, msgs, ref msgCount, 0)) {
-                        System.Console.WriteLine("Failed to get messages for " + description.ToString() + "!\n");
-                        PrintLastError();
-                        icsneocsharp.delete_neomessage_t_array(msgs);
-                        System.Console.WriteLine();
-                        break;
-                    }
-
-                    if(msgCount == 1) {
-                        System.Console.WriteLine("1 message received from " + description.ToString() + "!");
-                    } else {
-                        System.Console.WriteLine(msgCount + " messages received from " + description.ToString() + "!");
-                    }
-
-                    // Print out the received messages
-                    for(int i = 0; i < msgCount; i++) {
-                        neomessage_t msg = icsneocsharp.neomessage_t_array_getitem(msgs, i);
-                        if(msg.type == icsneocsharp.ICSNEO_NETWORK_TYPE_CAN) {
-                            System.Console.Write("\t0x" + "{0:x}" + " [" + msg.length + "] ", icsneocsharp.neomessage_can_t_cast(msg).arbid);
-                            for(int j = 0; j < msg.length; j++) {
-                                System.Console.Write("{0:x} ", icsneocsharp.neomessage_can_t_cast(msg).data[j]);
-                            }
-                            System.Console.WriteLine("(" + msg.timestamp + ")");
-                        } else {
-                            if(msg.netid != 0)
-                                System.Console.WriteLine("\tMessage on netid " + msg.netid + " with length " + msg.length);
-                        }
-                    }
-                    icsneocsharp.delete_neomessage_t_array(msgs);
-                    break;
-                }
-                // Send message
-                case 'G':
-                    goto case 'g';
-                case 'g': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    // Start generating sample msg
-                    neomessage_can_t msg = new neomessage_can_t();
-                    msg.arbid = 0x120;
-                    msg.length = 6;
-                    msg.netid = (ushort)icsneocsharp.ICSNEO_NETID_HSCAN;
-                    msg.data = new byte[6] { 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
-                    msg.status.canfdFDF = 0;
-                    msg.status.extendedFrame = 0;
-                    msg.status.canfdBRS = 0;
-                    // End generating sample msg
-
-                    // Attempt to transmit the sample msg
-                    if(icsneocsharp.icsneo_transmit(selectedDevice, icsneocsharp.from_can_neomessage_t_cast(msg))) {
-                        System.Console.WriteLine("Message transmit successful!");
-                    } else {
-                        System.Console.WriteLine("Failed to transmit message to " + description.ToString() + "!\n");
-                        PrintLastError();
-                        System.Console.WriteLine();
-                    }
-                    break;
-                }
-                // Get events
-                case 'H':
-                    goto case 'h';
-                case 'h':
-                    PrintAPIEvents();
-                    System.Console.WriteLine();
-                    break;
-                // Set HS CAN to 250k
-                case 'I':
-                    goto case 'i';
-                case 'i': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    // Attempt to set baudrate and apply settings
-                    if(icsneocsharp.icsneo_setBaudrate(selectedDevice, (ushort)icsneocsharp.ICSNEO_NETID_HSCAN, 250000) && icsneocsharp.icsneo_settingsApply(selectedDevice)) {
-                        System.Console.WriteLine("Successfully set HS CAN baudrate for " + description.ToString() + "to 250k!\n");
-                    } else {
-                        System.Console.WriteLine("Failed to set HS CAN for " + description.ToString() + " to 250k!\n");
-                        PrintLastError();
-                        System.Console.WriteLine();
-                    }
-                    break;
-                }
-                // Set HS CAN to 500k
-                case 'J':
-                    goto case 'j';
-                case 'j': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.Console.WriteLine("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = SelectDevice();
-
-                    // Get the product description for the device
-                    System.Text.StringBuilder description = new System.Text.StringBuilder(icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int maxLength = icsneocsharp.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-
-                    icsneocsharp.icsneo_describeDevice(selectedDevice, description, ref maxLength);
-
-                    // Attempt to set baudrate and apply settings
-                    if(icsneocsharp.icsneo_setBaudrate(selectedDevice, (ushort)icsneocsharp.ICSNEO_NETID_HSCAN, 500000) && icsneocsharp.icsneo_settingsApply(selectedDevice)) {
-                        System.Console.WriteLine("Successfully set HS CAN baudrate for " + description.ToString() + "to 500k!\n");
-                    } else {
-                        System.Console.WriteLine("Failed to set HS CAN for " + description.ToString() + " to 500k!\n");
-                        PrintLastError();
-                        System.Console.WriteLine();
-                    }
-                    break;
-                }
-                case 'X':
-                    goto case 'x';
-                case 'x':
-                    System.Console.WriteLine("Exiting program");
-                    return;
-                default:
-                    System.Console.WriteLine("Unexpected input, exiting!");
-                    return;
-                }
-            }
-        }
-    }
-}

examples/csharp/Program.cs

@@ -1,8 +0,0 @@
-namespace libicsneocsharp_example {
-    class Program {
-        static void Main(string[] args) {
-            InteractiveExample example = new InteractiveExample();
-            example.Run();
-        }
-    }
-}

examples/csharp/README.md

@@ -1,57 +0,0 @@
-# libicsneo C# Example
-
-This is an example console application that uses the icsneocsharp library to control an Intrepid Control Systems hardware device.
-
-## Cloning
-
-This will create a copy of the repository on your local machine.
-
-Run:
-
-```shell
-git clone https://github.com/intrepidcs/libicsneo-examples --recursive
-```
-
-Alternatively, if you cloned without the `--recursive` flag, you must enter the `libicsneo-examples` folder and run the following:
-
-```shell
-git submodule update --recursive --init
-```
-
-If you haven't done this, `third-party/libicsneo` will be empty and you won't be able to build!
-
-## Windows using Visual Studio 2017+
-
-### Building the DLLs
-
-#### icsneoc
-
-First, we are going to build the icsneoc library into a .dll file that is used by the C# wrapper to access the library functions.
-
-1. Launch Visual Studio and open the `libicsneo-examples` folder.
-2. Choose `File->Open->Cmake...`
-3. Navigate to `third-party/libicsneo` and select the `CMakeLists.txt` there.
-4. Visual Studio will process the CMake project.
-5. Select `Build->Rebuild All`
-6. Visual Studio will generate the `icsneoc.dll` file, which can then be found by selecting `Project->Cmake Cache (x64-Debug Only)->Open in Explorer`. If the file cannot be found, search in `libicsneo-examples/third-party/libicsneo/out/build/x64-Debug` and double-check that the build succeeded in step 5.
-7. Move the `icsneoc.dll` file to the `/C/Windows/System32` folder.
-
-#### icsneocsharp
-
-Next, we are going to build the wrapper functions into a .dll file that is used to access the library functions in C#.
-
-1. Launch a terminal window and change directories into `libicsneo-examples/libicsneocsharp-example`, then create a build directory by running `mkdir -p build`
-2. Enter the build directory with `cd build`
-3. Run `cmake ..`
-4. Run `cmake --build .`
-5. The `icsneocsharp.dll` file will be generated in `libicsneo-examples/libicsneocsharp-example/build/Debug`
-6. Move the `icsneocsharp.dll` file to the `/C/Windows/System32` folder.
-
-### Building the example program
-
-1. Choose `File->Open->Project/Solution...`
-2. Navigate to `libicsneo-examples/libicsneocsharp-example` and select the `libicsneocsharp-example.sln` there.
-3. Visual Studio will process the project.
-4. Select `Build->Rebuild Solution`
-5. Click on the dropdown arrow attached to the green play button (labelled "Select Startup Item") and select `libicsneocsharp-example`
-6. Click on the green play button to run the example.

examples/csharp/SWIGTYPE_p_time_t.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class SWIGTYPE_p_time_t {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_time_t(global::System.IntPtr cPtr, bool futureUse) {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_time_t() {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_time_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-}

examples/csharp/SWIGTYPE_p_unsigned_char.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class SWIGTYPE_p_unsigned_char {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_unsigned_char(global::System.IntPtr cPtr, bool futureUse) {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_unsigned_char() {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_unsigned_char obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-}

examples/csharp/SWIGTYPE_p_unsigned_int.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class SWIGTYPE_p_unsigned_int {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_unsigned_int(global::System.IntPtr cPtr, bool futureUse) {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_unsigned_int() {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_unsigned_int obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-}

examples/csharp/SWIGTYPE_p_unsigned_short.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class SWIGTYPE_p_unsigned_short {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_unsigned_short(global::System.IntPtr cPtr, bool futureUse) {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_unsigned_short() {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_unsigned_short obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-}

examples/csharp/SWIGTYPE_p_void.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class SWIGTYPE_p_void {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_void(global::System.IntPtr cPtr, bool futureUse) {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_void() {
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SWIGTYPE_p_void obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-}

examples/csharp/csharp.i

@@ -1,76 +0,0 @@
-%module icsneocsharp
-%include <windows.i>
-%include <typemaps.i>
-%include <stdint.i>
-%include <carrays.i>
-%include <arrays_csharp.i>
-
-#define DLLExport
-
-%typemap(ctype) uint8_t const *data "unsigned char *"
-%typemap(imtype, out="System.IntPtr") uint8_t const *data "byte[]"
-%typemap(cstype) uint8_t const *data "byte[]"
-
-%typemap(in) uint8_t const *data %{
-	$1 = $input;
-%}
-
-%typemap(csvarin) uint8_t const *data %{
-	set {
-		icsneocsharpPINVOKE.$csclazznamedata_set(swigCPtr, value);
-	}
-%}
-
-%typemap(csvarout, excode=SWIGEXCODE2) uint8_t const *data %{
-	get {
-		byte[] ret = new byte[this.length];
-        System.IntPtr data = $imcall;
-        System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length)$excode;
-		return ret;
-	}
-%}
-
-%typemap(ctype) char *str "char *"
-%typemap(imtype) char *str "System.Text.StringBuilder"
-%typemap(cstype) char *str "System.Text.StringBuilder"
-
-%{
-#include "icsneo/icsneoc.h"
-%}
-
-%apply int *INOUT {size_t *};
-
-%ignore icsneo_addMessageCallback;
-%ignore icsneo_removeMessageCallback;
-%ignore icsneo_addEventCallback;
-%ignore icsneo_removeEventCallback;
-
-%include "icsneo/icsneoc.h"
-%include "icsneo/device/neodevice.h"
-%include "icsneo/communication/message/neomessage.h"
-%include "icsneo/device/devicetype.h"
-%include "icsneo/api/version.h"
-%include "icsneo/api/event.h"
-%include "icsneo/communication/network.h"
-
-%inline %{
-static neomessage_can_t* neomessage_can_t_cast(neomessage_t* msg) {
-	return (neomessage_can_t*) msg;
-}
-
-static neomessage_eth_t* neomessage_eth_t_cast(neomessage_t* msg) {
-	return (neomessage_eth_t*) msg;
-}
-
-static neomessage_t* from_can_neomessage_t_cast(neomessage_can_t* msg) {
-	return (neomessage_t*) msg;
-}
-
-static neomessage_t* from_eth_neomessage_t_cast(neomessage_eth_t* msg) {
-	return (neomessage_t*) msg;
-}
-%}
-
-%array_functions(neodevice_t, neodevice_t_array);
-%array_functions(neoevent_t, neoevent_t_array);
-%array_functions(neomessage_t, neomessage_t_array);

examples/csharp/icsneocsharp.cs

@@ -1,425 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class icsneocsharp {
-  public static void icsneo_findAllDevices(neodevice_t devices, ref int count) {
-    icsneocsharpPINVOKE.icsneo_findAllDevices(neodevice_t.getCPtr(devices), ref count);
-  }
-
-  public static void icsneo_freeUnconnectedDevices() {
-    icsneocsharpPINVOKE.icsneo_freeUnconnectedDevices();
-  }
-
-  public static bool icsneo_serialNumToString(uint num, System.Text.StringBuilder str, ref int count) {
-    bool ret = icsneocsharpPINVOKE.icsneo_serialNumToString(num, str, ref count);
-    return ret;
-  }
-
-  public static uint icsneo_serialStringToNum(System.Text.StringBuilder str) {
-    uint ret = icsneocsharpPINVOKE.icsneo_serialStringToNum(str);
-    return ret;
-  }
-
-  public static bool icsneo_isValidNeoDevice(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_isValidNeoDevice(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_openDevice(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_openDevice(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_closeDevice(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_closeDevice(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_isOpen(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_isOpen(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_goOnline(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_goOnline(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_goOffline(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_goOffline(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_isOnline(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_isOnline(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_enableMessagePolling(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_enableMessagePolling(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_disableMessagePolling(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_disableMessagePolling(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_isMessagePollingEnabled(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_isMessagePollingEnabled(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_getMessages(neodevice_t device, neomessage_t messages, ref int items, ulong timeout) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getMessages(neodevice_t.getCPtr(device), neomessage_t.getCPtr(messages), ref items, timeout);
-    return ret;
-  }
-
-  public static uint icsneo_getPollingMessageLimit(neodevice_t device) {
-    uint ret = icsneocsharpPINVOKE.icsneo_getPollingMessageLimit(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_setPollingMessageLimit(neodevice_t device, uint newLimit) {
-    bool ret = icsneocsharpPINVOKE.icsneo_setPollingMessageLimit(neodevice_t.getCPtr(device), newLimit);
-    return ret;
-  }
-
-  public static bool icsneo_getProductName(neodevice_t device, System.Text.StringBuilder str, ref int maxLength) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getProductName(neodevice_t.getCPtr(device), str, ref maxLength);
-    return ret;
-  }
-
-  public static bool icsneo_getProductNameForType(uint type, System.Text.StringBuilder str, ref int maxLength) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getProductNameForType(type, str, ref maxLength);
-    return ret;
-  }
-
-  public static bool icsneo_settingsRefresh(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsRefresh(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_settingsApply(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsApply(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_settingsApplyTemporary(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsApplyTemporary(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_settingsApplyDefaults(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsApplyDefaults(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static bool icsneo_settingsApplyDefaultsTemporary(neodevice_t device) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsApplyDefaultsTemporary(neodevice_t.getCPtr(device));
-    return ret;
-  }
-
-  public static int icsneo_settingsReadStructure(neodevice_t device, SWIGTYPE_p_void structure, uint structureSize) {
-    int ret = icsneocsharpPINVOKE.icsneo_settingsReadStructure(neodevice_t.getCPtr(device), SWIGTYPE_p_void.getCPtr(structure), structureSize);
-    return ret;
-  }
-
-  public static bool icsneo_settingsApplyStructure(neodevice_t device, SWIGTYPE_p_void structure, uint structureSize) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsApplyStructure(neodevice_t.getCPtr(device), SWIGTYPE_p_void.getCPtr(structure), structureSize);
-    return ret;
-  }
-
-  public static bool icsneo_settingsApplyStructureTemporary(neodevice_t device, SWIGTYPE_p_void structure, uint structureSize) {
-    bool ret = icsneocsharpPINVOKE.icsneo_settingsApplyStructureTemporary(neodevice_t.getCPtr(device), SWIGTYPE_p_void.getCPtr(structure), structureSize);
-    return ret;
-  }
-
-  public static long icsneo_getBaudrate(neodevice_t device, ushort netid) {
-    long ret = icsneocsharpPINVOKE.icsneo_getBaudrate(neodevice_t.getCPtr(device), netid);
-    return ret;
-  }
-
-  public static bool icsneo_setBaudrate(neodevice_t device, ushort netid, long newBaudrate) {
-    bool ret = icsneocsharpPINVOKE.icsneo_setBaudrate(neodevice_t.getCPtr(device), netid, newBaudrate);
-    return ret;
-  }
-
-  public static long icsneo_getFDBaudrate(neodevice_t device, ushort netid) {
-    long ret = icsneocsharpPINVOKE.icsneo_getFDBaudrate(neodevice_t.getCPtr(device), netid);
-    return ret;
-  }
-
-  public static bool icsneo_setFDBaudrate(neodevice_t device, ushort netid, long newBaudrate) {
-    bool ret = icsneocsharpPINVOKE.icsneo_setFDBaudrate(neodevice_t.getCPtr(device), netid, newBaudrate);
-    return ret;
-  }
-
-  public static bool icsneo_transmit(neodevice_t device, neomessage_t message) {
-    bool ret = icsneocsharpPINVOKE.icsneo_transmit(neodevice_t.getCPtr(device), neomessage_t.getCPtr(message));
-    return ret;
-  }
-
-  public static bool icsneo_transmitMessages(neodevice_t device, neomessage_t messages, uint count) {
-    bool ret = icsneocsharpPINVOKE.icsneo_transmitMessages(neodevice_t.getCPtr(device), neomessage_t.getCPtr(messages), count);
-    return ret;
-  }
-
-  public static void icsneo_setWriteBlocks(neodevice_t device, bool blocks) {
-    icsneocsharpPINVOKE.icsneo_setWriteBlocks(neodevice_t.getCPtr(device), blocks);
-  }
-
-  public static bool icsneo_describeDevice(neodevice_t device, System.Text.StringBuilder str, ref int maxLength) {
-    bool ret = icsneocsharpPINVOKE.icsneo_describeDevice(neodevice_t.getCPtr(device), str, ref maxLength);
-    return ret;
-  }
-
-  public static neoversion_t icsneo_getVersion() {
-    neoversion_t ret = new neoversion_t(icsneocsharpPINVOKE.icsneo_getVersion(), true);
-    return ret;
-  }
-
-  public static bool icsneo_getEvents(neoevent_t events, ref int size) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getEvents(neoevent_t.getCPtr(events), ref size);
-    return ret;
-  }
-
-  public static bool icsneo_getDeviceEvents(neodevice_t device, neoevent_t events, ref int size) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getDeviceEvents(neodevice_t.getCPtr(device), neoevent_t.getCPtr(events), ref size);
-    return ret;
-  }
-
-  public static bool icsneo_getLastError(neoevent_t error) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getLastError(neoevent_t.getCPtr(error));
-    return ret;
-  }
-
-  public static void icsneo_discardAllEvents() {
-    icsneocsharpPINVOKE.icsneo_discardAllEvents();
-  }
-
-  public static void icsneo_discardDeviceEvents(neodevice_t device) {
-    icsneocsharpPINVOKE.icsneo_discardDeviceEvents(neodevice_t.getCPtr(device));
-  }
-
-  public static void icsneo_setEventLimit(uint newLimit) {
-    icsneocsharpPINVOKE.icsneo_setEventLimit(newLimit);
-  }
-
-  public static uint icsneo_getEventLimit() {
-    uint ret = icsneocsharpPINVOKE.icsneo_getEventLimit();
-    return ret;
-  }
-
-  public static bool icsneo_getSupportedDevices(SWIGTYPE_p_unsigned_int devices, ref int count) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getSupportedDevices(SWIGTYPE_p_unsigned_int.getCPtr(devices), ref count);
-    return ret;
-  }
-
-  public static bool icsneo_getTimestampResolution(neodevice_t device, SWIGTYPE_p_unsigned_short resolution) {
-    bool ret = icsneocsharpPINVOKE.icsneo_getTimestampResolution(neodevice_t.getCPtr(device), SWIGTYPE_p_unsigned_short.getCPtr(resolution));
-    return ret;
-  }
-
-  public static neomessage_can_t neomessage_can_t_cast(neomessage_t msg) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_cast(neomessage_t.getCPtr(msg));
-    neomessage_can_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_can_t(cPtr, false);
-    return ret;
-  }
-
-  public static neomessage_eth_t neomessage_eth_t_cast(neomessage_t msg) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_cast(neomessage_t.getCPtr(msg));
-    neomessage_eth_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_eth_t(cPtr, false);
-    return ret;
-  }
-
-  public static neomessage_t from_can_neomessage_t_cast(neomessage_can_t msg) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.from_can_neomessage_t_cast(neomessage_can_t.getCPtr(msg));
-    neomessage_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_t(cPtr, false);
-    return ret;
-  }
-
-  public static neomessage_t from_eth_neomessage_t_cast(neomessage_eth_t msg) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.from_eth_neomessage_t_cast(neomessage_eth_t.getCPtr(msg));
-    neomessage_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_t(cPtr, false);
-    return ret;
-  }
-
-  public static neodevice_t new_neodevice_t_array(int nelements) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.new_neodevice_t_array(nelements);
-    neodevice_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neodevice_t(cPtr, false);
-    return ret;
-  }
-
-  public static void delete_neodevice_t_array(neodevice_t ary) {
-    icsneocsharpPINVOKE.delete_neodevice_t_array(neodevice_t.getCPtr(ary));
-  }
-
-  public static neodevice_t neodevice_t_array_getitem(neodevice_t ary, int index) {
-    neodevice_t ret = new neodevice_t(icsneocsharpPINVOKE.neodevice_t_array_getitem(neodevice_t.getCPtr(ary), index), true);
-    return ret;
-  }
-
-  public static void neodevice_t_array_setitem(neodevice_t ary, int index, neodevice_t value) {
-    icsneocsharpPINVOKE.neodevice_t_array_setitem(neodevice_t.getCPtr(ary), index, neodevice_t.getCPtr(value));
-    if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static neoevent_t new_neoevent_t_array(int nelements) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.new_neoevent_t_array(nelements);
-    neoevent_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neoevent_t(cPtr, false);
-    return ret;
-  }
-
-  public static void delete_neoevent_t_array(neoevent_t ary) {
-    icsneocsharpPINVOKE.delete_neoevent_t_array(neoevent_t.getCPtr(ary));
-  }
-
-  public static neoevent_t neoevent_t_array_getitem(neoevent_t ary, int index) {
-    neoevent_t ret = new neoevent_t(icsneocsharpPINVOKE.neoevent_t_array_getitem(neoevent_t.getCPtr(ary), index), true);
-    return ret;
-  }
-
-  public static void neoevent_t_array_setitem(neoevent_t ary, int index, neoevent_t value) {
-    icsneocsharpPINVOKE.neoevent_t_array_setitem(neoevent_t.getCPtr(ary), index, neoevent_t.getCPtr(value));
-    if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static neomessage_t new_neomessage_t_array(int nelements) {
-    global::System.IntPtr cPtr = icsneocsharpPINVOKE.new_neomessage_t_array(nelements);
-    neomessage_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_t(cPtr, false);
-    return ret;
-  }
-
-  public static void delete_neomessage_t_array(neomessage_t ary) {
-    icsneocsharpPINVOKE.delete_neomessage_t_array(neomessage_t.getCPtr(ary));
-  }
-
-  public static neomessage_t neomessage_t_array_getitem(neomessage_t ary, int index) {
-    neomessage_t ret = new neomessage_t(icsneocsharpPINVOKE.neomessage_t_array_getitem(neomessage_t.getCPtr(ary), index), true);
-    return ret;
-  }
-
-  public static void neomessage_t_array_setitem(neomessage_t ary, int index, neomessage_t value) {
-    icsneocsharpPINVOKE.neomessage_t_array_setitem(neomessage_t.getCPtr(ary), index, neomessage_t.getCPtr(value));
-    if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static readonly int ICSNEO_DEVICETYPE_LONGEST_NAME = icsneocsharpPINVOKE.ICSNEO_DEVICETYPE_LONGEST_NAME_get();
-  public static readonly int ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION = icsneocsharpPINVOKE.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION_get();
-  public static readonly int ICSNEO_NETID_DEVICE = icsneocsharpPINVOKE.ICSNEO_NETID_DEVICE_get();
-  public static readonly int ICSNEO_NETID_HSCAN = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN_get();
-  public static readonly int ICSNEO_NETID_MSCAN = icsneocsharpPINVOKE.ICSNEO_NETID_MSCAN_get();
-  public static readonly int ICSNEO_NETID_SWCAN = icsneocsharpPINVOKE.ICSNEO_NETID_SWCAN_get();
-  public static readonly int ICSNEO_NETID_LSFTCAN = icsneocsharpPINVOKE.ICSNEO_NETID_LSFTCAN_get();
-  public static readonly int ICSNEO_NETID_FORDSCP = icsneocsharpPINVOKE.ICSNEO_NETID_FORDSCP_get();
-  public static readonly int ICSNEO_NETID_J1708 = icsneocsharpPINVOKE.ICSNEO_NETID_J1708_get();
-  public static readonly int ICSNEO_NETID_AUX = icsneocsharpPINVOKE.ICSNEO_NETID_AUX_get();
-  public static readonly int ICSNEO_NETID_J1850VPW = icsneocsharpPINVOKE.ICSNEO_NETID_J1850VPW_get();
-  public static readonly int ICSNEO_NETID_ISO = icsneocsharpPINVOKE.ICSNEO_NETID_ISO_get();
-  public static readonly int ICSNEO_NETID_MAIN51 = icsneocsharpPINVOKE.ICSNEO_NETID_MAIN51_get();
-  public static readonly int ICSNEO_NETID_RED = icsneocsharpPINVOKE.ICSNEO_NETID_RED_get();
-  public static readonly int ICSNEO_NETID_SCI = icsneocsharpPINVOKE.ICSNEO_NETID_SCI_get();
-  public static readonly int ICSNEO_NETID_ISO2 = icsneocsharpPINVOKE.ICSNEO_NETID_ISO2_get();
-  public static readonly int ICSNEO_NETID_ISO14230 = icsneocsharpPINVOKE.ICSNEO_NETID_ISO14230_get();
-  public static readonly int ICSNEO_NETID_LIN = icsneocsharpPINVOKE.ICSNEO_NETID_LIN_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET1 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET1_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET2 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET2_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET3 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET3_get();
-  public static readonly int ICSNEO_NETID_RED_EXT_MEMORYREAD = icsneocsharpPINVOKE.ICSNEO_NETID_RED_EXT_MEMORYREAD_get();
-  public static readonly int ICSNEO_NETID_RED_INT_MEMORYREAD = icsneocsharpPINVOKE.ICSNEO_NETID_RED_INT_MEMORYREAD_get();
-  public static readonly int ICSNEO_NETID_RED_DFLASH_READ = icsneocsharpPINVOKE.ICSNEO_NETID_RED_DFLASH_READ_get();
-  public static readonly int ICSNEO_NETID_RED_SDCARD_READ = icsneocsharpPINVOKE.ICSNEO_NETID_RED_SDCARD_READ_get();
-  public static readonly int ICSNEO_NETID_CAN_ERRBITS = icsneocsharpPINVOKE.ICSNEO_NETID_CAN_ERRBITS_get();
-  public static readonly int ICSNEO_NETID_RED_DFLASH_WRITE_DONE = icsneocsharpPINVOKE.ICSNEO_NETID_RED_DFLASH_WRITE_DONE_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_CAN1_LOGICAL = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_CAN1_LOGICAL_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_CAN2_LOGICAL = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_CAN2_LOGICAL_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_LIN1_LOGICAL = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_LIN1_LOGICAL_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_LIN2_LOGICAL = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_LIN2_LOGICAL_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_LIN1_ANALOG = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_LIN1_ANALOG_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_LIN2_ANALOG = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_LIN2_ANALOG_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_MISC_ANALOG = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_MISC_ANALOG_get();
-  public static readonly int ICSNEO_NETID_RED_WAVE_MISCDIO2_LOGICAL = icsneocsharpPINVOKE.ICSNEO_NETID_RED_WAVE_MISCDIO2_LOGICAL_get();
-  public static readonly int ICSNEO_NETID_RED_NETWORK_COM_ENABLE_EX = icsneocsharpPINVOKE.ICSNEO_NETID_RED_NETWORK_COM_ENABLE_EX_get();
-  public static readonly int ICSNEO_NETID_RED_NEOVI_NETWORK = icsneocsharpPINVOKE.ICSNEO_NETID_RED_NEOVI_NETWORK_get();
-  public static readonly int ICSNEO_NETID_RED_READ_BAUD_SETTINGS = icsneocsharpPINVOKE.ICSNEO_NETID_RED_READ_BAUD_SETTINGS_get();
-  public static readonly int ICSNEO_NETID_RED_OLDFORMAT = icsneocsharpPINVOKE.ICSNEO_NETID_RED_OLDFORMAT_get();
-  public static readonly int ICSNEO_NETID_RED_SCOPE_CAPTURE = icsneocsharpPINVOKE.ICSNEO_NETID_RED_SCOPE_CAPTURE_get();
-  public static readonly int ICSNEO_NETID_RED_HARDWARE_EXCEP = icsneocsharpPINVOKE.ICSNEO_NETID_RED_HARDWARE_EXCEP_get();
-  public static readonly int ICSNEO_NETID_RED_GET_RTC = icsneocsharpPINVOKE.ICSNEO_NETID_RED_GET_RTC_get();
-  public static readonly int ICSNEO_NETID_ISO3 = icsneocsharpPINVOKE.ICSNEO_NETID_ISO3_get();
-  public static readonly int ICSNEO_NETID_HSCAN2 = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN2_get();
-  public static readonly int ICSNEO_NETID_HSCAN3 = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN3_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET4 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET4_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET5 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET5_get();
-  public static readonly int ICSNEO_NETID_ISO4 = icsneocsharpPINVOKE.ICSNEO_NETID_ISO4_get();
-  public static readonly int ICSNEO_NETID_LIN2 = icsneocsharpPINVOKE.ICSNEO_NETID_LIN2_get();
-  public static readonly int ICSNEO_NETID_LIN3 = icsneocsharpPINVOKE.ICSNEO_NETID_LIN3_get();
-  public static readonly int ICSNEO_NETID_LIN4 = icsneocsharpPINVOKE.ICSNEO_NETID_LIN4_get();
-  public static readonly int ICSNEO_NETID_RED_APP_ERROR = icsneocsharpPINVOKE.ICSNEO_NETID_RED_APP_ERROR_get();
-  public static readonly int ICSNEO_NETID_CGI = icsneocsharpPINVOKE.ICSNEO_NETID_CGI_get();
-  public static readonly int ICSNEO_NETID_RESET_STATUS = icsneocsharpPINVOKE.ICSNEO_NETID_RESET_STATUS_get();
-  public static readonly int ICSNEO_NETID_FB_STATUS = icsneocsharpPINVOKE.ICSNEO_NETID_FB_STATUS_get();
-  public static readonly int ICSNEO_NETID_APP_SIGNAL_STATUS = icsneocsharpPINVOKE.ICSNEO_NETID_APP_SIGNAL_STATUS_get();
-  public static readonly int ICSNEO_NETID_READ_DATALINK_CM_TX_MSG = icsneocsharpPINVOKE.ICSNEO_NETID_READ_DATALINK_CM_TX_MSG_get();
-  public static readonly int ICSNEO_NETID_READ_DATALINK_CM_RX_MSG = icsneocsharpPINVOKE.ICSNEO_NETID_READ_DATALINK_CM_RX_MSG_get();
-  public static readonly int ICSNEO_NETID_LOGGING_OVERFLOW = icsneocsharpPINVOKE.ICSNEO_NETID_LOGGING_OVERFLOW_get();
-  public static readonly int ICSNEO_NETID_READ_SETTINGS = icsneocsharpPINVOKE.ICSNEO_NETID_READ_SETTINGS_get();
-  public static readonly int ICSNEO_NETID_HSCAN4 = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN4_get();
-  public static readonly int ICSNEO_NETID_HSCAN5 = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN5_get();
-  public static readonly int ICSNEO_NETID_RS232 = icsneocsharpPINVOKE.ICSNEO_NETID_RS232_get();
-  public static readonly int ICSNEO_NETID_UART = icsneocsharpPINVOKE.ICSNEO_NETID_UART_get();
-  public static readonly int ICSNEO_NETID_UART2 = icsneocsharpPINVOKE.ICSNEO_NETID_UART2_get();
-  public static readonly int ICSNEO_NETID_UART3 = icsneocsharpPINVOKE.ICSNEO_NETID_UART3_get();
-  public static readonly int ICSNEO_NETID_UART4 = icsneocsharpPINVOKE.ICSNEO_NETID_UART4_get();
-  public static readonly int ICSNEO_NETID_SWCAN2 = icsneocsharpPINVOKE.ICSNEO_NETID_SWCAN2_get();
-  public static readonly int ICSNEO_NETID_ETHERNET_DAQ = icsneocsharpPINVOKE.ICSNEO_NETID_ETHERNET_DAQ_get();
-  public static readonly int ICSNEO_NETID_DATA_TO_HOST = icsneocsharpPINVOKE.ICSNEO_NETID_DATA_TO_HOST_get();
-  public static readonly int ICSNEO_NETID_TEXTAPI_TO_HOST = icsneocsharpPINVOKE.ICSNEO_NETID_TEXTAPI_TO_HOST_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET6 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET6_get();
-  public static readonly int ICSNEO_NETID_RED_VBAT = icsneocsharpPINVOKE.ICSNEO_NETID_RED_VBAT_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET7 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET7_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET8 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET8_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET9 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET9_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET10 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET10_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET11 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET11_get();
-  public static readonly int ICSNEO_NETID_FLEXRAY1A = icsneocsharpPINVOKE.ICSNEO_NETID_FLEXRAY1A_get();
-  public static readonly int ICSNEO_NETID_FLEXRAY1B = icsneocsharpPINVOKE.ICSNEO_NETID_FLEXRAY1B_get();
-  public static readonly int ICSNEO_NETID_FLEXRAY2A = icsneocsharpPINVOKE.ICSNEO_NETID_FLEXRAY2A_get();
-  public static readonly int ICSNEO_NETID_FLEXRAY2B = icsneocsharpPINVOKE.ICSNEO_NETID_FLEXRAY2B_get();
-  public static readonly int ICSNEO_NETID_LIN5 = icsneocsharpPINVOKE.ICSNEO_NETID_LIN5_get();
-  public static readonly int ICSNEO_NETID_FLEXRAY = icsneocsharpPINVOKE.ICSNEO_NETID_FLEXRAY_get();
-  public static readonly int ICSNEO_NETID_FLEXRAY2 = icsneocsharpPINVOKE.ICSNEO_NETID_FLEXRAY2_get();
-  public static readonly int ICSNEO_NETID_OP_ETHERNET12 = icsneocsharpPINVOKE.ICSNEO_NETID_OP_ETHERNET12_get();
-  public static readonly int ICSNEO_NETID_MOST25 = icsneocsharpPINVOKE.ICSNEO_NETID_MOST25_get();
-  public static readonly int ICSNEO_NETID_MOST50 = icsneocsharpPINVOKE.ICSNEO_NETID_MOST50_get();
-  public static readonly int ICSNEO_NETID_MOST150 = icsneocsharpPINVOKE.ICSNEO_NETID_MOST150_get();
-  public static readonly int ICSNEO_NETID_ETHERNET = icsneocsharpPINVOKE.ICSNEO_NETID_ETHERNET_get();
-  public static readonly int ICSNEO_NETID_GMFSA = icsneocsharpPINVOKE.ICSNEO_NETID_GMFSA_get();
-  public static readonly int ICSNEO_NETID_TCP = icsneocsharpPINVOKE.ICSNEO_NETID_TCP_get();
-  public static readonly int ICSNEO_NETID_HSCAN6 = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN6_get();
-  public static readonly int ICSNEO_NETID_HSCAN7 = icsneocsharpPINVOKE.ICSNEO_NETID_HSCAN7_get();
-  public static readonly int ICSNEO_NETID_LIN6 = icsneocsharpPINVOKE.ICSNEO_NETID_LIN6_get();
-  public static readonly int ICSNEO_NETID_LSFTCAN2 = icsneocsharpPINVOKE.ICSNEO_NETID_LSFTCAN2_get();
-  public static readonly int ICSNEO_NETID_HW_COM_LATENCY_TEST = icsneocsharpPINVOKE.ICSNEO_NETID_HW_COM_LATENCY_TEST_get();
-  public static readonly int ICSNEO_NETID_DEVICE_STATUS = icsneocsharpPINVOKE.ICSNEO_NETID_DEVICE_STATUS_get();
-  public static readonly int ICSNEO_NETID_ANY = icsneocsharpPINVOKE.ICSNEO_NETID_ANY_get();
-  public static readonly int ICSNEO_NETID_INVALID = icsneocsharpPINVOKE.ICSNEO_NETID_INVALID_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_INVALID = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_INVALID_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_INTERNAL = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_INTERNAL_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_CAN = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_CAN_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_LIN = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_LIN_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_FLEXRAY = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_FLEXRAY_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_MOST = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_MOST_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_ETHERNET = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_ETHERNET_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_ANY = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_ANY_get();
-  public static readonly int ICSNEO_NETWORK_TYPE_OTHER = icsneocsharpPINVOKE.ICSNEO_NETWORK_TYPE_OTHER_get();
-}

examples/csharp/libicsneocsharp-example.csproj

@@ -1,9 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
-    <RootNamespace>libicsneocsharp_example</RootNamespace>
-  </PropertyGroup>
-
-</Project>

examples/csharp/libicsneocsharp-example.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.28922.388
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "libicsneocsharp-example", "libicsneocsharp-example.csproj", "{391FCF02-39BB-4C81-AE99-6785A7EA13A1}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{391FCF02-39BB-4C81-AE99-6785A7EA13A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{391FCF02-39BB-4C81-AE99-6785A7EA13A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{391FCF02-39BB-4C81-AE99-6785A7EA13A1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{391FCF02-39BB-4C81-AE99-6785A7EA13A1}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {9610ED61-57FA-46BD-A071-DC7DB7BAC3A9}
-	EndGlobalSection
-EndGlobal

examples/csharp/neodevice_t.cs

@@ -1,90 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neodevice_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neodevice_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neodevice_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neodevice_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neodevice_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public SWIGTYPE_p_void device {
-    set {
-      icsneocsharpPINVOKE.neodevice_t_device_set(swigCPtr, SWIGTYPE_p_void.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neodevice_t_device_get(swigCPtr);
-      SWIGTYPE_p_void ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
-      return ret;
-    }
-  }
-
-  public int handle {
-    set {
-      icsneocsharpPINVOKE.neodevice_t_handle_set(swigCPtr, value);
-    }
-    get {
-      int ret = icsneocsharpPINVOKE.neodevice_t_handle_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint type {
-    set {
-      icsneocsharpPINVOKE.neodevice_t_type_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neodevice_t_type_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public string serial {
-    set {
-      icsneocsharpPINVOKE.neodevice_t_serial_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neodevice_t_serial_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public neodevice_t() : this(icsneocsharpPINVOKE.new_neodevice_t(), true) {
-  }
-
-}

examples/csharp/neoevent_t.cs

@@ -1,112 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neoevent_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neoevent_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neoevent_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neoevent_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neoevent_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public string description {
-    set {
-      icsneocsharpPINVOKE.neoevent_t_description_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neoevent_t_description_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_time_t timestamp {
-    set {
-      icsneocsharpPINVOKE.neoevent_t_timestamp_set(swigCPtr, SWIGTYPE_p_time_t.getCPtr(value));
-      if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
-    }
-    get {
-      SWIGTYPE_p_time_t ret = new SWIGTYPE_p_time_t(icsneocsharpPINVOKE.neoevent_t_timestamp_get(swigCPtr), true);
-      if (icsneocsharpPINVOKE.SWIGPendingException.Pending) throw icsneocsharpPINVOKE.SWIGPendingException.Retrieve();
-      return ret;
-    }
-  }
-
-  public uint eventNumber {
-    set {
-      icsneocsharpPINVOKE.neoevent_t_eventNumber_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neoevent_t_eventNumber_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte severity {
-    set {
-      icsneocsharpPINVOKE.neoevent_t_severity_set(swigCPtr, value);
-    }
-    get {
-      byte ret = icsneocsharpPINVOKE.neoevent_t_severity_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public string serial {
-    set {
-      icsneocsharpPINVOKE.neoevent_t_serial_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neoevent_t_serial_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_char reserved {
-    set {
-      icsneocsharpPINVOKE.neoevent_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neoevent_t_reserved_get(swigCPtr);
-      SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
-      return ret;
-    }
-  }
-
-  public neoevent_t() : this(icsneocsharpPINVOKE.new_neoevent_t(), true) {
-  }
-
-}

examples/csharp/neomessage_can_t.cs

@@ -1,155 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neomessage_can_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neomessage_can_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neomessage_can_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neomessage_can_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neomessage_can_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public neomessage_statusbitfield_t status {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_status_get(swigCPtr);
-      neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
-      return ret;
-    }
-  }
-
-  public ulong timestamp {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_timestamp_set(swigCPtr, value);
-    }
-    get {
-      ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestamp_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public ulong timestampReserved {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_set(swigCPtr, value);
-    }
-    get {
-      ulong ret = icsneocsharpPINVOKE.neomessage_can_t_timestampReserved_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte[] data {
-	set {
-		icsneocsharpPINVOKE.neomessage_can_t_data_set(swigCPtr, value);
-	}
-
-	get {
-		byte[] ret = new byte[this.length];
-        System.IntPtr data = icsneocsharpPINVOKE.neomessage_can_t_data_get(swigCPtr);
-        System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length);
-		return ret;
-	}
-
-  }
-
-  public uint length {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_length_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_can_t_length_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint arbid {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_arbid_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_can_t_arbid_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public ushort netid {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_netid_set(swigCPtr, value);
-    }
-    get {
-      ushort ret = icsneocsharpPINVOKE.neomessage_can_t_netid_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte type {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_type_set(swigCPtr, value);
-    }
-    get {
-      byte ret = icsneocsharpPINVOKE.neomessage_can_t_type_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte dlcOnWire {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_set(swigCPtr, value);
-    }
-    get {
-      byte ret = icsneocsharpPINVOKE.neomessage_can_t_dlcOnWire_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_char reserved {
-    set {
-      icsneocsharpPINVOKE.neomessage_can_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_can_t_reserved_get(swigCPtr);
-      SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
-      return ret;
-    }
-  }
-
-  public neomessage_can_t() : this(icsneocsharpPINVOKE.new_neomessage_can_t(), true) {
-  }
-
-}

examples/csharp/neomessage_eth_t.cs

@@ -1,156 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neomessage_eth_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neomessage_eth_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neomessage_eth_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neomessage_eth_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neomessage_eth_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public neomessage_statusbitfield_t status {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_status_get(swigCPtr);
-      neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
-      return ret;
-    }
-  }
-
-  public ulong timestamp {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_timestamp_set(swigCPtr, value);
-    }
-    get {
-      ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestamp_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public ulong timestampReserved {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_set(swigCPtr, value);
-    }
-    get {
-      ulong ret = icsneocsharpPINVOKE.neomessage_eth_t_timestampReserved_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte[] data {
-	set {
-		icsneocsharpPINVOKE.neomessage_eth_t_data_set(swigCPtr, value);
-	}
-
-	get {
-		byte[] ret = new byte[this.length];
-        System.IntPtr data = icsneocsharpPINVOKE.neomessage_eth_t_data_get(swigCPtr);
-        System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length);
-		return ret;
-	}
-
-  }
-
-  public uint length {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_length_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_eth_t_length_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte preemptionFlags {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_set(swigCPtr, value);
-    }
-    get {
-      byte ret = icsneocsharpPINVOKE.neomessage_eth_t_preemptionFlags_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_char reservedHeader {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_reservedHeader_get(swigCPtr);
-      SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
-      return ret;
-    }
-  }
-
-  public ushort netid {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_netid_set(swigCPtr, value);
-    }
-    get {
-      ushort ret = icsneocsharpPINVOKE.neomessage_eth_t_netid_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte type {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_type_set(swigCPtr, value);
-    }
-    get {
-      byte ret = icsneocsharpPINVOKE.neomessage_eth_t_type_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_char reserved {
-    set {
-      icsneocsharpPINVOKE.neomessage_eth_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_eth_t_reserved_get(swigCPtr);
-      SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
-      return ret;
-    }
-  }
-
-  public neomessage_eth_t() : this(icsneocsharpPINVOKE.new_neomessage_eth_t(), true) {
-  }
-
-}

examples/csharp/neomessage_statusbitfield_t.cs

@@ -1,610 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neomessage_statusbitfield_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neomessage_statusbitfield_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neomessage_statusbitfield_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neomessage_statusbitfield_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neomessage_statusbitfield_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public uint globalError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint transmitMessage {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_transmitMessage_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint extendedFrame {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extendedFrame_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint remoteFrame {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_remoteFrame_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint crcError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_crcError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canErrorPassive {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorPassive_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint incompleteFrame {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incompleteFrame_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint lostArbitration {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_lostArbitration_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint undefinedError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_undefinedError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canBusOff {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusOff_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canErrorWarning {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canErrorWarning_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canBusShortedPlus {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedPlus_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canBusShortedGround {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canBusShortedGround_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint checksumError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_checksumError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint badMessageBitTimeError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_badMessageBitTimeError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint ifrData {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_ifrData_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint hardwareCommError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hardwareCommError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint expectedLengthError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_expectedLengthError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint incomingNoMatch {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_incomingNoMatch_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint statusBreak {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBreak_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint avsiRecOverflow {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_avsiRecOverflow_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint testTrigger {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_testTrigger_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint audioComment {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_audioComment_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint gpsData {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_gpsData_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint analogDigitalInput {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_analogDigitalInput_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint textComment {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_textComment_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint networkMessageType {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_networkMessageType_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint vsiTXUnderrun {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiTXUnderrun_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint vsiIFRCRCBit {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_vsiIFRCRCBit_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint initMessage {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_initMessage_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint flexraySecondStartupFrame {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_flexraySecondStartupFrame_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint extended {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_extended_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint hasValue {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_hasValue_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint valueIsBoolean {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_valueIsBoolean_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint highVoltage {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_highVoltage_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint longMessage {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_longMessage_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint globalChange {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_globalChange_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint errorFrame {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_errorFrame_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint endOfLongMessage {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_endOfLongMessage_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linErrorRXBreakNotZero {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakNotZero_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linErrorRXBreakTooShort {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXBreakTooShort_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linErrorRXSyncNot55 {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXSyncNot55_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linErrorRXDataGreaterEight {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linErrorTXRXMismatch {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorTXRXMismatch_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linErrorMessageIDParity {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linErrorMessageIDParity_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linSyncFrameError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSyncFrameError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linIDFrameError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linIDFrameError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linSlaveByteError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linSlaveByteError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint rxTimeoutError {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_rxTimeoutError_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint linNoSlaveData {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_linNoSlaveData_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canfdESI {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdESI_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canfdIDE {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdIDE_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canfdRTR {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdRTR_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canfdFDF {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdFDF_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public uint canfdBRS {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_statusbitfield_t_canfdBRS_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_int statusBitfield {
-    set {
-      icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_statusbitfield_t_statusBitfield_get(swigCPtr);
-      SWIGTYPE_p_unsigned_int ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
-      return ret;
-    }
-  }
-
-  public neomessage_statusbitfield_t() : this(icsneocsharpPINVOKE.new_neomessage_statusbitfield_t(), true) {
-  }
-
-}

examples/csharp/neomessage_t.cs

@@ -1,146 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neomessage_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neomessage_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neomessage_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neomessage_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neomessage_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public neomessage_statusbitfield_t status {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_status_set(swigCPtr, neomessage_statusbitfield_t.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_status_get(swigCPtr);
-      neomessage_statusbitfield_t ret = (cPtr == global::System.IntPtr.Zero) ? null : new neomessage_statusbitfield_t(cPtr, false);
-      return ret;
-    }
-  }
-
-  public ulong timestamp {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_timestamp_set(swigCPtr, value);
-    }
-    get {
-      ulong ret = icsneocsharpPINVOKE.neomessage_t_timestamp_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public ulong timestampReserved {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_timestampReserved_set(swigCPtr, value);
-    }
-    get {
-      ulong ret = icsneocsharpPINVOKE.neomessage_t_timestampReserved_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte[] data {
-	set {
-		icsneocsharpPINVOKE.neomessage_t_data_set(swigCPtr, value);
-	}
-
-	get {
-		byte[] ret = new byte[this.length];
-        System.IntPtr data = icsneocsharpPINVOKE.neomessage_t_data_get(swigCPtr);
-        System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.length);
-		return ret;
-	}
-
-  }
-
-  public uint length {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_length_set(swigCPtr, value);
-    }
-    get {
-      uint ret = icsneocsharpPINVOKE.neomessage_t_length_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_char header {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_header_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_header_get(swigCPtr);
-      SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
-      return ret;
-    }
-  }
-
-  public ushort netid {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_netid_set(swigCPtr, value);
-    }
-    get {
-      ushort ret = icsneocsharpPINVOKE.neomessage_t_netid_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public byte type {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_type_set(swigCPtr, value);
-    }
-    get {
-      byte ret = icsneocsharpPINVOKE.neomessage_t_type_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public SWIGTYPE_p_unsigned_char reserved {
-    set {
-      icsneocsharpPINVOKE.neomessage_t_reserved_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
-    }
-    get {
-      global::System.IntPtr cPtr = icsneocsharpPINVOKE.neomessage_t_reserved_get(swigCPtr);
-      SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
-      return ret;
-    }
-  }
-
-  public neomessage_t() : this(icsneocsharpPINVOKE.new_neomessage_t(), true) {
-  }
-
-}

examples/csharp/neoversion_t.cs

@@ -1,119 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 4.0.0
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-
-public class neoversion_t : global::System.IDisposable {
-  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal neoversion_t(global::System.IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
-  }
-
-  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(neoversion_t obj) {
-    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~neoversion_t() {
-    Dispose(false);
-  }
-
-  public void Dispose() {
-    Dispose(true);
-    global::System.GC.SuppressFinalize(this);
-  }
-
-  protected virtual void Dispose(bool disposing) {
-    lock(this) {
-      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          icsneocsharpPINVOKE.delete_neoversion_t(swigCPtr);
-        }
-        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
-      }
-    }
-  }
-
-  public ushort major {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_major_set(swigCPtr, value);
-    }
-    get {
-      ushort ret = icsneocsharpPINVOKE.neoversion_t_major_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public ushort minor {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_minor_set(swigCPtr, value);
-    }
-    get {
-      ushort ret = icsneocsharpPINVOKE.neoversion_t_minor_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public ushort patch {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_patch_set(swigCPtr, value);
-    }
-    get {
-      ushort ret = icsneocsharpPINVOKE.neoversion_t_patch_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public string metadata {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_metadata_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neoversion_t_metadata_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public string buildBranch {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_buildBranch_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neoversion_t_buildBranch_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public string buildTag {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_buildTag_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neoversion_t_buildTag_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public string reserved {
-    set {
-      icsneocsharpPINVOKE.neoversion_t_reserved_set(swigCPtr, value);
-    }
-    get {
-      string ret = icsneocsharpPINVOKE.neoversion_t_reserved_get(swigCPtr);
-      return ret;
-    }
-  }
-
-  public neoversion_t() : this(icsneocsharpPINVOKE.new_neoversion_t(), true) {
-  }
-
-}

examples/java/CMakeLists.txt

@@ -1,13 +0,0 @@
-cmake_minimum_required(VERSION 3.2)
-project(icsneojava VERSION 0.2.0)
-
-find_package(Java REQUIRED)
-find_package(JNI REQUIRED)
-
-include(UseJava)
-include_directories(${JNI_INCLUDE_DIRS})
-
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../third-party/libicsneo ${CMAKE_CURRENT_BINARY_DIR}/third-party/libicsneo)
-
-add_library(icsneojava SHARED ${CMAKE_CURRENT_SOURCE_DIR}/java_wrap.c)
-target_link_libraries(icsneojava icsneoc)

examples/java/README.md

@@ -1,91 +0,0 @@
-# libicsneo Java Example
-
-This is an example console application which uses icsneojava to connect to an Intrepid Control Systems hardware device. It has both interactive and simple examples for sending and receiving CAN & CAN FD traffic.
-
-## Cloning
-
-This will create a copy of the repository on your local machine.
-
-Run:
-
-```shell
-git clone https://github.com/intrepidcs/libicsneo-examples -b v0.2.0-dev --recursive
-```
-
-Alternatively, if you cloned without the `--recursive flag`, you must enter the `libicsneo-examples` folder and run the following:
-
-```shell
-git submodule update --recursive --init
-```
-
-If you haven't done this, `third-party/libicsneo` will be empty and you won't be able to build!
-
-## Windows
-
-### Building the DLL's
-
-#### icsneoc
-
-First, we are going to build the icsneoc library into a .dll file that is used by the Java wrapper to access the library functions.
-
-1. Change directories to the `libicsneo-examples/third-party/libicsneo` folder.
-2. Create a build directory by running `mkdir -p build`
-3. Enter the build directory with `cd build`
-4. Run `cmake ..` to generate your Makefile.
-    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
-5. Run `cmake --build .` to build the library.
-    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. The `icsneoc.dll` file will be generated in `libicsneo-examples/third-party/libicsneo/build/Debug`. Move this file to the `/C/Windows/System32` folder.
-
-#### icsneojava
-
-Next, we are going to build the wrapper functions into a .dll file that is used to access the library functions in Java.
-
-1. Change directories to the `libicsneo-examples/libicsneojava-example` folder.
-2. Create a build directory by running `mkdir -p build`
-3. Enter the build directory with `cd build`
-4. Run `cmake ..` to generate your Makefile.
-    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
-5. Run `cmake --build .` to build the library.
-    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. The `icsneojava.dll` file will be generated in `libicsneo-examples/libicsneojava-example/build/Debug`. Move this file to the `/C/Windows/System32` folder.
-
-### Building and running the example program
-
-1. Change directories to the `libicsneo-examples/libicsneojava-example/src` folder.
-2. Run `javac Run.java`
-3. Run `java Run`
-
-## Ubuntu 18.04 LTS
-
-### Building the .so's
-
-#### icsneoc
-
-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libusb-1.0-0-dev libpcap0.8-dev`
-2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
-3. Enter the build directory with `cd build`
-4. Run `cmake ..` to generate your Makefile.
-    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
-5. Run `make` to build the library.
-    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo cp libicsneoc.so /usr/lib` so that it can be found via the default ubuntu .so search path. For more information, see the [ld.so.8 man page](http://man7.org/linux/man-pages/man8/ld.so.8.html).
-
-#### icsneojava
-
-Next, we are going to build the wrapper functions into a .so file that is used to access the library functions in Java.
-
-1. Change directories to the `libicsneo-examples/libicsneojava-example` folder.
-2. Create a build directory by running `mkdir -p build`
-3. Enter the build directory with `cd build`
-4. Run `cmake ..` to generate your Makefile.
-    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
-5. Run `cmake --build .` to build the library.
-    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. The `icsneojava.so` file will be generated in `libicsneo-examples/libicsneojava-example/build/Debug`. Run `sudo cp libicsneojava.so /usr/lib` so that it can be found via the default ubuntu .so search path. For more information, see the [ld.so.8 man page](http://man7.org/linux/man-pages/man8/ld.so.8.html).
-
-### Building and running the example program
-
-1. Change directories to the `libicsneo-examples/libicsneojava-example/src` folder.
-2. Run `javac Run.java`
-3. Run `java Run`

examples/java/java.i

@@ -1,125 +0,0 @@
-%module icsneojava
-%include <windows.i>
-%include <typemaps.i>
-%include <stdint.i>
-%include <carrays.i>
-%include <various.i>
-%include <java.i>
-%include <arrays_java.i>
-
-#define DLLExport
-
-%typemap(jni) uint8_t const *data "jbyteArray"
-%typemap(jtype) uint8_t const *data "byte[]"
-%typemap(jstype) uint8_t const *data "byte[]"
-%typemap(javain) uint8_t const *data "$javainput"
-
-%typemap(javaout) uint8_t const *data {
-    return $jnicall;
-}
-
-%typemap(out) uint8_t const *data %{
-    $result = (*jenv)->NewByteArray(jenv, (int) arg1->length);
-    (*jenv)->SetByteArrayRegion(jenv, $result, 0, (int) arg1->length, $1);
-%}
-
-%typemap(in) uint8_t const *data %{
-    bool isCopy;
-    arg2 = (*jenv)->GetByteArrayElements(jenv, jarg2, &isCopy);
-%}
-
-%typemap(jni) char *str "jobject"
-%typemap(jtype) char *str "StringBuffer"
-%typemap(jstype) char *str "StringBuffer"
-
-/* How to convert Java(JNI) type to requested C type */
-%typemap(in) char *str {
-
-  $1 = NULL;
-  if($input != NULL) {
-    /* Get the String from the StringBuffer */
-    jmethodID setLengthID;
-    jclass strClass = (*jenv)->GetObjectClass(jenv, $input);
-    jmethodID toStringID = (*jenv)->GetMethodID(jenv, strClass, "toString", "()Ljava/lang/String;");
-    jstring js = (jstring) (*jenv)->CallObjectMethod(jenv, $input, toStringID);
-
-    /* Convert the String to a C string */
-    const char *pCharStr = (*jenv)->GetStringUTFChars(jenv, js, 0);
-
-    /* Take a copy of the C string as the typemap is for a non const C string */
-    jmethodID capacityID = (*jenv)->GetMethodID(jenv, strClass, "capacity", "()I");
-    jint capacity = (*jenv)->CallIntMethod(jenv, $input, capacityID);
-    $1 = (char *) malloc(capacity+1);
-    strcpy($1, pCharStr);
-
-    /* Release the UTF string we obtained with GetStringUTFChars */
-    (*jenv)->ReleaseStringUTFChars(jenv,  js, pCharStr);
-
-    /* Zero the original StringBuffer, so we can replace it with the result */
-    setLengthID = (*jenv)->GetMethodID(jenv, strClass, "setLength", "(I)V");
-    (*jenv)->CallVoidMethod(jenv, $input, setLengthID, (jint) 0);
-  }
-}
-
-/* How to convert the C type to the Java(JNI) type */
-%typemap(argout) char *str {
-
-  if($1 != NULL) {
-    /* Append the result to the empty StringBuffer */
-    jstring newString = (*jenv)->NewStringUTF(jenv, $1);
-    jclass strClass = (*jenv)->GetObjectClass(jenv, $input);
-    jmethodID appendStringID = (*jenv)->GetMethodID(jenv, strClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");
-    (*jenv)->CallObjectMethod(jenv, $input, appendStringID, newString);
-
-    /* Clean up the string object, no longer needed */
-    free($1);
-    $1 = NULL;
-  }
-}
-
-/* Prevent the default freearg typemap from being used */
-%typemap(freearg) char *str ""
-
-/* Convert the jstype to jtype typemap type */
-%typemap(javain) char *str "$javainput"
-
-%{
-#include "icsneo/icsneoc.h"
-%}
-
-%apply int *INOUT {size_t *};
-
-%ignore icsneo_addMessageCallback;
-%ignore icsneo_removeMessageCallback;
-%ignore icsneo_addEventCallback;
-%ignore icsneo_removeEventCallback;
-
-%include "icsneo/icsneoc.h"
-%include "icsneo/device/neodevice.h"
-%include "icsneo/communication/message/neomessage.h"
-%include "icsneo/device/devicetype.h"
-%include "icsneo/api/version.h"
-%include "icsneo/api/event.h"
-%include "icsneo/communication/network.h"
-
-%inline %{
-static neomessage_can_t* neomessage_can_t_cast(neomessage_t* msg) {
-	return (neomessage_can_t*) msg;
-}
-
-static neomessage_eth_t* neomessage_eth_t_cast(neomessage_t* msg) {
-	return (neomessage_eth_t*) msg;
-}
-
-static neomessage_t* from_can_neomessage_t_cast(neomessage_can_t* msg) {
-	return (neomessage_t*) msg;
-}
-
-static neomessage_t* from_eth_neomessage_t_cast(neomessage_eth_t* msg) {
-	return (neomessage_t*) msg;
-}
-%}
-
-%array_functions(neodevice_t, neodevice_t_array);
-%array_functions(neoevent_t, neoevent_t_array);
-%array_functions(neomessage_t, neomessage_t_array);

examples/java/src/InteractiveExample.java

@@ -1,511 +0,0 @@
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Scanner;
-
-public class InteractiveExample {
-
-    private int msgLimit = 50000;
-    private neodevice_t selectedDevice;
-    private ArrayList<neodevice_t> devices = new ArrayList<neodevice_t>();
-    private int numDevices = 0;
-
-    private void printAllDevices() {
-        if(numDevices == 0) {
-            System.out.println("No devices found! Please scan for new devices.");
-        }
-
-        for(int i = 0; i < numDevices; i++) {
-            StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-            int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-            if(icsneojava.icsneo_describeDevice(devices.get(i), description, maxLength)) {
-                System.out.print("[" + (i + 1) + "] " + description + "\tConnected: ");
-
-                if(icsneojava.icsneo_isOpen(devices.get(i))) {
-                    System.out.print("Yes\t");
-                } else System.out.print("No\t");
-
-                System.out.print("Online: ");
-                if(icsneojava.icsneo_isOnline(devices.get(i))) {
-                    System.out.print("Yes\t");
-                } else System.out.print("No\t");
-
-                System.out.print("Msg Polling: ");
-                if(icsneojava.icsneo_isMessagePollingEnabled(devices.get(i))) {
-                    System.out.print("On\n");
-                } else System.out.print("Off\n");
-            } else {
-                System.out.println("Description for device " + (i + 1) + " not available!");
-            }
-        }
-    }
-
-    private int scanNewDevices() {
-        neodevice_t newDevices = icsneojava.new_neodevice_t_array(99);
-
-        int[] count = {10};
-
-        icsneojava.icsneo_findAllDevices(newDevices, count);
-
-        numDevices += count[0];
-
-        for(int i = 0; i < numDevices; i++) {
-            devices.add(icsneojava.neodevice_t_array_getitem(newDevices, i));
-        }
-
-        icsneojava.delete_neodevice_t_array(newDevices);
-        return count[0];
-    }
-
-    private void printMainMenu() {
-        System.out.println("Press the letter next to the function you want to use:");
-        System.out.println("A - List all devices");
-        System.out.println("B - Scan for new devices");
-        System.out.println("C - Open/close");
-        System.out.println("D - Go online/offline");
-        System.out.println("E - Enable/disable message polling");
-        System.out.println("F - Get messages");
-        System.out.println("G - Send message");
-        System.out.println("H - Get events");
-        System.out.println("I - Set HS CAN to 250K");
-        System.out.println("J - Set HS CAN to 500K");
-        System.out.println("X - Exit");
-    }
-
-    private void printLastError() {
-        neoevent_t error = new neoevent_t();
-        if(icsneojava.icsneo_getLastError(error))
-            System.out.println("Error 0x" + error.getEventNumber() + ": " + error.getDescription());
-        else
-            System.out.println("No errors found!");
-    }
-
-    private void printAPIEvents() {
-        neoevent_t events = icsneojava.new_neoevent_t_array(99);
-        int[] eventCount = {99};
-        if(icsneojava.icsneo_getEvents(events, eventCount)) {
-            if(eventCount[0] == 1) {
-                neoevent_t evt = icsneojava.neoevent_t_array_getitem(events, 0);
-                System.out.println("1 API event found!");
-                System.out.println("Event 0x" + evt.getEventNumber() + ": " + evt.getDescription());
-            } else {
-                System.out.println(eventCount[0] + " API events found!");
-                for(var i = 0; i < eventCount[0]; ++i) {
-                    neoevent_t evt = icsneojava.neoevent_t_array_getitem(events, i);
-                    System.out.println("Event 0x" + evt.getEventNumber() + ": " + evt.getDescription());
-                }
-            }
-        } else {
-            System.out.println("Failed to get API events!");
-        }
-        icsneojava.delete_neoevent_t_array(events);
-    }
-
-    private void printDeviceEvents(neodevice_t device) {
-        neoevent_t events = icsneojava.new_neoevent_t_array(99);
-        int[] eventCount = {99};
-        if(icsneojava.icsneo_getDeviceEvents(device, events, eventCount)) {
-             if(eventCount[0] == 1) {
-                neoevent_t evt = icsneojava.neoevent_t_array_getitem(events, 0);
-                System.out.println("1 device event found!");
-                System.out.println("Event 0x" + evt.getEventNumber() + ": " + evt.getDescription());
-            } else {
-                System.out.println(eventCount[0] + " device events found!");
-                for(int i = 0; i < eventCount[0]; ++i) {
-                    neoevent_t evt = icsneojava.neoevent_t_array_getitem(events, i);
-                    System.out.println("Event 0x" + evt.getEventNumber() + ": " + evt.getDescription());
-                }
-            }
-        } else {
-            System.out.println("Failed to get API events!");
-        }
-        icsneojava.delete_neoevent_t_array(events);
-    }
-
-    private char getCharInput(char[] allowed) {
-        boolean found = false;
-        char key = '0';
-        Scanner sc = new Scanner(System.in);
-        while(!found) {
-            key = sc.next().charAt(0);
-            System.out.println();
-            for(char compare : allowed) {
-                if(compare == key) {
-                    found = true;
-                    break;
-                }
-            }
-
-            if(!found) {
-                System.out.println("Input did not match expected options. Please try again.");
-            }
-        }
-        return key;
-    }
-
-    private neodevice_t selectDevice() {
-        System.out.println("Please select a device:");
-        printAllDevices();
-        System.out.println();
-
-        int selectedDeviceNum = 10;
-        while(selectedDeviceNum > numDevices) {
-            char deviceSelection = getCharInput(new char[] { '1', '2', '3', '4', '5', '6', '7', '8', '9' });
-            selectedDeviceNum = deviceSelection - '0';
-            if(selectedDeviceNum > numDevices) {
-                System.out.println("Selected device out of range!");
-            }
-        }
-
-        System.out.println();
-
-        return devices.get(selectedDeviceNum - 1);
-    }
-
-    public void run() {
-        neoversion_t version = icsneojava.icsneo_getVersion();
-        System.out.println("ICS libicsneojava.dll version " + version.getMajor() + "." + version.getMinor() + "." + version.getPatch());
-        System.out.println();
-
-        while(true) {
-            printMainMenu();
-            System.out.println();
-            char input = getCharInput(new char[] { 'A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'X', 'x' });
-            System.out.println();
-            switch(input) {
-                // List current devices
-                case 'A':
-                case 'a':
-                    printAllDevices();
-                    System.out.println();
-                    break;
-                // Scan for new devices
-                case 'B':
-                case 'b': {
-                    var numNewDevices = scanNewDevices();
-                    if(numNewDevices == 1) {
-                        System.out.println("1 new device found!");
-                    } else {
-                        System.out.println(numNewDevices + " new devices found!");
-                    }
-                    printAllDevices();
-                    System.out.println();
-                    break;
-                }
-                // Open/close a device
-                case 'C':
-                case 'c': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    System.out.println("Would you like to open or close " + description + "?");
-                    System.out.println("[1] Open\n[2] Close\n[3] Cancel\n");
-
-                    char option = getCharInput(new char[] { '1', '2', '3' });
-                    System.out.println();
-
-                    switch(option) {
-                        case '1':
-                            // Attempt to open the selected device
-                            if(icsneojava.icsneo_openDevice(selectedDevice)) {
-                                System.out.println(description + " successfully opened!\n");
-                            } else {
-                                System.out.println(description + " failed to open!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-                            break;
-                        case '2':
-                            // Attempt to close the device
-                            if(icsneojava.icsneo_closeDevice(selectedDevice)) {
-                                numDevices--;
-                                System.out.println("Successfully closed " + description + "!\n");
-                                devices.remove(selectedDevice);
-                                selectedDevice = null;
-                            } else {
-                                System.out.println("Failed to close " + description + "!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-                            break;
-                        default:
-                            System.out.println("Canceling!\n");
-                            break;
-                    }
-                    break;
-                }
-                // Go online/offline
-                case 'D':
-                case 'd': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    System.out.println("Would you like to have " + description + " go online or offline?");
-                    System.out.println("[1] Online\n[2] Offline\n[3] Cancel\n");
-
-                    char option = getCharInput(new char[] { '1', '2', '3' });
-                    System.out.println();
-
-                    switch(option) {
-                        case '1':
-                            // Attempt to go online
-                            if(icsneojava.icsneo_goOnline(selectedDevice)) {
-                                System.out.println(description + " successfully went online!\n");
-                            } else {
-                                System.out.println(description + " failed to go online!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-                            break;
-                        case '2':
-                            // Attempt to go offline
-                            if(icsneojava.icsneo_goOffline(selectedDevice)) {
-                                System.out.println(description + " successfully went offline!\n");
-                            } else {
-                                System.out.println(description + " failed to go offline!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-                            break;
-                        default:
-                            System.out.println("Canceling!\n");
-                            break;
-                    }
-                    break;
-                }
-                // Enable/disable message polling
-                case 'E':
-                case 'e': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    System.out.println("Would you like to enable or disable message polling for " + description + "?");
-                    System.out.println("[1] Enable\n[2] Disable\n[3] Cancel\n");
-
-                    char option = getCharInput(new char[] { '1', '2', '3' });
-                    System.out.println();
-
-                    switch(option) {
-                        case '1':
-                            // Attempt to enable message polling
-                            if(icsneojava.icsneo_enableMessagePolling(selectedDevice)) {
-                                System.out.println("Successfully enabled message polling for " + description + "!\n");
-                            } else {
-                                System.out.println("Failed to enable message polling for " + description + "!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-
-                            // Manually setting the polling message limit as done below is optional
-                            // It will default to 20k if not set
-                            // Attempt to set the polling message limit
-                            if(icsneojava.icsneo_setPollingMessageLimit(selectedDevice, msgLimit)) {
-                                System.out.println("Successfully set message polling limit for " + description + "!\n");
-                            } else {
-                                System.out.println("Failed to set polling message limit for " + description + "!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-                            break;
-                        case '2':
-                            // Attempt to disable message polling
-                            if(icsneojava.icsneo_disableMessagePolling(selectedDevice)) {
-                                System.out.println("Successfully disabled message polling for " + description + "!\n");
-                            } else {
-                                System.out.println("Failed to disable message polling for " + description + "!\n");
-                                printLastError();
-                                System.out.println();
-                            }
-                            break;
-                        default:
-                            System.out.println("Canceling!\n");
-                            break;
-                    }
-                }
-                break;
-                case 'F':
-                case 'f': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    // Prepare the neomessage_t array and size for reading in the messages
-                    neomessage_t msgs = icsneojava.new_neomessage_t_array((int)msgLimit);
-                    int[] msgCount = {msgLimit};
-
-                    if(!icsneojava.icsneo_getMessages(selectedDevice, msgs, msgCount, BigInteger.ZERO)) {
-                        System.out.println("Failed to get messages for " + description + "!\n");
-                        icsneojava.delete_neomessage_t_array(msgs);
-                        printLastError();
-                        System.out.println();
-                        break;
-                    }
-
-                    if(msgCount[0] == 1) {
-                        System.out.println("1 message received from " + description + "!");
-                    } else {
-                        System.out.println(msgCount[0] + " messages received from " + description + "!");
-                    }
-
-                    // Print out the received messages
-                    for(int i = 0; i < msgCount[0]; i++) {
-                        neomessage_t msg = icsneojava.neomessage_t_array_getitem(msgs, i);
-                        if(msg.getType() == icsneojava.ICSNEO_NETWORK_TYPE_CAN) {
-                            System.out.print("\t0x" + String.format("%03x", icsneojava.neomessage_can_t_cast(msg).getArbid()) + " [" + msg.getLength() + "] ");
-                            for(int j = 0; j < msg.getLength(); j++) {
-                                System.out.print(String.format("%02x ", icsneojava.neomessage_can_t_cast(msg).getData()[j]));
-                            }
-                            System.out.println("(" + msg.getTimestamp() + ")");
-                        } else {
-                            if(msg.getNetid() != 0)
-                                System.out.println("\tMessage on netid " + msg.getNetid() + " with length " + msg.getLength());
-                        }
-                    }
-                    icsneojava.delete_neomessage_t_array(msgs);
-                    break;
-                }
-                // Send message
-                case 'G':
-                case 'g': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    // Start generating sample msg
-                    neomessage_can_t msg = new neomessage_can_t();
-                    msg.setArbid(0x120);
-                    msg.setLength(6);
-                    msg.setNetid(icsneojava.ICSNEO_NETID_HSCAN);
-                    msg.setData(new byte[] { (byte) 0xaa, (byte) 0xbb, (byte) 0xcc, (byte) 0xdd, (byte) 0xee, (byte) 0xff});
-                    msg.getStatus().setCanfdFDF(0);
-                    msg.getStatus().setExtendedFrame(0);
-                    msg.getStatus().setCanfdBRS(0);
-                    // End generating sample msg
-
-                    // Attempt to transmit the sample msg
-                    if(icsneojava.icsneo_transmit(selectedDevice, icsneojava.from_can_neomessage_t_cast(msg))) {
-                        System.out.println("Message transmit successful!");
-                    } else {
-                        System.out.println("Failed to transmit message to " + description + "!\n");
-                        printLastError();
-                        System.out.println();
-                    }
-                    break;
-                }
-                // Get events
-                case 'H':
-                case 'h':
-                    printAPIEvents();
-                    System.out.println();
-                    break;
-                // Set HS CAN to 250k
-                case 'I':
-                case 'i': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    // Attempt to set baudrate and apply settings
-                    if(icsneojava.icsneo_setBaudrate(selectedDevice, icsneojava.ICSNEO_NETID_HSCAN, 250000) && icsneojava.icsneo_settingsApply(selectedDevice)) {
-                        System.out.println("Successfully set HS CAN baudrate for " + description + "to 250k!\n");
-                    } else {
-                        System.out.println("Failed to set HS CAN for " + description + " to 250k!\n");
-                        printLastError();
-                        System.out.println();
-                    }
-                    break;
-                }
-                // Set HS CAN to 500k
-                case 'J':
-                case 'j': {
-                    // Select a device and get its description
-                    if(numDevices == 0) {
-                        System.out.println("No devices found! Please scan for new devices.\n");
-                        break;
-                    }
-                    selectedDevice = selectDevice();
-
-                    // Get the product description for the device
-                    StringBuffer description = new StringBuffer(icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION);
-                    int[] maxLength = {icsneojava.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION};
-
-                    icsneojava.icsneo_describeDevice(selectedDevice, description, maxLength);
-
-                    // Attempt to set baudrate and apply settings
-                    if(icsneojava.icsneo_setBaudrate(selectedDevice, icsneojava.ICSNEO_NETID_HSCAN, 500000) && icsneojava.icsneo_settingsApply(selectedDevice)) {
-                        System.out.println("Successfully set HS CAN baudrate for " + description + "to 500k!\n");
-                    } else {
-                        System.out.println("Failed to set HS CAN for " + description + " to 500k!\n");
-                        printLastError();
-                        System.out.println();
-                    }
-                    break;
-                }
-                case 'X':
-                case 'x':
-                    System.out.println("Exiting program");
-                    return;
-                default:
-                    System.out.println("Unexpected input, exiting!");
-                    return;
-            }
-        }
-    }
-}

examples/java/src/Run.java

@@ -1,10 +0,0 @@
-public class Run {
-    static {
-        System.loadLibrary("icsneojava");
-    }
-
-    public static void main(String[] args) {
-        InteractiveExample example = new InteractiveExample();
-        example.run();
-    }
-}

examples/java/src/SWIGTYPE_p_time_t.java

@@ -1,25 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class SWIGTYPE_p_time_t {
-  private transient long swigCPtr;
-
-  protected SWIGTYPE_p_time_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
-    swigCPtr = cPtr;
-  }
-
-  protected SWIGTYPE_p_time_t() {
-    swigCPtr = 0;
-  }
-
-  protected static long getCPtr(SWIGTYPE_p_time_t obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-}
-

examples/java/src/SWIGTYPE_p_unsigned_char.java

@@ -1,25 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class SWIGTYPE_p_unsigned_char {
-  private transient long swigCPtr;
-
-  protected SWIGTYPE_p_unsigned_char(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
-    swigCPtr = cPtr;
-  }
-
-  protected SWIGTYPE_p_unsigned_char() {
-    swigCPtr = 0;
-  }
-
-  protected static long getCPtr(SWIGTYPE_p_unsigned_char obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-}
-

examples/java/src/SWIGTYPE_p_unsigned_int.java

@@ -1,25 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class SWIGTYPE_p_unsigned_int {
-  private transient long swigCPtr;
-
-  protected SWIGTYPE_p_unsigned_int(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
-    swigCPtr = cPtr;
-  }
-
-  protected SWIGTYPE_p_unsigned_int() {
-    swigCPtr = 0;
-  }
-
-  protected static long getCPtr(SWIGTYPE_p_unsigned_int obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-}
-

examples/java/src/SWIGTYPE_p_unsigned_short.java

@@ -1,25 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class SWIGTYPE_p_unsigned_short {
-  private transient long swigCPtr;
-
-  protected SWIGTYPE_p_unsigned_short(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
-    swigCPtr = cPtr;
-  }
-
-  protected SWIGTYPE_p_unsigned_short() {
-    swigCPtr = 0;
-  }
-
-  protected static long getCPtr(SWIGTYPE_p_unsigned_short obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-}
-

examples/java/src/SWIGTYPE_p_void.java

@@ -1,25 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class SWIGTYPE_p_void {
-  private transient long swigCPtr;
-
-  protected SWIGTYPE_p_void(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
-    swigCPtr = cPtr;
-  }
-
-  protected SWIGTYPE_p_void() {
-    swigCPtr = 0;
-  }
-
-  protected static long getCPtr(SWIGTYPE_p_void obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-}
-

examples/java/src/icsneojava.java

@@ -1,262 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class icsneojava implements icsneojavaConstants {
-  public static void icsneo_findAllDevices(neodevice_t devices, int[] count) {
-    icsneojavaJNI.icsneo_findAllDevices(neodevice_t.getCPtr(devices), devices, count);
-  }
-
-  public static void icsneo_freeUnconnectedDevices() {
-    icsneojavaJNI.icsneo_freeUnconnectedDevices();
-  }
-
-  public static boolean icsneo_serialNumToString(long num, StringBuffer str, int[] count) {
-    return icsneojavaJNI.icsneo_serialNumToString(num, str, count);
-  }
-
-  public static long icsneo_serialStringToNum(StringBuffer str) {
-    return icsneojavaJNI.icsneo_serialStringToNum(str);
-  }
-
-  public static boolean icsneo_isValidNeoDevice(neodevice_t device) {
-    return icsneojavaJNI.icsneo_isValidNeoDevice(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_openDevice(neodevice_t device) {
-    return icsneojavaJNI.icsneo_openDevice(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_closeDevice(neodevice_t device) {
-    return icsneojavaJNI.icsneo_closeDevice(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_isOpen(neodevice_t device) {
-    return icsneojavaJNI.icsneo_isOpen(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_goOnline(neodevice_t device) {
-    return icsneojavaJNI.icsneo_goOnline(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_goOffline(neodevice_t device) {
-    return icsneojavaJNI.icsneo_goOffline(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_isOnline(neodevice_t device) {
-    return icsneojavaJNI.icsneo_isOnline(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_enableMessagePolling(neodevice_t device) {
-    return icsneojavaJNI.icsneo_enableMessagePolling(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_disableMessagePolling(neodevice_t device) {
-    return icsneojavaJNI.icsneo_disableMessagePolling(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_isMessagePollingEnabled(neodevice_t device) {
-    return icsneojavaJNI.icsneo_isMessagePollingEnabled(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_getMessages(neodevice_t device, neomessage_t messages, int[] items, java.math.BigInteger timeout) {
-    return icsneojavaJNI.icsneo_getMessages(neodevice_t.getCPtr(device), device, neomessage_t.getCPtr(messages), messages, items, timeout);
-  }
-
-  public static long icsneo_getPollingMessageLimit(neodevice_t device) {
-    return icsneojavaJNI.icsneo_getPollingMessageLimit(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_setPollingMessageLimit(neodevice_t device, long newLimit) {
-    return icsneojavaJNI.icsneo_setPollingMessageLimit(neodevice_t.getCPtr(device), device, newLimit);
-  }
-
-  public static boolean icsneo_getProductName(neodevice_t device, StringBuffer str, int[] maxLength) {
-    return icsneojavaJNI.icsneo_getProductName(neodevice_t.getCPtr(device), device, str, maxLength);
-  }
-
-  public static boolean icsneo_getProductNameForType(long type, StringBuffer str, int[] maxLength) {
-    return icsneojavaJNI.icsneo_getProductNameForType(type, str, maxLength);
-  }
-
-  public static boolean icsneo_settingsRefresh(neodevice_t device) {
-    return icsneojavaJNI.icsneo_settingsRefresh(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_settingsApply(neodevice_t device) {
-    return icsneojavaJNI.icsneo_settingsApply(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_settingsApplyTemporary(neodevice_t device) {
-    return icsneojavaJNI.icsneo_settingsApplyTemporary(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_settingsApplyDefaults(neodevice_t device) {
-    return icsneojavaJNI.icsneo_settingsApplyDefaults(neodevice_t.getCPtr(device), device);
-  }
-
-  public static boolean icsneo_settingsApplyDefaultsTemporary(neodevice_t device) {
-    return icsneojavaJNI.icsneo_settingsApplyDefaultsTemporary(neodevice_t.getCPtr(device), device);
-  }
-
-  public static int icsneo_settingsReadStructure(neodevice_t device, SWIGTYPE_p_void structure, long structureSize) {
-    return icsneojavaJNI.icsneo_settingsReadStructure(neodevice_t.getCPtr(device), device, SWIGTYPE_p_void.getCPtr(structure), structureSize);
-  }
-
-  public static boolean icsneo_settingsApplyStructure(neodevice_t device, SWIGTYPE_p_void structure, long structureSize) {
-    return icsneojavaJNI.icsneo_settingsApplyStructure(neodevice_t.getCPtr(device), device, SWIGTYPE_p_void.getCPtr(structure), structureSize);
-  }
-
-  public static boolean icsneo_settingsApplyStructureTemporary(neodevice_t device, SWIGTYPE_p_void structure, long structureSize) {
-    return icsneojavaJNI.icsneo_settingsApplyStructureTemporary(neodevice_t.getCPtr(device), device, SWIGTYPE_p_void.getCPtr(structure), structureSize);
-  }
-
-  public static long icsneo_getBaudrate(neodevice_t device, int netid) {
-    return icsneojavaJNI.icsneo_getBaudrate(neodevice_t.getCPtr(device), device, netid);
-  }
-
-  public static boolean icsneo_setBaudrate(neodevice_t device, int netid, long newBaudrate) {
-    return icsneojavaJNI.icsneo_setBaudrate(neodevice_t.getCPtr(device), device, netid, newBaudrate);
-  }
-
-  public static long icsneo_getFDBaudrate(neodevice_t device, int netid) {
-    return icsneojavaJNI.icsneo_getFDBaudrate(neodevice_t.getCPtr(device), device, netid);
-  }
-
-  public static boolean icsneo_setFDBaudrate(neodevice_t device, int netid, long newBaudrate) {
-    return icsneojavaJNI.icsneo_setFDBaudrate(neodevice_t.getCPtr(device), device, netid, newBaudrate);
-  }
-
-  public static boolean icsneo_transmit(neodevice_t device, neomessage_t message) {
-    return icsneojavaJNI.icsneo_transmit(neodevice_t.getCPtr(device), device, neomessage_t.getCPtr(message), message);
-  }
-
-  public static boolean icsneo_transmitMessages(neodevice_t device, neomessage_t messages, long count) {
-    return icsneojavaJNI.icsneo_transmitMessages(neodevice_t.getCPtr(device), device, neomessage_t.getCPtr(messages), messages, count);
-  }
-
-  public static void icsneo_setWriteBlocks(neodevice_t device, boolean blocks) {
-    icsneojavaJNI.icsneo_setWriteBlocks(neodevice_t.getCPtr(device), device, blocks);
-  }
-
-  public static boolean icsneo_describeDevice(neodevice_t device, StringBuffer str, int[] maxLength) {
-    return icsneojavaJNI.icsneo_describeDevice(neodevice_t.getCPtr(device), device, str, maxLength);
-  }
-
-  public static neoversion_t icsneo_getVersion() {
-    return new neoversion_t(icsneojavaJNI.icsneo_getVersion(), true);
-  }
-
-  public static boolean icsneo_getEvents(neoevent_t events, int[] size) {
-    return icsneojavaJNI.icsneo_getEvents(neoevent_t.getCPtr(events), events, size);
-  }
-
-  public static boolean icsneo_getDeviceEvents(neodevice_t device, neoevent_t events, int[] size) {
-    return icsneojavaJNI.icsneo_getDeviceEvents(neodevice_t.getCPtr(device), device, neoevent_t.getCPtr(events), events, size);
-  }
-
-  public static boolean icsneo_getLastError(neoevent_t error) {
-    return icsneojavaJNI.icsneo_getLastError(neoevent_t.getCPtr(error), error);
-  }
-
-  public static void icsneo_discardAllEvents() {
-    icsneojavaJNI.icsneo_discardAllEvents();
-  }
-
-  public static void icsneo_discardDeviceEvents(neodevice_t device) {
-    icsneojavaJNI.icsneo_discardDeviceEvents(neodevice_t.getCPtr(device), device);
-  }
-
-  public static void icsneo_setEventLimit(long newLimit) {
-    icsneojavaJNI.icsneo_setEventLimit(newLimit);
-  }
-
-  public static long icsneo_getEventLimit() {
-    return icsneojavaJNI.icsneo_getEventLimit();
-  }
-
-  public static boolean icsneo_getSupportedDevices(SWIGTYPE_p_unsigned_int devices, int[] count) {
-    return icsneojavaJNI.icsneo_getSupportedDevices(SWIGTYPE_p_unsigned_int.getCPtr(devices), count);
-  }
-
-  public static boolean icsneo_getTimestampResolution(neodevice_t device, SWIGTYPE_p_unsigned_short resolution) {
-    return icsneojavaJNI.icsneo_getTimestampResolution(neodevice_t.getCPtr(device), device, SWIGTYPE_p_unsigned_short.getCPtr(resolution));
-  }
-
-  public static neomessage_can_t neomessage_can_t_cast(neomessage_t msg) {
-    long cPtr = icsneojavaJNI.neomessage_can_t_cast(neomessage_t.getCPtr(msg), msg);
-    return (cPtr == 0) ? null : new neomessage_can_t(cPtr, false);
-  }
-
-  public static neomessage_eth_t neomessage_eth_t_cast(neomessage_t msg) {
-    long cPtr = icsneojavaJNI.neomessage_eth_t_cast(neomessage_t.getCPtr(msg), msg);
-    return (cPtr == 0) ? null : new neomessage_eth_t(cPtr, false);
-  }
-
-  public static neomessage_t from_can_neomessage_t_cast(neomessage_can_t msg) {
-    long cPtr = icsneojavaJNI.from_can_neomessage_t_cast(neomessage_can_t.getCPtr(msg), msg);
-    return (cPtr == 0) ? null : new neomessage_t(cPtr, false);
-  }
-
-  public static neomessage_t from_eth_neomessage_t_cast(neomessage_eth_t msg) {
-    long cPtr = icsneojavaJNI.from_eth_neomessage_t_cast(neomessage_eth_t.getCPtr(msg), msg);
-    return (cPtr == 0) ? null : new neomessage_t(cPtr, false);
-  }
-
-  public static neodevice_t new_neodevice_t_array(int nelements) {
-    long cPtr = icsneojavaJNI.new_neodevice_t_array(nelements);
-    return (cPtr == 0) ? null : new neodevice_t(cPtr, false);
-  }
-
-  public static void delete_neodevice_t_array(neodevice_t ary) {
-    icsneojavaJNI.delete_neodevice_t_array(neodevice_t.getCPtr(ary), ary);
-  }
-
-  public static neodevice_t neodevice_t_array_getitem(neodevice_t ary, int index) {
-    return new neodevice_t(icsneojavaJNI.neodevice_t_array_getitem(neodevice_t.getCPtr(ary), ary, index), true);
-  }
-
-  public static void neodevice_t_array_setitem(neodevice_t ary, int index, neodevice_t value) {
-    icsneojavaJNI.neodevice_t_array_setitem(neodevice_t.getCPtr(ary), ary, index, neodevice_t.getCPtr(value), value);
-  }
-
-  public static neoevent_t new_neoevent_t_array(int nelements) {
-    long cPtr = icsneojavaJNI.new_neoevent_t_array(nelements);
-    return (cPtr == 0) ? null : new neoevent_t(cPtr, false);
-  }
-
-  public static void delete_neoevent_t_array(neoevent_t ary) {
-    icsneojavaJNI.delete_neoevent_t_array(neoevent_t.getCPtr(ary), ary);
-  }
-
-  public static neoevent_t neoevent_t_array_getitem(neoevent_t ary, int index) {
-    return new neoevent_t(icsneojavaJNI.neoevent_t_array_getitem(neoevent_t.getCPtr(ary), ary, index), true);
-  }
-
-  public static void neoevent_t_array_setitem(neoevent_t ary, int index, neoevent_t value) {
-    icsneojavaJNI.neoevent_t_array_setitem(neoevent_t.getCPtr(ary), ary, index, neoevent_t.getCPtr(value), value);
-  }
-
-  public static neomessage_t new_neomessage_t_array(int nelements) {
-    long cPtr = icsneojavaJNI.new_neomessage_t_array(nelements);
-    return (cPtr == 0) ? null : new neomessage_t(cPtr, false);
-  }
-
-  public static void delete_neomessage_t_array(neomessage_t ary) {
-    icsneojavaJNI.delete_neomessage_t_array(neomessage_t.getCPtr(ary), ary);
-  }
-
-  public static neomessage_t neomessage_t_array_getitem(neomessage_t ary, int index) {
-    return new neomessage_t(icsneojavaJNI.neomessage_t_array_getitem(neomessage_t.getCPtr(ary), ary, index), true);
-  }
-
-  public static void neomessage_t_array_setitem(neomessage_t ary, int index, neomessage_t value) {
-    icsneojavaJNI.neomessage_t_array_setitem(neomessage_t.getCPtr(ary), ary, index, neomessage_t.getCPtr(value), value);
-  }
-
-}

examples/java/src/icsneojavaConstants.java

@@ -1,120 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public interface icsneojavaConstants {
-  public final static int ICSNEO_DEVICETYPE_LONGEST_NAME = icsneojavaJNI.ICSNEO_DEVICETYPE_LONGEST_NAME_get();
-  public final static int ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION = icsneojavaJNI.ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION_get();
-  public final static int ICSNEO_NETID_DEVICE = icsneojavaJNI.ICSNEO_NETID_DEVICE_get();
-  public final static int ICSNEO_NETID_HSCAN = icsneojavaJNI.ICSNEO_NETID_HSCAN_get();
-  public final static int ICSNEO_NETID_MSCAN = icsneojavaJNI.ICSNEO_NETID_MSCAN_get();
-  public final static int ICSNEO_NETID_SWCAN = icsneojavaJNI.ICSNEO_NETID_SWCAN_get();
-  public final static int ICSNEO_NETID_LSFTCAN = icsneojavaJNI.ICSNEO_NETID_LSFTCAN_get();
-  public final static int ICSNEO_NETID_FORDSCP = icsneojavaJNI.ICSNEO_NETID_FORDSCP_get();
-  public final static int ICSNEO_NETID_J1708 = icsneojavaJNI.ICSNEO_NETID_J1708_get();
-  public final static int ICSNEO_NETID_AUX = icsneojavaJNI.ICSNEO_NETID_AUX_get();
-  public final static int ICSNEO_NETID_J1850VPW = icsneojavaJNI.ICSNEO_NETID_J1850VPW_get();
-  public final static int ICSNEO_NETID_ISO = icsneojavaJNI.ICSNEO_NETID_ISO_get();
-  public final static int ICSNEO_NETID_MAIN51 = icsneojavaJNI.ICSNEO_NETID_MAIN51_get();
-  public final static int ICSNEO_NETID_RED = icsneojavaJNI.ICSNEO_NETID_RED_get();
-  public final static int ICSNEO_NETID_SCI = icsneojavaJNI.ICSNEO_NETID_SCI_get();
-  public final static int ICSNEO_NETID_ISO2 = icsneojavaJNI.ICSNEO_NETID_ISO2_get();
-  public final static int ICSNEO_NETID_ISO14230 = icsneojavaJNI.ICSNEO_NETID_ISO14230_get();
-  public final static int ICSNEO_NETID_LIN = icsneojavaJNI.ICSNEO_NETID_LIN_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET1 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET1_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET2 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET2_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET3 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET3_get();
-  public final static int ICSNEO_NETID_RED_EXT_MEMORYREAD = icsneojavaJNI.ICSNEO_NETID_RED_EXT_MEMORYREAD_get();
-  public final static int ICSNEO_NETID_RED_INT_MEMORYREAD = icsneojavaJNI.ICSNEO_NETID_RED_INT_MEMORYREAD_get();
-  public final static int ICSNEO_NETID_RED_DFLASH_READ = icsneojavaJNI.ICSNEO_NETID_RED_DFLASH_READ_get();
-  public final static int ICSNEO_NETID_RED_SDCARD_READ = icsneojavaJNI.ICSNEO_NETID_RED_SDCARD_READ_get();
-  public final static int ICSNEO_NETID_CAN_ERRBITS = icsneojavaJNI.ICSNEO_NETID_CAN_ERRBITS_get();
-  public final static int ICSNEO_NETID_RED_DFLASH_WRITE_DONE = icsneojavaJNI.ICSNEO_NETID_RED_DFLASH_WRITE_DONE_get();
-  public final static int ICSNEO_NETID_RED_WAVE_CAN1_LOGICAL = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_CAN1_LOGICAL_get();
-  public final static int ICSNEO_NETID_RED_WAVE_CAN2_LOGICAL = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_CAN2_LOGICAL_get();
-  public final static int ICSNEO_NETID_RED_WAVE_LIN1_LOGICAL = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_LIN1_LOGICAL_get();
-  public final static int ICSNEO_NETID_RED_WAVE_LIN2_LOGICAL = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_LIN2_LOGICAL_get();
-  public final static int ICSNEO_NETID_RED_WAVE_LIN1_ANALOG = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_LIN1_ANALOG_get();
-  public final static int ICSNEO_NETID_RED_WAVE_LIN2_ANALOG = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_LIN2_ANALOG_get();
-  public final static int ICSNEO_NETID_RED_WAVE_MISC_ANALOG = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_MISC_ANALOG_get();
-  public final static int ICSNEO_NETID_RED_WAVE_MISCDIO2_LOGICAL = icsneojavaJNI.ICSNEO_NETID_RED_WAVE_MISCDIO2_LOGICAL_get();
-  public final static int ICSNEO_NETID_RED_NETWORK_COM_ENABLE_EX = icsneojavaJNI.ICSNEO_NETID_RED_NETWORK_COM_ENABLE_EX_get();
-  public final static int ICSNEO_NETID_RED_NEOVI_NETWORK = icsneojavaJNI.ICSNEO_NETID_RED_NEOVI_NETWORK_get();
-  public final static int ICSNEO_NETID_RED_READ_BAUD_SETTINGS = icsneojavaJNI.ICSNEO_NETID_RED_READ_BAUD_SETTINGS_get();
-  public final static int ICSNEO_NETID_RED_OLDFORMAT = icsneojavaJNI.ICSNEO_NETID_RED_OLDFORMAT_get();
-  public final static int ICSNEO_NETID_RED_SCOPE_CAPTURE = icsneojavaJNI.ICSNEO_NETID_RED_SCOPE_CAPTURE_get();
-  public final static int ICSNEO_NETID_RED_HARDWARE_EXCEP = icsneojavaJNI.ICSNEO_NETID_RED_HARDWARE_EXCEP_get();
-  public final static int ICSNEO_NETID_RED_GET_RTC = icsneojavaJNI.ICSNEO_NETID_RED_GET_RTC_get();
-  public final static int ICSNEO_NETID_ISO3 = icsneojavaJNI.ICSNEO_NETID_ISO3_get();
-  public final static int ICSNEO_NETID_HSCAN2 = icsneojavaJNI.ICSNEO_NETID_HSCAN2_get();
-  public final static int ICSNEO_NETID_HSCAN3 = icsneojavaJNI.ICSNEO_NETID_HSCAN3_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET4 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET4_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET5 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET5_get();
-  public final static int ICSNEO_NETID_ISO4 = icsneojavaJNI.ICSNEO_NETID_ISO4_get();
-  public final static int ICSNEO_NETID_LIN2 = icsneojavaJNI.ICSNEO_NETID_LIN2_get();
-  public final static int ICSNEO_NETID_LIN3 = icsneojavaJNI.ICSNEO_NETID_LIN3_get();
-  public final static int ICSNEO_NETID_LIN4 = icsneojavaJNI.ICSNEO_NETID_LIN4_get();
-  public final static int ICSNEO_NETID_RED_APP_ERROR = icsneojavaJNI.ICSNEO_NETID_RED_APP_ERROR_get();
-  public final static int ICSNEO_NETID_CGI = icsneojavaJNI.ICSNEO_NETID_CGI_get();
-  public final static int ICSNEO_NETID_RESET_STATUS = icsneojavaJNI.ICSNEO_NETID_RESET_STATUS_get();
-  public final static int ICSNEO_NETID_FB_STATUS = icsneojavaJNI.ICSNEO_NETID_FB_STATUS_get();
-  public final static int ICSNEO_NETID_APP_SIGNAL_STATUS = icsneojavaJNI.ICSNEO_NETID_APP_SIGNAL_STATUS_get();
-  public final static int ICSNEO_NETID_READ_DATALINK_CM_TX_MSG = icsneojavaJNI.ICSNEO_NETID_READ_DATALINK_CM_TX_MSG_get();
-  public final static int ICSNEO_NETID_READ_DATALINK_CM_RX_MSG = icsneojavaJNI.ICSNEO_NETID_READ_DATALINK_CM_RX_MSG_get();
-  public final static int ICSNEO_NETID_LOGGING_OVERFLOW = icsneojavaJNI.ICSNEO_NETID_LOGGING_OVERFLOW_get();
-  public final static int ICSNEO_NETID_READ_SETTINGS = icsneojavaJNI.ICSNEO_NETID_READ_SETTINGS_get();
-  public final static int ICSNEO_NETID_HSCAN4 = icsneojavaJNI.ICSNEO_NETID_HSCAN4_get();
-  public final static int ICSNEO_NETID_HSCAN5 = icsneojavaJNI.ICSNEO_NETID_HSCAN5_get();
-  public final static int ICSNEO_NETID_RS232 = icsneojavaJNI.ICSNEO_NETID_RS232_get();
-  public final static int ICSNEO_NETID_UART = icsneojavaJNI.ICSNEO_NETID_UART_get();
-  public final static int ICSNEO_NETID_UART2 = icsneojavaJNI.ICSNEO_NETID_UART2_get();
-  public final static int ICSNEO_NETID_UART3 = icsneojavaJNI.ICSNEO_NETID_UART3_get();
-  public final static int ICSNEO_NETID_UART4 = icsneojavaJNI.ICSNEO_NETID_UART4_get();
-  public final static int ICSNEO_NETID_SWCAN2 = icsneojavaJNI.ICSNEO_NETID_SWCAN2_get();
-  public final static int ICSNEO_NETID_ETHERNET_DAQ = icsneojavaJNI.ICSNEO_NETID_ETHERNET_DAQ_get();
-  public final static int ICSNEO_NETID_DATA_TO_HOST = icsneojavaJNI.ICSNEO_NETID_DATA_TO_HOST_get();
-  public final static int ICSNEO_NETID_TEXTAPI_TO_HOST = icsneojavaJNI.ICSNEO_NETID_TEXTAPI_TO_HOST_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET6 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET6_get();
-  public final static int ICSNEO_NETID_RED_VBAT = icsneojavaJNI.ICSNEO_NETID_RED_VBAT_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET7 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET7_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET8 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET8_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET9 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET9_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET10 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET10_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET11 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET11_get();
-  public final static int ICSNEO_NETID_FLEXRAY1A = icsneojavaJNI.ICSNEO_NETID_FLEXRAY1A_get();
-  public final static int ICSNEO_NETID_FLEXRAY1B = icsneojavaJNI.ICSNEO_NETID_FLEXRAY1B_get();
-  public final static int ICSNEO_NETID_FLEXRAY2A = icsneojavaJNI.ICSNEO_NETID_FLEXRAY2A_get();
-  public final static int ICSNEO_NETID_FLEXRAY2B = icsneojavaJNI.ICSNEO_NETID_FLEXRAY2B_get();
-  public final static int ICSNEO_NETID_LIN5 = icsneojavaJNI.ICSNEO_NETID_LIN5_get();
-  public final static int ICSNEO_NETID_FLEXRAY = icsneojavaJNI.ICSNEO_NETID_FLEXRAY_get();
-  public final static int ICSNEO_NETID_FLEXRAY2 = icsneojavaJNI.ICSNEO_NETID_FLEXRAY2_get();
-  public final static int ICSNEO_NETID_OP_ETHERNET12 = icsneojavaJNI.ICSNEO_NETID_OP_ETHERNET12_get();
-  public final static int ICSNEO_NETID_MOST25 = icsneojavaJNI.ICSNEO_NETID_MOST25_get();
-  public final static int ICSNEO_NETID_MOST50 = icsneojavaJNI.ICSNEO_NETID_MOST50_get();
-  public final static int ICSNEO_NETID_MOST150 = icsneojavaJNI.ICSNEO_NETID_MOST150_get();
-  public final static int ICSNEO_NETID_ETHERNET = icsneojavaJNI.ICSNEO_NETID_ETHERNET_get();
-  public final static int ICSNEO_NETID_GMFSA = icsneojavaJNI.ICSNEO_NETID_GMFSA_get();
-  public final static int ICSNEO_NETID_TCP = icsneojavaJNI.ICSNEO_NETID_TCP_get();
-  public final static int ICSNEO_NETID_HSCAN6 = icsneojavaJNI.ICSNEO_NETID_HSCAN6_get();
-  public final static int ICSNEO_NETID_HSCAN7 = icsneojavaJNI.ICSNEO_NETID_HSCAN7_get();
-  public final static int ICSNEO_NETID_LIN6 = icsneojavaJNI.ICSNEO_NETID_LIN6_get();
-  public final static int ICSNEO_NETID_LSFTCAN2 = icsneojavaJNI.ICSNEO_NETID_LSFTCAN2_get();
-  public final static int ICSNEO_NETID_HW_COM_LATENCY_TEST = icsneojavaJNI.ICSNEO_NETID_HW_COM_LATENCY_TEST_get();
-  public final static int ICSNEO_NETID_DEVICE_STATUS = icsneojavaJNI.ICSNEO_NETID_DEVICE_STATUS_get();
-  public final static int ICSNEO_NETID_ANY = icsneojavaJNI.ICSNEO_NETID_ANY_get();
-  public final static int ICSNEO_NETID_INVALID = icsneojavaJNI.ICSNEO_NETID_INVALID_get();
-  public final static int ICSNEO_NETWORK_TYPE_INVALID = icsneojavaJNI.ICSNEO_NETWORK_TYPE_INVALID_get();
-  public final static int ICSNEO_NETWORK_TYPE_INTERNAL = icsneojavaJNI.ICSNEO_NETWORK_TYPE_INTERNAL_get();
-  public final static int ICSNEO_NETWORK_TYPE_CAN = icsneojavaJNI.ICSNEO_NETWORK_TYPE_CAN_get();
-  public final static int ICSNEO_NETWORK_TYPE_LIN = icsneojavaJNI.ICSNEO_NETWORK_TYPE_LIN_get();
-  public final static int ICSNEO_NETWORK_TYPE_FLEXRAY = icsneojavaJNI.ICSNEO_NETWORK_TYPE_FLEXRAY_get();
-  public final static int ICSNEO_NETWORK_TYPE_MOST = icsneojavaJNI.ICSNEO_NETWORK_TYPE_MOST_get();
-  public final static int ICSNEO_NETWORK_TYPE_ETHERNET = icsneojavaJNI.ICSNEO_NETWORK_TYPE_ETHERNET_get();
-  public final static int ICSNEO_NETWORK_TYPE_ANY = icsneojavaJNI.ICSNEO_NETWORK_TYPE_ANY_get();
-  public final static int ICSNEO_NETWORK_TYPE_OTHER = icsneojavaJNI.ICSNEO_NETWORK_TYPE_OTHER_get();
-}

examples/java/src/icsneojavaJNI.java

@@ -1,399 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class icsneojavaJNI {
-  public final static native void icsneo_findAllDevices(long jarg1, neodevice_t jarg1_, int[] jarg2);
-  public final static native void icsneo_freeUnconnectedDevices();
-  public final static native boolean icsneo_serialNumToString(long jarg1, StringBuffer jarg2, int[] jarg3);
-  public final static native long icsneo_serialStringToNum(StringBuffer jarg1);
-  public final static native boolean icsneo_isValidNeoDevice(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_openDevice(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_closeDevice(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_isOpen(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_goOnline(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_goOffline(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_isOnline(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_enableMessagePolling(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_disableMessagePolling(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_isMessagePollingEnabled(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_getMessages(long jarg1, neodevice_t jarg1_, long jarg2, neomessage_t jarg2_, int[] jarg3, java.math.BigInteger jarg4);
-  public final static native long icsneo_getPollingMessageLimit(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_setPollingMessageLimit(long jarg1, neodevice_t jarg1_, long jarg2);
-  public final static native boolean icsneo_getProductName(long jarg1, neodevice_t jarg1_, StringBuffer jarg2, int[] jarg3);
-  public final static native boolean icsneo_getProductNameForType(long jarg1, StringBuffer jarg2, int[] jarg3);
-  public final static native boolean icsneo_settingsRefresh(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_settingsApply(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_settingsApplyTemporary(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_settingsApplyDefaults(long jarg1, neodevice_t jarg1_);
-  public final static native boolean icsneo_settingsApplyDefaultsTemporary(long jarg1, neodevice_t jarg1_);
-  public final static native int icsneo_settingsReadStructure(long jarg1, neodevice_t jarg1_, long jarg2, long jarg3);
-  public final static native boolean icsneo_settingsApplyStructure(long jarg1, neodevice_t jarg1_, long jarg2, long jarg3);
-  public final static native boolean icsneo_settingsApplyStructureTemporary(long jarg1, neodevice_t jarg1_, long jarg2, long jarg3);
-  public final static native long icsneo_getBaudrate(long jarg1, neodevice_t jarg1_, int jarg2);
-  public final static native boolean icsneo_setBaudrate(long jarg1, neodevice_t jarg1_, int jarg2, long jarg3);
-  public final static native long icsneo_getFDBaudrate(long jarg1, neodevice_t jarg1_, int jarg2);
-  public final static native boolean icsneo_setFDBaudrate(long jarg1, neodevice_t jarg1_, int jarg2, long jarg3);
-  public final static native boolean icsneo_transmit(long jarg1, neodevice_t jarg1_, long jarg2, neomessage_t jarg2_);
-  public final static native boolean icsneo_transmitMessages(long jarg1, neodevice_t jarg1_, long jarg2, neomessage_t jarg2_, long jarg3);
-  public final static native void icsneo_setWriteBlocks(long jarg1, neodevice_t jarg1_, boolean jarg2);
-  public final static native boolean icsneo_describeDevice(long jarg1, neodevice_t jarg1_, StringBuffer jarg2, int[] jarg3);
-  public final static native long icsneo_getVersion();
-  public final static native boolean icsneo_getEvents(long jarg1, neoevent_t jarg1_, int[] jarg2);
-  public final static native boolean icsneo_getDeviceEvents(long jarg1, neodevice_t jarg1_, long jarg2, neoevent_t jarg2_, int[] jarg3);
-  public final static native boolean icsneo_getLastError(long jarg1, neoevent_t jarg1_);
-  public final static native void icsneo_discardAllEvents();
-  public final static native void icsneo_discardDeviceEvents(long jarg1, neodevice_t jarg1_);
-  public final static native void icsneo_setEventLimit(long jarg1);
-  public final static native long icsneo_getEventLimit();
-  public final static native boolean icsneo_getSupportedDevices(long jarg1, int[] jarg2);
-  public final static native boolean icsneo_getTimestampResolution(long jarg1, neodevice_t jarg1_, long jarg2);
-  public final static native void neodevice_t_device_set(long jarg1, neodevice_t jarg1_, long jarg2);
-  public final static native long neodevice_t_device_get(long jarg1, neodevice_t jarg1_);
-  public final static native void neodevice_t_handle_set(long jarg1, neodevice_t jarg1_, int jarg2);
-  public final static native int neodevice_t_handle_get(long jarg1, neodevice_t jarg1_);
-  public final static native void neodevice_t_type_set(long jarg1, neodevice_t jarg1_, long jarg2);
-  public final static native long neodevice_t_type_get(long jarg1, neodevice_t jarg1_);
-  public final static native void neodevice_t_serial_set(long jarg1, neodevice_t jarg1_, String jarg2);
-  public final static native String neodevice_t_serial_get(long jarg1, neodevice_t jarg1_);
-  public final static native long new_neodevice_t();
-  public final static native void delete_neodevice_t(long jarg1);
-  public final static native void neomessage_statusbitfield_t_globalError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_globalError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_transmitMessage_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_transmitMessage_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_extendedFrame_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_extendedFrame_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_remoteFrame_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_remoteFrame_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_crcError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_crcError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canErrorPassive_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canErrorPassive_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_incompleteFrame_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_incompleteFrame_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_lostArbitration_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_lostArbitration_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_undefinedError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_undefinedError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canBusOff_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canBusOff_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canErrorWarning_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canErrorWarning_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canBusShortedPlus_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canBusShortedPlus_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canBusShortedGround_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canBusShortedGround_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_checksumError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_checksumError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_badMessageBitTimeError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_badMessageBitTimeError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_ifrData_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_ifrData_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_hardwareCommError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_hardwareCommError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_expectedLengthError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_expectedLengthError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_incomingNoMatch_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_incomingNoMatch_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_statusBreak_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_statusBreak_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_avsiRecOverflow_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_avsiRecOverflow_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_testTrigger_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_testTrigger_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_audioComment_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_audioComment_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_gpsData_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_gpsData_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_analogDigitalInput_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_analogDigitalInput_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_textComment_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_textComment_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_networkMessageType_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_networkMessageType_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_vsiTXUnderrun_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_vsiTXUnderrun_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_vsiIFRCRCBit_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_vsiIFRCRCBit_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_initMessage_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_initMessage_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_flexraySecondStartupFrame_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_flexraySecondStartupFrame_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_extended_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_extended_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_hasValue_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_hasValue_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_valueIsBoolean_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_valueIsBoolean_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_highVoltage_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_highVoltage_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_longMessage_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_longMessage_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_globalChange_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_globalChange_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_errorFrame_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_errorFrame_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_endOfLongMessage_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_endOfLongMessage_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linErrorRXBreakNotZero_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linErrorRXBreakNotZero_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linErrorRXBreakTooShort_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linErrorRXBreakTooShort_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linErrorRXSyncNot55_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linErrorRXSyncNot55_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linErrorRXDataGreaterEight_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linErrorRXDataGreaterEight_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linErrorTXRXMismatch_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linErrorTXRXMismatch_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linErrorMessageIDParity_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linErrorMessageIDParity_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linSyncFrameError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linSyncFrameError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linIDFrameError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linIDFrameError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linSlaveByteError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linSlaveByteError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_rxTimeoutError_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_rxTimeoutError_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_linNoSlaveData_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_linNoSlaveData_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canfdESI_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canfdESI_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canfdIDE_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canfdIDE_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canfdRTR_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canfdRTR_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canfdFDF_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canfdFDF_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_canfdBRS_set(long jarg1, neomessage_statusbitfield_t jarg1_, long jarg2);
-  public final static native long neomessage_statusbitfield_t_canfdBRS_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native void neomessage_statusbitfield_t_statusBitfield_set(long jarg1, neomessage_statusbitfield_t jarg1_, long[] jarg2);
-  public final static native long[] neomessage_statusbitfield_t_statusBitfield_get(long jarg1, neomessage_statusbitfield_t jarg1_);
-  public final static native long new_neomessage_statusbitfield_t();
-  public final static native void delete_neomessage_statusbitfield_t(long jarg1);
-  public final static native void neomessage_t_status_set(long jarg1, neomessage_t jarg1_, long jarg2, neomessage_statusbitfield_t jarg2_);
-  public final static native long neomessage_t_status_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_timestamp_set(long jarg1, neomessage_t jarg1_, java.math.BigInteger jarg2);
-  public final static native java.math.BigInteger neomessage_t_timestamp_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_timestampReserved_set(long jarg1, neomessage_t jarg1_, java.math.BigInteger jarg2);
-  public final static native java.math.BigInteger neomessage_t_timestampReserved_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_data_set(long jarg1, neomessage_t jarg1_, byte[] jarg2);
-  public final static native byte[] neomessage_t_data_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_length_set(long jarg1, neomessage_t jarg1_, long jarg2);
-  public final static native long neomessage_t_length_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_header_set(long jarg1, neomessage_t jarg1_, short[] jarg2);
-  public final static native short[] neomessage_t_header_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_netid_set(long jarg1, neomessage_t jarg1_, int jarg2);
-  public final static native int neomessage_t_netid_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_type_set(long jarg1, neomessage_t jarg1_, short jarg2);
-  public final static native short neomessage_t_type_get(long jarg1, neomessage_t jarg1_);
-  public final static native void neomessage_t_reserved_set(long jarg1, neomessage_t jarg1_, short[] jarg2);
-  public final static native short[] neomessage_t_reserved_get(long jarg1, neomessage_t jarg1_);
-  public final static native long new_neomessage_t();
-  public final static native void delete_neomessage_t(long jarg1);
-  public final static native void neomessage_can_t_status_set(long jarg1, neomessage_can_t jarg1_, long jarg2, neomessage_statusbitfield_t jarg2_);
-  public final static native long neomessage_can_t_status_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_timestamp_set(long jarg1, neomessage_can_t jarg1_, java.math.BigInteger jarg2);
-  public final static native java.math.BigInteger neomessage_can_t_timestamp_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_timestampReserved_set(long jarg1, neomessage_can_t jarg1_, java.math.BigInteger jarg2);
-  public final static native java.math.BigInteger neomessage_can_t_timestampReserved_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_data_set(long jarg1, neomessage_can_t jarg1_, byte[] jarg2);
-  public final static native byte[] neomessage_can_t_data_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_length_set(long jarg1, neomessage_can_t jarg1_, long jarg2);
-  public final static native long neomessage_can_t_length_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_arbid_set(long jarg1, neomessage_can_t jarg1_, long jarg2);
-  public final static native long neomessage_can_t_arbid_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_netid_set(long jarg1, neomessage_can_t jarg1_, int jarg2);
-  public final static native int neomessage_can_t_netid_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_type_set(long jarg1, neomessage_can_t jarg1_, short jarg2);
-  public final static native short neomessage_can_t_type_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_dlcOnWire_set(long jarg1, neomessage_can_t jarg1_, short jarg2);
-  public final static native short neomessage_can_t_dlcOnWire_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native void neomessage_can_t_reserved_set(long jarg1, neomessage_can_t jarg1_, short[] jarg2);
-  public final static native short[] neomessage_can_t_reserved_get(long jarg1, neomessage_can_t jarg1_);
-  public final static native long new_neomessage_can_t();
-  public final static native void delete_neomessage_can_t(long jarg1);
-  public final static native void neomessage_eth_t_status_set(long jarg1, neomessage_eth_t jarg1_, long jarg2, neomessage_statusbitfield_t jarg2_);
-  public final static native long neomessage_eth_t_status_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_timestamp_set(long jarg1, neomessage_eth_t jarg1_, java.math.BigInteger jarg2);
-  public final static native java.math.BigInteger neomessage_eth_t_timestamp_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_timestampReserved_set(long jarg1, neomessage_eth_t jarg1_, java.math.BigInteger jarg2);
-  public final static native java.math.BigInteger neomessage_eth_t_timestampReserved_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_data_set(long jarg1, neomessage_eth_t jarg1_, byte[] jarg2);
-  public final static native byte[] neomessage_eth_t_data_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_length_set(long jarg1, neomessage_eth_t jarg1_, long jarg2);
-  public final static native long neomessage_eth_t_length_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_preemptionFlags_set(long jarg1, neomessage_eth_t jarg1_, short jarg2);
-  public final static native short neomessage_eth_t_preemptionFlags_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_reservedHeader_set(long jarg1, neomessage_eth_t jarg1_, short[] jarg2);
-  public final static native short[] neomessage_eth_t_reservedHeader_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_netid_set(long jarg1, neomessage_eth_t jarg1_, int jarg2);
-  public final static native int neomessage_eth_t_netid_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_type_set(long jarg1, neomessage_eth_t jarg1_, short jarg2);
-  public final static native short neomessage_eth_t_type_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native void neomessage_eth_t_reserved_set(long jarg1, neomessage_eth_t jarg1_, short[] jarg2);
-  public final static native short[] neomessage_eth_t_reserved_get(long jarg1, neomessage_eth_t jarg1_);
-  public final static native long new_neomessage_eth_t();
-  public final static native void delete_neomessage_eth_t(long jarg1);
-  public final static native int ICSNEO_DEVICETYPE_LONGEST_NAME_get();
-  public final static native int ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION_get();
-  public final static native void neoversion_t_major_set(long jarg1, neoversion_t jarg1_, int jarg2);
-  public final static native int neoversion_t_major_get(long jarg1, neoversion_t jarg1_);
-  public final static native void neoversion_t_minor_set(long jarg1, neoversion_t jarg1_, int jarg2);
-  public final static native int neoversion_t_minor_get(long jarg1, neoversion_t jarg1_);
-  public final static native void neoversion_t_patch_set(long jarg1, neoversion_t jarg1_, int jarg2);
-  public final static native int neoversion_t_patch_get(long jarg1, neoversion_t jarg1_);
-  public final static native void neoversion_t_metadata_set(long jarg1, neoversion_t jarg1_, String jarg2);
-  public final static native String neoversion_t_metadata_get(long jarg1, neoversion_t jarg1_);
-  public final static native void neoversion_t_buildBranch_set(long jarg1, neoversion_t jarg1_, String jarg2);
-  public final static native String neoversion_t_buildBranch_get(long jarg1, neoversion_t jarg1_);
-  public final static native void neoversion_t_buildTag_set(long jarg1, neoversion_t jarg1_, String jarg2);
-  public final static native String neoversion_t_buildTag_get(long jarg1, neoversion_t jarg1_);
-  public final static native void neoversion_t_reserved_set(long jarg1, neoversion_t jarg1_, String jarg2);
-  public final static native String neoversion_t_reserved_get(long jarg1, neoversion_t jarg1_);
-  public final static native long new_neoversion_t();
-  public final static native void delete_neoversion_t(long jarg1);
-  public final static native void neoevent_t_description_set(long jarg1, neoevent_t jarg1_, String jarg2);
-  public final static native String neoevent_t_description_get(long jarg1, neoevent_t jarg1_);
-  public final static native void neoevent_t_timestamp_set(long jarg1, neoevent_t jarg1_, long jarg2);
-  public final static native long neoevent_t_timestamp_get(long jarg1, neoevent_t jarg1_);
-  public final static native void neoevent_t_eventNumber_set(long jarg1, neoevent_t jarg1_, long jarg2);
-  public final static native long neoevent_t_eventNumber_get(long jarg1, neoevent_t jarg1_);
-  public final static native void neoevent_t_severity_set(long jarg1, neoevent_t jarg1_, short jarg2);
-  public final static native short neoevent_t_severity_get(long jarg1, neoevent_t jarg1_);
-  public final static native void neoevent_t_serial_set(long jarg1, neoevent_t jarg1_, String jarg2);
-  public final static native String neoevent_t_serial_get(long jarg1, neoevent_t jarg1_);
-  public final static native void neoevent_t_reserved_set(long jarg1, neoevent_t jarg1_, short[] jarg2);
-  public final static native short[] neoevent_t_reserved_get(long jarg1, neoevent_t jarg1_);
-  public final static native long new_neoevent_t();
-  public final static native void delete_neoevent_t(long jarg1);
-  public final static native int ICSNEO_NETID_DEVICE_get();
-  public final static native int ICSNEO_NETID_HSCAN_get();
-  public final static native int ICSNEO_NETID_MSCAN_get();
-  public final static native int ICSNEO_NETID_SWCAN_get();
-  public final static native int ICSNEO_NETID_LSFTCAN_get();
-  public final static native int ICSNEO_NETID_FORDSCP_get();
-  public final static native int ICSNEO_NETID_J1708_get();
-  public final static native int ICSNEO_NETID_AUX_get();
-  public final static native int ICSNEO_NETID_J1850VPW_get();
-  public final static native int ICSNEO_NETID_ISO_get();
-  public final static native int ICSNEO_NETID_MAIN51_get();
-  public final static native int ICSNEO_NETID_RED_get();
-  public final static native int ICSNEO_NETID_SCI_get();
-  public final static native int ICSNEO_NETID_ISO2_get();
-  public final static native int ICSNEO_NETID_ISO14230_get();
-  public final static native int ICSNEO_NETID_LIN_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET1_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET2_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET3_get();
-  public final static native int ICSNEO_NETID_RED_EXT_MEMORYREAD_get();
-  public final static native int ICSNEO_NETID_RED_INT_MEMORYREAD_get();
-  public final static native int ICSNEO_NETID_RED_DFLASH_READ_get();
-  public final static native int ICSNEO_NETID_RED_SDCARD_READ_get();
-  public final static native int ICSNEO_NETID_CAN_ERRBITS_get();
-  public final static native int ICSNEO_NETID_RED_DFLASH_WRITE_DONE_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_CAN1_LOGICAL_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_CAN2_LOGICAL_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_LIN1_LOGICAL_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_LIN2_LOGICAL_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_LIN1_ANALOG_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_LIN2_ANALOG_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_MISC_ANALOG_get();
-  public final static native int ICSNEO_NETID_RED_WAVE_MISCDIO2_LOGICAL_get();
-  public final static native int ICSNEO_NETID_RED_NETWORK_COM_ENABLE_EX_get();
-  public final static native int ICSNEO_NETID_RED_NEOVI_NETWORK_get();
-  public final static native int ICSNEO_NETID_RED_READ_BAUD_SETTINGS_get();
-  public final static native int ICSNEO_NETID_RED_OLDFORMAT_get();
-  public final static native int ICSNEO_NETID_RED_SCOPE_CAPTURE_get();
-  public final static native int ICSNEO_NETID_RED_HARDWARE_EXCEP_get();
-  public final static native int ICSNEO_NETID_RED_GET_RTC_get();
-  public final static native int ICSNEO_NETID_ISO3_get();
-  public final static native int ICSNEO_NETID_HSCAN2_get();
-  public final static native int ICSNEO_NETID_HSCAN3_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET4_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET5_get();
-  public final static native int ICSNEO_NETID_ISO4_get();
-  public final static native int ICSNEO_NETID_LIN2_get();
-  public final static native int ICSNEO_NETID_LIN3_get();
-  public final static native int ICSNEO_NETID_LIN4_get();
-  public final static native int ICSNEO_NETID_RED_APP_ERROR_get();
-  public final static native int ICSNEO_NETID_CGI_get();
-  public final static native int ICSNEO_NETID_RESET_STATUS_get();
-  public final static native int ICSNEO_NETID_FB_STATUS_get();
-  public final static native int ICSNEO_NETID_APP_SIGNAL_STATUS_get();
-  public final static native int ICSNEO_NETID_READ_DATALINK_CM_TX_MSG_get();
-  public final static native int ICSNEO_NETID_READ_DATALINK_CM_RX_MSG_get();
-  public final static native int ICSNEO_NETID_LOGGING_OVERFLOW_get();
-  public final static native int ICSNEO_NETID_READ_SETTINGS_get();
-  public final static native int ICSNEO_NETID_HSCAN4_get();
-  public final static native int ICSNEO_NETID_HSCAN5_get();
-  public final static native int ICSNEO_NETID_RS232_get();
-  public final static native int ICSNEO_NETID_UART_get();
-  public final static native int ICSNEO_NETID_UART2_get();
-  public final static native int ICSNEO_NETID_UART3_get();
-  public final static native int ICSNEO_NETID_UART4_get();
-  public final static native int ICSNEO_NETID_SWCAN2_get();
-  public final static native int ICSNEO_NETID_ETHERNET_DAQ_get();
-  public final static native int ICSNEO_NETID_DATA_TO_HOST_get();
-  public final static native int ICSNEO_NETID_TEXTAPI_TO_HOST_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET6_get();
-  public final static native int ICSNEO_NETID_RED_VBAT_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET7_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET8_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET9_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET10_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET11_get();
-  public final static native int ICSNEO_NETID_FLEXRAY1A_get();
-  public final static native int ICSNEO_NETID_FLEXRAY1B_get();
-  public final static native int ICSNEO_NETID_FLEXRAY2A_get();
-  public final static native int ICSNEO_NETID_FLEXRAY2B_get();
-  public final static native int ICSNEO_NETID_LIN5_get();
-  public final static native int ICSNEO_NETID_FLEXRAY_get();
-  public final static native int ICSNEO_NETID_FLEXRAY2_get();
-  public final static native int ICSNEO_NETID_OP_ETHERNET12_get();
-  public final static native int ICSNEO_NETID_MOST25_get();
-  public final static native int ICSNEO_NETID_MOST50_get();
-  public final static native int ICSNEO_NETID_MOST150_get();
-  public final static native int ICSNEO_NETID_ETHERNET_get();
-  public final static native int ICSNEO_NETID_GMFSA_get();
-  public final static native int ICSNEO_NETID_TCP_get();
-  public final static native int ICSNEO_NETID_HSCAN6_get();
-  public final static native int ICSNEO_NETID_HSCAN7_get();
-  public final static native int ICSNEO_NETID_LIN6_get();
-  public final static native int ICSNEO_NETID_LSFTCAN2_get();
-  public final static native int ICSNEO_NETID_HW_COM_LATENCY_TEST_get();
-  public final static native int ICSNEO_NETID_DEVICE_STATUS_get();
-  public final static native int ICSNEO_NETID_ANY_get();
-  public final static native int ICSNEO_NETID_INVALID_get();
-  public final static native int ICSNEO_NETWORK_TYPE_INVALID_get();
-  public final static native int ICSNEO_NETWORK_TYPE_INTERNAL_get();
-  public final static native int ICSNEO_NETWORK_TYPE_CAN_get();
-  public final static native int ICSNEO_NETWORK_TYPE_LIN_get();
-  public final static native int ICSNEO_NETWORK_TYPE_FLEXRAY_get();
-  public final static native int ICSNEO_NETWORK_TYPE_MOST_get();
-  public final static native int ICSNEO_NETWORK_TYPE_ETHERNET_get();
-  public final static native int ICSNEO_NETWORK_TYPE_ANY_get();
-  public final static native int ICSNEO_NETWORK_TYPE_OTHER_get();
-  public final static native long neomessage_can_t_cast(long jarg1, neomessage_t jarg1_);
-  public final static native long neomessage_eth_t_cast(long jarg1, neomessage_t jarg1_);
-  public final static native long from_can_neomessage_t_cast(long jarg1, neomessage_can_t jarg1_);
-  public final static native long from_eth_neomessage_t_cast(long jarg1, neomessage_eth_t jarg1_);
-  public final static native long new_neodevice_t_array(int jarg1);
-  public final static native void delete_neodevice_t_array(long jarg1, neodevice_t jarg1_);
-  public final static native long neodevice_t_array_getitem(long jarg1, neodevice_t jarg1_, int jarg2);
-  public final static native void neodevice_t_array_setitem(long jarg1, neodevice_t jarg1_, int jarg2, long jarg3, neodevice_t jarg3_);
-  public final static native long new_neoevent_t_array(int jarg1);
-  public final static native void delete_neoevent_t_array(long jarg1, neoevent_t jarg1_);
-  public final static native long neoevent_t_array_getitem(long jarg1, neoevent_t jarg1_, int jarg2);
-  public final static native void neoevent_t_array_setitem(long jarg1, neoevent_t jarg1_, int jarg2, long jarg3, neoevent_t jarg3_);
-  public final static native long new_neomessage_t_array(int jarg1);
-  public final static native void delete_neomessage_t_array(long jarg1, neomessage_t jarg1_);
-  public final static native long neomessage_t_array_getitem(long jarg1, neomessage_t jarg1_, int jarg2);
-  public final static native void neomessage_t_array_setitem(long jarg1, neomessage_t jarg1_, int jarg2, long jarg3, neomessage_t jarg3_);
-}

examples/java/src/neodevice_t.java

@@ -1,75 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class neodevice_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neodevice_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neodevice_t obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-
-  @SuppressWarnings("deprecation")
-  protected void finalize() {
-    delete();
-  }
-
-  public synchronized void delete() {
-    if (swigCPtr != 0) {
-      if (swigCMemOwn) {
-        swigCMemOwn = false;
-        icsneojavaJNI.delete_neodevice_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setDevice(SWIGTYPE_p_void value) {
-    icsneojavaJNI.neodevice_t_device_set(swigCPtr, this, SWIGTYPE_p_void.getCPtr(value));
-  }
-
-  public SWIGTYPE_p_void getDevice() {
-    long cPtr = icsneojavaJNI.neodevice_t_device_get(swigCPtr, this);
-    return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false);
-  }
-
-  public void setHandle(int value) {
-    icsneojavaJNI.neodevice_t_handle_set(swigCPtr, this, value);
-  }
-
-  public int getHandle() {
-    return icsneojavaJNI.neodevice_t_handle_get(swigCPtr, this);
-  }
-
-  public void setType(long value) {
-    icsneojavaJNI.neodevice_t_type_set(swigCPtr, this, value);
-  }
-
-  public long getType() {
-    return icsneojavaJNI.neodevice_t_type_get(swigCPtr, this);
-  }
-
-  public void setSerial(String value) {
-    icsneojavaJNI.neodevice_t_serial_set(swigCPtr, this, value);
-  }
-
-  public String getSerial() {
-    return icsneojavaJNI.neodevice_t_serial_get(swigCPtr, this);
-  }
-
-  public neodevice_t() {
-    this(icsneojavaJNI.new_neodevice_t(), true);
-  }
-
-}

examples/java/src/neoevent_t.java

@@ -1,90 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class neoevent_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neoevent_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neoevent_t obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-
-  @SuppressWarnings("deprecation")
-  protected void finalize() {
-    delete();
-  }
-
-  public synchronized void delete() {
-    if (swigCPtr != 0) {
-      if (swigCMemOwn) {
-        swigCMemOwn = false;
-        icsneojavaJNI.delete_neoevent_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setDescription(String value) {
-    icsneojavaJNI.neoevent_t_description_set(swigCPtr, this, value);
-  }
-
-  public String getDescription() {
-    return icsneojavaJNI.neoevent_t_description_get(swigCPtr, this);
-  }
-
-  public void setTimestamp(SWIGTYPE_p_time_t value) {
-    icsneojavaJNI.neoevent_t_timestamp_set(swigCPtr, this, SWIGTYPE_p_time_t.getCPtr(value));
-  }
-
-  public SWIGTYPE_p_time_t getTimestamp() {
-    return new SWIGTYPE_p_time_t(icsneojavaJNI.neoevent_t_timestamp_get(swigCPtr, this), true);
-  }
-
-  public void setEventNumber(long value) {
-    icsneojavaJNI.neoevent_t_eventNumber_set(swigCPtr, this, value);
-  }
-
-  public long getEventNumber() {
-    return icsneojavaJNI.neoevent_t_eventNumber_get(swigCPtr, this);
-  }
-
-  public void setSeverity(short value) {
-    icsneojavaJNI.neoevent_t_severity_set(swigCPtr, this, value);
-  }
-
-  public short getSeverity() {
-    return icsneojavaJNI.neoevent_t_severity_get(swigCPtr, this);
-  }
-
-  public void setSerial(String value) {
-    icsneojavaJNI.neoevent_t_serial_set(swigCPtr, this, value);
-  }
-
-  public String getSerial() {
-    return icsneojavaJNI.neoevent_t_serial_get(swigCPtr, this);
-  }
-
-  public void setReserved(short[] value) {
-    icsneojavaJNI.neoevent_t_reserved_set(swigCPtr, this, value);
-  }
-
-  public short[] getReserved() {
-    return icsneojavaJNI.neoevent_t_reserved_get(swigCPtr, this);
-  }
-
-  public neoevent_t() {
-    this(icsneojavaJNI.new_neoevent_t(), true);
-  }
-
-}

examples/java/src/neomessage_can_t.java

@@ -1,123 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public class neomessage_can_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neomessage_can_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neomessage_can_t obj) {
-    return (obj == null) ? 0 : obj.swigCPtr;
-  }
-
-  @SuppressWarnings("deprecation")
-  protected void finalize() {
-    delete();
-  }
-
-  public synchronized void delete() {
-    if (swigCPtr != 0) {
-      if (swigCMemOwn) {
-        swigCMemOwn = false;
-        icsneojavaJNI.delete_neomessage_can_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setStatus(neomessage_statusbitfield_t value) {
-    icsneojavaJNI.neomessage_can_t_status_set(swigCPtr, this, neomessage_statusbitfield_t.getCPtr(value), value);
-  }
-
-  public neomessage_statusbitfield_t getStatus() {
-    long cPtr = icsneojavaJNI.neomessage_can_t_status_get(swigCPtr, this);
-    return (cPtr == 0) ? null : new neomessage_statusbitfield_t(cPtr, false);
-  }
-
-  public void setTimestamp(java.math.BigInteger value) {
-    icsneojavaJNI.neomessage_can_t_timestamp_set(swigCPtr, this, value);
-  }
-
-  public java.math.BigInteger getTimestamp() {
-    return icsneojavaJNI.neomessage_can_t_timestamp_get(swigCPtr, this);
-  }
-
-  public void setTimestampReserved(java.math.BigInteger value) {
-    icsneojavaJNI.neomessage_can_t_timestampReserved_set(swigCPtr, this, value);
-  }
-
-  public java.math.BigInteger getTimestampReserved() {
-    return icsneojavaJNI.neomessage_can_t_timestampReserved_get(swigCPtr, this);
-  }
-
-  public void setData(byte[] value) {
-    icsneojavaJNI.neomessage_can_t_data_set(swigCPtr, this, value);
-  }
-
-  public byte[] getData() {
-    return icsneojavaJNI.neomessage_can_t_data_get(swigCPtr, this);
-}
-
-  public void setLength(long value) {
-    icsneojavaJNI.neomessage_can_t_length_set(swigCPtr, this, value);
-  }
-
-  public long getLength() {
-    return icsneojavaJNI.neomessage_can_t_length_get(swigCPtr, this);
-  }
-
-  public void setArbid(long value) {
-    icsneojavaJNI.neomessage_can_t_arbid_set(swigCPtr, this, value);
-  }
-
-  public long getArbid() {
-    return icsneojavaJNI.neomessage_can_t_arbid_get(swigCPtr, this);
-  }
-
-  public void setNetid(int value) {
-    icsneojavaJNI.neomessage_can_t_netid_set(swigCPtr, this, value);
-  }
-
-  public int getNetid() {
-    return icsneojavaJNI.neomessage_can_t_netid_get(swigCPtr, this);
-  }
-
-  public void setType(short value) {
-    icsneojavaJNI.neomessage_can_t_type_set(swigCPtr, this, value);
-  }
-
-  public short getType() {
-    return icsneojavaJNI.neomessage_can_t_type_get(swigCPtr, this);
-  }
-
-  public void setDlcOnWire(short value) {
-    icsneojavaJNI.neomessage_can_t_dlcOnWire_set(swigCPtr, this, value);
-  }
-
-  public short getDlcOnWire() {
-    return icsneojavaJNI.neomessage_can_t_dlcOnWire_get(swigCPtr, this);
-  }
-
-  public void setReserved(short[] value) {
-    icsneojavaJNI.neomessage_can_t_reserved_set(swigCPtr, this, value);
-  }
-
-  public short[] getReserved() {
-    return icsneojavaJNI.neomessage_can_t_reserved_get(swigCPtr, this);
-  }
-
-  public neomessage_can_t() {
-    this(icsneojavaJNI.new_neomessage_can_t(), true);
-  }
-
-}