Clean up example

Add second signal set to the example

.gitlab-ci.yml

@@ -4,7 +4,6 @@ variables:
 stages:
   - build
   - unit_test
-  - hardware_test
   - deploy
 
 #-------------------------------------------------------------------------------
@@ -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
-  stage: hardware_test
-  tags:
-    - 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
+build linux/fedora/40/amd64/gcc:
+  <<: *build_linux_fedora_gcc
+  image: fedora:40
 
-.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
-      artifacts: true
+    - build linux/fedora/40/amd64/gcc
 
-hardware_test fedora38-red2:
-  <<: *hw_test
-  <<: *fedora38_needs
-  variables:
-    GUEST_OS_TAG: fedora38
-    DEVICE_PORT: ETH_A
+build linux/fedora/40/amd64/clang:
+  <<: *build_linux_fedora_clang
+  image: fedora:40
 
-hardware_test fedora38-vcan42:
-  <<: *hw_test
-  <<: *fedora38_needs
-  variables:
-    GUEST_OS_TAG: fedora38
-    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
+unit_test linux/fedora/40/amd64/clang:
+  <<: *test_linux_fedora_clang
+  image: fedora:40
+  dependencies:
+    - build linux/fedora/40/amd64/clang
   needs:
-    - job: build linux/ubuntu/2204/amd64/clang
-      artifacts: true
+    - build linux/fedora/40/amd64/clang
 
-hardware_test ubuntu2204-red2:
-  <<: *hw_test
-  <<: *ubuntu2204_needs
-  variables:
-    GUEST_OS_TAG: ubuntu22.04
-    DEVICE_PORT: ETH_A
+build linux/fedora/41/amd64/gcc:
+  <<: *build_linux_fedora_gcc
+  image: fedora:41
 
-hardware_test ubuntu2204-vcan42:
-  <<: *hw_test
-  <<: *ubuntu2204_needs
-  variables:
-    GUEST_OS_TAG: ubuntu22.04
-    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
+unit_test linux/fedora/41/amd64/gcc:
+  <<: *test_linux_fedora_gcc
+  image: fedora:41
+  dependencies:
+    - build linux/fedora/41/amd64/gcc
   needs:
-    - job: build windows/x64
-      artifacts: true
+    - build linux/fedora/41/amd64/gcc
 
-hardware_test win10-red2:
-  <<: *hw_test
-  <<: *win10_needs
-  variables:
-    GUEST_OS_TAG: win10
-    DEVICE_PORT: ETH_A
+build linux/fedora/41/amd64/clang:
+  <<: *build_linux_fedora_clang
+  image: fedora:41
 
-hardware_test win10-vcan42:
-  <<: *hw_test
-  <<: *win10_needs
-  variables:
-    GUEST_OS_TAG: win10
-    DEVICE_PORT: USB_D
-
-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
+unit_test linux/fedora/41/amd64/clang:
+  <<: *test_linux_fedora_clang
+  image: fedora:41
+  dependencies:
+    - build linux/fedora/41/amd64/clang
+  needs:
+    - build linux/fedora/41/amd64/clang
 
 #-------------------------------------------------------------------------------
 # 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)
-project(libicsneo VERSION 0.3.0)
+cmake_minimum_required(VERSION 3.16)
+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,9 +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
@@ -275,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
@@ -304,6 +308,7 @@ set(SRC_FILES
 	disk/vsa/vsa0f.cpp
 	disk/vsa/vsa6a.cpp
 	disk/vsa/vsaparser.cpp
+	platform/servd.cpp
 	${PLATFORM_SRC}
 )
 
@@ -364,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})
@@ -422,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)
@@ -527,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)
@@ -539,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)

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/icsneocpp/event.cpp

@@ -121,6 +121,7 @@ static constexpr const char* UNEXPECTED_RESPONSE = "Received an unexpected or in
 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.";
@@ -183,6 +184,19 @@ 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.";
@@ -316,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;
@@ -434,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_MSCAN, 2},
-	{NETID_HSCAN2, 18},
-	{NETID_HSCAN3, 19},
-	{NETID_HSCAN4, 32},
-	{NETID_HSCAN5, 33},
-	{NETID_HSCAN6, 47},
-	{NETID_HSCAN7, 48},
+	{NETID_DWCAN_01, 1},
+	{NETID_DWCAN_08, 2},
+	{NETID_DWCAN_02, 18},
+	{NETID_DWCAN_03, 19},
+	{NETID_DWCAN_04, 32},
+	{NETID_DWCAN_05, 33},
+	{NETID_DWCAN_06, 47},
+	{NETID_DWCAN_07, 48},
 };
 
 static const std::map<size_t, size_t> mp_HWnetIDToCMnetID = {
-	{NETID_HSCAN, 0},
-	{NETID_MSCAN, 1},
-	{NETID_HSCAN2, 5},
-	{NETID_HSCAN3, 8},
-	{NETID_HSCAN4, 14},
-	{NETID_HSCAN5, 15},
-	{NETID_HSCAN6, 32},
-	{NETID_HSCAN7, 33},
+	{NETID_DWCAN_01, 0},
+	{NETID_DWCAN_08, 1},
+	{NETID_DWCAN_02, 5},
+	{NETID_DWCAN_03, 8},
+	{NETID_DWCAN_04, 14},
+	{NETID_DWCAN_05, 15},
+	{NETID_DWCAN_06, 32},
+	{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,6 +21,7 @@ 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
@@ -19,15 +31,24 @@ pybind11_add_module(icsneopy
     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 icsneopy)
 
-add_custom_command(TARGET icsneopy POST_BUILD COMMAND stubgen -m icsneopy -o .)
+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 ${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi __init__.py py.typed DESTINATION icsneopy)
+install(FILES __init__.py DESTINATION icsneopy)

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/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/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/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("MSCAN", Network::NetID::MSCAN)
-		.value("SWCAN", Network::NetID::SWCAN)
-		.value("LSFTCAN", Network::NetID::LSFTCAN)
+		.value("DWCAN_01", Network::NetID::DWCAN_01)
+		.value("DWCAN_08", Network::NetID::DWCAN_08)
+		.value("SWCAN_01", Network::NetID::SWCAN_01)
+		.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("OP_Ethernet1", Network::NetID::OP_Ethernet1)
-		.value("OP_Ethernet2", Network::NetID::OP_Ethernet2)
-		.value("OP_Ethernet3", Network::NetID::OP_Ethernet3)
+		.value("LIN_01", Network::NetID::LIN_01)
+		.value("AE_01", Network::NetID::AE_01)
+		.value("AE_02", Network::NetID::AE_02)
+		.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("HSCAN2", Network::NetID::HSCAN2)
-		.value("HSCAN3", Network::NetID::HSCAN3)
-		.value("OP_Ethernet4", Network::NetID::OP_Ethernet4)
-		.value("OP_Ethernet5", Network::NetID::OP_Ethernet5)
-		.value("ISO9141_4", Network::NetID::ISO9141_4)
-		.value("LIN2", Network::NetID::LIN2)
-		.value("LIN3", Network::NetID::LIN3)
-		.value("LIN4", Network::NetID::LIN4)
+		.value("ISO9141_03", Network::NetID::ISO9141_03)
+		.value("DWCAN_02", Network::NetID::DWCAN_02)
+		.value("DWCAN_03", Network::NetID::DWCAN_03)
+		.value("AE_04", Network::NetID::AE_04)
+		.value("AE_05", Network::NetID::AE_05)
+		.value("ISO9141_04", Network::NetID::ISO9141_04)
+		.value("LIN_02", Network::NetID::LIN_02)
+		.value("LIN_03", Network::NetID::LIN_03)
+		.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("HSCAN5", Network::NetID::HSCAN5)
+		.value("DWCAN_04", Network::NetID::DWCAN_04)
+		.value("DWCAN_05", Network::NetID::DWCAN_05)
 		.value("RS232", Network::NetID::RS232)
-		.value("UART", Network::NetID::UART)
-		.value("UART2", Network::NetID::UART2)
-		.value("UART3", Network::NetID::UART3)
-		.value("UART4", Network::NetID::UART4)
-		.value("SWCAN2", Network::NetID::SWCAN2)
-		.value("Ethernet_DAQ", Network::NetID::Ethernet_DAQ)
+		.value("UART_01", Network::NetID::UART_01)
+		.value("UART_02", Network::NetID::UART_02)
+		.value("UART_03", Network::NetID::UART_03)
+		.value("UART_04", Network::NetID::UART_04)
+		.value("SWCAN_02", Network::NetID::SWCAN_02)
+		.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("OP_Ethernet6", Network::NetID::OP_Ethernet6)
+		.value("SPI_01", Network::NetID::SPI_01)
+		.value("AE_06", Network::NetID::AE_06)
 		.value("Red_VBat", Network::NetID::Red_VBat)
-		.value("OP_Ethernet7", Network::NetID::OP_Ethernet7)
-		.value("OP_Ethernet8", Network::NetID::OP_Ethernet8)
-		.value("OP_Ethernet9", Network::NetID::OP_Ethernet9)
-		.value("OP_Ethernet10", Network::NetID::OP_Ethernet10)
-		.value("OP_Ethernet11", Network::NetID::OP_Ethernet11)
-		.value("FlexRay1a", Network::NetID::FlexRay1a)
-		.value("FlexRay1b", Network::NetID::FlexRay1b)
-		.value("FlexRay2a", Network::NetID::FlexRay2a)
-		.value("FlexRay2b", Network::NetID::FlexRay2b)
-		.value("LIN5", Network::NetID::LIN5)
-		.value("FlexRay", Network::NetID::FlexRay)
-		.value("FlexRay2", Network::NetID::FlexRay2)
-		.value("OP_Ethernet12", Network::NetID::OP_Ethernet12)
-		.value("I2C", Network::NetID::I2C)
-		.value("MOST25", Network::NetID::MOST25)
-		.value("MOST50", Network::NetID::MOST50)
-		.value("MOST150", Network::NetID::MOST150)
-		.value("Ethernet", Network::NetID::Ethernet)
+		.value("AE_07", Network::NetID::AE_07)
+		.value("AE_08", Network::NetID::AE_08)
+		.value("AE_09", Network::NetID::AE_09)
+		.value("AE_10", Network::NetID::AE_10)
+		.value("AE_11", Network::NetID::AE_11)
+		.value("FLEXRAY_01A", Network::NetID::FLEXRAY_01A)
+		.value("FLEXRAY_01B", Network::NetID::FLEXRAY_01B)
+		.value("FLEXRAY_02A", Network::NetID::FLEXRAY_02A)
+		.value("FLEXRAY_02B", Network::NetID::FLEXRAY_02B)
+		.value("LIN_05", Network::NetID::LIN_05)
+		.value("FLEXRAY_01", Network::NetID::FLEXRAY_01)
+		.value("FLEXRAY_02", Network::NetID::FLEXRAY_02)
+		.value("AE_12", Network::NetID::AE_12)
+		.value("I2C_01", Network::NetID::I2C_01)
+		.value("MOST_25", Network::NetID::MOST_25)
+		.value("MOST_50", Network::NetID::MOST_50)
+		.value("MOST_150", Network::NetID::MOST_150)
+		.value("ETHERNET_01", Network::NetID::ETHERNET_01)
 		.value("GMFSA", Network::NetID::GMFSA)
 		.value("TCP", Network::NetID::TCP)
-		.value("HSCAN6", Network::NetID::HSCAN6)
-		.value("HSCAN7", Network::NetID::HSCAN7)
-		.value("LIN6", Network::NetID::LIN6)
-		.value("LSFTCAN2", Network::NetID::LSFTCAN2)
+		.value("DWCAN_06", Network::NetID::DWCAN_06)
+		.value("DWCAN_07", Network::NetID::DWCAN_07)
+		.value("LIN_06", Network::NetID::LIN_06)
+		.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("I2C3", Network::NetID::I2C3)
-		.value("I2C4", Network::NetID::I2C4)
-		.value("Ethernet2", Network::NetID::Ethernet2)
-		.value("A2B1", Network::NetID::A2B1)
-		.value("A2B2", Network::NetID::A2B2)
-		.value("Ethernet3", Network::NetID::Ethernet3)
-		.value("WBMS", Network::NetID::WBMS)
-		.value("DWCAN9", Network::NetID::DWCAN9)
-		.value("DWCAN10", Network::NetID::DWCAN10)
-		.value("DWCAN11", Network::NetID::DWCAN11)
-		.value("DWCAN12", Network::NetID::DWCAN12)
-		.value("DWCAN13", Network::NetID::DWCAN13)
-		.value("DWCAN14", Network::NetID::DWCAN14)
-		.value("DWCAN15", Network::NetID::DWCAN15)
-		.value("DWCAN16", Network::NetID::DWCAN16)
-		.value("LIN7", Network::NetID::LIN7)
-		.value("LIN8", Network::NetID::LIN8)
-		.value("SPI2", Network::NetID::SPI2)
-		.value("MDIO1", Network::NetID::MDIO1)
-		.value("MDIO2", Network::NetID::MDIO2)
-		.value("MDIO3", Network::NetID::MDIO3)
-		.value("MDIO4", Network::NetID::MDIO4)
-		.value("MDIO5", Network::NetID::MDIO5)
-		.value("MDIO6", Network::NetID::MDIO6)
-		.value("MDIO7", Network::NetID::MDIO7)
-		.value("MDIO8", Network::NetID::MDIO8)
-		.value("OP_Ethernet13", Network::NetID::OP_Ethernet13)
-		.value("OP_Ethernet14", Network::NetID::OP_Ethernet14)
-		.value("OP_Ethernet15", Network::NetID::OP_Ethernet15)
-		.value("OP_Ethernet16", Network::NetID::OP_Ethernet16)
-		.value("SPI3", Network::NetID::SPI3)
-		.value("SPI4", Network::NetID::SPI4)
-		.value("SPI5", Network::NetID::SPI5)
-		.value("SPI6", Network::NetID::SPI6)
-		.value("SPI7", Network::NetID::SPI7)
-		.value("SPI8", Network::NetID::SPI8)
-		.value("LIN9", Network::NetID::LIN9)
-		.value("LIN10", Network::NetID::LIN10)
-		.value("LIN11", Network::NetID::LIN11)
-		.value("LIN12", Network::NetID::LIN12)
-		.value("LIN13", Network::NetID::LIN13)
-		.value("LIN14", Network::NetID::LIN14)
-		.value("LIN15", Network::NetID::LIN15)
-		.value("LIN16", Network::NetID::LIN16)
+		.value("I2C_02", Network::NetID::I2C_02)
+		.value("I2C_03", Network::NetID::I2C_03)
+		.value("I2C_04", Network::NetID::I2C_04)
+		.value("ETHERNET_02", Network::NetID::ETHERNET_02)
+		.value("A2B_01", Network::NetID::A2B_01)
+		.value("A2B_02", Network::NetID::A2B_02)
+		.value("ETHERNET_03", Network::NetID::ETHERNET_03)
+		.value("WBMS_01", Network::NetID::WBMS_01)
+		.value("DWCAN_09", Network::NetID::DWCAN_09)
+		.value("DWCAN_10", Network::NetID::DWCAN_10)
+		.value("DWCAN_11", Network::NetID::DWCAN_11)
+		.value("DWCAN_12", Network::NetID::DWCAN_12)
+		.value("DWCAN_13", Network::NetID::DWCAN_13)
+		.value("DWCAN_14", Network::NetID::DWCAN_14)
+		.value("DWCAN_15", Network::NetID::DWCAN_15)
+		.value("DWCAN_16", Network::NetID::DWCAN_16)
+		.value("LIN_07", Network::NetID::LIN_07)
+		.value("LIN_08", Network::NetID::LIN_08)
+		.value("SPI_02", Network::NetID::SPI_02)
+		.value("MDIO_01", Network::NetID::MDIO_01)
+		.value("MDIO_02", Network::NetID::MDIO_02)
+		.value("MDIO_03", Network::NetID::MDIO_03)
+		.value("MDIO_04", Network::NetID::MDIO_04)
+		.value("MDIO_05", Network::NetID::MDIO_05)
+		.value("MDIO_06", Network::NetID::MDIO_06)
+		.value("MDIO_07", Network::NetID::MDIO_07)
+		.value("MDIO_08", Network::NetID::MDIO_08)
+		.value("AE_13", Network::NetID::AE_13)
+		.value("AE_14", Network::NetID::AE_14)
+		.value("AE_15", Network::NetID::AE_15)
+		.value("AE_16", Network::NetID::AE_16)
+		.value("SPI_03", Network::NetID::SPI_03)
+		.value("SPI_04", Network::NetID::SPI_04)
+		.value("SPI_05", Network::NetID::SPI_05)
+		.value("SPI_06", Network::NetID::SPI_06)
+		.value("SPI_07", Network::NetID::SPI_07)
+		.value("SPI_08", Network::NetID::SPI_08)
+		.value("LIN_09", Network::NetID::LIN_09)
+		.value("LIN_10", Network::NetID::LIN_10)
+		.value("LIN_11", Network::NetID::LIN_11)
+		.value("LIN_12", Network::NetID::LIN_12)
+		.value("LIN_13", Network::NetID::LIN_13)
+		.value("LIN_14", Network::NetID::LIN_14)
+		.value("LIN_15", Network::NetID::LIN_15)
+		.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,42 +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("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("__repr__", &Device::describe)
 		.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("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("clear_script", &Device::clearScript, 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("get_gptp_status", &Device::getGPTPStatus, pybind11::arg("timeout") = std::chrono::milliseconds(100), 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,6 +10,7 @@ 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_&);
@@ -20,10 +21,15 @@ 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;
@@ -36,6 +42,7 @@ 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);
@@ -45,9 +52,14 @@ PYBIND11_MODULE(icsneopy, 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 CXXFLAGS=/WX
-cmake -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_BUILD_SYSTEM_TESTS=ON -DLIBICSNEO_ENABLE_TCP=ON ..
+set CFLAGS=/WX /W4 /wd4127
+set CXXFLAGS=/WX /W4 /wd4127
+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%

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

@@ -16,6 +16,7 @@
 #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"
@@ -491,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/livedata.cpp

@@ -18,5 +18,59 @@ double liveDataValueToDouble(const LiveDataValue& val) {
 	return val.value * liveDataFixedPointToDouble; 
 } 
 
+int liveDataDoubleToValue(LiveDataValue& value, const double& dFloat) {
+	union {
+		struct
+		{
+			uint32_t ValueFractionPart;
+			int32_t ValueInt32;
+		} parts;
+		int64_t ValueLarge;
+	} CminiFixedPt;
+	constexpr double CM_FIXED_POINT_TO_DOUBLEVALUE = (1.0 / (double)(1ULL << 32)); // 2^-32
+	constexpr double CM_DOUBLEVALUE_TO_FIXED_POINT = ((double)(1ULL << 32)); // 2^32
+	// Use const for limits (C++98 compatible)
+	const double INT32_MAX_DOUBLE =
+		static_cast<double>(std::numeric_limits<int32_t>::max()) + (1.0 - std::numeric_limits<double>::epsilon());
+	const double INT32_MIN_DOUBLE = static_cast<double>(std::numeric_limits<int32_t>::min());
+	const double MIN_FIXED_POINT_DOUBLE = (double)(1ull * CM_FIXED_POINT_TO_DOUBLEVALUE);
+
+	// This needs to be assigned separately, otherwise, for dFloat >= 2^31,
+	// long double dBigFloat = dFloat * CM_DOUBLEVALUE_TO_FIXED_POINT overflows
+	// long long (value is >= 2^63) and so the assignment ValueLarge = dBigFloat is undefined
+
+	int32_t intPart; //creating temp variable due to static analysis warning about writing and reading to different union members
+	if (dFloat < 0.0)
+		intPart = (int32_t)floor(dFloat);
+	else
+		intPart = (int32_t)dFloat;
+
+	//using temp varialbes to avoid static analysis warning about read/write to different union members
+	double frac = dFloat - (double)(intPart);
+	uint32_t fracPart = (uint32_t)floor((frac * CM_DOUBLEVALUE_TO_FIXED_POINT) + 0.5);
+
+	//write temp vars back into the union
+	CminiFixedPt.parts.ValueInt32 = intPart;
+	CminiFixedPt.parts.ValueFractionPart = fracPart;
+	value.value = CminiFixedPt.ValueLarge;
+
+	if (dFloat == (double)0.0)
+		return 0;
+
+	//check if double can be stored as 32.32
+	// 0x1 0000 0000 0000 0000 * CM_FIXED_POINT_TO_DOUBLEVALUE = 0x1 0000 0000
+	if (dFloat > INT32_MAX_DOUBLE)
+		return 1;
+	if (dFloat < INT32_MIN_DOUBLE)
+		return -1;
+
+	// Use absolute value for minimum fixed point check
+	double absFloat = (dFloat < 0.0) ? -dFloat : dFloat;
+	if (absFloat < MIN_FIXED_POINT_DOUBLE)
+		return -2;
+
+	return 0;
+}
+
 } // namespace LiveDataUtil
 } // namespace icsneo

communication/message/ethernetstatusmessage.cpp

@@ -14,10 +14,10 @@ enum LinkSpeed {
 };
 
 enum LinkMode {
-	OPETH_LINK_AUTO,
-	OPETH_LINK_MASTER,
-	OPETH_LINK_SLAVE,
-	OPETH_LINK_INVALID = 255,
+	AE_LINK_AUTO,
+	AE_LINK_MASTER,
+	AE_LINK_SLAVE,
+	AE_LINK_INVALID = 255,
 };
 
 struct Packet {
@@ -47,10 +47,10 @@ std::shared_ptr<Message> EthernetStatusMessage::DecodeToMessage(const std::vecto
 	}
 	LinkMode mode;
 	switch(packet->mode) {
-		case OPETH_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
-		case OPETH_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
-		case OPETH_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
-		case OPETH_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
+		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;
-	ret.reserve(args.size() + 4);
+	std::vector<uint8_t> ret(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/livedatamessage.cpp

@@ -12,4 +12,14 @@ void LiveDataCommandMessage::appendSignalArg(LiveDataValueType valueType) {
 	arg->valueType = valueType;
 }
 
+void LiveDataSetValueMessage::appendSetValue(LiveDataValueType valueType, const LiveDataValue& value) {
+	auto& arg = args.emplace_back(std::make_shared<LiveDataArgument>());
+	arg->objectType = LiveDataObjectType::MISC;
+	arg->objectIndex = 0u;
+	arg->signalIndex = 0u;
+	arg->valueType = valueType;
+
+	values.push_back(std::make_shared<LiveDataValue>(value));
+}
+
 } // namespace icsneo

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

@@ -75,13 +75,15 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 					lin.length = 1;
 				
 				lin.linStatus = {
-					linmsg->statusFlags.TxChecksumEnhanced,
-					linmsg->statusFlags.TxCommander,
-					linmsg->statusFlags.TxResponder,
-					linmsg->statusFlags.UpdateResponderOnce,
-					linmsg->statusFlags.HasUpdatedResponderOnce,
-					linmsg->statusFlags.BusRecovered,
-					linmsg->statusFlags.BreakOnly
+					linmsg->statusFlags.TxChecksumEnhanced, // .txChecksumEnhanced
+					linmsg->statusFlags.TxCommander, // .txCommander
+					linmsg->statusFlags.TxResponder, // .txResponder
+					0, // .txAborted
+					linmsg->statusFlags.UpdateResponderOnce, // .updateResponderOnce
+					linmsg->statusFlags.HasUpdatedResponderOnce, // .hasUpdatedResponderOnce
+					linmsg->statusFlags.BusRecovered, // .busRecovered
+					linmsg->statusFlags.BreakOnly // .breakOnly
+					
 				};
 
 				lin.status.linJustBreakSync = linmsg->errFlags.ErrRxBreakSyncOnly;

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);

communication/packet/livedatapacket.cpp

@@ -99,6 +99,33 @@ bool HardwareLiveDataPacket::EncodeFromMessage(LiveDataMessage& message, std::ve
 			clearMsg->cmd = static_cast<uint32_t>(message.cmd);
 			break;
 		}
+		case LiveDataCommand::SET_VALUE: {
+			auto setValMsg = reinterpret_cast<LiveDataSetValueMessage*>(&message);
+			const auto numArgs = setValMsg->args.size();
+			if(numArgs) {
+				payloadSize = static_cast<uint16_t>(sizeof(LiveDataSetValue) + (sizeof(LiveDataSetValueEntry) * (numArgs-1)));
+				bytestream.resize((payloadSize + sizeof(ExtendedCommandHeader)),0);
+				LiveDataSetValue* out = reinterpret_cast<LiveDataSetValue*>(bytestream.data() + sizeof(ExtendedCommandHeader));
+				out->version = icsneo::LiveDataUtil::LiveDataVersion;
+				out->cmd = static_cast<uint32_t>(setValMsg->cmd);
+				if(!setValMsg->handle)
+					setValMsg->handle = LiveDataUtil::getNewHandle();
+				out->handle = setValMsg->handle;
+				out->numArgs = static_cast<uint32_t>(setValMsg->args.size());
+				for(size_t i = 0; i < numArgs; ++i) {
+					out->values[i].arg.objectType = setValMsg->args[i]->objectType;
+					out->values[i].arg.objectIndex = setValMsg->args[i]->objectIndex;
+					out->values[i].arg.signalIndex = setValMsg->args[i]->signalIndex;
+					out->values[i].arg.valueType = setValMsg->args[i]->valueType;
+					out->values[i].value.value = setValMsg->values[i]->value;
+					out->values[i].value.header.length = sizeof(int64_t);
+				}
+			} else {
+				report(APIEvent::Type::LiveDataInvalidArgument, APIEvent::Severity::Error);
+				return false;
+			}
+			break;
+		}
 		default: {
 			report(APIEvent::Type::LiveDataInvalidCommand, APIEvent::Severity::Error);
 			return false;

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,15 +243,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	if(block) // Extensions say no
 		return false;
 
-	// Get component versions again *after* the extension "onDeviceOpen" hooks (e.g. device reflashes)
-	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);
-	}
-
+	refreshComponentVersions();
 	if(!settings->disabled) {
 		// Since we will not fail the open if a settings read fails,
 		// downgrade any errors to warnings. Otherwise the error will
@@ -245,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();
 
@@ -270,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
@@ -284,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);
-				if(heartbeatSuppressed())
-					continue;
+				std::unique_lock<std::mutex> lk(heartbeatMutex);
+				if(heartbeatSuppressed()) continue;
 
 				// No heartbeat received, request a status
 				com->sendCommand(Command::RequestStatusUpdate);
@@ -296,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;
 				}
@@ -323,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));
 
@@ -334,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();
 
@@ -347,13 +370,12 @@ 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
-			return getCommunicationNotEstablishedError();
+			report(APIEvent::Type::NotSupported, APIEvent::Severity::EventWarning); // outdated firmware
 	}
 
 	return APIEvent::Type::NoErrorFound;
@@ -379,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();
@@ -431,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;
@@ -814,7 +824,6 @@ std::shared_ptr<HardwareInfo> Device::getHardwareInfo(std::chrono::milliseconds
 		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
 		return nullptr;
 	}
-	
 	auto filter = std::make_shared<MessageFilter>(Message::Type::HardwareInfo);
 
 	auto response = com->waitForMessageSync([this]() {
@@ -1694,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) {
@@ -1987,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(
@@ -2054,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);
@@ -2194,6 +2235,61 @@ bool Device::clearAllLiveData() {
 	return true;
 }
 
+bool Device::setValueLiveData(std::shared_ptr<LiveDataSetValueMessage> message) {
+	if(!supportsLiveData()) {
+		report(APIEvent::Type::LiveDataNotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+	if(!isOpen()) {
+		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+		return false;
+	}
+	if((message->args.size() != message->values.size()) || message->args.empty()) {
+		report(APIEvent::Type::LiveDataInvalidArgument, APIEvent::Severity::Error);
+		return false;
+	}
+
+	std::vector<uint8_t> bytes;
+	if(!com->encoder->encode(*com->packetizer, bytes, message)) {
+		report(APIEvent::Type::LiveDataEncoderError, APIEvent::Severity::Error);
+		return false;
+	}
+
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this, &bytes](){ return com->sendPacket(bytes); },
+		std::make_shared<MessageFilter>(Message::Type::LiveData));
+
+	if(response) {
+		auto statusMsg = std::dynamic_pointer_cast<LiveDataStatusMessage>(response);
+		if(statusMsg && statusMsg->requestedCommand == message->cmd) {
+			switch(statusMsg->status) {
+				case LiveDataStatus::SUCCESS:
+					return true;
+				case LiveDataStatus::ERR_DUPLICATE:
+				case LiveDataStatus::ERR_HANDLE:
+				{
+					report(APIEvent::Type::LiveDataInvalidHandle, APIEvent::Severity::Error);
+					return false;
+				}
+				case LiveDataStatus::ERR_FULL:
+				{
+					report(APIEvent::Type::LiveDataMaxSignalsReached, APIEvent::Severity::Error);
+					return false;
+				}
+				case LiveDataStatus::ERR_UNKNOWN_COMMAND:
+				{
+					report(APIEvent::Type::LiveDataCommandFailed, APIEvent::Severity::Error);
+					return false;
+				}
+				default:
+					break;
+			}
+		}
+	}
+	report(APIEvent::Type::LiveDataNoDeviceResponse, APIEvent::Severity::Error);
+	return false;
+}
+
 bool Device::readVSA(const VSAExtractionSettings& extractionSettings) {
 	if(isOnline()) {
 		goOffline();
@@ -3369,3 +3465,25 @@ std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeou
 
 	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
-	FirmIO::Find(newDriverFoundDevices);
-	#endif
-
-	#ifdef ICSNEO_ENABLE_TCP
-	TCP::Find(newDriverFoundDevices);
-	#endif
-
-	#ifdef ICSNEO_ENABLE_RAW_ETHERNET
-	PCAP::Find(newDriverFoundDevices);
-	#endif
-
-	#ifdef ICSNEO_ENABLE_CDCACM
-	CDCACM::Find(newDriverFoundDevices);
-	#endif
-
-	#ifdef ICSNEO_ENABLE_FTDI
-	FTDI::Find(newDriverFoundDevices);
-	#endif
-
-	#ifdef ICSNEO_ENABLE_FTD3XX
-	FTD3XX::Find(newDriverFoundDevices);
-	#endif
+	if(Servd::Enabled()) {
+		Servd::Find(newDriverFoundDevices);
+	} else {
+		#ifdef ICSNEO_ENABLE_FIRMIO
+		FirmIO::Find(newDriverFoundDevices);
+		#endif
+	
+		#ifdef ICSNEO_ENABLE_TCP
+		TCP::Find(newDriverFoundDevices);
+		#endif
+	
+		#ifdef ICSNEO_ENABLE_RAW_ETHERNET
+		PCAP::Find(newDriverFoundDevices);
+		#endif
+	
+		#ifdef ICSNEO_ENABLE_CDCACM
+		CDCACM::Find(newDriverFoundDevices);
+		#endif
+	
+		#ifdef ICSNEO_ENABLE_FTDI
+		FTDI::Find(newDriverFoundDevices);
+		#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/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)
@@ -88,3 +88,76 @@ Monitor Ethernet Status
          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++) {
-									printf("%02x ", canMsg->data[i]);
+								for(size_t j = 0; j < canMsg->length; j++) {
+									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) {
-									if (i < 2) {
-										printf("%02x ", linMsg->header[i+1]);
+								for(size_t j = 0; j < dataLen; ++j) {
+									if (j < 2) {
+										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++) {
-								printf("%02x ", canMsg->data[i]);
+							for(size_t j = 0; i < canMsg->length; j++) {
+								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;
-							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) {
-								if (i < 2) {
-									printf("%02x ", linMsg->header[i+1]);
+							for(size_t j = 0; j < dataLen; ++j) {
+								if (j < 2) {
+									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

@@ -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... ";
-		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN, true);
+		std::cout << "Enable LIN 01 commander resistor... ";
+		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN_01, true);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Disable LIN2 commander resistor... ";
-		ret = device->settings->setCommanderResistorFor(icsneo::Network::NetID::LIN2, false);
+		std::cout << "Disable LIN 02 commander resistor... ";
+		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... ";
-		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN, baud);
+		std::cout << "Setting LIN 01 to operate at " << baud << "bit/s... ";
+		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... ";
-		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN2, baud);
+		std::cout << "Setting LIN 02 to operate at " << baud << "bit/s... ";
+		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::LIN_02, baud);
 		std::cout << (ret ? "OK" : "FAIL") << std::endl;
 
-		std::cout << "Setting LIN mode to NORMAL... ";
-		ret = device->settings->setLINModeFor(icsneo::Network::NetID::LIN, NORMAL_MODE);
+		std::cout << "Setting LIN 01 mode to NORMAL... ";
+		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... ";
-		ret = device->settings->setLINModeFor(icsneo::Network::NetID::LIN2, NORMAL_MODE);
+		std::cout << "Setting LIN 02 mode to NORMAL... ";
+		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... ";
-		readBaud = device->settings->getBaudrateFor(icsneo::Network::NetID::LIN2);
+		std::cout << "Getting LIN 02 Baudrate... ";
+		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/livedata/src/LiveDataExample.cpp

@@ -35,6 +35,8 @@ int main() {
 		msg->appendSignalArg(icsneo::LiveDataValueType::GPS_LATITUDE);
 		msg->appendSignalArg(icsneo::LiveDataValueType::GPS_LONGITUDE);
 		msg->appendSignalArg(icsneo::LiveDataValueType::GPS_ACCURACY);
+		msg->appendSignalArg(icsneo::LiveDataValueType::DAQ_ENABLE);
+		msg->appendSignalArg(icsneo::LiveDataValueType::MANUAL_TRIGGER);
 		msg->cmd = icsneo::LiveDataCommand::SUBSCRIBE;
 		msg->handle = icsneo::LiveDataUtil::getNewHandle();
 		msg->updatePeriod = std::chrono::milliseconds(100);
@@ -77,6 +79,28 @@ int main() {
 		}));
 		// Run handler for three seconds to observe the signal data
 		std::this_thread::sleep_for(std::chrono::seconds(3));
+		double val = 0;
+		for (unsigned int i = 0; i < 10; ++i)
+		{
+			// Set the values of signals we're watching so we can see them change live
+			auto setValMsg = std::make_shared<icsneo::LiveDataSetValueMessage>();
+			setValMsg->cmd = icsneo::LiveDataCommand::SET_VALUE;
+			setValMsg->handle = msg->handle;
+			// Convert the value format
+			icsneo::LiveDataValue ldValueDAQEnable;
+			icsneo::LiveDataValue ldValueManTrig;
+			if ((icsneo::LiveDataUtil::liveDataDoubleToValue(ldValueDAQEnable, val * 10) < 0) ||
+				(icsneo::LiveDataUtil::liveDataDoubleToValue(ldValueManTrig, val) < 0))
+			{
+				break;
+			}
+			setValMsg->appendSetValue(icsneo::LiveDataValueType::DAQ_ENABLE, ldValueDAQEnable);
+			setValMsg->appendSetValue(icsneo::LiveDataValueType::MANUAL_TRIGGER, ldValueManTrig);
+			device->setValueLiveData(setValMsg);
+			++val;
+			// Run handler for three seconds to observe the signal data
+			std::this_thread::sleep_for(std::chrono::seconds(3));
+		}
 		// Unsubscribe from the GPS signals and run handler for one more second
 		// Unsubscription only requires a valid in-use handle, in this case from our previous subscription
 		ret = device->unsubscribeLiveData(msg->handle);

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... ";
-		int64_t baud = device->settings->getBaudrateFor(icsneo::Network::NetID::HSCAN);
+		std::cout << "\tGetting DW CAN 01 Baudrate... ";
+		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... ";
-		ret = device->settings->setBaudrateFor(icsneo::Network::NetID::HSCAN, 125000);
+		std::cout << "\tSetting DW CAN 01 to operate at 125kbit/s... ";
+		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) ";
-		baud = device->settings->getBaudrateFor(icsneo::Network::NetID::HSCAN);
+		std::cout << "\tGetting DW CAN 01 Baudrate... (expected to be unchanged) ";
+		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... ";
-		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::HSCAN);
+		std::cout << "\tGetting DW CAN 01 FD Baudrate... ";
+		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... ";
-		ret = device->settings->setFDBaudrateFor(icsneo::Network::NetID::HSCAN, 8000000);
+		std::cout << "\tSetting DW CAN 01 FD to operate at 8Mbit/s... ";
+		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) ";
-		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::HSCAN);
+		std::cout << "\tGetting DW CAN 01 FD Baudrate... (expected to be unchanged) ";
+		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... ";
-		baud = device->settings->getBaudrateFor(icsneo::Network::NetID::HSCAN);
+		std::cout << "\tGetting DW CAN 01 Baudrate... ";
+		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... ";
-		baud = device->settings->getFDBaudrateFor(icsneo::Network::NetID::HSCAN);
+		std::cout << "\tGetting DW CAN 01 (FD) Baudrate... ";
+		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
@@ -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);
-  }
-
-}

examples/java/src/neomessage_eth_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_eth_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neomessage_eth_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neomessage_eth_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_eth_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setStatus(neomessage_statusbitfield_t value) {
-    icsneojavaJNI.neomessage_eth_t_status_set(swigCPtr, this, neomessage_statusbitfield_t.getCPtr(value), value);
-  }
-
-  public neomessage_statusbitfield_t getStatus() {
-    long cPtr = icsneojavaJNI.neomessage_eth_t_status_get(swigCPtr, this);
-    return (cPtr == 0) ? null : new neomessage_statusbitfield_t(cPtr, false);
-  }
-
-  public void setTimestamp(java.math.BigInteger value) {
-    icsneojavaJNI.neomessage_eth_t_timestamp_set(swigCPtr, this, value);
-  }
-
-  public java.math.BigInteger getTimestamp() {
-    return icsneojavaJNI.neomessage_eth_t_timestamp_get(swigCPtr, this);
-  }
-
-  public void setTimestampReserved(java.math.BigInteger value) {
-    icsneojavaJNI.neomessage_eth_t_timestampReserved_set(swigCPtr, this, value);
-  }
-
-  public java.math.BigInteger getTimestampReserved() {
-    return icsneojavaJNI.neomessage_eth_t_timestampReserved_get(swigCPtr, this);
-  }
-
-  public void setData(byte[] value) {
-    icsneojavaJNI.neomessage_eth_t_data_set(swigCPtr, this, value);
-  }
-
-  public byte[] getData() {
-    return icsneojavaJNI.neomessage_eth_t_data_get(swigCPtr, this);
-}
-
-  public void setLength(long value) {
-    icsneojavaJNI.neomessage_eth_t_length_set(swigCPtr, this, value);
-  }
-
-  public long getLength() {
-    return icsneojavaJNI.neomessage_eth_t_length_get(swigCPtr, this);
-  }
-
-  public void setPreemptionFlags(short value) {
-    icsneojavaJNI.neomessage_eth_t_preemptionFlags_set(swigCPtr, this, value);
-  }
-
-  public short getPreemptionFlags() {
-    return icsneojavaJNI.neomessage_eth_t_preemptionFlags_get(swigCPtr, this);
-  }
-
-  public void setReservedHeader(short[] value) {
-    icsneojavaJNI.neomessage_eth_t_reservedHeader_set(swigCPtr, this, value);
-  }
-
-  public short[] getReservedHeader() {
-    return icsneojavaJNI.neomessage_eth_t_reservedHeader_get(swigCPtr, this);
-  }
-
-  public void setNetid(int value) {
-    icsneojavaJNI.neomessage_eth_t_netid_set(swigCPtr, this, value);
-  }
-
-  public int getNetid() {
-    return icsneojavaJNI.neomessage_eth_t_netid_get(swigCPtr, this);
-  }
-
-  public void setType(short value) {
-    icsneojavaJNI.neomessage_eth_t_type_set(swigCPtr, this, value);
-  }
-
-  public short getType() {
-    return icsneojavaJNI.neomessage_eth_t_type_get(swigCPtr, this);
-  }
-
-  public void setReserved(short[] value) {
-    icsneojavaJNI.neomessage_eth_t_reserved_set(swigCPtr, this, value);
-  }
-
-  public short[] getReserved() {
-    return icsneojavaJNI.neomessage_eth_t_reserved_get(swigCPtr, this);
-  }
-
-  public neomessage_eth_t() {
-    this(icsneojavaJNI.new_neomessage_eth_t(), true);
-  }
-
-}

examples/java/src/neomessage_statusbitfield_t.java

@@ -1,490 +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_statusbitfield_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neomessage_statusbitfield_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neomessage_statusbitfield_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_statusbitfield_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setGlobalError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_globalError_set(swigCPtr, this, value);
-  }
-
-  public long getGlobalError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_globalError_get(swigCPtr, this);
-  }
-
-  public void setTransmitMessage(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_transmitMessage_set(swigCPtr, this, value);
-  }
-
-  public long getTransmitMessage() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_transmitMessage_get(swigCPtr, this);
-  }
-
-  public void setExtendedFrame(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_extendedFrame_set(swigCPtr, this, value);
-  }
-
-  public long getExtendedFrame() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_extendedFrame_get(swigCPtr, this);
-  }
-
-  public void setRemoteFrame(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_remoteFrame_set(swigCPtr, this, value);
-  }
-
-  public long getRemoteFrame() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_remoteFrame_get(swigCPtr, this);
-  }
-
-  public void setCrcError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_crcError_set(swigCPtr, this, value);
-  }
-
-  public long getCrcError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_crcError_get(swigCPtr, this);
-  }
-
-  public void setCanErrorPassive(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canErrorPassive_set(swigCPtr, this, value);
-  }
-
-  public long getCanErrorPassive() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canErrorPassive_get(swigCPtr, this);
-  }
-
-  public void setIncompleteFrame(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_incompleteFrame_set(swigCPtr, this, value);
-  }
-
-  public long getIncompleteFrame() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_incompleteFrame_get(swigCPtr, this);
-  }
-
-  public void setLostArbitration(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_lostArbitration_set(swigCPtr, this, value);
-  }
-
-  public long getLostArbitration() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_lostArbitration_get(swigCPtr, this);
-  }
-
-  public void setUndefinedError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_undefinedError_set(swigCPtr, this, value);
-  }
-
-  public long getUndefinedError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_undefinedError_get(swigCPtr, this);
-  }
-
-  public void setCanBusOff(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canBusOff_set(swigCPtr, this, value);
-  }
-
-  public long getCanBusOff() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canBusOff_get(swigCPtr, this);
-  }
-
-  public void setCanErrorWarning(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canErrorWarning_set(swigCPtr, this, value);
-  }
-
-  public long getCanErrorWarning() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canErrorWarning_get(swigCPtr, this);
-  }
-
-  public void setCanBusShortedPlus(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canBusShortedPlus_set(swigCPtr, this, value);
-  }
-
-  public long getCanBusShortedPlus() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canBusShortedPlus_get(swigCPtr, this);
-  }
-
-  public void setCanBusShortedGround(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canBusShortedGround_set(swigCPtr, this, value);
-  }
-
-  public long getCanBusShortedGround() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canBusShortedGround_get(swigCPtr, this);
-  }
-
-  public void setChecksumError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_checksumError_set(swigCPtr, this, value);
-  }
-
-  public long getChecksumError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_checksumError_get(swigCPtr, this);
-  }
-
-  public void setBadMessageBitTimeError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_badMessageBitTimeError_set(swigCPtr, this, value);
-  }
-
-  public long getBadMessageBitTimeError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_badMessageBitTimeError_get(swigCPtr, this);
-  }
-
-  public void setIfrData(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_ifrData_set(swigCPtr, this, value);
-  }
-
-  public long getIfrData() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_ifrData_get(swigCPtr, this);
-  }
-
-  public void setHardwareCommError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_hardwareCommError_set(swigCPtr, this, value);
-  }
-
-  public long getHardwareCommError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_hardwareCommError_get(swigCPtr, this);
-  }
-
-  public void setExpectedLengthError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_expectedLengthError_set(swigCPtr, this, value);
-  }
-
-  public long getExpectedLengthError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_expectedLengthError_get(swigCPtr, this);
-  }
-
-  public void setIncomingNoMatch(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_incomingNoMatch_set(swigCPtr, this, value);
-  }
-
-  public long getIncomingNoMatch() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_incomingNoMatch_get(swigCPtr, this);
-  }
-
-  public void setStatusBreak(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_statusBreak_set(swigCPtr, this, value);
-  }
-
-  public long getStatusBreak() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_statusBreak_get(swigCPtr, this);
-  }
-
-  public void setAvsiRecOverflow(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_avsiRecOverflow_set(swigCPtr, this, value);
-  }
-
-  public long getAvsiRecOverflow() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_avsiRecOverflow_get(swigCPtr, this);
-  }
-
-  public void setTestTrigger(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_testTrigger_set(swigCPtr, this, value);
-  }
-
-  public long getTestTrigger() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_testTrigger_get(swigCPtr, this);
-  }
-
-  public void setAudioComment(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_audioComment_set(swigCPtr, this, value);
-  }
-
-  public long getAudioComment() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_audioComment_get(swigCPtr, this);
-  }
-
-  public void setGpsData(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_gpsData_set(swigCPtr, this, value);
-  }
-
-  public long getGpsData() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_gpsData_get(swigCPtr, this);
-  }
-
-  public void setAnalogDigitalInput(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_analogDigitalInput_set(swigCPtr, this, value);
-  }
-
-  public long getAnalogDigitalInput() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_analogDigitalInput_get(swigCPtr, this);
-  }
-
-  public void setTextComment(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_textComment_set(swigCPtr, this, value);
-  }
-
-  public long getTextComment() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_textComment_get(swigCPtr, this);
-  }
-
-  public void setNetworkMessageType(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_networkMessageType_set(swigCPtr, this, value);
-  }
-
-  public long getNetworkMessageType() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_networkMessageType_get(swigCPtr, this);
-  }
-
-  public void setVsiTXUnderrun(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_vsiTXUnderrun_set(swigCPtr, this, value);
-  }
-
-  public long getVsiTXUnderrun() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_vsiTXUnderrun_get(swigCPtr, this);
-  }
-
-  public void setVsiIFRCRCBit(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_vsiIFRCRCBit_set(swigCPtr, this, value);
-  }
-
-  public long getVsiIFRCRCBit() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_vsiIFRCRCBit_get(swigCPtr, this);
-  }
-
-  public void setInitMessage(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_initMessage_set(swigCPtr, this, value);
-  }
-
-  public long getInitMessage() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_initMessage_get(swigCPtr, this);
-  }
-
-  public void setFlexraySecondStartupFrame(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_flexraySecondStartupFrame_set(swigCPtr, this, value);
-  }
-
-  public long getFlexraySecondStartupFrame() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_flexraySecondStartupFrame_get(swigCPtr, this);
-  }
-
-  public void setExtended(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_extended_set(swigCPtr, this, value);
-  }
-
-  public long getExtended() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_extended_get(swigCPtr, this);
-  }
-
-  public void setHasValue(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_hasValue_set(swigCPtr, this, value);
-  }
-
-  public long getHasValue() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_hasValue_get(swigCPtr, this);
-  }
-
-  public void setValueIsBoolean(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_valueIsBoolean_set(swigCPtr, this, value);
-  }
-
-  public long getValueIsBoolean() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_valueIsBoolean_get(swigCPtr, this);
-  }
-
-  public void setHighVoltage(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_highVoltage_set(swigCPtr, this, value);
-  }
-
-  public long getHighVoltage() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_highVoltage_get(swigCPtr, this);
-  }
-
-  public void setLongMessage(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_longMessage_set(swigCPtr, this, value);
-  }
-
-  public long getLongMessage() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_longMessage_get(swigCPtr, this);
-  }
-
-  public void setGlobalChange(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_globalChange_set(swigCPtr, this, value);
-  }
-
-  public long getGlobalChange() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_globalChange_get(swigCPtr, this);
-  }
-
-  public void setErrorFrame(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_errorFrame_set(swigCPtr, this, value);
-  }
-
-  public long getErrorFrame() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_errorFrame_get(swigCPtr, this);
-  }
-
-  public void setEndOfLongMessage(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_endOfLongMessage_set(swigCPtr, this, value);
-  }
-
-  public long getEndOfLongMessage() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_endOfLongMessage_get(swigCPtr, this);
-  }
-
-  public void setLinErrorRXBreakNotZero(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXBreakNotZero_set(swigCPtr, this, value);
-  }
-
-  public long getLinErrorRXBreakNotZero() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXBreakNotZero_get(swigCPtr, this);
-  }
-
-  public void setLinErrorRXBreakTooShort(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXBreakTooShort_set(swigCPtr, this, value);
-  }
-
-  public long getLinErrorRXBreakTooShort() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXBreakTooShort_get(swigCPtr, this);
-  }
-
-  public void setLinErrorRXSyncNot55(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXSyncNot55_set(swigCPtr, this, value);
-  }
-
-  public long getLinErrorRXSyncNot55() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXSyncNot55_get(swigCPtr, this);
-  }
-
-  public void setLinErrorRXDataGreaterEight(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_set(swigCPtr, this, value);
-  }
-
-  public long getLinErrorRXDataGreaterEight() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linErrorRXDataGreaterEight_get(swigCPtr, this);
-  }
-
-  public void setLinErrorTXRXMismatch(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linErrorTXRXMismatch_set(swigCPtr, this, value);
-  }
-
-  public long getLinErrorTXRXMismatch() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linErrorTXRXMismatch_get(swigCPtr, this);
-  }
-
-  public void setLinErrorMessageIDParity(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linErrorMessageIDParity_set(swigCPtr, this, value);
-  }
-
-  public long getLinErrorMessageIDParity() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linErrorMessageIDParity_get(swigCPtr, this);
-  }
-
-  public void setLinSyncFrameError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linSyncFrameError_set(swigCPtr, this, value);
-  }
-
-  public long getLinSyncFrameError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linSyncFrameError_get(swigCPtr, this);
-  }
-
-  public void setLinIDFrameError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linIDFrameError_set(swigCPtr, this, value);
-  }
-
-  public long getLinIDFrameError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linIDFrameError_get(swigCPtr, this);
-  }
-
-  public void setLinSlaveByteError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linSlaveByteError_set(swigCPtr, this, value);
-  }
-
-  public long getLinSlaveByteError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linSlaveByteError_get(swigCPtr, this);
-  }
-
-  public void setRxTimeoutError(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_rxTimeoutError_set(swigCPtr, this, value);
-  }
-
-  public long getRxTimeoutError() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_rxTimeoutError_get(swigCPtr, this);
-  }
-
-  public void setLinNoSlaveData(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_linNoSlaveData_set(swigCPtr, this, value);
-  }
-
-  public long getLinNoSlaveData() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_linNoSlaveData_get(swigCPtr, this);
-  }
-
-  public void setCanfdESI(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canfdESI_set(swigCPtr, this, value);
-  }
-
-  public long getCanfdESI() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canfdESI_get(swigCPtr, this);
-  }
-
-  public void setCanfdIDE(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canfdIDE_set(swigCPtr, this, value);
-  }
-
-  public long getCanfdIDE() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canfdIDE_get(swigCPtr, this);
-  }
-
-  public void setCanfdRTR(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canfdRTR_set(swigCPtr, this, value);
-  }
-
-  public long getCanfdRTR() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canfdRTR_get(swigCPtr, this);
-  }
-
-  public void setCanfdFDF(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canfdFDF_set(swigCPtr, this, value);
-  }
-
-  public long getCanfdFDF() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canfdFDF_get(swigCPtr, this);
-  }
-
-  public void setCanfdBRS(long value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_canfdBRS_set(swigCPtr, this, value);
-  }
-
-  public long getCanfdBRS() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_canfdBRS_get(swigCPtr, this);
-  }
-
-  public void setStatusBitfield(long[] value) {
-    icsneojavaJNI.neomessage_statusbitfield_t_statusBitfield_set(swigCPtr, this, value);
-  }
-
-  public long[] getStatusBitfield() {
-    return icsneojavaJNI.neomessage_statusbitfield_t_statusBitfield_get(swigCPtr, this);
-  }
-
-  public neomessage_statusbitfield_t() {
-    this(icsneojavaJNI.new_neomessage_statusbitfield_t(), true);
-  }
-
-}

examples/java/src/neomessage_t.java

@@ -1,115 +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_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neomessage_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neomessage_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_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setStatus(neomessage_statusbitfield_t value) {
-    icsneojavaJNI.neomessage_t_status_set(swigCPtr, this, neomessage_statusbitfield_t.getCPtr(value), value);
-  }
-
-  public neomessage_statusbitfield_t getStatus() {
-    long cPtr = icsneojavaJNI.neomessage_t_status_get(swigCPtr, this);
-    return (cPtr == 0) ? null : new neomessage_statusbitfield_t(cPtr, false);
-  }
-
-  public void setTimestamp(java.math.BigInteger value) {
-    icsneojavaJNI.neomessage_t_timestamp_set(swigCPtr, this, value);
-  }
-
-  public java.math.BigInteger getTimestamp() {
-    return icsneojavaJNI.neomessage_t_timestamp_get(swigCPtr, this);
-  }
-
-  public void setTimestampReserved(java.math.BigInteger value) {
-    icsneojavaJNI.neomessage_t_timestampReserved_set(swigCPtr, this, value);
-  }
-
-  public java.math.BigInteger getTimestampReserved() {
-    return icsneojavaJNI.neomessage_t_timestampReserved_get(swigCPtr, this);
-  }
-
-  public void setData(byte[] value) {
-    icsneojavaJNI.neomessage_t_data_set(swigCPtr, this, value);
-  }
-
-  public byte[] getData() {
-    return icsneojavaJNI.neomessage_t_data_get(swigCPtr, this);
-}
-
-  public void setLength(long value) {
-    icsneojavaJNI.neomessage_t_length_set(swigCPtr, this, value);
-  }
-
-  public long getLength() {
-    return icsneojavaJNI.neomessage_t_length_get(swigCPtr, this);
-  }
-
-  public void setHeader(short[] value) {
-    icsneojavaJNI.neomessage_t_header_set(swigCPtr, this, value);
-  }
-
-  public short[] getHeader() {
-    return icsneojavaJNI.neomessage_t_header_get(swigCPtr, this);
-  }
-
-  public void setNetid(int value) {
-    icsneojavaJNI.neomessage_t_netid_set(swigCPtr, this, value);
-  }
-
-  public int getNetid() {
-    return icsneojavaJNI.neomessage_t_netid_get(swigCPtr, this);
-  }
-
-  public void setType(short value) {
-    icsneojavaJNI.neomessage_t_type_set(swigCPtr, this, value);
-  }
-
-  public short getType() {
-    return icsneojavaJNI.neomessage_t_type_get(swigCPtr, this);
-  }
-
-  public void setReserved(short[] value) {
-    icsneojavaJNI.neomessage_t_reserved_set(swigCPtr, this, value);
-  }
-
-  public short[] getReserved() {
-    return icsneojavaJNI.neomessage_t_reserved_get(swigCPtr, this);
-  }
-
-  public neomessage_t() {
-    this(icsneojavaJNI.new_neomessage_t(), true);
-  }
-
-}

examples/java/src/neoversion_t.java

@@ -1,98 +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 neoversion_t {
-  private transient long swigCPtr;
-  protected transient boolean swigCMemOwn;
-
-  protected neoversion_t(long cPtr, boolean cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = cPtr;
-  }
-
-  protected static long getCPtr(neoversion_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_neoversion_t(swigCPtr);
-      }
-      swigCPtr = 0;
-    }
-  }
-
-  public void setMajor(int value) {
-    icsneojavaJNI.neoversion_t_major_set(swigCPtr, this, value);
-  }
-
-  public int getMajor() {
-    return icsneojavaJNI.neoversion_t_major_get(swigCPtr, this);
-  }
-
-  public void setMinor(int value) {
-    icsneojavaJNI.neoversion_t_minor_set(swigCPtr, this, value);
-  }
-
-  public int getMinor() {
-    return icsneojavaJNI.neoversion_t_minor_get(swigCPtr, this);
-  }
-
-  public void setPatch(int value) {
-    icsneojavaJNI.neoversion_t_patch_set(swigCPtr, this, value);
-  }
-
-  public int getPatch() {
-    return icsneojavaJNI.neoversion_t_patch_get(swigCPtr, this);
-  }
-
-  public void setMetadata(String value) {
-    icsneojavaJNI.neoversion_t_metadata_set(swigCPtr, this, value);
-  }
-
-  public String getMetadata() {
-    return icsneojavaJNI.neoversion_t_metadata_get(swigCPtr, this);
-  }
-
-  public void setBuildBranch(String value) {
-    icsneojavaJNI.neoversion_t_buildBranch_set(swigCPtr, this, value);
-  }
-
-  public String getBuildBranch() {
-    return icsneojavaJNI.neoversion_t_buildBranch_get(swigCPtr, this);
-  }
-
-  public void setBuildTag(String value) {
-    icsneojavaJNI.neoversion_t_buildTag_set(swigCPtr, this, value);
-  }
-
-  public String getBuildTag() {
-    return icsneojavaJNI.neoversion_t_buildTag_get(swigCPtr, this);
-  }
-
-  public void setReserved(String value) {
-    icsneojavaJNI.neoversion_t_reserved_set(swigCPtr, this, value);
-  }
-
-  public String getReserved() {
-    return icsneojavaJNI.neoversion_t_reserved_get(swigCPtr, this);
-  }
-
-  public neoversion_t() {
-    this(icsneojavaJNI.new_neoversion_t(), true);
-  }
-
-}

include/icsneo/api/event.h

@@ -110,6 +110,7 @@ public:
 		ModeNotFound = 0x2054,
 		AppErrorParsingFailed = 0x2055,
 		GPTPNotSupported = 0x2056,
+		SettingNotAvaiableDevice = 0x2057,
 
 		// Transport Events
 		FailedToRead = 0x3000,
@@ -173,6 +174,19 @@ public:
 		VSAExtendedMessageError = VSABufferCorrupted + 5,
 		VSAOtherError = VSABufferCorrupted + 6,
 
+		// Servd
+		ServdBindError = 0x6000,
+		ServdNonblockError = ServdBindError + 1,
+		ServdTransceiveError = ServdBindError + 2,
+		ServdOutdatedError = ServdBindError + 3,
+		ServdInvalidResponseError = ServdBindError + 4,
+		ServdLockError = ServdBindError + 5,
+		ServdSendError = ServdBindError + 6,
+		ServdRecvError = ServdBindError + 7,
+		ServdPollError = ServdBindError + 8,
+		ServdNoDataError = ServdBindError + 9,
+		ServdJoinMulticastError = ServdBindError + 10,
+
 		NoErrorFound = 0xFFFFFFFD,
 		TooManyEvents = 0xFFFFFFFE,
 		Unknown = 0xFFFFFFFF
@@ -186,19 +200,19 @@ public:
 
 	APIEvent() : eventStruct({}), serial(), timepoint(), device(nullptr) {}
 	APIEvent(APIEvent::Type event, APIEvent::Severity severity, const Device* device = nullptr);
-	
+
 	const neoevent_t* getNeoEvent() const noexcept { return &eventStruct; }
 	Type getType() const noexcept { return Type(eventStruct.eventNumber); }
 	Severity getSeverity() const noexcept { return Severity(eventStruct.severity); }
 	std::string getDescription() const noexcept { return std::string(eventStruct.description); }
 	const Device* getDevice() const noexcept { return device; } // Will return nullptr if this is an API-wide event
 	EventTimePoint getTimestamp() const noexcept { return timepoint; }
-	
+
 	void downgradeFromError() noexcept;
 
 	bool isForDevice(const Device* forDevice) const noexcept { return forDevice == device; }
 	bool isForDevice(std::string serial) const noexcept;
-	
+
 	// As opposed to getDescription, this will also add text such as "neoVI FIRE 2 CY2468 Error: " to fully describe the problem
 	std::string describe() const noexcept;
 	friend std::ostream& operator<<(std::ostream& os, const APIEvent& event) {

include/icsneo/communication/command.h

@@ -38,6 +38,7 @@ enum class Command : uint8_t {
 	FlexRayControl = 0xF3,
 	CoreMiniPreload = 0xF4, // Previously known as RED_CMD_COREMINI_PRELOAD
 	PHYControlRegisters = 0xEF,
+	EnableLogData = 0xF6,
 };
 
 enum class ExtendedCommand : uint16_t {
@@ -73,6 +74,7 @@ enum class ExtendedResponse : int32_t {
 
 enum class ExtendedDataSubCommand : uint32_t {
 	GenericBinaryRead = 13,
+	GenericBinaryWrite = 14,
 };
 
 #pragma pack(push,1)

include/icsneo/communication/crc32.h

@@ -0,0 +1,27 @@
+/*
+ * crc32.h
+ *
+ *  Created on: Jun 22, 2020
+ *      Author: BJones
+ */
+
+#pragma once
+
+#ifndef CRC32_H_
+#define CRC32_H_
+
+#include <stdint.h>
+
+/*
+ * When any data/buffer is run through calCRC(), then the resulting CRC value
+ *  is appended to the end of the data/buffer and the data/buffer is rerun
+ *  through calCRC(), the result will be CRC32_IDENT
+ */
+#define CRC32_IDENT (0x2144DF1C) /**< CRC check value */
+
+#define CRC32_ISVALID(crc) ((crc) == CRC32_IDENT)
+
+uint32_t crc32(uint32_t crc, const unsigned char* buf, uint32_t len);
+uint32_t revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len);
+
+#endif // CRC32_H_

include/icsneo/communication/driver.h

@@ -37,6 +37,8 @@ public:
 	bool readAvailable() { return readBuffer.size() > 0; }
 	RingBuffer& getReadBuffer() { return readBuffer; }
 
+	virtual bool enableCommunication(bool /* enable */, bool& sendMsg) { sendMsg = true; return true; }
+
 	device_eventhandler_t report;
 
 	size_t writeQueueSize = 50;

include/icsneo/communication/livedata.h

@@ -19,6 +19,7 @@ enum class LiveDataCommand : uint32_t {
 	UNSUBSCRIBE,
 	RESPONSE,
 	CLEAR_ALL,
+	SET_VALUE,
 };
 
 enum class LiveDataStatus : uint32_t {
@@ -41,10 +42,13 @@ enum class LiveDataValueType : uint32_t {
 	GPS_SPEED,
 	GPS_VALID,
 	GPS_ENABLE = 62,
+	MANUAL_TRIGGER = 108,
+	TIME_SINCE_MSG = 111,
 	GPS_ACCURACY = 120,
 	GPS_BEARING = 121,
 	GPS_TIME = 122,
 	GPS_TIME_VALID = 123,
+	DAQ_ENABLE = 124,
 };
 
 inline std::ostream& operator<<(std::ostream& os, const LiveDataCommand cmd) {
@@ -54,6 +58,7 @@ inline std::ostream& operator<<(std::ostream& os, const LiveDataCommand cmd) {
 		case LiveDataCommand::UNSUBSCRIBE: return os << "Unsubscribe";
 		case LiveDataCommand::RESPONSE: return os << "Response";
 		case LiveDataCommand::CLEAR_ALL: return os << "Clear All";
+		case LiveDataCommand::SET_VALUE: return os << "Set Value";
 	}
 	return os;
 }
@@ -81,6 +86,8 @@ inline std::ostream& operator<<(std::ostream& os, const LiveDataValueType cmd) {
 		case LiveDataValueType::GPS_BEARING: return os << "GPS Bearing";
 		case LiveDataValueType::GPS_TIME: return os << "GPS Time";
 		case LiveDataValueType::GPS_TIME_VALID: return os << "GPS Time Valid";
+		case LiveDataValueType::DAQ_ENABLE: return os << "DAQ Enable";
+		case LiveDataValueType::MANUAL_TRIGGER: return os << "Manual Trigger";
 	}
 	return os;
 }
@@ -127,6 +134,17 @@ struct LiveDataSubscribe : public LiveDataHeader {
 	LiveDataArgument args[1];
 };
 
+struct LiveDataSetValueEntry
+{
+	LiveDataArgument arg;
+	LiveDataValue value;
+};
+
+struct LiveDataSetValue : public LiveDataHeader {
+	uint32_t numArgs;
+	LiveDataSetValueEntry values[1];
+};
+
 struct ExtResponseHeader {
 	ExtendedCommand command;
 	uint16_t length;
@@ -138,6 +156,7 @@ namespace LiveDataUtil
 
 LiveDataHandle getNewHandle();
 double liveDataValueToDouble(const LiveDataValue& val);
+int liveDataDoubleToValue(LiveDataValue& value, const double& dFloat);
 static constexpr uint32_t LiveDataVersion = 1;
 
 } // namespace LiveDataUtil

include/icsneo/communication/message/callback/streamoutput/streamoutput.h

@@ -126,13 +126,13 @@ public:
 		) {}
 
 	StreamOutput(const char* filename) : 
-		MessageCallback([](std::shared_ptr<Message> msg) {}),
+		MessageCallback([](std::shared_ptr<Message>) {}),
 		stream(
 			new std::ofstream(filename, std::ios::binary),
 			std::default_delete<std::ostream>()
 		) {}
 
-	StreamOutput(std::ostream& os) : MessageCallback([](std::shared_ptr<Message> msg) {}), stream(&os, [](std::ostream*){}) {}
+	StreamOutput(std::ostream& os) : MessageCallback([](std::shared_ptr<Message>) {}), stream(&os, [](std::ostream*){}) {}
 
 protected:
 	std::unique_ptr<std::ostream, std::function<void(std::ostream*)>> stream;

include/icsneo/communication/message/componentversionsmessage.h

@@ -7,8 +7,8 @@
 namespace icsneo {
 class ComponentVersion {
 public:
-	ComponentVersion(uint8_t valid, uint8_t componentInfo, uint32_t identifier, uint32_t dotVersion, uint32_t commitHash) :
-		valid(valid), componentInfo(componentInfo), identifier(identifier), dotVersion(dotVersion), commitHash(commitHash) {}
+	ComponentVersion(uint8_t valid, uint8_t componentInfo, uint32_t identifier, uint32_t dotVersion, uint32_t commitHash, uint8_t expansionSlot) :
+		valid(valid), componentInfo(componentInfo), identifier(identifier), dotVersion(dotVersion), commitHash(commitHash), expansionSlot(expansionSlot) {}
 
 	static ComponentVersion FromAppVersion(uint32_t identifier, uint8_t appMajor, uint8_t appMinor) {
 		uint32_t dotVersion = (appMajor << 24) | (appMinor << 16);
@@ -19,6 +19,7 @@ public:
 			static_cast<uint8_t>(0u),
 			identifier,
 			dotVersion,
+			static_cast<uint8_t>(0u),
 			static_cast<uint8_t>(0u)
 		);
 	}
@@ -28,6 +29,7 @@ public:
 	const uint32_t identifier;
 	const uint32_t dotVersion;
 	const uint32_t commitHash;
+	const uint8_t expansionSlot;
 };
 
 class ComponentVersionsMessage : public Message {