Clean up example

Add second signal set to the example

.gitignore

@@ -15,4 +15,3 @@ third-party/concurrentqueue/tests
 examples/csharp/bin
 examples/csharp/obj
 test/system
-.env

.gitlab-ci.yml

@@ -1,6 +1,5 @@
 variables:
   DEBIAN_FRONTEND: noninteractive
-  LIBICSNEO_ICSPB_REPO: https://gitlab-ci-token:${CI_JOB_TOKEN}@${LIBICSNEO_ICSPB_GIT}
 
 stages:
   - build
@@ -14,7 +13,7 @@ stages:
 build windows/x64:
   stage: build
   script:
-    - cmd /C ci\build-windows64.bat
+    - CMD.EXE /C ci\build-windows64.bat
   artifacts:
     when: always
     paths:
@@ -38,7 +37,7 @@ unit_test windows/x64:
 build windows/x86:
   stage: build
   script:
-    - cmd /C ci\build-windows32.bat
+    - CMD.EXE /C ci\build-windows32.bat
   artifacts:
     when: always
     paths:
@@ -68,9 +67,7 @@ unit_test windows/x86:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y g++ ninja-build cmake libpcap-dev git ca-certificates
+    - apt install -y g++ ninja-build cmake libusb-1.0-0-dev libpcap-dev git
-    - echo "$ICS_IPA_CA_CRT" >/usr/local/share/ca-certificates/ica-ipa-ca.crt
-    - update-ca-certificates --fresh
     - sh ci/build-posix.sh
   artifacts:
     when: always
@@ -85,7 +82,7 @@ unit_test windows/x86:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y libpcap-dev
+    - apt install -y libusb-1.0-0-dev libpcap-dev
     - build/libicsneo-unit-tests
   tags:
     - linux-build
@@ -96,9 +93,7 @@ unit_test windows/x86:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y clang lld ninja-build cmake libpcap-dev git ca-certificates
+    - apt install -y clang lld ninja-build cmake libusb-1.0-0-dev libpcap-dev git
-    - echo "$ICS_IPA_CA_CRT" >/usr/local/share/ca-certificates/ica-ipa-ca.crt
-    - update-ca-certificates --fresh
     - CC=clang CXX=clang++ LDFLAGS=-fuse-ld=lld sh ci/build-posix.sh
   artifacts:
     when: always
@@ -113,59 +108,59 @@ unit_test windows/x86:
   script:
     - apt update -y
     - apt upgrade -y
-    - apt install -y libpcap-dev
+    - apt install -y libusb-1.0-0-dev libpcap-dev
     - build/libicsneo-unit-tests
   tags:
     - linux-build
   timeout: 5m
 
-build linux/ubuntu/2404/amd64/gcc:
+build linux/ubuntu/2004/amd64/gcc:
   <<: *build_linux_ubuntu_gcc
-  image: ubuntu:24.04
+  image: ubuntu:20.04
 
-unit_test linux/ubuntu/2404/amd64/gcc:
+unit_test linux/ubuntu/2004/amd64/gcc:
   <<: *test_linux_ubuntu_gcc
-  image: ubuntu:24.04
+  image: ubuntu:20.04
   dependencies:
-    - build linux/ubuntu/2404/amd64/gcc
+    - build linux/ubuntu/2004/amd64/gcc
   needs:
-    - build linux/ubuntu/2404/amd64/gcc
+    - build linux/ubuntu/2004/amd64/gcc
 
-build linux/ubuntu/2404/amd64/clang:
+build linux/ubuntu/2004/amd64/clang:
   <<: *build_linux_ubuntu_clang
-  image: ubuntu:24.04
+  image: ubuntu:20.04
 
-unit_test linux/ubuntu/2404/amd64/clang:
+unit_test linux/ubuntu/2004/amd64/clang:
   <<: *test_linux_ubuntu_clang
-  image: ubuntu:24.04
+  image: ubuntu:20.04
   dependencies:
-    - build linux/ubuntu/2404/amd64/clang
+    - build linux/ubuntu/2004/amd64/clang
   needs:
-    - build linux/ubuntu/2404/amd64/clang
+    - build linux/ubuntu/2004/amd64/clang
 
-build linux/ubuntu/2604/amd64/gcc:
+build linux/ubuntu/2204/amd64/gcc:
   <<: *build_linux_ubuntu_gcc
-  image: ubuntu:26.04
+  image: ubuntu:22.04
 
-unit_test linux/ubuntu/2604/amd64/gcc:
+unit_test linux/ubuntu/2204/amd64/gcc:
   <<: *test_linux_ubuntu_gcc
-  image: ubuntu:26.04
+  image: ubuntu:22.04
   dependencies:
-    - build linux/ubuntu/2604/amd64/gcc
+    - build linux/ubuntu/2204/amd64/gcc
   needs:
-    - build linux/ubuntu/2604/amd64/gcc
+    - build linux/ubuntu/2204/amd64/gcc
 
-build linux/ubuntu/2604/amd64/clang:
+build linux/ubuntu/2204/amd64/clang:
   <<: *build_linux_ubuntu_clang
-  image: ubuntu:26.04
+  image: ubuntu:22.04
 
-unit_test linux/ubuntu/2604/amd64/clang:
+unit_test linux/ubuntu/2204/amd64/clang:
   <<: *test_linux_ubuntu_clang
-  image: ubuntu:26.04
+  image: ubuntu:22.04
   dependencies:
-    - build linux/ubuntu/2604/amd64/clang
+    - build linux/ubuntu/2204/amd64/clang
   needs:
-    - build linux/ubuntu/2604/amd64/clang
+    - build linux/ubuntu/2204/amd64/clang
 
 #-------------------------------------------------------------------------------
 # Fedora
@@ -180,9 +175,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y g++ libpcap-devel cmake ninja-build git ca-certificates
+    - dnf install -y g++ libpcap-devel cmake ninja-build libusb1-devel git
-    - echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
-    - update-ca-trust
     - sh ci/build-posix.sh
   artifacts:
     when: always
@@ -201,7 +194,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y libpcap-devel
+    - dnf install -y libpcap-devel libusb1-devel
     - build/libicsneo-unit-tests
   tags:
     - linux-build
@@ -216,9 +209,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y clang lld libpcap-devel cmake ninja-build git ca-certificates
+    - dnf install -y clang lld libpcap-devel cmake ninja-build libusb1-devel git
-    - echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
-    - update-ca-trust
     - CC=clang CXX=clang++ LDFLAGS=-fuse-ld=lld sh ci/build-posix.sh
   artifacts:
     when: always
@@ -237,59 +228,83 @@ unit_test linux/ubuntu/2604/amd64/clang:
     - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
     - echo fastestmirror=True >>/etc/dnf/dnf.conf
     - dnf upgrade -y
-    - dnf install -y libpcap-devel
+    - dnf install -y libpcap-devel libusb1-devel
     - build/libicsneo-unit-tests
   tags:
     - linux-build
   timeout: 5m
 
-build linux/fedora/43/amd64/gcc:
+build linux/fedora/39/amd64/gcc:
   <<: *build_linux_fedora_gcc
-  image: fedora:43
+  image: fedora:39
 
-unit_test linux/fedora/43/amd64/gcc:
+unit_test linux/fedora/39/amd64/gcc:
   <<: *test_linux_fedora_gcc
-  image: fedora:43
+  image: fedora:39
   dependencies:
-    - build linux/fedora/43/amd64/gcc
+    - build linux/fedora/39/amd64/gcc
   needs:
-    - build linux/fedora/43/amd64/gcc
+    - build linux/fedora/39/amd64/gcc
 
-build linux/fedora/43/amd64/clang:
+build linux/fedora/39/amd64/clang:
   <<: *build_linux_fedora_clang
-  image: fedora:43
+  image: fedora:39
 
-unit_test linux/fedora/43/amd64/clang:
+unit_test linux/fedora/39/amd64/clang:
   <<: *test_linux_fedora_clang
-  image: fedora:43
+  image: fedora:39
   dependencies:
-    - build linux/fedora/43/amd64/clang
+    - build linux/fedora/39/amd64/clang
   needs:
-    - build linux/fedora/43/amd64/clang
+    - build linux/fedora/39/amd64/clang
 
-build linux/fedora/44/amd64/gcc:
+build linux/fedora/40/amd64/gcc:
   <<: *build_linux_fedora_gcc
-  image: fedora:44
+  image: fedora:40
 
-unit_test linux/fedora/44/amd64/gcc:
+unit_test linux/fedora/40/amd64/gcc:
   <<: *test_linux_fedora_gcc
-  image: fedora:44
+  image: fedora:40
   dependencies:
-    - build linux/fedora/44/amd64/gcc
+    - build linux/fedora/40/amd64/gcc
   needs:
-    - build linux/fedora/44/amd64/gcc
+    - build linux/fedora/40/amd64/gcc
 
-build linux/fedora/44/amd64/clang:
+build linux/fedora/40/amd64/clang:
   <<: *build_linux_fedora_clang
-  image: fedora:44
+  image: fedora:40
 
-unit_test linux/fedora/44/amd64/clang:
+unit_test linux/fedora/40/amd64/clang:
   <<: *test_linux_fedora_clang
-  image: fedora:44
+  image: fedora:40
   dependencies:
-    - build linux/fedora/44/amd64/clang
+    - build linux/fedora/40/amd64/clang
   needs:
-    - build linux/fedora/44/amd64/clang
+    - build linux/fedora/40/amd64/clang
+
+build linux/fedora/41/amd64/gcc:
+  <<: *build_linux_fedora_gcc
+  image: fedora:41
+
+unit_test linux/fedora/41/amd64/gcc:
+  <<: *test_linux_fedora_gcc
+  image: fedora:41
+  dependencies:
+    - build linux/fedora/41/amd64/gcc
+  needs:
+    - build linux/fedora/41/amd64/gcc
+
+build linux/fedora/41/amd64/clang:
+  <<: *build_linux_fedora_clang
+  image: fedora:41
+
+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
@@ -298,13 +313,22 @@ unit_test linux/fedora/44/amd64/clang:
 build python/linux/amd64:
   stage: build
   tags:
-    - linux-native-amd64
+    - linux-build
+  image: python:3.12
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
   variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
+    CIBW_BEFORE_ALL: yum install -y flex && sh ci/bootstrap-libpcap.sh && sh ci/bootstrap-libusb.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: x86_64
-    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install
+    DOCKER_HOST: unix:///var/run/docker.sock
+    DOCKER_DRIVER: overlay2
+    DOCKER_TLS_CERTDIR: ""
+    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install:/project/libusb/install
   script:
+    - curl -sSL https://get.docker.com/ | sh
     - sh ci/build-wheel-posix.sh
   artifacts:
     paths:
@@ -315,10 +339,10 @@ build python/linux/arm64:
   tags:
     - arm64-linux-build
   variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
+    CIBW_BEFORE_ALL: yum install -y flex && sh ci/bootstrap-libpcap.sh && sh ci/bootstrap-libusb.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: aarch64
-    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install
+    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install:/project/libusb/install
   script:
     - sh ci/build-wheel-posix.sh
   artifacts:
@@ -330,9 +354,9 @@ build python/macos:
   tags:
     - macos-arm64
   variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-libpcap.sh
+    CIBW_BEFORE_ALL: sh ci/bootstrap-libpcap.sh && sh ci/bootstrap-libusb.sh
     CIBW_ARCHS: arm64
-    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=$CI_PROJECT_DIR/libpcap/install
+    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=$CI_PROJECT_DIR/libpcap/install:$CI_PROJECT_DIR/libusb/install
     MACOSX_DEPLOYMENT_TARGET: 10.14
   script:
     - sh ci/build-wheel-posix.sh
@@ -360,7 +384,7 @@ deploy python/pypi:
     TWINE_PASSWORD: $PYPI_TOKEN
   tags:
     - linux-build
-  image: python:3.13
+  image: python:3.12
   rules:
     - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
   script:

99-intrepidcs.rules

@@ -3,8 +3,24 @@ SUBSYSTEM=="usb", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
 KERNEL=="ttyUSB?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
 KERNEL=="ttyACM?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
 
-ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", KERNEL=="ttyUSB*", \
+# neoVI ION/PLASMA PIDs are not in the latest ftdi_sio driver so lets make a
-RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/ftdi_sio/unbind'"
+# rule to add it when we see a new unclaimed device.
-
+# PLASMA = 0x0801, ION = 0x0901
-ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", DRIVER=="usbhid", \
+ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
-RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/usbhid/unbind'"
+        ATTRS{idVendor}=="093c", ATTRS{idProduct}=="0801", \
+        DRIVER=="", \
+        RUN+="/sbin/modprobe -b ftdi_sio"
+ACTION=="add", SUBSYSTEM=="drivers", \
+        ENV{DEVPATH}=="/bus/usb-serial/drivers/ftdi_sio", \
+        ATTR{new_id}="093c 0801"
+ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
+        ATTRS{idVendor}=="093c", ATTRS{idProduct}=="0901", \
+        DRIVER=="", \
+        RUN+="/sbin/modprobe -b ftdi_sio"
+ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_interface", \
+        ATTRS{idVendor}=="093c", ATTRS{idProduct}=="1000", \
+        DRIVER=="", \
+        RUN+="/sbin/modprobe -b ftdi_sio"
+ACTION=="add", SUBSYSTEM=="drivers", \
+        ENV{DEVPATH}=="/bus/usb-serial/drivers/ftdi_sio", \
+        ATTR{new_id}="093c 0901"

CMakeLists.txt

@@ -11,8 +11,6 @@ option(LIBICSNEO_BUILD_DOCS "Build documentation. Don't use in Visual Studio." O
 option(LIBICSNEO_BUILD_EXAMPLES "Build examples." ON)
 option(LIBICSNEO_BUILD_ICSNEOC "Build dynamic C library" ON)
 option(LIBICSNEO_BUILD_ICSNEOC_STATIC "Build static C library" ON)
-option(LIBICSNEO_BUILD_ICSNEOC2 "Build dynamic C2 library" ON)
-option(LIBICSNEO_BUILD_ICSNEOC2_STATIC "Build static C2 library" ON)
 option(LIBICSNEO_BUILD_ICSNEOLEGACY "Build icsnVC40 compatibility library" ON)
 option(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC "Build static icsnVC40 compatibility library" ON)
 set(LIBICSNEO_NPCAP_INCLUDE_DIR "" CACHE STRING "Npcap include directory; set to build with Npcap")
@@ -24,13 +22,15 @@ set(LIBICSNEO_NPCAP_INCLUDE_DIR "" CACHE STRING "Npcap include directory; set to
 option(LIBICSNEO_ENABLE_FIRMIO "Enable communication between Linux and CoreMini within the same device" OFF)
 option(LIBICSNEO_ENABLE_RAW_ETHERNET "Enable devices which communicate over raw ethernet" ON)
 option(LIBICSNEO_ENABLE_CDCACM "Enable devices which communicate over USB CDC ACM" ON)
+option(LIBICSNEO_ENABLE_FTDI "Enable devices which communicate over USB FTDI2XX" ON)
 option(LIBICSNEO_ENABLE_TCP "Enable devices which communicate over TCP" OFF)
-option(LIBICSNEO_ENABLE_DXX "Enable devices which communicate over D2XX/D3XX via libredxx" ON)
+option(LIBICSNEO_ENABLE_FTD3XX "Enable devices which communicate over USB FTD3XX" ON)
 
 option(LIBICSNEO_ENABLE_BINDINGS_PYTHON "Enable Python library" OFF)
 
-set(CMAKE_CXX_STANDARD 17)
+if(NOT CMAKE_CXX_STANDARD)
-set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
+	set(CMAKE_CXX_STANDARD 17)
+endif()
 
 include(GNUInstallDirs)
 
@@ -38,13 +38,17 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 # Enable Warnings
 if(MSVC)
-	set(LIBICSNEO_COMPILER_WARNINGS /W4)
+	# 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()
 	# http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html
 	# Still supported until a suitable replacement is standardized
 	add_definitions(-D_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING)
-	add_definitions(-D_ITERATOR_DEBUG_LEVEL=0)
 else() #if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-	set(LIBICSNEO_COMPILER_WARNINGS -Wall -Wno-switch -Wno-unknown-pragmas)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-switch -Wno-unknown-pragmas")
 endif()
 
 find_package(Threads REQUIRED)
@@ -105,6 +109,7 @@ 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
@@ -117,9 +122,9 @@ if(WIN32)
 		)
 	endif()
 
-	if(LIBICSNEO_ENABLE_CDCACM)
+	if(LIBICSNEO_ENABLE_CDCACM OR LIBICSNEO_ENABLE_FTDI)
 		list(APPEND PLATFORM_SRC
-			platform/windows/cdcacm.cpp
+			platform/windows/vcp.cpp
 		)
 	endif()
 else() # Darwin or Linux
@@ -137,6 +142,12 @@ else() # Darwin or Linux
 		)
 	endif()
 
+	if(LIBICSNEO_ENABLE_FTDI)
+		list(APPEND PLATFORM_SRC
+			platform/posix/ftdi.cpp
+		)
+	endif()
+
 	if(LIBICSNEO_ENABLE_CDCACM)
 		list(APPEND PLATFORM_SRC
 			platform/posix/cdcacm.cpp
@@ -160,9 +171,51 @@ else() # Darwin or Linux
 	endif()
 endif()
 
-if(LIBICSNEO_ENABLE_DXX)
+if(LIBICSNEO_ENABLE_FTD3XX)
+	if(NOT FTD3XX_ROOT) # allow system override
+		include(FetchContent)
+		if(WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+			set(LIBICSNEO_FTD3XX_URL "https://github.com/intrepidcs/libftd3xx-repack/releases/download/24.34.0/libftd3xx-1.3.0.10-win-x64.zip")
+			set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=459e635496ab47d6069c9d3515fdd6d82cba3d95e7ae34f794d66ffdf336e9d1")
+		elseif(WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 4)
+			set(LIBICSNEO_FTD3XX_URL "https://github.com/intrepidcs/libftd3xx-repack/releases/download/24.34.0/libftd3xx-1.3.0.10-win-i686.zip")
+			set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=ce4259ae11772d6ede7d217172156fa392f329b29d9455131f4126a2fb89dad1")
+		elseif(APPLE AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+			set(LIBICSNEO_FTD3XX_URL "https://github.com/intrepidcs/libftd3xx-repack/releases/download/24.34.0/libftd3xx-1.0.16-macos-universal2.zip")
+			set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=0904ac5eda8e1dc4b5aac3714383bcc7792b42dfeb585dce6cbfb8b67b8c0c51")
+		elseif(UNIX)
+			if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64")
+				if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+					set(LIBICSNEO_FTD3XX_URL "https://github.com/intrepidcs/libftd3xx-repack/releases/download/24.34.0/libftd3xx-1.0.16-linux-x64.zip")
+					set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=cf66bf299fc722f050cdd3c36998a670f1df69f7c0df18afa73707277067114b")
+				endif()
+			elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm.*|aarch64")
+				if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+					set(LIBICSNEO_FTD3XX_URL "https://github.com/intrepidcs/libftd3xx-repack/releases/download/24.34.0/libftd3xx-1.0.16-linux-aarch64.zip")
+					set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=66341b5112b9841e959e81400b51711be96fec91894477c5cbfc29b10a0c00a6")
+				elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
+					set(LIBICSNEO_FTD3XX_URL "https://github.com/intrepidcs/libftd3xx-repack/releases/download/24.34.0/libftd3xx-1.0.16-linux-armhf.zip")
+					set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=cec1f959b48a11eb6b829ed43c81b6ba1c0bcf3e797bafcc84a6376e5ffc3c47")
+				endif()
+			endif()
+		endif()
+		if(NOT LIBICSNEO_FTD3XX_URL)
+			message(FATAL_ERROR "Unsupported platform for FTD3XX driver")
+		endif()
+		FetchContent_Declare(
+			ftdi3xx
+			URL ${LIBICSNEO_FTD3XX_URL}
+			URL_HASH ${LIBICSNEO_FTD3XX_URL_HASH}
+		)
+		FetchContent_GetProperties(ftdi3xx)
+		if(NOT ftdi3xx_POPULATED)
+			FetchContent_Populate(ftdi3xx)
+		endif()
+		set(FTD3XX_ROOT "${ftdi3xx_SOURCE_DIR}")
+	endif()
+	find_package(FTD3XX REQUIRED)
 	list(APPEND PLATFORM_SRC
-		platform/dxx.cpp
+		platform/ftd3xx.cpp
 	)
 endif()
 
@@ -172,6 +225,10 @@ if(LIBICSNEO_ENABLE_TCP)
 	)
 endif()
 
+if(LIBICSNEO_BUILD_EXAMPLES)
+	add_subdirectory(examples)
+endif()
+
 # Extensions
 set(LIBICSNEO_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 foreach(EXT_PATH ${LIBICSNEO_EXTENSION_DIRS})
@@ -193,13 +250,10 @@ set(SRC_FILES
 	communication/message/tc10statusmessage.cpp
 	communication/message/gptpstatusmessage.cpp
 	communication/message/ethernetstatusmessage.cpp
-	communication/message/networkmutexmessage.cpp
+	communication/message/macsecmessage.cpp
-	communication/message/clientidmessage.cpp
-	communication/message/transmitmessage.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp
-	communication/packet/spipacket.cpp
 	communication/packet/ethernetpacket.cpp
 	communication/packet/versionpacket.cpp
 	communication/packet/iso9141packet.cpp
@@ -223,9 +277,8 @@ set(SRC_FILES
 	communication/communication.cpp
 	communication/driver.cpp
 	communication/livedata.cpp
-	core/ringbuffer.cpp
+	communication/ringbuffer.cpp
-	core/crc32.cpp
+	communication/crc32.cpp
-	core/macseccfg.cpp
 	device/extensions/flexray/extension.cpp
 	device/extensions/flexray/controller.cpp
 	device/idevicesettings.cpp
@@ -239,7 +292,6 @@ set(SRC_FILES
 	disk/plasiondiskreaddriver.cpp
 	disk/extextractordiskreaddriver.cpp
 	disk/fat.cpp
-	disk/diskdetails.cpp
 	disk/vsa/vsa.cpp
 	disk/vsa/vsa02.cpp
 	disk/vsa/vsa03.cpp
@@ -287,7 +339,6 @@ endif()
 
 configure_file(api/icsneocpp/buildinfo.h.template ${CMAKE_CURRENT_BINARY_DIR}/generated/buildinfo.h)
 configure_file(api/icsneoc/version.rc.template ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
-configure_file(api/icsneoc2/version.rc.template ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc2/version.rc)
 
 foreach(EXTINC ${LIBICSNEO_EXTENSION_INCLUDES})
 	message("Including " ${EXTINC})
@@ -321,7 +372,6 @@ target_include_directories(icsneocpp
 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)
-target_compile_options(icsneocpp PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 message("Loaded extensions: " ${LIBICSNEO_EXTENSION_TARGETS})
 target_link_libraries(icsneocpp PUBLIC ${LIBICSNEO_EXTENSION_TARGETS})
 if(LIBICSNEO_ENABLE_FIRMIO)
@@ -332,15 +382,13 @@ if(LIBICSNEO_ENABLE_RAW_ETHERNET)
 endif()
 if(LIBICSNEO_ENABLE_CDCACM)
 	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_CDCACM)
-	if(APPLE)
-		find_library(CORE_FOUNDATION_FRAMEWORK CoreFoundation REQUIRED)
-		find_library(IO_KIT_FRAMEWORK IOKit REQUIRED)
-		target_link_libraries(icsneocpp PRIVATE ${CORE_FOUNDATION_FRAMEWORK} ${IO_KIT_FRAMEWORK})
-	endif()
 endif()
-if(LIBICSNEO_ENABLE_DXX)
+if(LIBICSNEO_ENABLE_FTDI)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_DXX)
+	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_FTDI)
-	target_link_libraries(icsneocpp PRIVATE libredxx::libredxx)
+endif()
+if(LIBICSNEO_ENABLE_FTD3XX)
+	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_FTD3XX)
+	target_link_libraries(icsneocpp PRIVATE FTD3XX::FTD3XX)
 endif()
 if(LIBICSNEO_ENABLE_TCP)
 	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_TCP)
@@ -354,16 +402,25 @@ add_subdirectory(third-party/fatfs)
 set_property(TARGET fatfs PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(icsneocpp PRIVATE fatfs)
 
-# dxx
+# libftdi
-if(LIBICSNEO_ENABLE_DXX)
+if(LIBICSNEO_ENABLE_FTDI)
-	include(FetchContent)
+	if(NOT WIN32)
-	FetchContent_Declare(libredxx
+		target_include_directories(icsneocpp PUBLIC third-party/libftdi/src)
-		GIT_REPOSITORY https://github.com/Zeranoe/libredxx.git
+		set(LIBFTDI_DOCUMENTATION OFF CACHE INTERNAL "")
-		GIT_TAG e823a96c39a64ab41b7d1632dbe8f86bb854df83
+		set(LIBFTDI_BUILD_TESTS OFF CACHE INTERNAL "")
-	)
+		set(LIBFTDI_INSTALL OFF CACHE INTERNAL "")
-	set(LIBREDXX_DISABLE_INSTALL ON)
+		set(LIBFTDI_PYTHON_BINDINGS OFF CACHE INTERNAL "")
-	FetchContent_MakeAvailable(libredxx)
+		set(LIBFTDI_LINK_PYTHON_LIBRARY OFF CACHE INTERNAL "")
-endif()
+		set(FTDIPP OFF CACHE INTERNAL "")
+		set(FTDI_EEPROM OFF CACHE INTERNAL "")
+		add_subdirectory(third-party/libftdi)
+		target_include_directories(icsneocpp PRIVATE ${LIBUSB_INCLUDE_DIR})
+
+		set_property(TARGET ftdi1-static PROPERTY POSITION_INDEPENDENT_CODE ON)
+		target_link_libraries(icsneocpp PUBLIC ftdi1-static)
+		target_link_libraries(icsneocpp PUBLIC ${CMAKE_THREAD_LIBS_INIT})
+	endif(NOT WIN32)
+endif(LIBICSNEO_ENABLE_FTDI)
 
 # pcap
 if(LIBICSNEO_ENABLE_RAW_ETHERNET)
@@ -381,21 +438,6 @@ if(LIBICSNEO_ENABLE_RAW_ETHERNET)
 	endif(WIN32)
 endif(LIBICSNEO_ENABLE_RAW_ETHERNET)
 
-# protobuf
-if(DEFINED ENV{LIBICSNEO_ICSPB_REPO})
-	set(LIBICSNEO_ICSPB_REPO "$ENV{LIBICSNEO_ICSPB_REPO}")
-endif()
-if(NOT LIBICSNEO_ICSPB_REPO)
-	set(LIBICSNEO_ICSPB_REPO https://github.com/intrepidcs/icspb.git)
-endif()
-include(FetchContent)
-FetchContent_Declare(icspb
-	GIT_REPOSITORY ${LIBICSNEO_ICSPB_REPO}
-	GIT_TAG 3339fa6b83a6b3e7704d41f5c2f2175cfc761a1f
-)
-FetchContent_MakeAvailable(icspb)
-target_link_libraries(icsneocpp PRIVATE icspb::icspb)
-
 if(LIBICSNEO_BUILD_ICSNEOC)
 	add_library(icsneoc SHARED api/icsneoc/icsneoc.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
 	target_include_directories(icsneoc
@@ -407,7 +449,6 @@ if(LIBICSNEO_BUILD_ICSNEOC)
 	)
 	target_link_libraries(icsneoc PRIVATE icsneocpp)
 	target_compile_features(icsneoc PRIVATE cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
-	target_compile_options(icsneoc PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 if(LIBICSNEO_BUILD_ICSNEOC_STATIC)
@@ -422,39 +463,6 @@ if(LIBICSNEO_BUILD_ICSNEOC_STATIC)
 	target_link_libraries(icsneoc-static PUBLIC icsneocpp)
 	target_compile_features(icsneoc-static PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 	target_compile_definitions(icsneoc-static PUBLIC ICSNEOC_BUILD_STATIC)
-	target_compile_options(icsneoc-static PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
-endif()
-
-if(LIBICSNEO_BUILD_ICSNEOC2)
-	add_library(icsneoc2 SHARED api/icsneoc2/icsneoc2.cpp api/icsneoc2/icsneoc2settings.cpp api/icsneoc2/icsneoc2messages.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc2/version.rc)
-	target_include_directories(icsneoc2
-		PUBLIC
-			$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-			$<INSTALL_INTERFACE:>
-		PRIVATE
-			${CMAKE_CURRENT_SOURCE_DIR}/include
-	)
-	target_link_libraries(icsneoc2 PRIVATE icsneocpp)
-	target_compile_features(icsneoc2 PRIVATE cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
-	target_compile_options(icsneoc2 PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
-	if(WIN32)
-		set_target_properties(icsneoc2 PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
-	endif()
-endif()
-
-if(LIBICSNEO_BUILD_ICSNEOC2_STATIC)
-	add_library(icsneoc2-static STATIC api/icsneoc2/icsneoc2.cpp api/icsneoc2/icsneoc2settings.cpp api/icsneoc2/icsneoc2messages.cpp)
-	target_include_directories(icsneoc2-static
-		PUBLIC
-			$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-			$<INSTALL_INTERFACE:>
-		PRIVATE
-			${CMAKE_CURRENT_SOURCE_DIR}/include
-	)
-	target_link_libraries(icsneoc2-static PUBLIC icsneocpp)
-	target_compile_features(icsneoc2-static PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
-	target_compile_definitions(icsneoc2-static PUBLIC ICSNEOC2_BUILD_STATIC)
-	target_compile_options(icsneoc2-static PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 if(LIBICSNEO_BUILD_ICSNEOLEGACY)
@@ -473,7 +481,6 @@ if(LIBICSNEO_BUILD_ICSNEOLEGACY)
 	)
 	target_link_libraries(icsneolegacy PRIVATE icsneocpp)
 	target_compile_features(icsneolegacy PRIVATE cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
-	target_compile_options(icsneolegacy PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 if(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC)
@@ -493,24 +500,23 @@ if(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC)
 	target_link_libraries(icsneolegacy-static PUBLIC icsneocpp)
 	target_compile_features(icsneolegacy-static PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 	target_compile_definitions(icsneolegacy-static PUBLIC ICSNEOC_BUILD_STATIC)
-	target_compile_options(icsneolegacy-static PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
 endif()
 
 add_subdirectory(bindings)
 
-if(LIBICSNEO_BUILD_EXAMPLES)
-	add_subdirectory(examples)
-endif()
-
 # googletest
 if(LIBICSNEO_BUILD_UNIT_TESTS)
-	include(FetchContent)
+	if(WIN32)
-	FetchContent_Declare(googletest
+		set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-		GIT_REPOSITORY https://github.com/google/googletest.git
+	endif()
-		GIT_TAG 6986c2b575f77135401a4e1c65a7a42f20e18fef
+
-	)
+	if (NOT TARGET gtest)
-	FetchContent_MakeAvailable(googletest)
+		add_subdirectory(third-party/googletest-master)
-	include(GoogleTest)
+	endif()
+
+	if (CMAKE_VERSION VERSION_LESS 2.8.11)
+		include_directories("${gtest_SOURCE_DIR}/include")
+	endif()
 
 	add_executable(libicsneo-unit-tests
 		test/unit/main.cpp
@@ -525,24 +531,19 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 		test/unit/livedataencoderdecodertest.cpp
 		test/unit/ringbuffertest.cpp
 		test/unit/apperrordecodertest.cpp
-		test/unit/icsneoc2.cpp
 		test/unit/windowsstrings.cpp
-		test/unit/periodictest.cpp
 	)
 
-	target_compile_options(libicsneo-unit-tests PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
-
 	target_link_libraries(libicsneo-unit-tests gtest gtest_main)
 	target_link_libraries(libicsneo-unit-tests icsneocpp)
-	target_link_libraries(libicsneo-unit-tests icsneoc2-static)
 
 	target_include_directories(libicsneo-unit-tests PUBLIC ${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
 
 	enable_testing()
 
-	gtest_discover_tests(libicsneo-unit-tests TEST_PREFIX "unit/" PROPERTIES LABELS "unit")
+	add_test(NAME libicsneo-unit-test-suite COMMAND libicsneo-unit-tests)
 endif()
 
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
-include(CPack)
+include(CPack)

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018-2026 Intrepid Control Systems, Inc.
+Copyright (c) 2018-2025 Intrepid Control Systems, Inc.
 
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

README.md

@@ -4,20 +4,11 @@ libicsneo is the [Intrepid Control Systems](https://intrepidcs.com/) device
 communication library. Installation and usage documentation can be found within
 each of the respective APIs.
 
-## Installation
-
-libicsneo relies on Servd, IntrepidCS's device communication server.
-
-Servd can be installed for all platforms from https://cdn.intrepidcs.net/servd/.
-
-Instructions for installing each API can be found in its respective documentation.
-
 ## Documentation
 
 - [C++](https://libicsneo.readthedocs.io/en/latest/icsneocpp/)
 - [Python](https://libicsneo.readthedocs.io/en/latest/icsneopy/)
-- [C](https://libicsneo.readthedocs.io/en/latest/icsneoc/) (deprecated, use C2)
+- [C](https://libicsneo.readthedocs.io/en/latest/icsneoc/)
-- [C2](https://libicsneo.readthedocs.io/en/latest/icsneoc2/)
 
 ## Hardware Support
 
@@ -36,7 +27,6 @@ Instructions for installing each API can be found in its respective documentatio
 - RAD-EpsilonXL
 - RAD-Galaxy
 - RAD-Galaxy 2
-- RAD-Gemini
 - RAD-Gigastar
 - RAD-Gigastar 2
 - RAD-Moon 2

api/icsneoc/icsneoc.cpp

@@ -757,33 +757,3 @@ bool icsneo_isOnlineSupported(const neodevice_t* device) {
 	
 	return device->device->isOnlineSupported();
 }
-
-bool icsneo_requestTC10Wake(const neodevice_t* device, neonetid_t netid) {
-	if(!icsneo_isValidNeoDevice(device))
-		return false;
-
-	return device->device->requestTC10Wake((Network::NetID)netid);
-}
-
-bool icsneo_requestTC10Sleep(const neodevice_t* device, neonetid_t netid) {
-	if(!icsneo_isValidNeoDevice(device))
-		return false;
-
-	return device->device->requestTC10Sleep((Network::NetID)netid);
-}
-
-bool icsneo_getTC10Status(const neodevice_t* device, neonetid_t netid, neotc10status_t* status) {
-	if(!icsneo_isValidNeoDevice(device))
-		return false;
-	
-	const auto statusMsg = device->device->getTC10Status((Network::NetID)netid);
-
-	if(!statusMsg)
-		return false;
-
-	status->wakeStatus = (neotc10wakestatus_t)statusMsg->wakeStatus;
-	status->sleepStatus = (neotc10sleepstatus_t)statusMsg->sleepStatus;
-
-	return true;
-}
-

api/icsneoc/version.rc.template

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

api/icsneoc2/icsneoc2_internal.h

@@ -1,53 +0,0 @@
-// This header is for internal icsneoc2 use only, it should not be included by users of the API.
-#pragma once
-
-#include "icsneo/icsneoc2.h"
-#include "icsneo/device/device.h"
-#include "icsneo/communication/message/message.h"
-#include "icsneo/communication/message/scriptstatusmessage.h"
-#include "icsneo/api/event.h"
-#include "icsneo/disk/diskdetails.h"
-
-#include <memory>
-#include <vector>
-
-using namespace icsneo;
-
-typedef struct icsneoc2_message_t {
-	std::shared_ptr<Message> message;
-} icsneoc2_message_t;
-
-typedef struct icsneoc2_event_t {
-	APIEvent event;
-} icsneoc2_event_t;
-
-typedef struct icsneoc2_device_info_t {
-	std::shared_ptr<Device> device;
-	icsneoc2_device_info_t* next;
-} icsneoc2_device_info_t;
-
-typedef struct icsneoc2_device_t {
-	std::shared_ptr<Device> device;
-} icsneoc2_device_t;
-
-typedef struct icsneoc2_disk_details_t {
-	std::shared_ptr<DiskDetails> details;
-} icsneoc2_disk_details_t;
-
-typedef struct icsneoc2_script_status_t {
-	std::shared_ptr<ScriptStatusMessage> status;
-} icsneoc2_script_status_t;
-
-/**
- * Safely copies a std::string to a char array.
- *
- * @param dest The buffer to copy the string into
- * @param dest_size* The size of the buffer. Will be modified to the length of the string without the null terminator.
- * @param src The string to copy
- *
- * @return true if the string was successfully copied, false otherwise
- *
- * @note This function always null terminates the buffer, even if the string is too long. 
- * In the case of truncation, dest_size will reflect the truncated length (not including the null terminator).
- */
-bool safe_str_copy(char* dest, size_t* dest_size, std::string_view src);

api/icsneoc2/icsneoc2messages.cpp

@@ -1,617 +0,0 @@
-#include "icsneo/icsneoc2messages.h" // TODO: Remove this after the complete refactor
-
-#include "icsneo/icsneoc2.h"
-#include "icsneoc2_internal.h"
-
-#include "icsneo/icsneocpp.h"
-#include "icsneo/communication/message/message.h"
-#include "icsneo/communication/message/canmessage.h"
-#include "icsneo/communication/message/canerrormessage.h"
-#include "icsneo/communication/message/linmessage.h"
-#include "icsneo/communication/message/ethernetmessage.h"
-#include "icsneo/communication/packet/canpacket.h"
-
-icsneoc2_error_t icsneoc2_message_is_valid(icsneoc2_message_t* message, bool* is_valid) {
-	if(!message || !is_valid) {
-		return icsneoc2_error_invalid_parameters;
-	}
-
-	*is_valid = (bool)message->message;
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_transmit(icsneoc2_message_t* message, bool* value) {
-	if(!message || !value) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	// We can static cast here because we are relying on the type being correct at this point
-	auto frame = std::dynamic_pointer_cast<Frame>(message->message);
-	if(!frame) {
-		return icsneoc2_error_invalid_type;
-	}
-	*value = frame->transmitted;
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_error(icsneoc2_message_t* message, bool* value) {
-	if(!message || !value) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto frame = std::dynamic_pointer_cast<Frame>(message->message);
-	if(!frame) {
-		return icsneoc2_error_invalid_type;
-	}
-	*value = frame->error;
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_netid_get(icsneoc2_message_t* message, icsneoc2_netid_t* netid) {
-	if(!message || !netid) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto raw = std::dynamic_pointer_cast<RawMessage>(message->message);
-	if(!raw) {
-		return icsneoc2_error_invalid_type;
-	}
-	*netid = static_cast<icsneoc2_netid_t>(raw->network.getNetID());
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_netid_name_get(icsneoc2_netid_t netid, char* value, size_t* value_length) {
-	if(!value || !value_length) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto netid_str = std::string(Network::GetNetIDString(static_cast<Network::NetID>(netid), true));
-	// Copy the string into value
-	return safe_str_copy(value, value_length, netid_str) ? icsneoc2_error_success : icsneoc2_error_string_copy_failed;
-}
-
-icsneoc2_error_t icsneoc2_netid_network_type_get(icsneoc2_netid_t netid, icsneoc2_network_type_t* network_type) {
-	if(!network_type) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*network_type = static_cast<icsneoc2_network_type_t>(Network::GetTypeOfNetID(static_cast<Network::NetID>(netid), true));
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_netid_set(icsneoc2_message_t* message, icsneoc2_netid_t netid) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto raw = std::dynamic_pointer_cast<RawMessage>(message->message);
-	if(!raw) {
-		return icsneoc2_error_invalid_type;
-	}
-	raw->network = Network(static_cast<neonetid_t>(netid), true);
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_data_set(icsneoc2_message_t* message, uint8_t* data, size_t data_length) {
-	if(!message || !data) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	// Make sure the message has the data field (RawMessage or Frame)
-	auto raw_message = std::dynamic_pointer_cast<RawMessage>(message->message);
-	if(!raw_message) {
-		return icsneoc2_error_invalid_type;
-	}
-	raw_message->data.resize(data_length);
-	std::copy(data, data + data_length, raw_message->data.begin());
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_data_get(icsneoc2_message_t* message, uint8_t* data, size_t* data_length) {
-	if(!message || !data_length) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	// Make sure the message has the data field (RawMessage or Frame)
-	auto raw_message = std::dynamic_pointer_cast<RawMessage>(message->message);
-	if(!raw_message) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(!data) {
-		*data_length = raw_message->data.size();
-		return icsneoc2_error_success;
-	}
-	if(*data_length < raw_message->data.size()) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	std::copy(raw_message->data.begin(), raw_message->data.begin() + raw_message->data.size(), data);
-	*data_length = raw_message->data.size();
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_can_create(icsneoc2_message_t** message) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	try {
-		*message = new icsneoc2_message_t;
-		// Initialize the internal message as a CANMessage so that all icsneoc2_message_can_*_set
-		// functions work correctly on user-created transmit messages.
-		(*message)->message = std::make_shared<CANMessage>();
-	} catch(const std::bad_alloc&) {
-		return icsneoc2_error_out_of_memory;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_free(icsneoc2_message_t* message) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	delete message;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_can_props_set(icsneoc2_message_t* message, const uint64_t* arb_id, const uint64_t* flags) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto can_msg = std::dynamic_pointer_cast<CANMessage>(message->message);
-	if(!can_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(arb_id) {
-		can_msg->arbid = static_cast<uint32_t>(*arb_id);
-	}
-	if(flags) {
-		can_msg->isRemote = (*flags & ICSNEOC2_MESSAGE_CAN_FLAGS_RTR);
-		can_msg->isExtended = (*flags & ICSNEOC2_MESSAGE_CAN_FLAGS_IDE);
-		can_msg->isCANFD = (*flags & ICSNEOC2_MESSAGE_CAN_FLAGS_FDF);
-		can_msg->baudrateSwitch = (*flags & ICSNEOC2_MESSAGE_CAN_FLAGS_BRS);
-		can_msg->errorStateIndicator = (*flags & ICSNEOC2_MESSAGE_CAN_FLAGS_ESI);
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_can_props_get(icsneoc2_message_t* message, uint64_t* arb_id, uint64_t* flags) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto can_msg = std::dynamic_pointer_cast<CANMessage>(message->message);
-	if(!can_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(arb_id) {
-		*arb_id = can_msg->arbid;
-	}
-	if(flags) {
-		*flags = 0;
-		if(can_msg->isRemote) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_RTR;
-		}
-		if(can_msg->isExtended) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_IDE;
-		}
-		if(can_msg->isCANFD) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_FDF;
-		}
-		if(can_msg->baudrateSwitch) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_BRS;
-		}
-		if(can_msg->errorStateIndicator) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_ESI;
-		}
-		if(can_msg->txAborted) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED;
-		}
-		if(can_msg->txLostArb) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB;
-		}
-		if(can_msg->txError) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR;
-		}
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_network_type_get(icsneoc2_message_t* message, icsneoc2_network_type_t* network_type) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto raw = std::dynamic_pointer_cast<RawMessage>(message->message);
-	if(!raw) {
-		return icsneoc2_error_invalid_type;
-	}
-	*network_type = (icsneoc2_network_type_t)raw->network.getType();
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_raw(icsneoc2_message_t* message, bool* is_raw) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_raw = std::dynamic_pointer_cast<RawMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_frame(icsneoc2_message_t* message, bool* is_frame) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_frame = std::dynamic_pointer_cast<Frame>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_can(icsneoc2_message_t* message, bool* is_can) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_can = std::dynamic_pointer_cast<CANMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_can_error(icsneoc2_message_t* message, bool* is_can_error) {
-	if(!message || !is_can_error) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_can_error = std::dynamic_pointer_cast<CANErrorMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_can_error_props_get(
-    icsneoc2_message_t *message, uint8_t *tx_err_count, uint8_t *rx_err_count,
-    icsneoc2_can_error_code_t *error_code,
-    icsneoc2_can_error_code_t *data_error_code,
-    icsneoc2_message_can_error_flags_t *flags) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto can_err = std::dynamic_pointer_cast<CANErrorMessage>(message->message);
-	if(!can_err) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(tx_err_count) {
-		*tx_err_count = can_err->transmitErrorCount;
-	}
-	if(rx_err_count) {
-		*rx_err_count = can_err->receiveErrorCount;
-	}
-	if(error_code) {
-		*error_code = static_cast<icsneoc2_can_error_code_t>(can_err->errorCode);
-	}
-	if(data_error_code) {
-		*data_error_code = static_cast<icsneoc2_can_error_code_t>(can_err->dataErrorCode);
-	}
-	if(flags) {
-		*flags = 0;
-		if(can_err->busOff) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF;
-		}
-		if(can_err->errorPassive) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE;
-		}
-		if(can_err->errorWarn) {
-			*flags |= ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN;
-		}
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_lin(icsneoc2_message_t* message, bool* is_lin) {
-	if(!message || !is_lin) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_lin = std::dynamic_pointer_cast<LINMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_lin_create(icsneoc2_message_t** message, uint8_t id) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	try {
-		*message = new icsneoc2_message_t;
-		(*message)->message = std::make_shared<LINMessage>(id);
-	} catch(const std::bad_alloc&) {
-		return icsneoc2_error_out_of_memory;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_lin_props_get(const icsneoc2_message_t* message,
-	uint8_t* id, uint8_t* protected_id, uint8_t* checksum,
-	icsneoc2_lin_msg_type_t* msg_type, bool* is_enhanced_checksum) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
-	if(!lin_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(id) {
-		*id = lin_msg->ID;
-	}
-	if(protected_id) {
-		*protected_id = lin_msg->protectedID;
-	}
-	if(checksum) {
-		*checksum = lin_msg->checksum;
-	}
-	if(msg_type) {
-		*msg_type = static_cast<icsneoc2_lin_msg_type_t>(lin_msg->linMsgType);
-	}
-	if(is_enhanced_checksum) {
-		*is_enhanced_checksum = lin_msg->isEnhancedChecksum;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_lin_props_set(icsneoc2_message_t* message,
-	const uint8_t* id, const uint8_t* checksum,
-	const icsneoc2_lin_msg_type_t* msg_type, const bool* is_enhanced_checksum) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
-	if(!lin_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(id) {
-		lin_msg->ID = *id & 0x3Fu;
-		lin_msg->protectedID = lin_msg->calcProtectedID(lin_msg->ID);
-	}
-	if(checksum) {
-		lin_msg->checksum = *checksum;
-	}
-	if(msg_type) {
-		lin_msg->linMsgType = static_cast<LINMessage::Type>(*msg_type);
-	}
-	if(is_enhanced_checksum) {
-		lin_msg->isEnhancedChecksum = *is_enhanced_checksum;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_lin_err_flags_get(const icsneoc2_message_t* message, icsneoc2_lin_err_flags_t* err_flags) {
-	if(!message || !err_flags) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
-	if(!lin_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	*err_flags = 0;
-	if(lin_msg->errFlags.ErrRxBreakOnly) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_ONLY;
-	if(lin_msg->errFlags.ErrRxBreakSyncOnly) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_SYNC_ONLY;
-	if(lin_msg->errFlags.ErrTxRxMismatch) *err_flags |= ICSNEOC2_LIN_ERR_TX_RX_MISMATCH;
-	if(lin_msg->errFlags.ErrRxBreakNotZero) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_NOT_ZERO;
-	if(lin_msg->errFlags.ErrRxBreakTooShort) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_TOO_SHORT;
-	if(lin_msg->errFlags.ErrRxSyncNot55) *err_flags |= ICSNEOC2_LIN_ERR_RX_SYNC_NOT_55;
-	if(lin_msg->errFlags.ErrRxDataLenOver8) *err_flags |= ICSNEOC2_LIN_ERR_RX_DATA_LEN_OVER_8;
-	if(lin_msg->errFlags.ErrFrameSync) *err_flags |= ICSNEOC2_LIN_ERR_FRAME_SYNC;
-	if(lin_msg->errFlags.ErrFrameMessageID) *err_flags |= ICSNEOC2_LIN_ERR_FRAME_MESSAGE_ID;
-	if(lin_msg->errFlags.ErrFrameResponderData) *err_flags |= ICSNEOC2_LIN_ERR_FRAME_RESPONDER_DATA;
-	if(lin_msg->errFlags.ErrChecksumMatch) *err_flags |= ICSNEOC2_LIN_ERR_CHECKSUM_MATCH;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_lin_status_flags_get(const icsneoc2_message_t* message, icsneoc2_lin_status_flags_t* status_flags) {
-	if(!message || !status_flags) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
-	if(!lin_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	*status_flags = 0;
-	if(lin_msg->statusFlags.TxChecksumEnhanced) *status_flags |= ICSNEOC2_LIN_STATUS_TX_CHECKSUM_ENHANCED;
-	if(lin_msg->statusFlags.TxCommander) *status_flags |= ICSNEOC2_LIN_STATUS_TX_COMMANDER;
-	if(lin_msg->statusFlags.TxResponder) *status_flags |= ICSNEOC2_LIN_STATUS_TX_RESPONDER;
-	if(lin_msg->statusFlags.TxAborted) *status_flags |= ICSNEOC2_LIN_STATUS_TX_ABORTED;
-	if(lin_msg->statusFlags.UpdateResponderOnce) *status_flags |= ICSNEOC2_LIN_STATUS_UPDATE_RESPONDER_ONCE;
-	if(lin_msg->statusFlags.HasUpdatedResponderOnce) *status_flags |= ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE;
-	if(lin_msg->statusFlags.BusRecovered) *status_flags |= ICSNEOC2_LIN_STATUS_BUS_RECOVERED;
-	if(lin_msg->statusFlags.BreakOnly) *status_flags |= ICSNEOC2_LIN_STATUS_BREAK_ONLY;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_lin_calc_checksum(icsneoc2_message_t* message) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
-	if(!lin_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	LINMessage::calcChecksum(*lin_msg);
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_create(icsneoc2_message_t** message) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	try {
-		*message = new icsneoc2_message_t;
-		(*message)->message = std::make_shared<EthernetMessage>();
-	} catch(const std::bad_alloc&) {
-		return icsneoc2_error_out_of_memory;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_props_set(icsneoc2_message_t* message, const icsneoc2_message_eth_flags_t* flags, const bool* has_fcs, const uint32_t* fcs) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
-	if(!eth_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(flags) {
-		eth_msg->frameTooShort = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT);
-		eth_msg->noPadding = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING);
-		eth_msg->fcsVerified = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED);
-		eth_msg->txAborted = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED);
-		eth_msg->crcError = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR);
-	}
-	if(has_fcs && !*has_fcs) {
-		eth_msg->fcs = std::nullopt;
-	} else if(has_fcs && *has_fcs) {
-		// I'm pretty sure we can leave this alone, setting fcs below will take care of the behavior,
-		// otherwise we get into a weird state where we have to set fcs to zero if fcs is null but has_fcs is true.
-	}
-	if (fcs) {
-		eth_msg->fcs = *fcs;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_props_get(icsneoc2_message_t* message, icsneoc2_message_eth_flags_t* flags, bool* has_fcs, uint32_t* fcs) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
-	if(!eth_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(flags) {
-		*flags = 0;
-		if(eth_msg->noPadding)
-			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING;
-		if(eth_msg->fcsVerified)
-			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED;
-		if(eth_msg->txAborted)
-			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED;
-		if(eth_msg->crcError)
-			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR;
-		if(eth_msg->frameTooShort)
-			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT;
-	}
-	if(has_fcs) {
-		*has_fcs = eth_msg->fcs.has_value();
-	}
-	if(fcs) {
-		if(eth_msg->fcs) {
-			*fcs = eth_msg->fcs.value();
-		} else {
-			*fcs = 0;
-		}
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_mac_get(icsneoc2_message_t* message, uint8_t* dst_mac, uint8_t* src_mac) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
-	if(!eth_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(dst_mac) {
-		if(auto mac = eth_msg->getDestinationMAC(); mac.has_value()) {
-			const auto& mac_value = mac.value();
-			std::memcpy(dst_mac, mac_value.data(), mac_value.size());
-		} else {
-			return icsneoc2_error_invalid_data;
-		}
-	}
-	if(src_mac) {
-		if(auto mac = eth_msg->getSourceMAC(); mac.has_value()) {
-			const auto& mac_value = mac.value();
-			std::memcpy(src_mac, mac_value.data(), mac_value.size());
-		} else {
-			return icsneoc2_error_invalid_data;
-		}
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_ether_type_get(icsneoc2_message_t* message, uint16_t* ether_type) {
-	if(!message || !ether_type) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
-	if(!eth_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if (auto et = eth_msg->getEtherType(); et.has_value()) {
-		*ether_type = et.value();
-	} else {
-		return icsneoc2_error_invalid_data;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_t1s_props_set(icsneoc2_message_t* message, const icsneoc2_message_eth_t1s_flags_t* flags, const uint8_t* node_id, const uint8_t* burst_count, const uint8_t* symbol_type) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
-	if(!eth_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	// If all parameters are null/zero, clear the T1S state. Otherwise, if any parameters are set and we don't have a T1S state, create it.
-	if(!flags && !node_id && !burst_count && !symbol_type) {
-		eth_msg->t1s = std::nullopt;
-		return icsneoc2_error_success;
-	}
-	if((flags || node_id || burst_count || symbol_type) && !eth_msg->t1s.has_value()) {
-		eth_msg->t1s.emplace();
-	}
-	if(flags) {
-		eth_msg->t1s->isSymbol = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL);
-		eth_msg->t1s->isBurst = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST);
-		eth_msg->t1s->txCollision = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION);
-		eth_msg->t1s->isWake = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE);
-	}
-	if(node_id) {
-		eth_msg->t1s->nodeId = *node_id;
-	}
-	if(burst_count) {
-		eth_msg->t1s->burstCount = *burst_count;
-	}
-	if(symbol_type) {
-		eth_msg->t1s->symbolType = *symbol_type;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_t1s_props_get(icsneoc2_message_t* message, icsneoc2_message_eth_t1s_flags_t* flags, uint8_t* node_id, uint8_t* burst_count, uint8_t* symbol_type) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
-	if(!eth_msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(flags) {
-		*flags = 0;
-		if(eth_msg->t1s.has_value()) {
-			if(eth_msg->t1s->isSymbol)
-				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL;
-			if(eth_msg->t1s->isBurst)
-				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST;
-			if(eth_msg->t1s->txCollision)
-				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION;
-			if(eth_msg->t1s->isWake)
-				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE;
-		}
-	}
-	if(node_id) {
-		*node_id = eth_msg->t1s.has_value() ? eth_msg->t1s->nodeId : 0;
-	}
-	if(burst_count) {
-		*burst_count = eth_msg->t1s.has_value() ? eth_msg->t1s->burstCount : 0;
-	}
-	if(symbol_type) {
-		*symbol_type = eth_msg->t1s.has_value() ? eth_msg->t1s->symbolType : 0;
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_is_ethernet(icsneoc2_message_t* message, bool* is_ethernet) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_ethernet = std::dynamic_pointer_cast<EthernetMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}

api/icsneoc2/icsneoc2settings.cpp

@@ -1,894 +0,0 @@
-#include "icsneo/icsneoc2.h"
-#include "icsneo/icsneoc2settings.h"
-#include "icsneo/device/device.h"
-#include "icsneo/device/devicefinder.h"
-#include "icsneo/icsneocpp.h"
-#include "icsneo/communication/message/message.h"
-#include "icsneo/communication/message/canmessage.h"
-#include "icsneo/communication/message/linmessage.h"
-#include "icsneo/communication/message/ethernetmessage.h"
-#include "icsneo/communication/packet/canpacket.h"
-#include "icsneo/communication/io.h"
-
-#include <string>
-#include <vector>
-#include <list>
-#include <map>
-#include <algorithm>
-#include <optional>
-#include <sstream>
-
-using namespace icsneo;
-
-#include "icsneoc2_internal.h"
-
-icsneoc2_error_t icsneoc2_settings_apply_defaults(icsneoc2_device_t* device, bool save) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!device->device->settings->applyDefaults(!save)) {
-		return icsneoc2_error_set_settings_failure;
-	}
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_apply(icsneoc2_device_t* device) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!device->device->settings->apply()) {
-		return icsneoc2_error_set_settings_failure;
-	}
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_refresh(icsneoc2_device_t* device) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->refresh()) {
-        return icsneoc2_error_get_settings_failure;
-    }
-
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_baudrate_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, int64_t* baudrate) {
-	if(!baudrate) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	auto baudrate_value = device->device->settings->getBaudrateFor(Network(netid));
-	if(baudrate_value < 0) {
-		*baudrate = 0;
-		return icsneoc2_error_invalid_type;
-	}
-	*baudrate = baudrate_value;
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_baudrate_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, int64_t baudrate) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!device->device->settings->setBaudrateFor(Network(netid), baudrate)) {
-		return icsneoc2_error_set_settings_failure;
-	}
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_canfd_baudrate_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, int64_t* baudrate) {
-	if(!baudrate) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	*baudrate = device->device->settings->getFDBaudrateFor(Network(netid));
-	if(*baudrate < 0) {
-		*baudrate = 0;
-		return icsneoc2_error_invalid_type;
-	}
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_canfd_baudrate_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, int64_t baudrate) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!device->device->settings->setFDBaudrateFor(Network(netid), baudrate)) {
-		return icsneoc2_error_set_settings_failure;
-	}
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_termination_is_supported(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* supported) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!supported) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*supported = device->device->settings->isTerminationSupportedFor(Network(static_cast<Network::NetID>(netid)));
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_termination_can_enable(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* can_enable) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!can_enable) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*can_enable = device->device->settings->canTerminationBeEnabledFor(Network(static_cast<Network::NetID>(netid)));
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_termination_is_enabled(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* enabled) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!enabled) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*enabled = device->device->settings->isTerminationEnabledFor(Network(static_cast<Network::NetID>(netid))).value_or(false);
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_termination_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool enable) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!device->device->settings->setTerminationFor(Network(static_cast<Network::NetID>(netid)), enable)) {
-		return icsneoc2_error_set_settings_failure;
-	}
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_commander_resistor_enabled(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* enabled) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!enabled) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    *enabled = device->device->settings->isCommanderResistorEnabledFor(Network(static_cast<Network::NetID>(netid))).value_or(false);
-
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_commander_resistor_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool enable) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setCommanderResistorFor(Network(static_cast<Network::NetID>(netid)), enable)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_lin_mode_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_lin_mode_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getLINModeFor(network); result.has_value()) {
-        *value = static_cast<icsneoc2_lin_mode_t>(result.value());
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_lin_mode_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_lin_mode_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setLINModeFor(network, static_cast<LINMode>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_lin_commander_response_time_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getLINCommanderResponseTimeFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_lin_commander_response_time_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setLINCommanderResponseTimeFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_enable_get(icsneoc2_device_t* device, uint8_t index, bool* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getPhyEnable(index); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_enable_set(icsneoc2_device_t* device, uint8_t index, bool value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setPhyEnable(index, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_mode_get(icsneoc2_device_t* device, uint8_t index, icsneoc2_ae_link_mode_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getPhyMode(index); result.has_value()) {
-        *value = static_cast<icsneoc2_ae_link_mode_t>(result.value());
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_mode_set(icsneoc2_device_t* device, uint8_t index, icsneoc2_ae_link_mode_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setPhyMode(index, static_cast<AELinkMode>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_speed_get(icsneoc2_device_t* device, uint8_t index, icsneoc2_eth_phy_link_mode_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getPhySpeed(index); result.has_value()) {
-        *value = static_cast<icsneoc2_eth_phy_link_mode_t>(result.value());
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-icsneoc2_error_t icsneoc2_settings_phy_speed_set(icsneoc2_device_t* device, uint8_t index, icsneoc2_eth_phy_link_mode_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setPhySpeed(index, static_cast<EthPhyLinkMode>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_role_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_ae_link_mode_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getPhyRoleFor(network); result.has_value()) {
-        *value = static_cast<icsneoc2_ae_link_mode_t>(result.value());
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_role_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_ae_link_mode_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setPhyRoleFor(network, static_cast<AELinkMode>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_link_mode_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_eth_phy_link_mode_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getPhyLinkModeFor(network); result.has_value()) {
-        *value = static_cast<icsneoc2_eth_phy_link_mode_t>(result.value());
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_link_mode_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_eth_phy_link_mode_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setPhyLinkModeFor(network, static_cast<EthPhyLinkMode>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_enable_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getPhyEnableFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_phy_enable_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setPhyEnableFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_supported_phy_link_modes_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, icsneoc2_eth_phy_link_mode_t** link_modes, size_t* link_modes_count) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!link_modes || !link_modes_count) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    auto modes = device->device->settings->getSupportedPhyLinkModesFor(network);
-    *link_modes_count = std::minmax(modes.size(), *link_modes_count).first;
-    memcpy(*link_modes, modes.data(), *link_modes_count * sizeof(icsneoc2_eth_phy_link_mode_t));
-
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_is_plca_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->isT1SPLCAEnabledFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_plca_enabled_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SPLCAFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_local_id_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value){
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SLocalIDFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_local_id_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value){
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SLocalIDFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_max_nodes_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SMaxNodesFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_max_nodes_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SMaxNodesFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_tx_opp_timer_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1STxOppTimerFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_tx_opp_timer_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1STxOppTimerFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SBurstTimerFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SBurstTimerFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SMaxBurstFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SMaxBurstFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_local_id_alternate_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SLocalIDAlternateFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_local_id_alternate_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SLocalIDAlternateFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_is_termination_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->isT1STerminationEnabledFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_termination_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1STerminationFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_is_bus_decoding_beacons_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->isT1SBusDecodingBeaconsEnabledFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_bus_decoding_beacons_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SBusDecodingBeaconsFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_is_bus_decoding_all_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->isT1SBusDecodingAllEnabledFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_bus_decoding_all_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SBusDecodingAllFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_multi_id_enable_mask_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SMultiIDEnableMaskFor(network); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_multi_id_enable_mask_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SMultiIDEnableMaskFor(network, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_multi_id_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t index, uint8_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(auto result = device->device->settings->getT1SMultiIDFor(network, index); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = 0;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_t1s_multi_id_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t index, uint8_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    auto network = Network(static_cast<Network::NetID>(netid));
-    if(!device->device->settings->setT1SMultiIDFor(network, index, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_misc_io_analog_output_enabled_set(icsneoc2_device_t* device, uint8_t pin, uint8_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setMiscIOAnalogOutputEnabled(pin, value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-
-icsneoc2_error_t icsneoc2_settings_misc_io_analog_output_set(icsneoc2_device_t* device, uint8_t pin, icsneoc2_misc_io_analog_voltage_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setMiscIOAnalogOutput(pin, static_cast<MiscIOAnalogVoltage>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_disabled_get(icsneoc2_device_t* device, bool* value) {
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    *value = device->device->settings->disabled;
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_readonly_get(icsneoc2_device_t* device, bool* value) {
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    *value = device->device->settings->readonly;
-    return icsneoc2_error_success;
-}

api/icsneoc2/version.rc.template

@@ -1,51 +0,0 @@
-#define VER_FILEVERSION             @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@
-#define VER_FILEVERSION_STR         "v@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@@BUILD_METADATA_PLUS@ @BUILD_GIT_INFO@"
-
-#define VER_PRODUCTVERSION          VER_FILEVERSION
-#define VER_PRODUCTVERSION_STR      VER_FILEVERSION_STR
-
-#ifndef DEBUG
-#define VER_DEBUG                   0
-#else
-#define VER_DEBUG                   VS_FF_DEBUG
-#endif
-
-#include <windows.h>
-
-VS_VERSION_INFO VERSIONINFO
-FILEVERSION     VER_FILEVERSION
-PRODUCTVERSION  VER_PRODUCTVERSION
-FILEFLAGSMASK   (VS_FF_DEBUG)
-FILEFLAGS       (VER_DEBUG)
-FILEOS          VOS__WINDOWS32
-FILETYPE        VFT_DLL
-FILESUBTYPE     VFT2_UNKNOWN
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904E4"
-        BEGIN
-            VALUE "CompanyName",      "Intrepid Control Systems, Inc."
-            VALUE "FileDescription",  "Intrepid Control Systems Open Device Communication C API"
-            VALUE "FileVersion",      VER_FILEVERSION_STR
-            VALUE "InternalName",     "icsneoc2.dll"
-            VALUE "LegalCopyright",   "Intrepid Control Systems, Inc. (C) 2018-2026"
-            VALUE "OriginalFilename", "icsneoc2.dll"
-            VALUE "ProductName",      "libicsneo"
-            VALUE "ProductVersion",   VER_PRODUCTVERSION_STR
-        END
-    END
-
-    BLOCK "VarFileInfo"
-    BEGIN
-        /* The following line should only be modified for localized versions.     */
-        /* It consists of any number of WORD,WORD pairs, with each pair           */
-        /* describing a language,codepage combination supported by the file.      */
-        /*                                                                        */
-        /* For example, a file might have values "0x409,1252" indicating that it  */
-        /* supports English language (0x409) in the Windows ANSI codepage (1252). */
-
-        VALUE "Translation", 0x409, 1252
-
-    END
-END

api/icsneocpp/event.cpp

@@ -22,6 +22,29 @@ void APIEvent::init(Type event, APIEvent::Severity severity) {
 	eventStruct.timestamp = EventClock::to_time_t(timepoint);
 }
 
+std::string APIEvent::describe() const noexcept {
+	std::stringstream ss;
+	if(device)
+		ss << *device; // Makes use of device.describe()
+	else
+		ss << "API";
+	
+	Severity severity = getSeverity();
+	if(severity == Severity::EventInfo) {
+		ss << " Info: ";
+	} else if(severity == Severity::EventWarning) {
+		ss << " Warning: ";
+	} else if(severity == Severity::Error) {
+		ss << " Error: ";
+	} else {
+		// Should never get here, since Severity::Any should only be used for filtering
+		ss << " Any: ";
+	}
+
+	ss << getDescription();
+	return ss.str();
+}
+
 void APIEvent::downgradeFromError() noexcept {
 	eventStruct.severity = (uint8_t) APIEvent::Severity::EventWarning;
 }
@@ -51,9 +74,6 @@ static constexpr const char* TIMEOUT = "The timeout was reached.";
 static constexpr const char* WIVI_NOT_SUPPORTED = "Wireless neoVI functions are not supported on this device.";
 static constexpr const char* RESTRICTED_ENTRY_FLAG = "Attempted to set a restricted flag in a Root Directory entry.";
 static constexpr const char* NOT_SUPPORTED = "The requested feature is not supported.";
-static constexpr const char* FIXED_POINT_OVERFLOW = "Value is too large to convert to fixed point.";
-static constexpr const char* FIXED_POINT_PRECISION = "Value is too small for fixed point precision.";
-static constexpr const char* SYSCALL_ERROR = "Error returned from syscall, check errno/GetLastError().";
 
 // Device Errors
 static constexpr const char* POLLING_MESSAGE_OVERFLOW = "Too many messages have been recieved for the polling message buffer, some have been lost!";
@@ -63,8 +83,8 @@ static constexpr const char* NO_SERIAL_NUMBER_12V = "Communication could not be
 static constexpr const char* NO_SERIAL_NUMBER = "Communication could not be established with the device. Perhaps it is not powered or requires a firmware update using Vehicle Spy.";
 static constexpr const char* INCORRECT_SERIAL_NUMBER = "The device did not return the expected serial number!";
 static constexpr const char* SETTINGS_READ = "The device settings could not be read.";
-static constexpr const char* SETTINGS_VERSION = "The settings version is incorrect, please update your firmware with ICS Device Manager.";
+static constexpr const char* SETTINGS_VERSION = "The settings version is incorrect, please update your firmware with neoVI Explorer.";
-static constexpr const char* SETTINGS_LENGTH = "The settings length is incorrect, please update your firmware with ICS Device Manager.";
+static constexpr const char* SETTINGS_LENGTH = "The settings length is incorrect, please update your firmware with neoVI Explorer.";
 static constexpr const char* SETTINGS_CHECKSUM = "The settings checksum is incorrect, attempting to set defaults may remedy this issue.";
 static constexpr const char* SETTINGS_NOT_AVAILABLE = "Settings are not available for this device.";
 static constexpr const char* SETTINGS_READONLY = "Settings are read-only for this device.";
@@ -94,28 +114,14 @@ static constexpr const char* ATOMIC_OPERATION_RETRIED = "An operation failed to
 static constexpr const char* ATOMIC_OPERATION_COMPLETED_NONATOMICALLY = "An ideally-atomic operation was completed nonatomically.";
 static constexpr const char* WIVI_STACK_REFRESH_FAILED = "The Wireless neoVI stack encountered a communication error.";
 static constexpr const char* WIVI_UPLOAD_STACK_OVERFLOW = "The Wireless neoVI upload stack has encountered an overflow condition.";
-static constexpr const char* A2B_MESSAGE_INCOMPLETE_FRAME = "At least one of the frames of the A2B message does not contain samples for each channel and stream.";
+static constexpr const char* A2B_MESSAGE_INCOMPLETE_FRAME = "At least one of the frames of the A2B message does not contain samples for each channel and stream."; 
-static constexpr const char* I2C_MESSAGE_EXCEED_MAX_LENGTH = "The I2C message was too long.";
 static constexpr const char* COREMINI_UPLOAD_VERSION_MISMATCH = "The version of the coremini engine on the device and the script uploaded are not the same.";
 static constexpr const char* DISK_NOT_CONNECTED = "The program tried to access a disk that is not connected.";
 static constexpr const char* UNEXPECTED_RESPONSE = "Received an unexpected or invalid response from the device.";
-static constexpr const char* LIVE_DATA_INVALID_HANDLE = "The live data handle was invalid.";
-static constexpr const char* LIVE_DATA_INVALID_COMMAND = "The live data command was invalid.";
-static constexpr const char* LIVE_DATA_INVALID_ARGUMENT = "The live data argument was invalid.";
-static constexpr const char* LIVE_DATA_VERSION_MISMATCH = "The live data version between libicsneo and firmware are not the same.";
-static constexpr const char* LIVE_DATA_NO_DEVICE_RESPONSE = "Expected a response from the device for live data but none were found.";
-static constexpr const char* LIVE_DATA_MAX_SIGNALS_REACHED = "The max amound of signals to subscribe to for live data has been reached.";
-static constexpr const char* LIVE_DATA_COMMAND_FAILED = "The live data command failed.";
-static constexpr const char* LIVE_DATA_ENCODER_ERROR = "Failure to encode live data message.";
-static constexpr const char* LIVE_DATA_DECODER_ERROR = "Failure to decode live data message.";
-static constexpr const char* LIVE_DATA_NOT_SUPPORTED = "Live data is not supported on this device.";
 static constexpr const char* LIN_SETTINGS_NOT_AVAILABLE = "LIN settings are not available for this device.";
 static constexpr const char* MODE_NOT_FOUND = "The mode was not found.";
-static constexpr const char* APP_ERROR_PARSING_FAILED = "Failure to decode app error message.";
 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";
-static constexpr const char* DISK_FORMAT_NOT_SUPPORTED = "Disk formatting is not supported on this device.";
-static constexpr const char* DISK_FORMAT_INVALID_COUNT = "Disk format config disk count is mismatched with device disk count.";
 
 // Transport Errors
 static constexpr const char* FAILED_TO_READ = "A read operation failed.";
@@ -133,7 +139,41 @@ static constexpr const char* FAILED_TO_BIND = "Unable to bind socket.";
 static constexpr const char* ERROR_SETTING_SOCKET_OPTION = "A call to setsockopt() failed.";
 static constexpr const char* GETIFADDRS_ERROR = "A call to getifaddrs() failed.";
 static constexpr const char* SEND_TO_ERROR = "A call to sendto() failed.";
-static constexpr const char* MDIO_MESSAGE_EXCEED_MAX_LENGTH = "The MDIO message was too long.";
+
+// FTD3XX
+static constexpr const char* FT_OK = "FTD3XX success.";
+static constexpr const char* FT_INVALID_HANDLE = "Invalid FTD3XX handle.";
+static constexpr const char* FT_DEVICE_NOT_FOUND = "FTD3XX device not found.";
+static constexpr const char* FT_DEVICE_NOT_OPENED = "FTD3XX device not opened.";
+static constexpr const char* FT_IO_ERROR = "FTD3XX IO error.";
+static constexpr const char* FT_INSUFFICIENT_RESOURCES = "Insufficient resources for FTD3XX.";
+static constexpr const char* FT_INVALID_PARAMETER = "Invalid FTD3XX parameter.";
+static constexpr const char* FT_INVALID_BAUD_RATE = "Invalid FTD3XX baud rate.";
+static constexpr const char* FT_DEVICE_NOT_OPENED_FOR_ERASE = "FTD3XX device not opened for erase.";
+static constexpr const char* FT_DEVICE_NOT_OPENED_FOR_WRITE = "FTD3XX not opened for write.";
+static constexpr const char* FT_FAILED_TO_WRITE_DEVICE = "FTD3XX failed to write device.";
+static constexpr const char* FT_EEPROM_READ_FAILED = "FTD3XX EEPROM read failed.";
+static constexpr const char* FT_EEPROM_WRITE_FAILED = "FTD3XX EEPROM write failed.";
+static constexpr const char* FT_EEPROM_ERASE_FAILED = "FTD3XX EEPROM erase failed.";
+static constexpr const char* FT_EEPROM_NOT_PRESENT = "FTD3XX EEPROM not present.";
+static constexpr const char* FT_EEPROM_NOT_PROGRAMMED = "FTD3XX EEPROM not programmed.";
+static constexpr const char* FT_INVALID_ARGS = "Invalid FTD3XX arguments.";
+static constexpr const char* FT_NOT_SUPPORTED = "FTD3XX not supported.";
+static constexpr const char* FT_NO_MORE_ITEMS = "No more FTD3XX items.";
+static constexpr const char* FT_TIMEOUT = "FTD3XX timeout.";
+static constexpr const char* FT_OPERATION_ABORTED = "FTD3XX operation aborted.";
+static constexpr const char* FT_RESERVED_PIPE = "Reserved FTD3XX pipe.";
+static constexpr const char* FT_INVALID_CONTROL_REQUEST_DIRECTION = "Invalid FTD3XX control request direction.";
+static constexpr const char* FT_INVALID_CONTROL_REQUEST_TYPE = "Invalid FTD3XX control request type.";
+static constexpr const char* FT_IO_PENDING = "FTD3XX IO pending.";
+static constexpr const char* FT_IO_INCOMPLETE = "FTD3XX IO incomplete.";
+static constexpr const char* FT_HANDLE_EOF = "Handle FTD3XX EOF.";
+static constexpr const char* FT_BUSY = "FTD3XX busy.";
+static constexpr const char* FT_NO_SYSTEM_RESOURCES = "No FTD3XX system resources.";
+static constexpr const char* FT_DEVICE_LIST_NOT_READY = "FTD3XX device list not ready.";
+static constexpr const char* FT_DEVICE_NOT_CONNECTED = "FTD3XX device not connected.";
+static constexpr const char* FT_INCORRECT_DEVICE_PATH = "Incorrect FTD3XX device path.";
+static constexpr const char* FT_OTHER_ERROR = "Other FTD3XX error.";
 
 // VSA
 static constexpr const char* VSA_BUFFER_CORRUPTED = "VSA data in record buffer is corrupted.";
@@ -144,16 +184,6 @@ 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.";
 
-// MACSEC
-static constexpr const char* MACSEC_SECY_LIMIT = "Attempted to exceed the limit of SecY additions to this port";
-static constexpr const char* MACSEC_RULE_LIMIT = "Attempted to exceed the limit of rule additions to this port";
-static constexpr const char* MACSEC_SA_LIMIT = "Attempted to exceed the limit of SA additions to this port";
-static constexpr const char* MACSEC_INVALID_SECY_INDEX = "Attempted to access an invalid SecY index";
-static constexpr const char* MACSEC_INVALID_SA_INDEX = "Attempted to access an invalid SA index";
-static constexpr const char* MACSEC_INVALID_RULE_INDEX = "Attempted to access an invalid rule index";
-static constexpr const char* MACSEC_REKEY_NOT_ENABLED = "Attempted to set rekey SA when rekey was not enabled";
-static constexpr const char* MACSEC_NOT_SUPPORTED = "MACsec is not supported on this device";
-static constexpr const char* MACSEC_CONFIG_MISMATCH = "Attempted to configure device with a macsec configuration for a different device";
 // 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";
@@ -166,16 +196,7 @@ 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* SERVD_NOT_REACHABLE = "Could not reach Servd; ensure it is installed and running";
 
-// DXX
-static constexpr const char* DXX_ERROR_SYS = "System error, check errno/GetLastError()";
-static constexpr const char* DXX_ERROR_INT = "DXX interrupt called";
-static constexpr const char* DXX_ERROR_OVERFLOW = "Overflow in DXX";
-static constexpr const char* DXX_ERROR_IO = "I/O failure in DXX";
-static constexpr const char* DXX_ERROR_ARG = "Invalid arg passed to DXX";
-
-static constexpr const char* NO_ERROR_FOUND = "No errors were found.";
 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.";
@@ -219,12 +240,6 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return RESTRICTED_ENTRY_FLAG;
 		case Type::NotSupported:
 			return NOT_SUPPORTED;
-		case Type::FixedPointOverflow:
-			return FIXED_POINT_OVERFLOW;
-		case Type::FixedPointPrecision:
-			return FIXED_POINT_PRECISION;
-		case Type::SyscallError:
-			return SYSCALL_ERROR;
 
 		// Device Errors
 		case Type::PollingMessageOverflow:
@@ -303,8 +318,6 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return WIVI_STACK_REFRESH_FAILED;
 		case Type::WiVIUploadStackOverflow:
 			return WIVI_UPLOAD_STACK_OVERFLOW;
-		case Type::I2CMessageExceedsMaxLength:
-			return I2C_MESSAGE_EXCEED_MAX_LENGTH;
 		case Type::A2BMessageIncompleteFrame:
 			return A2B_MESSAGE_INCOMPLETE_FRAME;
 		case Type::CoreminiUploadVersionMismatch:
@@ -313,32 +326,10 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return DISK_NOT_CONNECTED;
 		case Type::UnexpectedResponse:
 			return UNEXPECTED_RESPONSE;
-		case Type::LiveDataInvalidHandle:
-			return LIVE_DATA_INVALID_HANDLE;
-		case Type::LiveDataInvalidCommand:
-			return LIVE_DATA_INVALID_COMMAND;
-		case Type::LiveDataInvalidArgument:
-			return LIVE_DATA_INVALID_ARGUMENT;
-		case Type::LiveDataVersionMismatch:
-			return LIVE_DATA_VERSION_MISMATCH;
-		case Type::LiveDataNoDeviceResponse:
-			return LIVE_DATA_NO_DEVICE_RESPONSE;
-		case Type::LiveDataMaxSignalsReached:
-			return LIVE_DATA_MAX_SIGNALS_REACHED;
-		case Type::LiveDataCommandFailed:
-			return LIVE_DATA_COMMAND_FAILED;
-		case Type::LiveDataEncoderError:
-			return LIVE_DATA_ENCODER_ERROR;
-		case Type::LiveDataDecoderError:
-			return LIVE_DATA_DECODER_ERROR;
-		case Type::LiveDataNotSupported:
-			return LIVE_DATA_NOT_SUPPORTED;
 		case Type::LINSettingsNotAvailable:
 			return LIN_SETTINGS_NOT_AVAILABLE;
 		case Type::ModeNotFound:
 			return MODE_NOT_FOUND;
-		case Type::AppErrorParsingFailed:
-			return APP_ERROR_PARSING_FAILED;
 		case Type::SettingNotAvaiableDevice:
 			return SETTING_NOT_AVAILABLE;
 		// Transport Errors
@@ -372,14 +363,76 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return GETIFADDRS_ERROR;
 		case Type::SendToError:
 			return SEND_TO_ERROR;
-		case Type::MDIOMessageExceedsMaxLength:
-			return MDIO_MESSAGE_EXCEED_MAX_LENGTH;
 		case Type::GPTPNotSupported:
 			return GPTP_NOT_SUPPORTED;
-		case Type::DiskFormatNotSupported:
+	
-			return DISK_FORMAT_NOT_SUPPORTED;
+		// FTD3XX
-		case Type::DiskFormatInvalidCount:
+		case Type::FTOK:
-			return DISK_FORMAT_INVALID_COUNT;
+			return FT_OK;
+		case Type::FTInvalidHandle:
+			return FT_INVALID_HANDLE;
+		case Type::FTDeviceNotFound:
+			return FT_DEVICE_NOT_FOUND;
+		case Type::FTDeviceNotOpened:
+			return FT_DEVICE_NOT_OPENED;
+		case Type::FTIOError:
+			return FT_IO_ERROR;
+		case Type::FTInsufficientResources:
+			return FT_INSUFFICIENT_RESOURCES;
+		case Type::FTInvalidParameter:
+			return FT_INVALID_PARAMETER;
+		case Type::FTInvalidBaudRate:
+			return FT_INVALID_BAUD_RATE;
+		case Type::FTDeviceNotOpenedForErase:
+			return FT_DEVICE_NOT_OPENED_FOR_ERASE;
+		case Type::FTDeviceNotOpenedForWrite:
+			return FT_DEVICE_NOT_OPENED_FOR_WRITE;
+		case Type::FTFailedToWriteDevice:
+			return FT_FAILED_TO_WRITE_DEVICE;
+		case Type::FTEEPROMReadFailed:
+			return FT_EEPROM_READ_FAILED;
+		case Type::FTEEPROMWriteFailed:
+			return FT_EEPROM_WRITE_FAILED;
+		case Type::FTEEPROMEraseFailed:
+			return FT_EEPROM_ERASE_FAILED;
+		case Type::FTEEPROMNotPresent:
+			return FT_EEPROM_NOT_PRESENT;
+		case Type::FTEEPROMNotProgrammed:
+			return FT_EEPROM_NOT_PROGRAMMED;
+		case Type::FTInvalidArgs:
+			return FT_INVALID_ARGS;
+		case Type::FTNotSupported:
+			return FT_NOT_SUPPORTED;
+		case Type::FTNoMoreItems:
+			return FT_NO_MORE_ITEMS;
+		case Type::FTTimeout:
+			return FT_TIMEOUT;
+		case Type::FTOperationAborted:
+			return FT_OPERATION_ABORTED;
+		case Type::FTReservedPipe:
+			return FT_RESERVED_PIPE;
+		case Type::FTInvalidControlRequestDirection:
+			return FT_INVALID_CONTROL_REQUEST_DIRECTION;
+		case Type::FTInvalidControlRequestType:
+			return FT_INVALID_CONTROL_REQUEST_TYPE;
+		case Type::FTIOPending:
+			return FT_IO_PENDING;
+		case Type::FTIOIncomplete:
+			return FT_IO_INCOMPLETE;
+		case Type::FTHandleEOF:
+			return FT_HANDLE_EOF;
+		case Type::FTBusy:
+			return FT_BUSY;
+		case Type::FTNoSystemResources:
+			return FT_NO_SYSTEM_RESOURCES;
+		case Type::FTDeviceListNotReady:
+			return FT_DEVICE_LIST_NOT_READY;
+		case Type::FTDeviceNotConnected:
+			return FT_DEVICE_NOT_CONNECTED;
+		case Type::FTIncorrectDevicePath:
+			return FT_INCORRECT_DEVICE_PATH;
+		case Type::FTOtherError:
+			return FT_OTHER_ERROR;
 
 		// VSA
 		case Type::VSABufferCorrupted:
@@ -397,25 +450,6 @@ const char* APIEvent::DescriptionForType(Type type) {
 		case Type::VSAOtherError:
 			return VSA_OTHER_ERROR;
 
-		// MACSEC
-		case Type::MACsecSecYLimit:
-			return MACSEC_SECY_LIMIT;
-		case Type::MACsecSaLimit:
-			return MACSEC_SA_LIMIT;
-		case Type::MACsecRuleLimit:
-			return MACSEC_RULE_LIMIT;
-		case Type::MACsecInvalidSecYIndex:
-			return MACSEC_INVALID_SECY_INDEX;
-		case Type::MACsecInvalidSaIndex:
-			return MACSEC_INVALID_SA_INDEX;
-		case Type::MACsecInvalidRuleIndex:
-			return MACSEC_INVALID_RULE_INDEX;
-		case Type::MACsecRekeyNotEnabled:
-			return MACSEC_REKEY_NOT_ENABLED;
-		case Type::MACsecNotSupported:
-			return MACSEC_NOT_SUPPORTED;
-		case Type::MACsecConfigMismatch:
-			return MACSEC_CONFIG_MISMATCH;
 		// Servd
 		case Type::ServdBindError:
 			return SERVD_BIND_ERROR;
@@ -439,63 +473,21 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return SERVD_NODATA_ERROR;
 		case Type::ServdJoinMulticastError:
 			return SERVD_JOIN_MULTICAST_ERROR;
-		case Type::ServdNotReachable:
-			return SERVD_NOT_REACHABLE;
-
-		// DXX
-		case Type::DXXErrorSys:
-			return DXX_ERROR_SYS;
-		case Type::DXXErrorInt:
-			return DXX_ERROR_INT;
-		case Type::DXXErrorOverflow:
-			return DXX_ERROR_OVERFLOW;
-		case Type::DXXErrorIO:
-			return DXX_ERROR_IO;
-		case Type::DXXErrorArg:
-			return DXX_ERROR_ARG;
 
 		// Other Errors
-		case Type::NoErrorFound:
-			return NO_ERROR_FOUND;
 		case Type::TooManyEvents:
 			return TOO_MANY_EVENTS;
 		case Type::Unknown:
 			return UNKNOWN;
+		default:
+			return INVALID;
 	}
-	return INVALID;
-}
-
-std::string APIEvent::describe() const noexcept {
-	std::stringstream ss;
-	if(device)
-		ss << *device; // Makes use of device.describe()
-	else
-		ss << "API";
-
-	Severity severity = getSeverity();
-	if(severity == Severity::EventInfo) {
-		ss << " Info: ";
-	} else if(severity == Severity::EventWarning) {
-		ss << " Warning: ";
-	} else if(severity == Severity::Error) {
-		ss << " Error: ";
-	} else {
-		// Should never get here, since Severity::Any should only be used for filtering
-		ss << " Any: ";
-	}
-
-	const char* description = DescriptionForType(getType());
-	if(description == INVALID)
-		ss << description << " (0x" << std::hex << eventStruct.eventNumber << ")";
-	else
-		ss << description;
-	return ss.str();
 }
 
 bool EventFilter::match(const APIEvent& event) const noexcept {
 	if(type != APIEvent::Type::Any && type != event.getType())
 		return false;
-
+	
 	if(matchOnDevicePtr && !event.isForDevice(device))
 		return false;
 

api/icsneolegacy/dllhelper/icsneo40DLLAPI.h

@@ -1,7 +1,5 @@
 //FILE: icsneo40DLLAPI.H
 
-#define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
 #include <windows.h>
 #include "icsneo/icsnVC40.h"
 

api/icsneolegacy/icsneolegacy.cpp

@@ -90,7 +90,6 @@ static bool NeoMessageToSpyMessage(const neodevice_t* device, const neomessage_t
 		copyFrameData();
 		break;
 	case Network::Type::Ethernet:
-	case Network::Type::AutomotiveEthernet:
 		oldmsg.Protocol = SPY_PROTOCOL_ETHERNET;
 		oldmsg.NumberBytesData = static_cast<uint8_t>(frame.length & 0xFF);
 		oldmsg.NumberBytesHeader = static_cast<uint8_t>(frame.length >> 8);
@@ -1076,9 +1075,6 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_RADMOON3:
 		*pDeviceSettingsType = DeviceRADMoon3SettingsType;
 		break;
-	case NEODEVICE_RADGEMINI:
-		*pDeviceSettingsType = DeviceRADGeminiSettingsType;
-		break;
 	case NEODEVICE_RED2:
 		*pDeviceSettingsType = DeviceRed2SettingsType;
 		break;

bindings/python/CMakeLists.txt

@@ -9,7 +9,7 @@ else()
     FetchContent_Declare(
         pybind11
         GIT_REPOSITORY https://github.com/pybind/pybind11.git
-        GIT_TAG v3.0.3
+        GIT_TAG v2.13.6
     )
     FetchContent_MakeAvailable(pybind11)
 endif()
@@ -22,7 +22,6 @@ pybind11_add_module(icsneopy
     icsneopy/device/devicetype.cpp
     icsneopy/communication/network.cpp
     icsneopy/communication/io.cpp
-    icsneopy/communication/livedata.cpp
     icsneopy/communication/message/message.cpp
     icsneopy/communication/message/canmessage.cpp
     icsneopy/communication/message/canerrormessage.cpp
@@ -32,20 +31,13 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/mdiomessage.cpp
     icsneopy/communication/message/gptpstatusmessage.cpp
     icsneopy/communication/message/ethernetstatusmessage.cpp
-    icsneopy/communication/message/spimessage.cpp
+    icsneopy/communication/message/macsecmessage.cpp
     icsneopy/communication/message/scriptstatusmessage.cpp
-    icsneopy/communication/message/ethphymessage.cpp
-    icsneopy/communication/message/livedatamessage.cpp
     icsneopy/communication/message/callback/messagecallback.cpp
     icsneopy/communication/message/filter/messagefilter.cpp
-    icsneopy/core/macseccfg.cpp
+    icsneopy/communication/message/flexray/flexraymessage.cpp
-    icsneopy/flexray/flexray.cpp
     icsneopy/disk/diskdriver.cpp
-    icsneopy/disk/diskdetails.cpp
-    icsneopy/device/chipid.cpp
-    icsneopy/device/versionreport.cpp
     icsneopy/device/device.cpp
-    icsneopy/device/extensions/deviceextension.cpp
     icsneopy/device/idevicesettings.cpp
     icsneopy/icsneocpp.cpp
 )

bindings/python/icsneopy/api/event.cpp

@@ -1,15 +1,14 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
 
 #include "icsneo/api/event.h"
 
 namespace icsneo {
 
 void init_event(pybind11::module_& m) {
-	pybind11::classh<APIEvent> apiEvent(m, "APIEvent");
+	pybind11::class_<APIEvent, std::shared_ptr<APIEvent>> apiEvent(m, "APIEvent");
-	pybind11::native_enum<APIEvent::Type>(apiEvent, "Type", "enum.IntEnum")
+	pybind11::enum_<APIEvent::Type>(apiEvent, "Type")
 		.value("Any", APIEvent::Type::Any)
 		.value("InvalidNeoDevice", APIEvent::Type::InvalidNeoDevice)
 		.value("RequiredParameterNull", APIEvent::Type::RequiredParameterNull)
@@ -29,9 +28,6 @@ void init_event(pybind11::module_& m) {
 		.value("WiVINotSupported", APIEvent::Type::WiVINotSupported)
 		.value("RestrictedEntryFlag", APIEvent::Type::RestrictedEntryFlag)
 		.value("NotSupported", APIEvent::Type::NotSupported)
-		.value("FixedPointOverflow", APIEvent::Type::FixedPointOverflow)
-		.value("FixedPointPrecision", APIEvent::Type::FixedPointPrecision)
-		.value("SyscallError", APIEvent::Type::SyscallError)
 		.value("PollingMessageOverflow", APIEvent::Type::PollingMessageOverflow)
 		.value("NoSerialNumber", APIEvent::Type::NoSerialNumber)
 		.value("IncorrectSerialNumber", APIEvent::Type::IncorrectSerialNumber)
@@ -88,10 +84,6 @@ void init_event(pybind11::module_& m) {
 		.value("LINSettingsNotAvailable", APIEvent::Type::LINSettingsNotAvailable)
 		.value("ModeNotFound", APIEvent::Type::ModeNotFound)
 		.value("AppErrorParsingFailed", APIEvent::Type::AppErrorParsingFailed)
-		.value("GPTPNotSupported", APIEvent::Type::GPTPNotSupported)
-		.value("SettingNotAvaiableDevice", APIEvent::Type::SettingNotAvaiableDevice)
-		.value("DiskFormatNotSupported", APIEvent::Type::DiskFormatNotSupported)
-		.value("DiskFormatInvalidCount", APIEvent::Type::DiskFormatInvalidCount)
 		.value("FailedToRead", APIEvent::Type::FailedToRead)
 		.value("FailedToWrite", APIEvent::Type::FailedToWrite)
 		.value("DriverFailedToOpen", APIEvent::Type::DriverFailedToOpen)
@@ -108,6 +100,39 @@ void init_event(pybind11::module_& m) {
 		.value("GetIfAddrsError", APIEvent::Type::GetIfAddrsError)
 		.value("SendToError", APIEvent::Type::SendToError)
 		.value("MDIOMessageExceedsMaxLength", APIEvent::Type::MDIOMessageExceedsMaxLength)
+		.value("FTOK", APIEvent::Type::FTOK)
+		.value("FTInvalidHandle", APIEvent::Type::FTInvalidHandle)
+		.value("FTDeviceNotFound", APIEvent::Type::FTDeviceNotFound)
+		.value("FTDeviceNotOpened", APIEvent::Type::FTDeviceNotOpened)
+		.value("FTIOError", APIEvent::Type::FTIOError)
+		.value("FTInsufficientResources", APIEvent::Type::FTInsufficientResources)
+		.value("FTInvalidParameter", APIEvent::Type::FTInvalidParameter)
+		.value("FTInvalidBaudRate", APIEvent::Type::FTInvalidBaudRate)
+		.value("FTDeviceNotOpenedForErase", APIEvent::Type::FTDeviceNotOpenedForErase)
+		.value("FTDeviceNotOpenedForWrite", APIEvent::Type::FTDeviceNotOpenedForWrite)
+		.value("FTFailedToWriteDevice", APIEvent::Type::FTFailedToWriteDevice)
+		.value("FTEEPROMReadFailed", APIEvent::Type::FTEEPROMReadFailed)
+		.value("FTEEPROMWriteFailed", APIEvent::Type::FTEEPROMWriteFailed)
+		.value("FTEEPROMEraseFailed", APIEvent::Type::FTEEPROMEraseFailed)
+		.value("FTEEPROMNotPresent", APIEvent::Type::FTEEPROMNotPresent)
+		.value("FTEEPROMNotProgrammed", APIEvent::Type::FTEEPROMNotProgrammed)
+		.value("FTInvalidArgs", APIEvent::Type::FTInvalidArgs)
+		.value("FTNotSupported", APIEvent::Type::FTNotSupported)
+		.value("FTNoMoreItems", APIEvent::Type::FTNoMoreItems)
+		.value("FTTimeout", APIEvent::Type::FTTimeout)
+		.value("FTOperationAborted", APIEvent::Type::FTOperationAborted)
+		.value("FTReservedPipe", APIEvent::Type::FTReservedPipe)
+		.value("FTInvalidControlRequestDirection", APIEvent::Type::FTInvalidControlRequestDirection)
+		.value("FTInvalidControlRequestType", APIEvent::Type::FTInvalidControlRequestType)
+		.value("FTIOPending", APIEvent::Type::FTIOPending)
+		.value("FTIOIncomplete", APIEvent::Type::FTIOIncomplete)
+		.value("FTHandleEOF", APIEvent::Type::FTHandleEOF)
+		.value("FTBusy", APIEvent::Type::FTBusy)
+		.value("FTNoSystemResources", APIEvent::Type::FTNoSystemResources)
+		.value("FTDeviceListNotReady", APIEvent::Type::FTDeviceListNotReady)
+		.value("FTDeviceNotConnected", APIEvent::Type::FTDeviceNotConnected)
+		.value("FTIncorrectDevicePath", APIEvent::Type::FTIncorrectDevicePath)
+		.value("FTOtherError", APIEvent::Type::FTOtherError)
 		.value("VSABufferCorrupted", APIEvent::Type::VSABufferCorrupted)
 		.value("VSATimestampNotFound", APIEvent::Type::VSATimestampNotFound)
 		.value("VSABufferFormatError", APIEvent::Type::VSABufferFormatError)
@@ -115,35 +140,16 @@ void init_event(pybind11::module_& m) {
 		.value("VSAByteParseFailure", APIEvent::Type::VSAByteParseFailure)
 		.value("VSAExtendedMessageError", APIEvent::Type::VSAExtendedMessageError)
 		.value("VSAOtherError", APIEvent::Type::VSAOtherError)
-		.value("ServdBindError", APIEvent::Type::ServdBindError)
-		.value("ServdNonblockError", APIEvent::Type::ServdNonblockError)
-		.value("ServdTransceiveError", APIEvent::Type::ServdTransceiveError)
-		.value("ServdOutdatedError", APIEvent::Type::ServdOutdatedError)
-		.value("ServdInvalidResponseError", APIEvent::Type::ServdInvalidResponseError)
-		.value("ServdLockError", APIEvent::Type::ServdLockError)
-		.value("ServdSendError", APIEvent::Type::ServdSendError)
-		.value("ServdRecvError", APIEvent::Type::ServdRecvError)
-		.value("ServdPollError", APIEvent::Type::ServdPollError)
-		.value("ServdNoDataError", APIEvent::Type::ServdNoDataError)
-		.value("ServdJoinMulticastError", APIEvent::Type::ServdJoinMulticastError)
-		.value("ServdNotReachable", APIEvent::Type::ServdNotReachable)
-		.value("DXXErrorSys", APIEvent::Type::DXXErrorSys)
-		.value("DXXErrorInt", APIEvent::Type::DXXErrorInt)
-		.value("DXXErrorOverflow", APIEvent::Type::DXXErrorOverflow)
-		.value("DXXErrorIO", APIEvent::Type::DXXErrorIO)
-		.value("DXXErrorArg", APIEvent::Type::DXXErrorArg)
 		.value("NoErrorFound", APIEvent::Type::NoErrorFound)
 		.value("TooManyEvents", APIEvent::Type::TooManyEvents)
-		.value("Unknown", APIEvent::Type::Unknown)
+		.value("Unknown", APIEvent::Type::Unknown);
-		.finalize();
+	
-
+	pybind11::enum_<APIEvent::Severity>(apiEvent, "Severity")
-		pybind11::native_enum<APIEvent::Severity>(apiEvent, "Severity", "enum.IntEnum")
 		.value("Any", APIEvent::Severity::Any)
 		.value("EventInfo", APIEvent::Severity::EventInfo)
 		.value("EventWarning", APIEvent::Severity::EventWarning)
-		.value("Error", APIEvent::Severity::Error)
+		.value("Error", APIEvent::Severity::Error);
-		.finalize();
+	
-
 	apiEvent
 		.def("get_type", &APIEvent::getType)
 		.def("get_severity", &APIEvent::getSeverity)
@@ -151,7 +157,7 @@ void init_event(pybind11::module_& m) {
 		.def("describe", &APIEvent::describe)
 		.def("__repr__", &APIEvent::describe);
 
-	pybind11::classh<EventFilter>(m, "EventFilter")
+	pybind11::class_<EventFilter, std::shared_ptr<EventFilter>>(m, "EventFilter")
 		.def(pybind11::init())
 		.def(pybind11::init<APIEvent::Type>())
 		.def(pybind11::init<APIEvent::Severity>())
@@ -160,5 +166,5 @@ void init_event(pybind11::module_& m) {
 		.def_readwrite("serial", &EventFilter::serial);
 }
 
-} // namespace icsneo
+} // namespace icsneo 
 

bindings/python/icsneopy/api/eventcallback.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_eventcallback(pybind11::module_& m) {
-	pybind11::classh<EventCallback>(m, "EventCallback")
+	pybind11::class_<EventCallback>(m, "EventCallback")
 		.def(pybind11::init<EventCallback::fn_eventCallback, EventFilter>())
 		.def(pybind11::init<EventCallback::fn_eventCallback>());
 }

bindings/python/icsneopy/api/eventmanager.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_eventmanager(pybind11::module_& m) {
-	pybind11::classh<EventManager>(m, "EventManager")
+	pybind11::class_<EventManager>(m, "EventManager")
 		.def_static("get_instance", &EventManager::GetInstance, pybind11::return_value_policy::reference)
 		.def("add_event_callback", &EventManager::addEventCallback)
 		.def("remove_event_callback", &EventManager::removeEventCallback)

bindings/python/icsneopy/api/version.cpp

@@ -9,7 +9,7 @@
 namespace icsneo {
 
 void init_version(pybind11::module_& m) {
-	pybind11::classh<neoversion_t>(m, "NeoVersion")
+	pybind11::class_<neoversion_t>(m, "NeoVersion")
 		.def_readonly("major", &neoversion_t::major)
 		.def_readonly("minor", &neoversion_t::minor)
 		.def_readonly("patch", &neoversion_t::patch)

bindings/python/icsneopy/communication/livedata.cpp

@@ -1,79 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
-
-#include "icsneo/communication/livedata.h"
-
-namespace icsneo {
-
-void init_livedata(pybind11::module_& m) {
-	// LiveDataValue struct
-	pybind11::classh<LiveDataValue>(m, "LiveDataValue")
-		.def(pybind11::init<>())
-		.def_readwrite("value", &LiveDataValue::value);
-
-	// LiveDataArgument struct
-	pybind11::classh<LiveDataArgument>(m, "LiveDataArgument")
-		.def(pybind11::init<>())
-		.def_readwrite("object_type", &LiveDataArgument::objectType)
-		.def_readwrite("object_index", &LiveDataArgument::objectIndex)
-		.def_readwrite("signal_index", &LiveDataArgument::signalIndex)
-		.def_readwrite("value_type", &LiveDataArgument::valueType);
-
-	// LiveDataCommand enum
-	pybind11::native_enum<LiveDataCommand>(m, "LiveDataCommand", "enum.IntEnum")
-		.value("STATUS", LiveDataCommand::STATUS)
-		.value("SUBSCRIBE", LiveDataCommand::SUBSCRIBE)
-		.value("UNSUBSCRIBE", LiveDataCommand::UNSUBSCRIBE)
-		.value("RESPONSE", LiveDataCommand::RESPONSE)
-		.value("CLEAR_ALL", LiveDataCommand::CLEAR_ALL)
-		.value("SET_VALUE", LiveDataCommand::SET_VALUE)
-		.finalize();
-
-	// LiveDataStatus enum
-	pybind11::native_enum<LiveDataStatus>(m, "LiveDataStatus", "enum.IntEnum")
-		.value("SUCCESS", LiveDataStatus::SUCCESS)
-		.value("ERR_UNKNOWN_COMMAND", LiveDataStatus::ERR_UNKNOWN_COMMAND)
-		.value("ERR_HANDLE", LiveDataStatus::ERR_HANDLE)
-		.value("ERR_DUPLICATE", LiveDataStatus::ERR_DUPLICATE)
-		.value("ERR_FULL", LiveDataStatus::ERR_FULL)
-		.finalize();
-
-	// LiveDataObjectType enum
-	pybind11::enum_<LiveDataObjectType>(m, "LiveDataObjectType")
-		.value("MISC", LiveDataObjectType::MISC)
-		.value("SNA", LiveDataObjectType::SNA)
-		.export_values();
-
-	// LiveDataValueType enum
-	pybind11::native_enum<LiveDataValueType>(m, "LiveDataValueType", "enum.IntEnum")
-		.value("GPS_LATITUDE", LiveDataValueType::GPS_LATITUDE)
-		.value("GPS_LONGITUDE", LiveDataValueType::GPS_LONGITUDE)
-		.value("GPS_ALTITUDE", LiveDataValueType::GPS_ALTITUDE)
-		.value("GPS_SPEED", LiveDataValueType::GPS_SPEED)
-		.value("GPS_VALID", LiveDataValueType::GPS_VALID)
-		.value("GPS_ENABLE", LiveDataValueType::GPS_ENABLE)
-		.value("MANUAL_TRIGGER", LiveDataValueType::MANUAL_TRIGGER)
-		.value("TIME_SINCE_MSG", LiveDataValueType::TIME_SINCE_MSG)
-		.value("GPS_ACCURACY", LiveDataValueType::GPS_ACCURACY)
-		.value("GPS_BEARING", LiveDataValueType::GPS_BEARING)
-		.value("GPS_TIME", LiveDataValueType::GPS_TIME)
-		.value("GPS_TIME_VALID", LiveDataValueType::GPS_TIME_VALID)
-		.value("DAQ_ENABLE", LiveDataValueType::DAQ_ENABLE)
-		.finalize();
-
-	// LiveDataUtil namespace functions
-	m.def("get_new_handle", &LiveDataUtil::getNewHandle,
-		"Generate a new unique LiveData handle");
-
-	m.def("livedata_value_to_double", &LiveDataUtil::liveDataValueToDouble,
-		pybind11::arg("val"),
-		"Convert LiveDataValue to double (32.32 fixed-point to floating-point)");
-
-	m.def("livedata_double_to_value", &LiveDataUtil::liveDataDoubleToValue,
-		pybind11::arg("d"),
-		"Convert double to LiveDataValue (32.32 fixed-point format). Returns LiveDataValue or None on failure.");
-}
-
-} // namespace icsneo

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_messagecallback(pybind11::module_& m) {
-	pybind11::classh<MessageCallback>(m, "MessageCallback")
+	pybind11::class_<MessageCallback, std::shared_ptr<MessageCallback>>(m, "MessageCallback")
 		.def(pybind11::init<MessageCallback::fn_messageCallback, std::shared_ptr<MessageFilter>>());
 }
 

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

@@ -1,14 +1,13 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
 
 #include "icsneo/communication/message/canerrormessage.h"
 
 namespace icsneo {
 
 void init_errorcodes(pybind11::module_& m) {
-	pybind11::native_enum<CANErrorCode>(m, "CANErrorCode", "enum.IntEnum")
+	pybind11::enum_<CANErrorCode>(m, "CANErrorCode")
 		.value("NoError", CANErrorCode::NoError)
 		.value("StuffError", CANErrorCode::StuffError)
 		.value("FormError", CANErrorCode::FormError)
@@ -16,13 +15,12 @@ void init_errorcodes(pybind11::module_& m) {
 		.value("Bit1Error", CANErrorCode::Bit1Error)
 		.value("Bit0Error", CANErrorCode::Bit0Error)
 		.value("CRCError", CANErrorCode::CRCError)
-		.value("NoChange", CANErrorCode::NoChange)
+		.value("NoChange", CANErrorCode::NoChange);
-		.finalize();
 }
 
 void init_canerrormessage(pybind11::module_& m) {
 	init_errorcodes(m);
-	pybind11::classh<CANErrorMessage, Message>(m, "CANErrorMessage")
+	pybind11::class_<CANErrorMessage, std::shared_ptr<CANErrorMessage>, Message>(m, "CANErrorMessage")
 		.def_readonly("network", &CANErrorMessage::network)
 		.def_readonly("transmitErrorCount", &CANErrorMessage::transmitErrorCount)
 		.def_readonly("receiveErrorCount", &CANErrorMessage::receiveErrorCount)

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_canmessage(pybind11::module_& m) {
-	pybind11::classh<CANMessage, Frame>(m, "CANMessage")
+	pybind11::class_<CANMessage, std::shared_ptr<CANMessage>, Frame>(m, "CANMessage")
 		.def(pybind11::init())
 		.def_readwrite("arbid", &CANMessage::arbid)
 		.def_readwrite("dlcOnWire", &CANMessage::dlcOnWire)
@@ -15,10 +15,7 @@ void init_canmessage(pybind11::module_& m) {
 		.def_readwrite("isExtended", &CANMessage::isExtended)
 		.def_readwrite("isCANFD", &CANMessage::isCANFD)
 		.def_readwrite("baudrateSwitch", &CANMessage::baudrateSwitch)
-		.def_readwrite("errorStateIndicator", &CANMessage::errorStateIndicator)
+		.def_readwrite("errorStateIndicator", &CANMessage::errorStateIndicator);
-		.def_readwrite("txAborted", &CANMessage::txAborted)
-		.def_readwrite("txLostArb", &CANMessage::txLostArb)
-		.def_readwrite("txError", &CANMessage::txError);
 }
 
 } // namespace icsneo 

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

@@ -7,29 +7,21 @@
 namespace icsneo {
 
 void init_ethernetmessage(pybind11::module_& m) {
-	pybind11::classh<EthernetMessage::T1S>(m, "EthernetMessageT1S")
+	pybind11::class_<MACAddress>(m, "MACAddress")
-		.def(pybind11::init())
+		.def("to_string", &MACAddress::toString)
-		.def_readwrite("isSymbol", &EthernetMessage::T1S::isSymbol)
+		.def("__repr__", &MACAddress::toString);
-		.def_readwrite("isBurst", &EthernetMessage::T1S::isBurst)
+	
-		.def_readwrite("txCollision", &EthernetMessage::T1S::txCollision)
+	pybind11::class_<EthernetMessage, std::shared_ptr<EthernetMessage>, Frame>(m, "EthernetMessage")
-		.def_readwrite("isWake", &EthernetMessage::T1S::isWake)
-		.def_readwrite("nodeId", &EthernetMessage::T1S::nodeId)
-		.def_readwrite("burstCount", &EthernetMessage::T1S::burstCount)
-		.def_readwrite("symbolType", &EthernetMessage::T1S::symbolType);
-		
-	pybind11::classh<EthernetMessage, Frame>(m, "EthernetMessage")
 		.def(pybind11::init())
+		.def_readwrite("preemptionEnabled", &EthernetMessage::preemptionEnabled)
+		.def_readwrite("preemptionFlags", &EthernetMessage::preemptionFlags)
 		.def_readwrite("fcs", &EthernetMessage::fcs)
 		.def_readwrite("frameTooShort", &EthernetMessage::frameTooShort)
 		.def_readwrite("noPadding", &EthernetMessage::noPadding)
-		.def_readwrite("fcsVerified", &EthernetMessage::fcsVerified)
+		.def("get_destination_mac", &EthernetMessage::getDestinationMAC, pybind11::return_value_policy::reference)
-		.def_readwrite("txAborted", &EthernetMessage::txAborted)
+		.def("get_source_mac", &EthernetMessage::getSourceMAC, pybind11::return_value_policy::reference)
-		.def_readwrite("crcError", &EthernetMessage::crcError)
-		.def_readwrite("t1s", &EthernetMessage::t1s)
-		.def_readwrite("preemptionFlags", &EthernetMessage::preemptionFlags)
-		.def("get_destination_mac", &EthernetMessage::getDestinationMAC)
-		.def("get_source_mac", &EthernetMessage::getSourceMAC)
 		.def("get_ether_type", &EthernetMessage::getEtherType);
 }
 
 } // namespace icsneo 
+

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_ethernetstatusmessage(pybind11::module_& m) {
-	pybind11::classh<EthernetStatusMessage, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
+	pybind11::class_<EthernetStatusMessage, std::shared_ptr<EthernetStatusMessage>, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
 
 	pybind11::enum_<EthernetStatusMessage::LinkSpeed>(ethernetStatusMessage, "LinkSpeed")
 		.value("LinkSpeedAuto", EthernetStatusMessage::LinkSpeed::LinkSpeedAuto)
@@ -22,8 +22,7 @@ void init_ethernetstatusmessage(pybind11::module_& m) {
 		.value("LinkModeAuto", EthernetStatusMessage::LinkMode::LinkModeAuto)
 		.value("LinkModeMaster", EthernetStatusMessage::LinkMode::LinkModeMaster)
 		.value("LinkModeSlave", EthernetStatusMessage::LinkMode::LinkModeSlave)
-		.value("LinkModeInvalid", EthernetStatusMessage::LinkMode::LinkModeInvalid)
+		.value("LinkModeInvalid", EthernetStatusMessage::LinkMode::LinkModeInvalid);
-		.value("LinkModeNone", EthernetStatusMessage::LinkMode::LinkModeNone);
 
 	ethernetStatusMessage
 		.def_readonly("network", &EthernetStatusMessage::network)

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

@@ -1,34 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-
-#include "icsneo/communication/message/ethphymessage.h"
-
-namespace icsneo {
-
-void init_ethphymessage(pybind11::module_& m) {
-	pybind11::classh<Clause22Message>(m, "Clause22Message")
-		.def_readwrite("phyAddr", &Clause22Message::phyAddr)
-		.def_readwrite("page", &Clause22Message::page)
-		.def_readwrite("regAddr", &Clause22Message::regAddr)
-		.def_readwrite("regVal", &Clause22Message::regVal);
-	pybind11::classh<Clause45Message>(m, "Clause45Message")
-		.def_readwrite("port", &Clause45Message::port)
-		.def_readwrite("device", &Clause45Message::device)
-		.def_readwrite("regAddr", &Clause45Message::regAddr)
-		.def_readwrite("regVal", &Clause45Message::regVal);
-	pybind11::classh<PhyMessage>(m, "PhyMessage")
-		.def(pybind11::init())
-		.def_readwrite("Enabled", &PhyMessage::Enabled)
-		.def_readwrite("WriteEnable", &PhyMessage::WriteEnable)
-		.def_readwrite("Clause45Enable", &PhyMessage::Clause45Enable)
-		.def_readwrite("Version", &PhyMessage::Version)
-		.def_readwrite("BusIndex", &PhyMessage::BusIndex)
-		.def_readwrite("Clause22", &PhyMessage::Clause22)
-		.def_readwrite("Clause45", &PhyMessage::Clause45);
-	pybind11::classh<EthPhyMessage, Message>(m, "EthPhyMessage")
-		.def(pybind11::init())
-		.def_readwrite("messages", &EthPhyMessage::messages);
-}
-
-} // namespace icsneo

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

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

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

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

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

@@ -7,73 +7,72 @@
 namespace icsneo {
 
 void init_gptpstatusmessage(pybind11::module_& m) {
-	pybind11::classh<GPTPStatus, Message> gptpStatus(m, "GPTPStatus");
+	pybind11::class_<GPTPStatus, std::shared_ptr<GPTPStatus>, Message> gptpStatus(m, "GPTPStatus");
 	
-	pybind11::classh<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
+	pybind11::class_<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
 		.def_readonly("seconds", &GPTPStatus::Timestamp::seconds)
 		.def_readonly("nanoseconds", &GPTPStatus::Timestamp::nanoseconds)
 		.def("to_seconds", &GPTPStatus::Timestamp::toSeconds, pybind11::call_guard<pybind11::gil_scoped_release>());
 	
-	pybind11::classh<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
+	pybind11::class_<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
-		.def_readonly("nanoseconds_msb", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
+		.def_readonly("nanosecondsMSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
-		.def_readonly("nanoseconds_lsb", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
+		.def_readonly("nanosecondsLSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
-		.def_readonly("fractional_nanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
+		.def_readonly("fractionalNanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
 	
-	pybind11::classh<GPTPStatus::PortID>(gptpStatus, "PortID")
+	pybind11::class_<GPTPStatus::PortID>(gptpStatus, "PortID")
-		.def_readonly("clock_identity", &GPTPStatus::PortID::clockIdentity)
+		.def_readonly("clockIdentity", &GPTPStatus::PortID::clockIdentity)
-		.def_readonly("port_number", &GPTPStatus::PortID::portNumber);
+		.def_readonly("portNumber", &GPTPStatus::PortID::portNumber);
 	
-	pybind11::classh<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
+	pybind11::class_<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
-		.def_readonly("clock_class", &GPTPStatus::ClockQuality::clockClass)
+		.def_readonly("clockClass", &GPTPStatus::ClockQuality::clockClass)
-		.def_readonly("clock_accuracy", &GPTPStatus::ClockQuality::clockAccuracy)
+		.def_readonly("clockAccuracy", &GPTPStatus::ClockQuality::clockAccuracy)
-		.def_readonly("offset_scaled_log_variance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
+		.def_readonly("offsetScaledLogVariance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
 	
-	pybind11::classh<GPTPStatus::SystemID>(gptpStatus, "SystemID")
+	pybind11::class_<GPTPStatus::SystemID>(gptpStatus, "SystemID")
 		.def_readonly("priority1", &GPTPStatus::SystemID::priority1)
-		.def_readonly("clock_quality", &GPTPStatus::SystemID::clockQuality)
+		.def_readonly("clockQuality", &GPTPStatus::SystemID::clockQuality)
 		.def_readonly("priority2", &GPTPStatus::SystemID::priority2)
-		.def_readonly("clock_id", &GPTPStatus::SystemID::clockID);
+		.def_readonly("clockID", &GPTPStatus::SystemID::clockID);
 	
-	pybind11::classh<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
+	pybind11::class_<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
-		.def_readonly("sys_id", &GPTPStatus::PriorityVector::sysID)
+		.def_readonly("sysID", &GPTPStatus::PriorityVector::sysID)
-		.def_readonly("steps_removed", &GPTPStatus::PriorityVector::stepsRemoved)
+		.def_readonly("stepsRemoved", &GPTPStatus::PriorityVector::stepsRemoved)
-		.def_readonly("port_id", &GPTPStatus::PriorityVector::portID)
+		.def_readonly("portID", &GPTPStatus::PriorityVector::portID)
-		.def_readonly("port_number", &GPTPStatus::PriorityVector::portNumber);
+		.def_readonly("portNumber", &GPTPStatus::PriorityVector::portNumber);
 	
-	pybind11::classh<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
+	pybind11::class_<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
-		.def_readonly("parent_port_identity", &GPTPStatus::ParentDS::parentPortIdentity)
+		.def_readonly("parentPortIdentity", &GPTPStatus::ParentDS::parentPortIdentity)
-		.def_readonly("cumulative_rate_ratio", &GPTPStatus::ParentDS::cumulativeRateRatio)
+		.def_readonly("cumulativeRateRatio", &GPTPStatus::ParentDS::cumulativeRateRatio)
-		.def_readonly("grandmaster_identity", &GPTPStatus::ParentDS::grandmasterIdentity)
+		.def_readonly("grandmasterIdentity", &GPTPStatus::ParentDS::grandmasterIdentity)
-		.def_readonly("gm_clock_quality_clock_class", &GPTPStatus::ParentDS::gmClockQualityClockClass)
+		.def_readonly("gmClockQualityClockClass", &GPTPStatus::ParentDS::gmClockQualityClockClass)
-		.def_readonly("gm_clock_quality_clock_accuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
+		.def_readonly("gmClockQualityClockAccuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
-		.def_readonly("gm_clock_quality_offset_scaled_log_variance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
+		.def_readonly("gmClockQualityOffsetScaledLogVariance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
-		.def_readonly("gm_priority1", &GPTPStatus::ParentDS::gmPriority1)
+		.def_readonly("gmPriority1", &GPTPStatus::ParentDS::gmPriority1)
-		.def_readonly("gm_priority2", &GPTPStatus::ParentDS::gmPriority2);
+		.def_readonly("gmPriority2", &GPTPStatus::ParentDS::gmPriority2);
 
-	pybind11::classh<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
+	pybind11::class_<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
-		.def_readonly("steps_removed", &GPTPStatus::CurrentDS::stepsRemoved)
+		.def_readonly("stepsRemoved", &GPTPStatus::CurrentDS::stepsRemoved)
-		.def_readonly("offset_from_master", &GPTPStatus::CurrentDS::offsetFromMaster)
+		.def_readonly("offsetFromMaster", &GPTPStatus::CurrentDS::offsetFromMaster)
-		.def_readonly("lastgm_phase_change", &GPTPStatus::CurrentDS::lastgmPhaseChange)
+		.def_readonly("lastgmPhaseChange", &GPTPStatus::CurrentDS::lastgmPhaseChange)
-		.def_readonly("lastgm_freq_change", &GPTPStatus::CurrentDS::lastgmFreqChange)
+		.def_readonly("lastgmFreqChange", &GPTPStatus::CurrentDS::lastgmFreqChange)
-		.def_readonly("gm_time_base_indicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
+		.def_readonly("gmTimeBaseIndicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
-		.def_readonly("gm_change_count", &GPTPStatus::CurrentDS::gmChangeCount)
+		.def_readonly("gmChangeCount", &GPTPStatus::CurrentDS::gmChangeCount)
-		.def_readonly("time_of_lastgm_change_event", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
+		.def_readonly("timeOfLastgmChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
-		.def_readonly("time_of_lastgm_phase_change_event", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
+		.def_readonly("timeOfLastgmPhaseChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
-		.def_readonly("time_of_lastgm_freq_change_event", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
+		.def_readonly("timeOfLastgmFreqChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
 
-	gptpStatus.def_readonly("current_time", &GPTPStatus::currentTime)
+	gptpStatus.def_readonly("currentTime", &GPTPStatus::currentTime)
-		.def_readonly("gm_priority", &GPTPStatus::gmPriority)
+		.def_readonly("gmPriority", &GPTPStatus::gmPriority)
-		.def_readonly("ms_offset_ns", &GPTPStatus::msOffsetNs)
+		.def_readonly("msOffsetNs", &GPTPStatus::msOffsetNs)
-		.def_readonly("is_sync", &GPTPStatus::isSync)
+		.def_readonly("isSync", &GPTPStatus::isSync)
-		.def_readonly("link_status", &GPTPStatus::linkStatus)
+		.def_readonly("linkStatus", &GPTPStatus::linkStatus)
-		.def_readonly("link_delay_ns", &GPTPStatus::linkDelayNS)
+		.def_readonly("linkDelayNS", &GPTPStatus::linkDelayNS)
-		.def_readonly("selected_role", &GPTPStatus::selectedRole)
+		.def_readonly("selectedRole", &GPTPStatus::selectedRole)
-		.def_readonly("as_capable", &GPTPStatus::asCapable)
+		.def_readonly("asCapable", &GPTPStatus::asCapable)
-		.def_readonly("is_syntonized", &GPTPStatus::isSyntonized)
+		.def_readonly("isSyntonized", &GPTPStatus::isSyntonized)
-		.def_readonly("last_rx_sync_ts", &GPTPStatus::lastRXSyncTS)
+		.def_readonly("lastRXSyncTS", &GPTPStatus::lastRXSyncTS)
-		.def_readonly("current_ds", &GPTPStatus::currentDS)
+		.def_readonly("currentDS", &GPTPStatus::currentDS)
-		.def_readonly("parent_ds", &GPTPStatus::parentDS)
+		.def_readonly("parentDS", &GPTPStatus::parentDS);
-		.def_readonly("short_format", &GPTPStatus::shortFormat);
 
 }
 

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_linmessage(pybind11::module_& m) {
-	pybind11::classh<LINErrorFlags>(m, "LINErrorFlags")
+	pybind11::class_<LINErrorFlags>(m, "LINErrorFlags")
 		.def_readwrite("ErrRxBreakOnly", &LINErrorFlags::ErrRxBreakOnly)
 		.def_readwrite("ErrRxBreakSyncOnly", &LINErrorFlags::ErrRxBreakSyncOnly)
 		.def_readwrite("ErrTxRxMismatch", &LINErrorFlags::ErrTxRxMismatch)
@@ -20,7 +20,7 @@ void init_linmessage(pybind11::module_& m) {
 		.def_readwrite("ErrFrameResponderData", &LINErrorFlags::ErrFrameResponderData)
 		.def_readwrite("ErrChecksumMatch", &LINErrorFlags::ErrChecksumMatch);
 
-	pybind11::classh<LINStatusFlags>(m, "LINStatusFlags")
+	pybind11::class_<LINStatusFlags>(m, "LINStatusFlags")
 		.def_readwrite("TxChecksumEnhanced", &LINStatusFlags::TxChecksumEnhanced)
 		.def_readwrite("TxCommander", &LINStatusFlags::TxCommander)
 		.def_readwrite("TxResponder", &LINStatusFlags::TxResponder)
@@ -30,7 +30,7 @@ void init_linmessage(pybind11::module_& m) {
 		.def_readwrite("BusRecovered", &LINStatusFlags::BusRecovered)
 		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly);
 
-	pybind11::classh<LINMessage, Frame> linMessage(m, "LINMessage");
+	pybind11::class_<LINMessage, std::shared_ptr<LINMessage>, Frame> linMessage(m, "LINMessage");
 
 	pybind11::enum_<LINMessage::Type>(linMessage, "Type")
 		.value("NOT_SET", LINMessage::Type::NOT_SET)

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

@@ -1,50 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-#include <pybind11/chrono.h>
-
-#include "icsneo/communication/message/livedatamessage.h"
-
-namespace icsneo {
-
-void init_livedatamessage(pybind11::module_& m) {
-	// LiveDataMessage base class
-	pybind11::classh<LiveDataMessage, RawMessage>(m, "LiveDataMessage")
-		.def(pybind11::init<>())
-		.def_readwrite("handle", &LiveDataMessage::handle)
-		.def_readwrite("cmd", &LiveDataMessage::cmd);
-
-	// LiveDataCommandMessage (for subscribe/unsubscribe)
-	pybind11::classh<LiveDataCommandMessage, LiveDataMessage>(m, "LiveDataCommandMessage")
-		.def(pybind11::init<>())
-		.def_readwrite("update_period", &LiveDataCommandMessage::updatePeriod)
-		.def_readwrite("expiration_time", &LiveDataCommandMessage::expirationTime)
-		.def_readwrite("args", &LiveDataCommandMessage::args)
-		.def("append_signal_arg", &LiveDataCommandMessage::appendSignalArg,
-			pybind11::arg("value_type"),
-			"Append a signal argument to the command message");
-
-	// LiveDataValueMessage (received values)
-	pybind11::classh<LiveDataValueMessage, LiveDataMessage>(m, "LiveDataValueMessage")
-		.def(pybind11::init<>())
-		.def_readwrite("num_args", &LiveDataValueMessage::numArgs)
-		.def_readwrite("values", &LiveDataValueMessage::values);
-
-	// LiveDataStatusMessage (status responses)
-	pybind11::classh<LiveDataStatusMessage, LiveDataMessage>(m, "LiveDataStatusMessage")
-		.def(pybind11::init<>())
-		.def_readwrite("requested_command", &LiveDataStatusMessage::requestedCommand)
-		.def_readwrite("status", &LiveDataStatusMessage::status);
-
-	// LiveDataSetValueMessage (for setting values)
-	pybind11::classh<LiveDataSetValueMessage, LiveDataMessage>(m, "LiveDataSetValueMessage")
-		.def(pybind11::init<>())
-		.def_readwrite("args", &LiveDataSetValueMessage::args)
-		.def_readwrite("values", &LiveDataSetValueMessage::values)
-		.def("append_set_value", &LiveDataSetValueMessage::appendSetValue,
-			pybind11::arg("value_type"),
-			pybind11::arg("value"),
-			"Append a value to set in the message");
-}
-
-} // 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/mdiomessage.cpp

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_mdiomessage(pybind11::module_& m) {
-	pybind11::classh<MDIOMessage, Frame> mdioMessage(m, "MDIOMessage");
+	pybind11::class_<MDIOMessage, std::shared_ptr<MDIOMessage>, Frame> mdioMessage(m, "MDIOMessage");
 	pybind11::enum_<MDIOMessage::Clause>(mdioMessage, "Clause")
 		.value("Clause45", MDIOMessage::Clause::Clause45)
 		.value("Clause22", MDIOMessage::Clause::Clause22);

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

@@ -1,16 +1,14 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
 
 #include "icsneo/communication/message/message.h"
 
 namespace icsneo {
 
 void init_message(pybind11::module_& m) {
-	// Using py::smart_holder for safer lifetime management
+	pybind11::class_<Message, std::shared_ptr<Message>> message(m, "Message");
-	pybind11::classh<Message> message(m, "Message");
+	pybind11::enum_<Message::Type>(message, "Type")
-	pybind11::native_enum<Message::Type>(message, "Type", "enum.IntEnum")
 		.value("Frame", Message::Type::Frame)
 		.value("CANErrorCount", Message::Type::CANErrorCount)
 		.value("CANError", Message::Type::CANError)
@@ -36,18 +34,17 @@ void init_message(pybind11::module_& m) {
 		.value("TC10Status", Message::Type::TC10Status)
 		.value("AppError", Message::Type::AppError)
 		.value("GPTPStatus", Message::Type::GPTPStatus)
-		.value("EthernetStatus", Message::Type::EthernetStatus)
+		.value("EthernetStatus", Message::Type::EthernetStatus);
-		.finalize();
 
 	message.def(pybind11::init<Message::Type>());
 	message.def_readonly("type", &Message::type);
 	message.def_readwrite("timestamp", &Message::timestamp);
 
-	pybind11::classh<RawMessage, Message>(m, "RawMessage")
+	pybind11::class_<RawMessage, std::shared_ptr<RawMessage>, Message>(m, "RawMessage")
 		.def_readwrite("network", &RawMessage::network)
 		.def_readwrite("data", &RawMessage::data);
 
-	pybind11::classh<Frame, RawMessage>(m, "Frame")
+	pybind11::class_<Frame, std::shared_ptr<Frame>, RawMessage>(m, "Frame")
 		.def_readwrite("description", &Frame::description)
 		.def_readwrite("transmitted", &Frame::transmitted)
 		.def_readwrite("error", &Frame::error);

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_scriptstatusmessage(pybind11::module_& m) {
-	pybind11::classh<ScriptStatusMessage, Message>(m, "ScriptStatusMessage")
+	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)

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

@@ -1,24 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-
-#include "icsneo/communication/message/spimessage.h"
-
-namespace icsneo {
-
-void init_spimessage(pybind11::module_& m) {
-	pybind11::classh<SPIMessage, Frame> spiMessage(m, "SPIMessage");
-	pybind11::enum_<SPIMessage::Direction>(spiMessage, "Direction")
-		.value("Write", SPIMessage::Direction::Write)
-		.value("Read", SPIMessage::Direction::Read);
-	spiMessage
-		.def(pybind11::init())
-		.def_readwrite("direction", &SPIMessage::direction)
-		.def_readwrite("address", &SPIMessage::address)
-		.def_readwrite("mms", &SPIMessage::mms)
-		.def_readwrite("stats", &SPIMessage::stats)
-		.def_readwrite("payload", &SPIMessage::payload);
-}
-
-} // namespace icsneo 
-

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

@@ -17,7 +17,7 @@ void init_tc10statusmessage(pybind11::module_& m) {
 		.value("SleepFailed", TC10SleepStatus::SleepFailed)
 		.value("SleepAborted", TC10SleepStatus::SleepAborted);
 
-	pybind11::classh<TC10StatusMessage, Message>(m, "TC10StatusMessage")
+	pybind11::class_<TC10StatusMessage, std::shared_ptr<TC10StatusMessage>, Message>(m, "TC10StatusMessage")
 		.def_readonly("wakeStatus", &TC10StatusMessage::wakeStatus)
 		.def_readonly("sleepStatus", &TC10StatusMessage::sleepStatus);
 }

bindings/python/icsneopy/communication/network.cpp

@@ -1,16 +1,15 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
 
 #include "icsneo/communication/network.h"
 
 namespace icsneo {
 
 void init_network(pybind11::module_& m) {
-	pybind11::classh<Network> network(m, "Network");
+	pybind11::class_<Network> network(m, "Network");
 
-	pybind11::native_enum<Network::NetID>(network, "NetID", "enum.IntEnum")
+	pybind11::enum_<Network::NetID>(network, "NetID")
 		.value("Device", Network::NetID::Device)
 		.value("DWCAN_01", Network::NetID::DWCAN_01)
 		.value("DWCAN_08", Network::NetID::DWCAN_08)
@@ -124,7 +123,6 @@ void init_network(pybind11::module_& m) {
 		.value("I2C_03", Network::NetID::I2C_03)
 		.value("I2C_04", Network::NetID::I2C_04)
 		.value("ETHERNET_02", Network::NetID::ETHERNET_02)
-		.value("ETHERNET_TX_WRAP", Network::NetID::ETHERNET_TX_WRAP)
 		.value("A2B_01", Network::NetID::A2B_01)
 		.value("A2B_02", Network::NetID::A2B_02)
 		.value("ETHERNET_03", Network::NetID::ETHERNET_03)
@@ -167,10 +165,9 @@ void init_network(pybind11::module_& m) {
 		.value("LIN_15", Network::NetID::LIN_15)
 		.value("LIN_16", Network::NetID::LIN_16)
 		.value("Any", Network::NetID::Any)
-		.value("Invalid", Network::NetID::Invalid)
+		.value("Invalid", Network::NetID::Invalid);
-		.finalize();
 	
-	pybind11::native_enum<Network::Type>(network, "Type", "enum.Enum")
+	pybind11::enum_<Network::Type>(network, "Type")
 		.value("Invalid", Network::Type::Invalid)
 		.value("Internal", Network::Type::Internal)
 		.value("CAN", Network::Type::CAN)
@@ -181,14 +178,12 @@ 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)
-		.value("AutomotiveEthernet", Network::Type::AutomotiveEthernet)
 		.value("Any", Network::Type::Any)
-		.value("Other", Network::Type::Other)
+		.value("Other", Network::Type::Other);
-		.finalize();
 
     network
 		.def(pybind11::init<Network::NetID>())

bindings/python/icsneopy/core/macseccfg.cpp

@@ -1,166 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-
-#include "icsneo/core/macseccfg.h"
-
-namespace icsneo {
-
-void init_macsecconfig(pybind11::module_ & m)
-{
-	pybind11::enum_<MACsecPacketType>(m, "MACsecPacketType")
-		.value("DEFAULT", MACsecPacketType::Default)
-		.value("SINGLE_VLAN", MACsecPacketType::SingleVLAN)
-		.value("DUAL_VLAN", MACsecPacketType::DualVLAN)
-		.value("MPLS", MACsecPacketType::MPLS)
-		.value("SINGLE_VLAN_FOLLOWED_BY_MPLS", MACsecPacketType::SingleVLANFollowedByMPLS)
-		.value("DUAL_VLAN_FOLLOWED_BY_MPLS", MACsecPacketType::DualVLANFollowedByMPLS)
-		.value("UNSUPPORTED", MACsecPacketType::Unsupported);
-
-	pybind11::enum_<MACsecValidation>(m, "MACsecValidation")
-		.value("DISABLED", MACsecValidation::Disabled)
-		.value("CHECK", MACsecValidation::Check)
-		.value("STRICT", MACsecValidation::Strict)
-		.value("NA", MACsecValidation::NA);
-
-	pybind11::enum_<MACsecStrip>(m, "MACsecStrip")
-		.value("STRIP_SECTAG_AND_ICV", MACsecStrip::StripSecTagAndIcv)
-		.value("STRIP_SECTAG_PRESERVE_ICV", MACsecStrip::StripSecTagPreserveICV)
-		.value("PRESERVE_SECTAG_STRIP_ICV", MACsecStrip::PreserveSecTagStripICV)
-		.value("NO_STRIP", MACsecStrip::NoStrip);
-
-	pybind11::enum_<MACsecCipherSuite>(m, "MACsecCipherSuite")
-		.value("GCM_AES_128", MACsecCipherSuite::GcmAes128)
-		.value("GCM_AES_256", MACsecCipherSuite::GcmAes256)
-		.value("GCM_AES_128_XPN", MACsecCipherSuite::GcmAes128Xpn)
-		.value("GCM_AES_256_XPN", MACsecCipherSuite::GcmAes256Xpn);
-
-	pybind11::classh<MACsecVLANTag>(m, "MACsecVLANTag")
-		.def(pybind11::init())
-		.def_readwrite("vid", &MACsecVLANTag::vid)
-		.def_readwrite("pri_cfi", &MACsecVLANTag::priCfi);
-
-	pybind11::classh<MACsecMPLSOuter>(m, "MACsecMPLSOuter")
-		.def(pybind11::init())
-		.def_readwrite("mpls_label", &MACsecMPLSOuter::mplsLabel)
-		.def_readwrite("exp", &MACsecMPLSOuter::exp);
-
-	pybind11::classh<MACsecTci>(m, "MACsecTci")
-		.def(pybind11::init())
-		.def_readwrite("es", &MACsecTci::es)
-		.def_readwrite("sc", &MACsecTci::sc)
-		.def_readwrite("scb", &MACsecTci::scb)
-		.def_readwrite("e", &MACsecTci::e)
-		.def_readwrite("c", &MACsecTci::c);
-
-	pybind11::classh<MACsecRxRule>(m, "MACsecRxRule")
-		.def(pybind11::init())
-		.def_readwrite("key_mac_da", &MACsecRxRule::keyMacDa)
-		.def_readwrite("mask_mac_da", &MACsecRxRule::maskMacDa)
-		.def_readwrite("key_mask_sa", &MACsecRxRule::keyMacSa)
-		.def_readwrite("mask_mac_sa", &MACsecRxRule::maskMacSa)
-		.def_readwrite("key_ether_type", &MACsecRxRule::keyEthertype)
-		.def_readwrite("mask_ether_type", &MACsecRxRule::maskEthertype)
-		.def_readwrite("key_vlan_tag_outer1", &MACsecRxRule::keyVlanTagOuter1)
-		.def_readwrite("key_mpls_outer1", &MACsecRxRule::keyMplsOuter1)
-		.def_readwrite("mask_vlan_tag_outer1", &MACsecRxRule::maskVlanTagOuter1)
-		.def_readwrite("mask_mpls_outer1", &MACsecRxRule::maskMplsOuter1)
-		.def_readwrite("key_vlan_tag_outer2", &MACsecRxRule::keyVlanTagOuter2)
-		.def_readwrite("key_mpls_outer2", &MACsecRxRule::keyMplsOuter2)
-		.def_readwrite("mask_vlan_tag_outer2", &MACsecRxRule::maskVlanTagOuter2)
-		.def_readwrite("mask_mpls_outer2", &MACsecRxRule::maskMplsOuter2)
-		.def_readwrite("key_bonus_data", &MACsecRxRule::keyBonusData)
-		.def_readwrite("mask_bonus_data", &MACsecRxRule::maskBonusData)
-		.def_readwrite("key_tag_match_bitmap", &MACsecRxRule::keyTagMatchBitmap)
-		.def_readwrite("mask_tag_match_bitmap", &MACsecRxRule::maskTagMatchBitmap)
-		.def_readwrite("key_packet_type", &MACsecRxRule::keyPacketType)
-		.def_readwrite("mask_packet_type", &MACsecRxRule::maskPacketType)
-		.def_readwrite("key_inner_vlan_type", &MACsecRxRule::keyInnerVlanType)
-		.def_readwrite("mask_inner_vlan_type", &MACsecRxRule::maskInnerVlanType)
-		.def_readwrite("key_outer_vlan_type", &MACsecRxRule::keyOuterVlanType)
-		.def_readwrite("mask_outer_vlan_type", &MACsecRxRule::maskOuterVlanType)
-		.def_readwrite("key_num_tags", &MACsecRxRule::keyNumTags)
-		.def_readwrite("mask_num_tags", &MACsecRxRule::maskNumTags)
-		.def_readwrite("key_express", &MACsecRxRule::keyExpress)
-		.def_readwrite("mask_express", &MACsecRxRule::maskExpress)
-		.def_readwrite("is_mpls", &MACsecRxRule::isMpls);
-
-	pybind11::classh<MACsecTxSecY>(m, "MACsecTxSecY")
-		.def(pybind11::init())
-		.def_readwrite("enable_control_port", &MACsecTxSecY::enableControlPort)
-		.def_readwrite("cipher", &MACsecTxSecY::cipher)
-		.def_readwrite("confidentiality_offset", &MACsecTxSecY::confidentialityOffset)
-		.def_readwrite("icv_includes_da_sa", &MACsecTxSecY::icvIncludesDaSa)
-		.def_readwrite("protect_frames", &MACsecTxSecY::protectFrames)
-		.def_readwrite("sec_tag_offset", &MACsecTxSecY::secTagOffset)
-		.def_readwrite("sec_tag_tci", &MACsecTxSecY::tci)
-		.def_readwrite("mtu", &MACsecTxSecY::mtu)
-		.def_readwrite("is_control_packet", &MACsecTxSecY::isControlPacket)
-		.def_readwrite("auxiliary_policy", &MACsecTxSecY::auxiliaryPolicy)
-		.def_readwrite("sci", &MACsecTxSecY::sci);
-		
-	pybind11::classh<MACsecRxSecY>(m, "MACsecRxSecY")
-		.def(pybind11::init())
-		.def_readwrite("enable_control_port", &MACsecRxSecY::enableControlPort)
-		.def_readwrite("frame_validation", &MACsecRxSecY::frameValidation)
-		.def_readwrite("frame_strip", &MACsecRxSecY::frameStrip)
-		.def_readwrite("cipher", &MACsecRxSecY::cipher)
-		.def_readwrite("confidentiality_offset", &MACsecRxSecY::confidentialityOffset)
-		.def_readwrite("icv_includes_da_sa", &MACsecRxSecY::icvIncludesDaSa)
-		.def_readwrite("replay_protect", &MACsecRxSecY::replayProtect)
-		.def_readwrite("replay_window", &MACsecRxSecY::replayWindow)
-		.def_readwrite("is_control_packet", &MACsecRxSecY::isControlPacket)
-		.def_readwrite("sci", &MACsecRxSecY::sci);
-
-	pybind11::classh<MACsecTxSa>(m, "MACsecTxSa")
-		.def(pybind11::init())
-		.def_readwrite("sak", &MACsecTxSa::sak)
-		.def_readwrite("hash_key", &MACsecTxSa::hashKey)
-		.def_readwrite("salt", &MACsecTxSa::salt)
-		.def_readwrite("ssci", &MACsecTxSa::ssci)
-		.def_readwrite("next_pn", &MACsecTxSa::nextPn)
-		.def_readwrite("an", &MACsecTxSa::an);
-
-	pybind11::classh<MACsecRxSa>(m, "MACsecRxSa")
-		.def(pybind11::init())
-		.def_readwrite("sak", &MACsecRxSa::sak)
-		.def_readwrite("hash_key", &MACsecRxSa::hashKey)
-		.def_readwrite("salt", &MACsecRxSa::salt)
-		.def_readwrite("ssci", &MACsecRxSa::ssci)
-		.def_readwrite("next_pn", &MACsecRxSa::nextPn);
-
-	pybind11::classh<MACsecConfig>(m, "MACsecConfig")
-		.def(pybind11::init<icsneo::DeviceType>())
-		.def("add_rx_secy", &MACsecConfig::addRxSecY, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("add_tx_secY", &MACsecConfig::addTxSecY, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("add_rx_rule", &MACsecConfig::addRxRule, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("add_rx_sa", &MACsecConfig::addRxSa, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("add_tx_sa", &MACsecConfig::addTxSa, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_rx_secy", [](MACsecConfig& cfg, uint8_t index) -> MACsecRxSecY& { return cfg.getRxSecY(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_tx_secy", [](MACsecConfig& cfg, uint8_t index) -> MACsecTxSecY& { return cfg.getTxSecY(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_rx_sa", [](MACsecConfig& cfg, uint8_t index) -> MACsecRxSa& { return cfg.getRxSa(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_tx_sa", [](MACsecConfig& cfg, uint8_t index) -> MACsecTxSa& { return cfg.getTxSa(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_rx_rule", [](MACsecConfig& cfg, uint8_t index) -> MACsecRxRule& { return cfg.getRxRule(index); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_tx_sa_index", &MACsecConfig::setTxSaIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("enable_tx_rekey", &MACsecConfig::enableTxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_tx_sa_rekey_index", &MACsecConfig::setTxSaRekeyIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("disable_tx_rekey", &MACsecConfig::disableTxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_rx_sa_index", &MACsecConfig::setRxSaIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("enable_rx_rekey", &MACsecConfig::enableRxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_rx_sa_rekey_index", &MACsecConfig::setRxSaRekeyIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("disable_rx_rekey", &MACsecConfig::disableRxRekey, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_rx_enable", &MACsecConfig::setRxEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_tx_enable", &MACsecConfig::setTxEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_storage", &MACsecConfig::setStorage, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("clear", &MACsecConfig::clear, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("serialize", &MACsecConfig::serialize, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_bin_index", &MACsecConfig::getBinIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_type", &MACsecConfig::getType, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_max_num_rule", &MACsecConfig::getMaxNumRule, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_max_num_secy", &MACsecConfig::getMaxNumSecY, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_max_num_sa", &MACsecConfig::getMaxNumSa, pybind11::call_guard<pybind11::gil_scoped_release>());
-
-}
-
-} // namespace icsneo 
-

bindings/python/icsneopy/device/chipid.cpp

@@ -1,142 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
-
-#include "icsneo/device/chipid.h"
-
-namespace icsneo {
-
-void init_chipid(pybind11::module_& m) {
-	pybind11::native_enum<ChipID>(m, "ChipID", "enum.IntEnum")
-		.value("neoVIFIRE_MCHIP", ChipID::neoVIFIRE_MCHIP)
-		.value("neoVIFIRE_LCHIP", ChipID::neoVIFIRE_LCHIP)
-		.value("neoVIFIRE_UCHIP", ChipID::neoVIFIRE_UCHIP)
-		.value("neoVIFIRE_JCHIP", ChipID::neoVIFIRE_JCHIP)
-		.value("ValueCAN3_MCHIP", ChipID::ValueCAN3_MCHIP)
-		.value("neoVIECU_MPIC", ChipID::neoVIECU_MPIC)
-		.value("neoVIIEVB_MPIC", ChipID::neoVIIEVB_MPIC)
-		.value("neoVIPENDANT_MPIC", ChipID::neoVIPENDANT_MPIC)
-		.value("neoVIFIRE_VNET_MCHIP", ChipID::neoVIFIRE_VNET_MCHIP)
-		.value("neoVIFIRE_VNET_LCHIP", ChipID::neoVIFIRE_VNET_LCHIP)
-		.value("neoVIPLASMA_Core", ChipID::neoVIPLASMA_Core)
-		.value("neoVIPLASMA_HID", ChipID::neoVIPLASMA_HID)
-		.value("neoVIANALOG_MPIC", ChipID::neoVIANALOG_MPIC)
-		.value("neoVIPLASMA_ANALOG_Core", ChipID::neoVIPLASMA_ANALOG_Core)
-		.value("neoVIPLASMA_FlexRay_Core", ChipID::neoVIPLASMA_FlexRay_Core)
-		.value("neoVIPLASMA_Core_1_12", ChipID::neoVIPLASMA_Core_1_12)
-		.value("neoVIFIRE_Slave_VNET_MCHIP", ChipID::neoVIFIRE_Slave_VNET_MCHIP)
-		.value("neoVIFIRE_Slave_VNET_LCHIP", ChipID::neoVIFIRE_Slave_VNET_LCHIP)
-		.value("neoVIION_Core", ChipID::neoVIION_Core)
-		.value("neoVIION_HID", ChipID::neoVIION_HID)
-		.value("neoVIION_Core_Loader", ChipID::neoVIION_Core_Loader)
-		.value("neoVIION_HID_Loader", ChipID::neoVIION_HID_Loader)
-		.value("neoVIION_FPGA_BIT", ChipID::neoVIION_FPGA_BIT)
-		.value("neoVIFIRE_VNET_EP_MCHIP", ChipID::neoVIFIRE_VNET_EP_MCHIP)
-		.value("neoVIFIRE_VNET_EP_LCHIP", ChipID::neoVIFIRE_VNET_EP_LCHIP)
-		.value("neoVIAnalogOut_MCHIP", ChipID::neoVIAnalogOut_MCHIP)
-		.value("neoVIMOST25_MCHIP", ChipID::neoVIMOST25_MCHIP)
-		.value("neoVIMOST50_MCHIP", ChipID::neoVIMOST50_MCHIP)
-		.value("neoVIMOST150_MCHIP", ChipID::neoVIMOST150_MCHIP)
-		.value("ValueCAN4_4_MCHIP", ChipID::ValueCAN4_4_MCHIP)
-		.value("ValueCAN4_4_SCHIP", ChipID::ValueCAN4_4_SCHIP)
-		.value("cmProbe_ZYNQ", ChipID::cmProbe_ZYNQ)
-		.value("EEVB_STM32", ChipID::EEVB_STM32)
-		.value("neoVIFIRE_Slave_VNET_EP_MCHIP", ChipID::neoVIFIRE_Slave_VNET_EP_MCHIP)
-		.value("neoVIFIRE_Slave_VNET_EP_LCHIP", ChipID::neoVIFIRE_Slave_VNET_EP_LCHIP)
-		.value("RADStar_MCHIP", ChipID::RADStar_MCHIP)
-		.value("ValueCANrf_MCHIP", ChipID::ValueCANrf_MCHIP)
-		.value("neoVIFIRE2_MCHIP", ChipID::neoVIFIRE2_MCHIP)
-		.value("neoVIFIRE2_CCHIP", ChipID::neoVIFIRE2_CCHIP)
-		.value("neoVIFIRE2_Core", ChipID::neoVIFIRE2_Core)
-		.value("neoVIFIRE2_BLECHIP", ChipID::neoVIFIRE2_BLECHIP)
-		.value("neoVIFIRE2_ZYNQ", ChipID::neoVIFIRE2_ZYNQ)
-		.value("neoVIFIRE2_SECURITYCHIP", ChipID::neoVIFIRE2_SECURITYCHIP)
-		.value("RADGalaxy_ZYNQ", ChipID::RADGalaxy_ZYNQ)
-		.value("neoVIFIRE2_VNET_MCHIP", ChipID::neoVIFIRE2_VNET_MCHIP)
-		.value("neoVIFIRE2_Slave_VNET_A_MCHIP", ChipID::neoVIFIRE2_Slave_VNET_A_MCHIP)
-		.value("neoVIFIRE2_Slave_VNET_A_CCHIP", ChipID::neoVIFIRE2_Slave_VNET_A_CCHIP)
-		.value("neoVIFIRE2_VNET_CCHIP", ChipID::neoVIFIRE2_VNET_CCHIP)
-		.value("neoVIFIRE2_VNET_Core", ChipID::neoVIFIRE2_VNET_Core)
-		.value("RADStar2_ZYNQ", ChipID::RADStar2_ZYNQ)
-		.value("VividCAN_MCHIP", ChipID::VividCAN_MCHIP)
-		.value("neoOBD2SIM_MCHIP", ChipID::neoOBD2SIM_MCHIP)
-		.value("neoVIFIRE2_VNETZ_MCHIP", ChipID::neoVIFIRE2_VNETZ_MCHIP)
-		.value("neoVIFIRE2_VNETZ_ZYNQ", ChipID::neoVIFIRE2_VNETZ_ZYNQ)
-		.value("neoVIFIRE2_Slave_VNETZ_A_MCHIP", ChipID::neoVIFIRE2_Slave_VNETZ_A_MCHIP)
-		.value("neoVIFIRE2_Slave_VNETZ_A_ZYNQ", ChipID::neoVIFIRE2_Slave_VNETZ_A_ZYNQ)
-		.value("VividCAN_EXT_FLASH", ChipID::VividCAN_EXT_FLASH)
-		.value("VividCAN_NRF52", ChipID::VividCAN_NRF52)
-		.value("cmProbe_ZYNQ_Unused", ChipID::cmProbe_ZYNQ_Unused)
-		.value("neoOBD2PRO_MCHIP", ChipID::neoOBD2PRO_MCHIP)
-		.value("ValueCAN4_1_MCHIP", ChipID::ValueCAN4_1_MCHIP)
-		.value("ValueCAN4_2_MCHIP", ChipID::ValueCAN4_2_MCHIP)
-		.value("ValueCAN4_4_2EL_Core", ChipID::ValueCAN4_4_2EL_Core)
-		.value("neoOBD2PRO_SCHIP", ChipID::neoOBD2PRO_SCHIP)
-		.value("ValueCAN4_2EL_MCHIP", ChipID::ValueCAN4_2EL_MCHIP)
-		.value("neoECUAVBTSN_MCHIP", ChipID::neoECUAVBTSN_MCHIP)
-		.value("neoOBD2PRO_Core", ChipID::neoOBD2PRO_Core)
-		.value("RADSupermoon_ZYNQ", ChipID::RADSupermoon_ZYNQ)
-		.value("RADMoon2_ZYNQ", ChipID::RADMoon2_ZYNQ)
-		.value("VividCANPRO_MCHIP", ChipID::VividCANPRO_MCHIP)
-		.value("VividCANPRO_EXT_FLASH", ChipID::VividCANPRO_EXT_FLASH)
-		.value("RADPluto_MCHIP", ChipID::RADPluto_MCHIP)
-		.value("RADMars_ZYNQ", ChipID::RADMars_ZYNQ)
-		.value("neoECU12_MCHIP", ChipID::neoECU12_MCHIP)
-		.value("RADIOCANHUB_MCHIP", ChipID::RADIOCANHUB_MCHIP)
-		.value("FlexRay_VNETZ_ZCHIP", ChipID::FlexRay_VNETZ_ZCHIP)
-		.value("neoOBD2_LCBADGE_MCHIP", ChipID::neoOBD2_LCBADGE_MCHIP)
-		.value("neoOBD2_LCBADGE_SCHIP", ChipID::neoOBD2_LCBADGE_SCHIP)
-		.value("RADMoonDuo_MCHIP", ChipID::RADMoonDuo_MCHIP)
-		.value("neoVIFIRE3_ZCHIP", ChipID::neoVIFIRE3_ZCHIP)
-		.value("FlexRay_VNETZ_FCHIP", ChipID::FlexRay_VNETZ_FCHIP)
-		.value("RADJupiter_MCHIP", ChipID::RADJupiter_MCHIP)
-		.value("ValueCAN4Industrial_MCHIP", ChipID::ValueCAN4Industrial_MCHIP)
-		.value("EtherBADGE_MCHIP", ChipID::EtherBADGE_MCHIP)
-		.value("RADMars_3_ZYNQ", ChipID::RADMars_3_ZYNQ)
-		.value("RADGigastar_USBZ_ZYNQ", ChipID::RADGigastar_USBZ_ZYNQ)
-		.value("RADGigastar_ZYNQ", ChipID::RADGigastar_ZYNQ)
-		.value("RAD4G_MCHIP", ChipID::RAD4G_MCHIP)
-		.value("neoVIFIRE3_SCHIP", ChipID::neoVIFIRE3_SCHIP)
-		.value("RADEpsilon_MCHIP", ChipID::RADEpsilon_MCHIP)
-		.value("RADA2B_ZCHIP", ChipID::RADA2B_ZCHIP)
-		.value("neoOBD2Dev_MCHIP", ChipID::neoOBD2Dev_MCHIP)
-		.value("neoOBD2Dev_SCHIP", ChipID::neoOBD2Dev_SCHIP)
-		.value("neoOBD2SIMDoIP_MCHIP", ChipID::neoOBD2SIMDoIP_MCHIP)
-		.value("SFPModule_88q2112_MCHIP", ChipID::SFPModule_88q2112_MCHIP)
-		.value("RADEpsilonT_MCHIP", ChipID::RADEpsilonT_MCHIP)
-		.value("RADEpsilonExpress_MCHIP", ChipID::RADEpsilonExpress_MCHIP)
-		.value("RADProxima_MCHIP", ChipID::RADProxima_MCHIP)
-		.value("NewDevice57_ZCHIP", ChipID::NewDevice57_ZCHIP)
-		.value("RAD_GALAXY_2_ZMPCHIP_ID", ChipID::RAD_GALAXY_2_ZMPCHIP_ID)
-		.value("NewDevice59_MCHIP", ChipID::NewDevice59_MCHIP)
-		.value("RADMoon2_Z7010_ZYNQ", ChipID::RADMoon2_Z7010_ZYNQ)
-		.value("neoVIFIRE2_Core_SG4", ChipID::neoVIFIRE2_Core_SG4)
-		.value("RADBMS_MCHIP", ChipID::RADBMS_MCHIP)
-		.value("RADMoon2_ZL_MCHIP", ChipID::RADMoon2_ZL_MCHIP)
-		.value("RADGigastar_USBZ_Z7010_ZYNQ", ChipID::RADGigastar_USBZ_Z7010_ZYNQ)
-		.value("neoVIFIRE3_LINUX", ChipID::neoVIFIRE3_LINUX)
-		.value("RADGigastar_USBZ_Z7007S_ZYNQ", ChipID::RADGigastar_USBZ_Z7007S_ZYNQ)
-		.value("VEM_01_8DW_ZCHIP", ChipID::VEM_01_8DW_ZCHIP)
-		.value("RADGalaxy_FFG_Zynq", ChipID::RADGalaxy_FFG_Zynq)
-		.value("RADMoon3_MCHIP", ChipID::RADMoon3_MCHIP)
-		.value("RADComet_ZYNQ", ChipID::RADComet_ZYNQ)
-		.value("VEM_02_FR_ZCHIP", ChipID::VEM_02_FR_ZCHIP)
-		.value("RADA2B_REVB_ZCHIP", ChipID::RADA2B_REVB_ZCHIP)
-		.value("RADGigastar_FFG_ZYNQ", ChipID::RADGigastar_FFG_ZYNQ)
-		.value("VEM_02_FR_FCHIP", ChipID::VEM_02_FR_FCHIP)
-		.value("Connect_ZCHIP", ChipID::Connect_ZCHIP)
-		.value("SFPModule_88q2221_MCHIP", ChipID::SFPModule_88q2221_MCHIP)
-		.value("RADGALAXY2_SYSMON_CHIP", ChipID::RADGALAXY2_SYSMON_CHIP)
-		.value("SFPModule_88q3244_MCHIP", ChipID::SFPModule_88q3244_MCHIP)
-		.value("RADCOMET3_ZCHIP", ChipID::RADCOMET3_ZCHIP)
-		.value("Connect_LINUX", ChipID::Connect_LINUX)
-		.value("SFPModule_lan8670_MCHIP", ChipID::SFPModule_lan8670_MCHIP)
-		.value("RADGigastar2_ZYNQ", ChipID::RADGigastar2_ZYNQ)
-		.value("SFPModule_ent11100_MCHIP", ChipID::SFPModule_ent11100_MCHIP)
-		.value("RADGemini_MCHIP", ChipID::RADGemini_MCHIP)
-		.value("Invalid", ChipID::Invalid)
-		.finalize();
-}
-
-} // namespace icsneo

bindings/python/icsneopy/device/device.cpp

@@ -4,26 +4,22 @@
 #include <pybind11/chrono.h>
 
 #include "icsneo/device/device.h"
-#include "icsneo/device/extensions/deviceextension.h"
-#include "icsneo/disk/diskdetails.h"
 
 #include <fstream>
 
 namespace icsneo {
 
 void init_device(pybind11::module_& m) {
-	pybind11::classh<Device>(m, "Device")
+	pybind11::class_<Device, std::shared_ptr<Device>>(m, "Device")
 		.def("__repr__", &Device::describe)
 		.def("add_message_callback", &Device::addMessageCallback, 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::arg("filter") = std::nullopt, 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_extension", static_cast<std::shared_ptr<DeviceExtension>(Device::*)(const std::string&) const>(&Device::getExtension)) // This has to be static_casted rather than overload_casted because DeviceExtension is forward declared in device.h
-        .def("get_flexray_controllers", &Device::getFlexRayControllers)
 		.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)
@@ -32,8 +28,6 @@ void init_device(pybind11::module_& m) {
 		.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_pcb_serial", &Device::getPCBSerial, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_mac_address", &Device::getMACAddress, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.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_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -55,21 +49,9 @@ void init_device(pybind11::module_& m) {
 		.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("supports_live_data", &Device::supportsLiveData)
-		.def("subscribe_live_data", &Device::subscribeLiveData, pybind11::arg("message"), pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("unsubscribe_live_data", &Device::unsubscribeLiveData, pybind11::arg("handle"), pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("clear_all_live_data", &Device::clearAllLiveData, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("set_value_live_data", &Device::setValueLiveData, pybind11::arg("message"), 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("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("send_eth_phy_msg", &Device::sendEthPhyMsg, pybind11::arg("message"), pybind11::arg("timeout") = std::chrono::milliseconds(50), pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_chip_versions", &Device::getChipVersions, pybind11::arg("refreshComponents") = true, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("supports_disk_formatting", &Device::supportsDiskFormatting, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_disk_count", &Device::getDiskCount, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_disk_details", &Device::getDiskDetails, pybind11::arg("timeout") = std::chrono::milliseconds(100), pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("force_disk_config_update", &Device::forceDiskConfigUpdate, pybind11::arg("config"), pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("format_disk", [](Device& device, const DiskDetails& config) -> bool { return device.formatDisk(config); }, pybind11::arg("config"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def_readonly("settings", &Device::settings);
 }
 

bindings/python/icsneopy/device/devicetype.cpp

@@ -1,15 +1,14 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
-#include <pybind11/native_enum.h>
 
 #include "icsneo/device/devicetype.h"
 
 namespace icsneo {
 
 void init_devicetype(pybind11::module_& m) {
-	pybind11::classh<DeviceType> deviceType(m, "DeviceType");
+	pybind11::class_<DeviceType> deviceType(m, "DeviceType");
-	pybind11::native_enum<DeviceType::Enum>(deviceType, "Enum", "enum.IntEnum")
+	pybind11::enum_<DeviceType::Enum>(deviceType, "Enum")
 		.value("Unknown", DeviceType::Enum::Unknown)
 		.value("BLUE", DeviceType::Enum::BLUE)
 		.value("ECU_AVB", DeviceType::Enum::ECU_AVB)
@@ -37,11 +36,8 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADEpsilonXL", DeviceType::Enum::RADEpsilonXL)
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
-		.value("RADGemini", DeviceType::Enum::RADGemini)
 		.value("RADComet", DeviceType::Enum::RADComet)
 		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)
-		.value("FIRE3_T1S_LIN", DeviceType::Enum::FIRE3_T1S_LIN)
-		.value("FIRE3_T1S_SENT", DeviceType::Enum::FIRE3_T1S_SENT)
 		.value("Connect", DeviceType::Enum::Connect)
 		.value("RADComet3", DeviceType::Enum::RADComet3)
 		.value("RADMoonT1S", DeviceType::Enum::RADMoonT1S)
@@ -71,8 +67,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADGalaxy", DeviceType::Enum::RADGalaxy)
 		.value("RADStar2", DeviceType::Enum::RADStar2)
 		.value("VividCAN", DeviceType::Enum::VividCAN)
-		.value("OBD2_SIM", DeviceType::Enum::OBD2_SIM)
+		.value("OBD2_SIM", DeviceType::Enum::OBD2_SIM);
-		.finalize();
 	deviceType.def(pybind11::init<DeviceType::Enum>());
 	deviceType.def("get_device_type", &DeviceType::getDeviceType);
 	deviceType.def("get_generic_product_name", &DeviceType::getGenericProductName);

bindings/python/icsneopy/device/extensions/deviceextension.cpp

@@ -1,14 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-
-#include "icsneo/device/extensions/deviceextension.h"
-
-namespace icsneo {
-
-void init_deviceextension(pybind11::module_& m) {
-    pybind11::classh<DeviceExtension>(m, "DeviceExtension")
-        .def("get_name", &DeviceExtension::getName);
-}
-
-} // namespace icsneo

bindings/python/icsneopy/device/idevicesettings.cpp

@@ -12,117 +12,35 @@ namespace icsneo {
 
 struct DeviceSettingsNamespace {
     using EthLinkMode = AELinkMode;
+    using LinkSpeed = EthLinkSpeed;
 };
 
 void init_idevicesettings(pybind11::module_& m) {
-    pybind11::classh<DeviceSettingsNamespace> settings(m, "Settings");
+    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_<EthPhyLinkMode>(settings, "PhyLinkMode")
+    pybind11::enum_<DeviceSettingsNamespace::LinkSpeed>(settings, "EthernetLinkSpeed")
-        .value("ETH_LINK_MODE_AUTO_NEGOTIATION", ETH_LINK_MODE_AUTO_NEGOTIATION)
+        .value("Speed10M", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10)
-        .value("ETH_LINK_MODE_10MBPS_HALFDUPLEX", ETH_LINK_MODE_10MBPS_HALFDUPLEX)
+        .value("Speed100M", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_100)
-        .value("ETH_LINK_MODE_10MBPS_FULLDUPLEX", ETH_LINK_MODE_10MBPS_FULLDUPLEX)
+        .value("Speed1G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_1000)
-        .value("ETH_LINK_MODE_100MBPS_HALFDUPLEX", ETH_LINK_MODE_100MBPS_HALFDUPLEX)
+        .value("Speed2_5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_2500)
-        .value("ETH_LINK_MODE_100MBPS_FULLDUPLEX", ETH_LINK_MODE_100MBPS_FULLDUPLEX)
+        .value("Speed5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_5000)
-        .value("ETH_LINK_MODE_1GBPS_HALFDUPLEX", ETH_LINK_MODE_1GBPS_HALFDUPLEX)
+        .value("Speed10G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10000);
-        .value("ETH_LINK_MODE_1GBPS_FULLDUPLEX", ETH_LINK_MODE_1GBPS_FULLDUPLEX)
-        .value("ETH_LINK_MODE_2_5GBPS_FULLDUPLEX", ETH_LINK_MODE_2_5GBPS_FULLDUPLEX)
-        .value("ETH_LINK_MODE_5GBPS_FULLDUPLEX", ETH_LINK_MODE_5GBPS_FULLDUPLEX)
-        .value("ETH_LINK_MODE_10GBPS_FULLDUPLEX", ETH_LINK_MODE_10GBPS_FULLDUPLEX);
 
-    pybind11::enum_<LINMode>(settings, "LINMode")
+    pybind11::class_<IDeviceSettings, std::shared_ptr<IDeviceSettings>>(m, "IDeviceSettings")
-        .value("Sleep", LINMode::SLEEP_MODE)
-        .value("Slow", LINMode::SLOW_MODE)
-        .value("Normal", LINMode::NORMAL_MODE)
-        .value("Fast", LINMode::FAST_MODE);
-
-    pybind11::enum_<MiscIOAnalogVoltage>(settings, "MiscIOAnalogVoltage")
-        .value("V0", MiscIOAnalogVoltage::V0)
-        .value("V1", MiscIOAnalogVoltage::V1)
-        .value("V2", MiscIOAnalogVoltage::V2)
-        .value("V3", MiscIOAnalogVoltage::V3)
-        .value("V4", MiscIOAnalogVoltage::V4)
-        .value("V5", MiscIOAnalogVoltage::V5);
-
-    pybind11::classh<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("refresh", &IDeviceSettings::refresh, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // Baudrate methods
-        .def("get_baudrate", &IDeviceSettings::getBaudrateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_baudrate", &IDeviceSettings::setBaudrateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_fd_baudrate", &IDeviceSettings::getFDBaudrateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_fd_baudrate", &IDeviceSettings::setFDBaudrateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // Termination methods
-        .def("is_termination_supported", &IDeviceSettings::isTerminationSupportedFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("can_termination_be_enabled", &IDeviceSettings::canTerminationBeEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("is_termination_enabled", &IDeviceSettings::isTerminationEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_termination", &IDeviceSettings::setTerminationFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_termination_groups", &IDeviceSettings::getTerminationGroups, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // LIN methods
-        .def("is_commander_resistor_enabled", &IDeviceSettings::isCommanderResistorEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_commander_resistor", &IDeviceSettings::setCommanderResistorFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_lin_mode", &IDeviceSettings::getLINModeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_lin_mode", &IDeviceSettings::setLINModeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_lin_commander_response_time", &IDeviceSettings::getLINCommanderResponseTimeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_lin_commander_response_time", &IDeviceSettings::setLINCommanderResponseTimeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // Ethernet PHY methods (index-based for switch devices)
         .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>());
-        // Ethernet PHY methods (network-based for multi-interface devices)
-        .def("get_phy_enable_for", &IDeviceSettings::getPhyEnableFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_phy_role_for", &IDeviceSettings::getPhyRoleFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_phy_link_mode_for", &IDeviceSettings::getPhyLinkModeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_phy_enable_for", &IDeviceSettings::setPhyEnableFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_phy_role_for", &IDeviceSettings::setPhyRoleFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_phy_link_mode_for", &IDeviceSettings::setPhyLinkModeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_supported_phy_link_modes_for", &IDeviceSettings::getSupportedPhyLinkModesFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // 10BASE-T1S methods
-        .def("is_t1s_plca_enabled", &IDeviceSettings::isT1SPLCAEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_plca", &IDeviceSettings::setT1SPLCAFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_local_id", &IDeviceSettings::getT1SLocalIDFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_local_id", &IDeviceSettings::setT1SLocalIDFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_max_nodes", &IDeviceSettings::getT1SMaxNodesFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_max_nodes", &IDeviceSettings::setT1SMaxNodesFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_tx_opp_timer", &IDeviceSettings::getT1STxOppTimerFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_tx_opp_timer", &IDeviceSettings::setT1STxOppTimerFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_max_burst", &IDeviceSettings::getT1SMaxBurstFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_max_burst", &IDeviceSettings::setT1SMaxBurstFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_burst_timer", &IDeviceSettings::getT1SBurstTimerFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_burst_timer", &IDeviceSettings::setT1SBurstTimerFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_local_id_alternate", &IDeviceSettings::getT1SLocalIDAlternateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_local_id_alternate", &IDeviceSettings::setT1SLocalIDAlternateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("is_t1s_termination_enabled", &IDeviceSettings::isT1STerminationEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_termination", &IDeviceSettings::setT1STerminationFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("is_t1s_bus_decoding_beacons_enabled", &IDeviceSettings::isT1SBusDecodingBeaconsEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_bus_decoding_beacons", &IDeviceSettings::setT1SBusDecodingBeaconsFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("is_t1s_bus_decoding_all_enabled", &IDeviceSettings::isT1SBusDecodingAllEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_bus_decoding_all", &IDeviceSettings::setT1SBusDecodingAllFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_multi_id_enable_mask", &IDeviceSettings::getT1SMultiIDEnableMaskFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_multi_id_enable_mask", &IDeviceSettings::setT1SMultiIDEnableMaskFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_t1s_multi_id", &IDeviceSettings::getT1SMultiIDFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_t1s_multi_id", &IDeviceSettings::setT1SMultiIDFor, pybind11::call_guard<pybind11::gil_scoped_release>())
-        
-        .def("set_misc_io_analog_output_enabled", &IDeviceSettings::setMiscIOAnalogOutputEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_misc_io_analog_output", &IDeviceSettings::setMiscIOAnalogOutput, pybind11::call_guard<pybind11::gil_scoped_release>())
-        
-        // Status properties
-        .def_readonly("disabled", &IDeviceSettings::disabled)
-        .def_readonly("readonly", &IDeviceSettings::readonly);
 }
 
 } // namespace icsneo

bindings/python/icsneopy/device/versionreport.cpp

@@ -1,19 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/functional.h>
-
-#include "icsneo/device/versionreport.h"
-
-namespace icsneo {
-
-void init_versionreport(pybind11::module_& m) {
-	pybind11::classh<VersionReport>(m, "VersionReport")
-		.def_readonly("id", &VersionReport::id)
-		.def_readonly("name", &VersionReport::name)
-		.def_readonly("major", &VersionReport::major)
-		.def_readonly("minor", &VersionReport::minor)
-		.def_readonly("maintenance", &VersionReport::maintenance)
-		.def_readonly("build", &VersionReport::build);
-}
-
-} // namespace icsneo

bindings/python/icsneopy/disk/diskdetails.cpp

@@ -1,29 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-
-#include "icsneo/disk/diskdetails.h"
-
-namespace icsneo {
-
-void init_diskdetails(pybind11::module_& m) {
-	pybind11::enum_<DiskLayout>(m, "DiskLayout")
-		.value("Spanned", DiskLayout::Spanned)
-		.value("RAID0", DiskLayout::RAID0);
-
-	pybind11::classh<DiskInfo>(m, "DiskInfo")
-		.def(pybind11::init())
-		.def_readwrite("present", &DiskInfo::present)
-		.def_readwrite("initialized", &DiskInfo::initialized)
-		.def_readwrite("formatted", &DiskInfo::formatted)
-		.def_readwrite("sectors", &DiskInfo::sectors)
-		.def_readwrite("bytes_per_sector", &DiskInfo::bytesPerSector)
-		.def("size", &DiskInfo::size);
-
-	pybind11::classh<DiskDetails>(m, "DiskDetails")
-		.def(pybind11::init())
-		.def_readwrite("layout", &DiskDetails::layout)
-		.def_readwrite("full_format", &DiskDetails::fullFormat)
-		.def_readwrite("disks", &DiskDetails::disks);
-}
-
-} // namespace icsneo

bindings/python/icsneopy/disk/diskdriver.cpp

@@ -13,7 +13,7 @@ struct DiskNamespace {
 };
 
 void init_diskdriver(pybind11::module_& m) {
-	pybind11::classh<DiskNamespace> disk(m, "Disk");
+	pybind11::class_<DiskNamespace> disk(m, "Disk");
 	pybind11::enum_<Disk::Access>(disk, "Access")
 		.value("None", Disk::Access::None)
 		.value("EntireCard", Disk::Access::EntireCard)

bindings/python/icsneopy/flexray/flexray.cpp

@@ -1,195 +0,0 @@
-#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"
-#include "icsneo/device/extensions/flexray/controller.h"
-
-namespace icsneo {
-
-struct FlexRayNamespace {
-    using Symbol = icsneo::FlexRay::Symbol;
-    using CRCStatus = icsneo::FlexRay::CRCStatus;
-    using Channel = icsneo::FlexRay::Channel;
-};
-
-namespace FlexRay {
-
-struct ClusterNamespace {
-    using SpeedType = icsneo::FlexRay::Cluster::SpeedType;
-    using SPPType = icsneo::FlexRay::Cluster::SPPType;
-};
-
-void init_extension(pybind11::classh<FlexRayNamespace>& c) {
-    pybind11::classh<MessageBuffer>(c, "MessageBuffer")
-        .def(pybind11::init())
-        .def_readwrite("is_dynamic", &MessageBuffer::isDynamic)
-        .def_readwrite("is_sync", &MessageBuffer::isSync)
-        .def_readwrite("is_startup", &MessageBuffer::isStartup)
-        .def_readwrite("is_network_management_frame", &MessageBuffer::isNetworkManagementFrame)
-        .def_readwrite("is_transmit", &MessageBuffer::isTransmit)
-        .def_readwrite("frame_id", &MessageBuffer::frameID)
-        .def_readwrite("channel_a", &MessageBuffer::channelA)
-        .def_readwrite("channel_b", &MessageBuffer::channelB)
-        .def_readwrite("frame_length_bytes", &MessageBuffer::frameLengthBytes)
-        .def_readwrite("base_cycle", &MessageBuffer::baseCycle)
-        .def_readwrite("cycle_repetition", &MessageBuffer::cycleRepetition)
-        .def_readwrite("continuous_mode", &MessageBuffer::continuousMode);
-
-    auto controller = pybind11::classh<Controller>(c, "Controller")
-        .def("get_network", &Controller::getNetwork)
-        .def("get_configuration", &Controller::getConfiguration)
-        .def("set_configuration", &Controller::setConfiguration)
-        .def("get_start_when_going_online", &Controller::getStartWhenGoingOnline)
-        .def("set_start_when_going_online", &Controller::setStartWhenGoingOnline)
-        .def("get_allow_coldstart", &Controller::getAllowColdstart)
-        .def("set_allow_coldstart", &Controller::setAllowColdstart)
-        .def("get_wakeup_before_start", &Controller::getWakeupBeforeStart)
-        .def("set_wakeup_before_start", &Controller::setWakeupBeforeStart)
-        .def("add_message_buffer", &Controller::addMessageBuffer)
-        .def("clear_message_buffers", &Controller::clearMessageBuffers)
-        .def("wakeup", &Controller::wakeup)
-        .def("configure", &Controller::getReady)
-        .def("start", &Controller::start)
-        .def("transmit", &Controller::transmit)
-        .def("halt", &Controller::halt)
-        .def("freeze", &Controller::freeze)
-        .def("trigger_mts", &Controller::triggerMTS);
-
-    pybind11::classh<Controller::Configuration>(controller, "Configuration")
-        .def(pybind11::init())
-        .def_readwrite("accept_startup_range_microticks", &Controller::Configuration::AcceptStartupRangeMicroticks)
-        .def_readwrite("allow_passive_to_active_cycle_pairs", &Controller::Configuration::AllowPassiveToActiveCyclePairs)
-        .def_readwrite("cluster_drift_damping", &Controller::Configuration::ClusterDriftDamping)
-        .def_readwrite("allow_halt_due_to_clock", &Controller::Configuration::AllowHaltDueToClock)
-        .def_readwrite("channel_a", &Controller::Configuration::ChannelA)
-        .def_readwrite("channel_b", &Controller::Configuration::ChannelB)
-        .def_readwrite("decoding_correction_microticks", &Controller::Configuration::DecodingCorrectionMicroticks)
-        .def_readwrite("delay_compensation_a_microticks", &Controller::Configuration::DelayCompensationAMicroticks)
-        .def_readwrite("delay_compensation_b_microticks", &Controller::Configuration::DelayCompensationBMicroticks)
-        .def_readwrite("extern_offset_correction_control", &Controller::Configuration::ExternOffsetCorrectionControl)
-        .def_readwrite("extern_rate_correction_control", &Controller::Configuration::ExternRateCorrectionControl)
-        .def_readwrite("extern_offset_correction_microticks", &Controller::Configuration::ExternOffsetCorrectionMicroticks)
-        .def_readwrite("extern_rate_correction_microticks", &Controller::Configuration::ExternRateCorrectionMicroticks)
-        .def_readwrite("key_slot_id", &Controller::Configuration::KeySlotID)
-        .def_readwrite("key_slot_only_enabled", &Controller::Configuration::KeySlotOnlyEnabled)
-        .def_readwrite("key_slot_used_for_startup", &Controller::Configuration::KeySlotUsedForStartup)
-        .def_readwrite("key_slot_used_for_sync", &Controller::Configuration::KeySlotUsedForSync)
-        .def_readwrite("latest_tx_minislot", &Controller::Configuration::LatestTxMinislot)
-        .def_readwrite("listen_timeout", &Controller::Configuration::ListenTimeout)
-        .def_readwrite("macro_initial_offset_a", &Controller::Configuration::MacroInitialOffsetA)
-        .def_readwrite("macro_initial_offset_b", &Controller::Configuration::MacroInitialOffsetB)
-        .def_readwrite("micro_initial_offset_a", &Controller::Configuration::MicroInitialOffsetA)
-        .def_readwrite("micro_initial_offset_b", &Controller::Configuration::MicroInitialOffsetB)
-        .def_readwrite("micro_per_cycle", &Controller::Configuration::MicroPerCycle)
-        .def_readwrite("mts_on_a", &Controller::Configuration::MTSOnA)
-        .def_readwrite("mts_on_b", &Controller::Configuration::MTSOnB)
-        .def_readwrite("offset_correction_out_microticks", &Controller::Configuration::OffsetCorrectionOutMicroticks)
-        .def_readwrite("rate_correction_out_microticks", &Controller::Configuration::RateCorrectionOutMicroticks)
-        .def_readwrite("second_key_slot_id", &Controller::Configuration::SecondKeySlotID)
-        .def_readwrite("two_key_slot_mode", &Controller::Configuration::TwoKeySlotMode)
-        .def_readwrite("wakeup_pattern", &Controller::Configuration::WakeupPattern)
-        .def_readwrite("wakeup_on_channel_b", &Controller::Configuration::WakeupOnChannelB);
-
-    // Dummy class for cluster namespace
-    pybind11::classh<ClusterNamespace> cluster(c, "Cluster");
-
-    pybind11::enum_<Cluster::SpeedType>(cluster, "SpeedType")
-        .value("FLEXRAY_BAUDRATE_10M", Cluster::SpeedType::FLEXRAY_BAUDRATE_10M)
-        .value("FLEXRAY_BAUDRATE_5M", Cluster::SpeedType::FLEXRAY_BAUDRATE_5M)
-        .value("FLEXRAY_BAUDRATE_2M5", Cluster::SpeedType::FLEXRAY_BAUDRATE_2M5)
-        .value("FLEXRAY_BAUDRATE_2M5_ALT", Cluster::SpeedType::FLEXRAY_BAUDRATE_2M5_ALT);
-
-    pybind11::enum_<Cluster::SPPType>(cluster, "SPPType")
-        .value("FLEXRAY_SPP_5", Cluster::SPPType::FLEXRAY_SPP_5)
-        .value("FLEXRAY_SPP_4", Cluster::SPPType::FLEXRAY_SPP_4)
-        .value("FLEXRAY_SPP_6", Cluster::SPPType::FLEXRAY_SPP_6)
-        .value("FLEXRAY_SPP_5_ALT", Cluster::SPPType::FLEXRAY_SPP_5_ALT);
-
-    pybind11::classh<Cluster::Configuration>(cluster, "Configuration")
-        .def(pybind11::init())
-        .def_readwrite("speed", &Cluster::Configuration::Speed)
-        .def_readwrite("strobe_point_position", &Cluster::Configuration::StrobePointPosition)
-        .def_readwrite("action_point_offset", &Cluster::Configuration::ActionPointOffset)
-        .def_readwrite("casr_x_low_max", &Cluster::Configuration::CASRxLowMax)
-        .def_readwrite("cold_start_attempts", &Cluster::Configuration::ColdStartAttempts)
-        .def_readwrite("cycle_duration_micro_sec", &Cluster::Configuration::CycleDurationMicroSec)
-        .def_readwrite("dynamic_slot_idle_phase_minislots", &Cluster::Configuration::DynamicSlotIdlePhaseMinislots)
-        .def_readwrite("listen_noise_macroticks", &Cluster::Configuration::ListenNoiseMacroticks)
-        .def_readwrite("macroticks_per_cycle", &Cluster::Configuration::MacroticksPerCycle)
-        .def_readwrite("macrotick_duration_micro_sec", &Cluster::Configuration::MacrotickDurationMicroSec)
-        .def_readwrite("max_without_clock_correction_fatal", &Cluster::Configuration::MaxWithoutClockCorrectionFatal)
-        .def_readwrite("max_without_clock_correction_passive", &Cluster::Configuration::MaxWithoutClockCorrectionPassive)
-        .def_readwrite("minislot_action_point_offset_macroticks", &Cluster::Configuration::MinislotActionPointOffsetMacroticks)
-        .def_readwrite("minislot_duration_macroticks", &Cluster::Configuration::MinislotDurationMacroticks)
-        .def_readwrite("network_idle_time_macroticks", &Cluster::Configuration::NetworkIdleTimeMacroticks)
-        .def_readwrite("network_management_vector_length_bytes", &Cluster::Configuration::NetworkManagementVectorLengthBytes)
-        .def_readwrite("number_of_minislots", &Cluster::Configuration::NumberOfMinislots)
-        .def_readwrite("number_of_static_slots", &Cluster::Configuration::NumberOfStaticSlots)
-        .def_readwrite("offset_correction_start_macroticks", &Cluster::Configuration::OffsetCorrectionStartMacroticks)
-        .def_readwrite("payload_length_of_static_slot_in_words", &Cluster::Configuration::PayloadLengthOfStaticSlotInWords)
-        .def_readwrite("static_slot_macroticks", &Cluster::Configuration::StaticSlotMacroticks)
-        .def_readwrite("symbol_window_macroticks", &Cluster::Configuration::SymbolWindowMacroticks)
-        .def_readwrite("symbol_window_action_point_offset_macroticks", &Cluster::Configuration::SymbolWindowActionPointOffsetMacroticks)
-        .def_readwrite("sync_frame_id_count_max", &Cluster::Configuration::SyncFrameIDCountMax)
-        .def_readwrite("transmission_start_sequence_duration_bits", &Cluster::Configuration::TransmissionStartSequenceDurationBits)
-        .def_readwrite("wakeup_rx_idle_bits", &Cluster::Configuration::WakeupRxIdleBits)
-        .def_readwrite("wakeup_rx_low_bits", &Cluster::Configuration::WakeupRxLowBits)
-        .def_readwrite("wakeup_rx_window_bits", &Cluster::Configuration::WakeupRxWindowBits)
-        .def_readwrite("wakeup_tx_active_bits", &Cluster::Configuration::WakeupTxActiveBits)
-        .def_readwrite("wakeup_tx_idle_bits", &Cluster::Configuration::WakeupTxIdleBits);
-}
-
-} // namespace FlexRay
-
-void init_flexraymessage(pybind11::module_& m) {
-	pybind11::classh<FlexRayMessage, Frame>(m, "FlexRayMessage")
-		.def(pybind11::init())
-		.def_readwrite("slotid", &FlexRayMessage::slotid)
-		.def_readwrite("tsslen", &FlexRayMessage::tsslen)
-        .def_readwrite("framelen", &FlexRayMessage::framelen)
-		.def_readwrite("symbol", &FlexRayMessage::symbol)
-		.def_readwrite("header_crc_status", &FlexRayMessage::headerCRCStatus)
-		.def_readwrite("header_crc", &FlexRayMessage::headerCRC)
-		.def_readwrite("frame_crc_status", &FlexRayMessage::crcStatus)
-		.def_readwrite("frame_crc", &FlexRayMessage::frameCRC)
-		.def_readwrite("channel", &FlexRayMessage::channel)
-        .def_readwrite("null_frame", &FlexRayMessage::nullFrame)
-        .def_readwrite("payload_preamble", &FlexRayMessage::payloadPreamble)
-        .def_readwrite("sync_frame", &FlexRayMessage::sync)
-        .def_readwrite("startup_frame", &FlexRayMessage::startup)
-        .def_readwrite("dynamic_frame", &FlexRayMessage::dynamic)
-        .def_readwrite("cycle", &FlexRayMessage::cycle)
-        .def_readwrite("cycle_repetition", &FlexRayMessage::cycleRepetition);
-
-    //// TODO: Eliminate FlexRayControlMessage class references in controller class and eliminate getStatus function in bindings
-}
-
-void init_flexray(pybind11::module_& m) {
-    // Dummy class to act as FlexRay namespace
-    pybind11::classh<FlexRayNamespace> flexray(m, "FlexRay");
-    
-    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);
-    
-    init_flexraymessage(m);
-    FlexRay::init_extension(flexray);
-}
-
-} // namespace icsneo 
-

bindings/python/icsneopy/icsneocpp.cpp

@@ -20,24 +20,16 @@ void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
 void init_gptpstatusmessage(pybind11::module_&);
 void init_mdiomessage(pybind11::module_&);
-void init_spimessage(pybind11::module_&);
 void init_ethernetstatusmessage(pybind11::module_&);
-void init_macsecconfig(pybind11::module_&);
+void init_macsecmessage(pybind11::module_&);
 void init_scriptstatusmessage(pybind11::module_&);
 void init_diskdriver(pybind11::module_&);
-void init_diskdetails(pybind11::module_&);
-void init_deviceextension(pybind11::module_&);
-void init_chipid(pybind11::module_&);
-void init_versionreport(pybind11::module_&);
 void init_device(pybind11::module_&);
 void init_messagefilter(pybind11::module_&);
 void init_messagecallback(pybind11::module_&);
 void init_version(pybind11::module_&);
-void init_flexray(pybind11::module_& m);
+void init_flexraymessage(pybind11::module_& m);
 void init_idevicesettings(pybind11::module_&);
-void init_ethphymessage(pybind11::module_&);
-void init_livedata(pybind11::module_&);
-void init_livedatamessage(pybind11::module_&);
 
 PYBIND11_MODULE(icsneopy, m) {
 	pybind11::options options;
@@ -51,7 +43,6 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_devicetype(m);
 	init_network(m);
 	init_io(m);
-	init_livedata(m);
 	init_message(m);
 	init_canmessage(m);
 	init_canerrormessage(m);
@@ -61,20 +52,13 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_gptpstatusmessage(m);
 	init_mdiomessage(m);
 	init_ethernetstatusmessage(m);
-	init_macsecconfig(m);
+	init_macsecmessage(m);
 	init_scriptstatusmessage(m);
-	init_spimessage(m);
-	init_livedatamessage(m);
 	init_messagefilter(m);
 	init_messagecallback(m);
 	init_diskdriver(m);
-	init_diskdetails(m);
-    init_flexray(m);
-	init_ethphymessage(m);
-	init_chipid(m);
-	init_versionreport(m);
 	init_device(m);
-    init_deviceextension(m);
+	init_flexraymessage(m);
 	init_idevicesettings(m);
 
 	m.def("find_all_devices", &FindAllDevices);

ci/bootstrap-cibuildwheel.sh

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-yum install -y flex ca-certificates || exit 1
-
-echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
-
-update-ca-trust || exit 1

ci/bootstrap-libusb.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+VERSION="1.0.27"
+ROOT="$PWD/libusb"
+SOURCE="$ROOT/source"
+BUILD="$ROOT/build"
+INSTALL="$ROOT/install"
+
+mkdir -p "$ROOT"
+cd "$ROOT" || exit 1
+
+curl -LO "https://github.com/libusb/libusb/releases/download/v$VERSION/libusb-$VERSION.tar.bz2" || exit 1
+tar -xf "libusb-$VERSION.tar.bz2" || exit 1
+mv "libusb-$VERSION" "$SOURCE" || exit 1
+
+mkdir "$BUILD" || exit 1
+cd "$BUILD" || exit 1
+"$SOURCE/configure" --prefix="$INSTALL" --disable-shared --disable-udev --disable-eventfd --disable-timerfd --with-pic || exit 1
+make || exit 1
+make install || exit 1
+

ci/build-posix.sh

@@ -1,5 +1,6 @@
 #!/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_ENABLE_TCP=OFF || exit 1
 

ci/build-windows.bat

@@ -1,9 +1,12 @@
-@setlocal
+REM clean intermediate directories
-@echo off
+rmdir /s /q build
+mkdir build
 
-mkdir build >nul 2>&1
+REM build
-
+cd build
-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_UNIT_TESTS=ON ^
+set CFLAGS=/WX /W4 /wd4127
-    -DLIBICSNEO_ENABLE_TCP=ON || exit /b 1
+set CXXFLAGS=/WX /W4 /wd4127
-
+cmake -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=ON ..
-cmake --build build || exit /b 1
+if %errorlevel% neq 0 exit /b %errorlevel%
+cmake --build .
+if %errorlevel% neq 0 exit /b %errorlevel%

cmake/FindFTD3XX.cmake

@@ -0,0 +1,22 @@
+find_path(FTD3XX_INCLUDE_DIR
+	NAMES ftd3xx.h FTD3XX.h
+)
+
+find_library(FTD3XX_LIBRARY
+	NAMES libftd3xx.a libftd3xx-static.a FTD3XX.lib
+	PATH_SUFFIXES x64/Static
+)
+
+mark_as_advanced(FTD3XX_FOUND FTD3XX_INCLUDE_DIR FTD3XX_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(FTD3XX
+	REQUIRED_VARS FTD3XX_INCLUDE_DIR FTD3XX_LIBRARY
+)
+if(FTD3XX_FOUND AND NOT TARGET D3XX::D3XX)
+	add_library(FTD3XX::FTD3XX INTERFACE IMPORTED)
+	set_target_properties(FTD3XX::FTD3XX PROPERTIES
+		INTERFACE_INCLUDE_DIRECTORIES "${FTD3XX_INCLUDE_DIR}"
+		INTERFACE_LINK_LIBRARIES "${FTD3XX_LIBRARY}"
+	)
+endif()

communication/communication.cpp

@@ -14,12 +14,6 @@
 #include "icsneo/communication/message/readsettingsmessage.h"
 #include "icsneo/communication/message/versionmessage.h"
 #include "icsneo/communication/message/componentversionsmessage.h"
-#include "icsneo/communication/message/filter/extendedresponsefilter.h"
-#include "icsneo/communication/message/clientidmessage.h"
-#include "icsneo/communication/icspb.h"
-
-#include <commands/generic/v1/client_id.pb.h>
-#include <commands/network/v1/mutex.pb.h>
 
 using namespace icsneo;
 
@@ -319,32 +313,3 @@ std::optional< std::vector<ComponentVersion> > Communication::getComponentVersio
 
 	return std::make_optional< std::vector<ComponentVersion> >(std::move(ver->versions));
 }
-
-std::optional<uint32_t> Communication::getClientIDSync() {	
-	constexpr auto timeout = std::chrono::milliseconds(250);
-	commands::generic::v1::ClientId msg;
-	msg.Clear();
-
-	std::vector<uint8_t> payload = protoapi::getPayload(protoapi::Command::GET, msg);
-
-	std::shared_ptr<Message> response = waitForMessageSync(
-		[this, payload](){
-			return sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<MessageFilter>(Message::Type::ClientId),
-		timeout
-	);
-
-	if(!response) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	auto clientIdMessage = std::dynamic_pointer_cast<ClientIdMessage>(response);
-	if(!clientIdMessage) {
-		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	return clientIdMessage->clientId;
-}

communication/crc32.cpp

@@ -4,7 +4,8 @@
  *  Created on: Jun 22, 2020
  *      Author: BJones
  */
-#include "icsneo/core/crc32.h"
+#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,
@@ -31,7 +32,7 @@ static const unsigned long crc32_table[256] = { 0x00000000, 0x77073096, 0xEE0E61
 	0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E,
 	0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D };
 
-uint32_t icsneo::crc32(uint32_t crc, const unsigned char* buf, uint32_t len)
+uint32_t crc32(uint32_t crc, const unsigned char* buf, uint32_t len)
 {
 	unsigned char octet;
 	const unsigned char* p = buf;
@@ -49,13 +50,13 @@ static unsigned char rev_crc32_table[256];
 
 static void revgen(void)
 {
-	uint16_t k;
+	size_t k;
 
 	for (k = 0; k < 256; k++)
-		rev_crc32_table[crc32_table[k] >> 24] = (unsigned char)k;
+		rev_crc32_table[crc32_table[k] >> 24] = (uint8_t)k;
 }
 
-uint32_t icsneo::revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len)
+uint32_t revcrc32(uint32_t crc, const unsigned char* buf, uint32_t len)
 {
 	unsigned char k;
 	revgen();

communication/decoder.cpp

@@ -23,8 +23,6 @@
 #include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/apperrormessage.h"
 #include "icsneo/communication/message/ethernetstatusmessage.h"
-#include "icsneo/communication/message/networkmutexmessage.h"
-#include "icsneo/communication/message/clientidmessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -45,9 +43,6 @@
 #include "icsneo/communication/packet/genericbinarystatuspacket.h"
 #include "icsneo/communication/packet/livedatapacket.h"
 #include "icsneo/communication/packet/hardwareinfopacket.h"
-#include "icsneo/communication/packet/spipacket.h"
-#include "icsneo/communication/icspb.h"
-
 
 #include <iostream>
 
@@ -62,9 +57,8 @@ uint64_t Decoder::GetUInt64FromLEBytes(const uint8_t* bytes) {
 
 bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Packet>& packet) {
 	switch(packet->network.getType()) {
-		case Network::Type::Ethernet:
+		case Network::Type::Ethernet: {
-		case Network::Type::AutomotiveEthernet: {
+			result = HardwareEthernetPacket::DecodeToMessage(packet->data, report);
-			result = HardwareEthernetPacket::DecodeToMessage(packet->data);
 			if(!result) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false; // A nullptr was returned, the packet was not long enough to decode
@@ -190,19 +184,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.timestamp *= timestampResolution;
 			return true;
 		}
-		case Network::Type::SPI: {
-			result = HardwareSPIPacket::DecodeToMessage(packet->data);
-
-			if(!result) {
-				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-				return false; // A nullptr was returned, the packet was not long enough to decode
-			}
-
-			SPIMessage& msg = *static_cast<SPIMessage*>(result.get());
-			msg.network = packet->network;
-			msg.timestamp *= timestampResolution;
-			return true;
-		}
 		case Network::Type::MDIO: {
 			result = HardwareMDIOPacket::DecodeToMessage(packet->data);
 
@@ -278,7 +259,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						result = can;
 					}
 
-					result->timestamp = can->timestamp * timestampResolution;
+					result->timestamp *= timestampResolution;
 					return true;
 				}
 				case Network::NetID::DeviceStatus: {
@@ -326,15 +307,11 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::GenericBinaryInfo:
 							result = GenericBinaryStatusPacket::DecodeToMessage(packet->data);
 							return true;
-						case ExtendedCommand::SoftwareUpdate: {
-							result = std::make_shared<ExtendedResponseMessage>(ExtendedCommand::SoftwareUpdate, ExtendedResponse::OperationPending, packet->data);
-							return true;
-						}
 						case ExtendedCommand::GenericReturn: {
 							if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
 								break;
 							const auto& packedResp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
-							result = std::make_shared<ExtendedResponseMessage>(packedResp.command, packedResp.returnCode, packet->data);
+							result = std::make_shared<ExtendedResponseMessage>(packedResp.command, packedResp.returnCode);
 							return true;
 						}
 						case ExtendedCommand::LiveData:
@@ -347,36 +324,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 							result = GPTPStatus::DecodeToMessage(packet->data, report);
 							return true;
 						}
-						case ExtendedCommand::ProtobufAPI: {
-							// get the proto id
-							std::vector<uint8_t> responseBody(
-								packet->data.begin() + sizeof(ExtendedResponseMessage::ResponseHeader),
-								packet->data.end()
-							);
-							protoapi::Id protoId = protoapi::getProtoId(responseBody.data(), responseBody.size());
-							switch(protoId) {
-								case protoapi::Id::NetworkMutex:
-									result = NetworkMutexMessage::DecodeToMessage(responseBody);
-									return true;
-								case protoapi::Id::ClientId:
-									result = ClientIdMessage::DecodeToMessage(responseBody);
-									return true;
-								default:
-									report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-									return false;
-							}
-						}
-						case ExtendedCommand::GetDiskDetails:
-						case ExtendedCommand::DiskFormatProgress: {
-							std::vector<uint8_t> responseBody(
-								packet->data.begin() + sizeof(ExtendedResponseMessage::ResponseHeader),
-								packet->data.end()
-							);
-							auto response = std::make_shared<ExtendedResponseMessage>(resp.command);
-							response->data = std::move(responseBody);
-							result = response;
-							return true;
-						}
 						default:
 							// No defined handler, treat this as a RawMessage
 							break;

communication/driver.cpp

@@ -38,10 +38,18 @@ bool Driver::waitForRx(std::function<bool()> predicate, std::chrono::millisecond
 }
 
 bool Driver::readWait(std::vector<uint8_t>& bytes, std::chrono::milliseconds timeout, size_t limit) {
-	// wait until we have enough data, or the timeout occurs
+	// A limit of zero indicates no limit
+	if(limit == 0)
+		limit = (size_t)-1;
+
+	if(limit > (readBuffer.size() + 4))
+		limit = (readBuffer.size() + 4);
+
+
+	// wait until we have enough data, or the timout occurs
 	waitForRx(limit, timeout);
 
-	size_t actuallyRead = readBuffer.size();
+	size_t actuallyRead = std::min(readBuffer.size(), limit);
 	bytes.resize(actuallyRead);
 
 	readBuffer.read(bytes.data(), 0, actuallyRead);
@@ -71,12 +79,8 @@ bool Driver::write(const std::vector<uint8_t>& bytes) {
 
 	if(writeBlocks) {
 		if(writeQueueFull()) {
-			while(writeQueueAlmostFull() && !isDisconnected() && !isClosing()) // Wait until we have some decent amount of space
+			while(writeQueueAlmostFull()) // Wait until we have some decent amount of space
 				std::this_thread::sleep_for(std::chrono::milliseconds(10));
-			
-			if(isDisconnected() || isClosing()) {
-				return false;
-			}
 		}
 	} else {
 		if(writeQueueFull()) {

communication/encoder.cpp

@@ -13,7 +13,6 @@
 #include "icsneo/communication/packet/a2bpacket.h"
 #include "icsneo/communication/packet/linpacket.h"
 #include "icsneo/communication/packet/mdiopacket.h"
-#include "icsneo/communication/packet/spipacket.h"
 
 using namespace icsneo;
 
@@ -32,31 +31,19 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			netid = uint16_t(frame->network.getNetID());
 
 			switch(frame->network.getType()) {
-				case Network::Type::Ethernet:
+				case Network::Type::Ethernet: {
-				case Network::Type::AutomotiveEthernet: {
 					auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
 					if(!ethmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-						return false;
+						return false; // The message was not a properly formed EthernetMessage
 					}
 
-					shortFormat = false; // Ensure long-format RED header is added
-					netid = static_cast<uint16_t>(Network::NetID::ETHERNET_TX_WRAP);
 					buffer = &result;
-
+					if(!HardwareEthernetPacket::EncodeFromMessage(*ethmsg, result, report))
-					if(!HardwareEthernetPacket::EncodeFromMessage(*ethmsg, result, report)) {
-						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
 						return false;
-					}
-
-					if(result.empty()) {
-						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-						return false;
-					}
 
 					break;
-				}
+				} // End of Network::Type::Ethernet
-				case Network::Type::Internal:
 				case Network::Type::CAN:
 				case Network::Type::SWCAN:
 				case Network::Type::LSFTCAN: {
@@ -136,17 +123,6 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::MDIO
-				case Network::Type::SPI: {
-					auto msg = std::dynamic_pointer_cast<SPIMessage>(message);
-					if(!msg) {
-						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-						return false; // The message was not a properly formed LiveDataMessage
-					}
-					if(!HardwareSPIPacket::EncodeFromMessage(*msg, result, report))
-						return false;
-					result = packetizer.packetWrap(result, false);
-					return true;
-				} // End of Network::Type::SPI
 				default:
 					report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
 					return false;
@@ -254,6 +230,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			(uint8_t)(netid >> 8)
 		});
 	}
+
 	result = packetizer.packetWrap(*buffer, shortFormat);
 	return true;
 }
@@ -285,7 +262,6 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			case Command::RequestSerialNumber:
 			case Command::EnableNetworkCommunication:
 			case Command::EnableNetworkCommunicationEx:
-			case Command::KeepAlive:
 			case Command::GetMainVersion:
 			case Command::GetSecondaryVersions:
 			case Command::NeoReadMemory:

communication/livedata.cpp

@@ -1,5 +1,4 @@
 #include "icsneo/communication/livedata.h"
-#include <cmath>
 namespace icsneo {
 
 namespace LiveDataUtil {
@@ -19,8 +18,7 @@ double liveDataValueToDouble(const LiveDataValue& val) {
 	return val.value * liveDataFixedPointToDouble; 
 } 
 
-std::optional<LiveDataValue> liveDataDoubleToValue(const double& dFloat) {
+int liveDataDoubleToValue(LiveDataValue& value, const double& dFloat) {
-	LiveDataValue value;
 	union {
 		struct
 		{
@@ -42,38 +40,36 @@ std::optional<LiveDataValue> liveDataDoubleToValue(const double& dFloat) {
 	// 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)
+	if (dFloat < 0.0)
-		intPart = (int32_t)std::floor(dFloat);
+		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)std::floor((frac * CM_DOUBLEVALUE_TO_FIXED_POINT) + 0.5);
+	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)
+	if (dFloat == (double)0.0)
-		return value;
+		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 || dFloat < INT32_MIN_DOUBLE) {
+	if (dFloat > INT32_MAX_DOUBLE)
-		EventManager::GetInstance().add(APIEvent::Type::FixedPointOverflow, APIEvent::Severity::Error);
+		return 1;
-		return std::nullopt;
+	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) {
+	if (absFloat < MIN_FIXED_POINT_DOUBLE)
-		EventManager::GetInstance().add(APIEvent::Type::FixedPointPrecision, APIEvent::Severity::Error);
+		return -2;
-		return std::nullopt;
-	}
 
-	return value;
+	return 0;
 }
 
 } // namespace LiveDataUtil

communication/message/clientidmessage.cpp

@@ -1,21 +0,0 @@
-#include "icsneo/communication/message/clientidmessage.h"
-#include "icsneo/communication/icspb.h"
-#include "icsneo/communication/command.h"
-#include "icsneo/communication/message/extendedresponsemessage.h"
-
-using namespace icsneo;
-
-std::shared_ptr<ClientIdMessage> ClientIdMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	ClientIdMessage decoded;
-	commands::generic::v1::ClientId msg;
-
-	if(!protoapi::processResponse(bytestream.data(), bytestream.size(), msg)) {
-		return nullptr;
-	}
-
-	if(msg.has_client_id()) {
-		decoded.clientId.emplace(msg.client_id());
-	}
-
-	return std::make_shared<ClientIdMessage>(decoded);
-}

communication/message/ethernetstatusmessage.cpp

@@ -13,15 +13,7 @@ enum LinkSpeed {
 	ethSpeed10000,
 };
 
-enum TLinkMode {
+enum LinkMode {
-	T_LINK_NONE,
-	T_LINK_MASTER,
-	T_LINK_SLAVE,
-	T_LINK_AUTO,
-	T_LINK_INVALID = 255,
-};
-
-enum AELinkMode {
 	AE_LINK_AUTO,
 	AE_LINK_MASTER,
 	AE_LINK_SLAVE,
@@ -54,26 +46,11 @@ std::shared_ptr<Message> EthernetStatusMessage::DecodeToMessage(const std::vecto
 		default: return nullptr;
 	}
 	LinkMode mode;
-	switch(Network::GetTypeOfNetID((Network::NetID)packet->network, false)) {
+	switch(packet->mode) {
-		case Network::Type::Ethernet:
+		case AE_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
-			switch(packet->mode) {
+		case AE_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
-				case T_LINK_NONE: mode = EthernetStatusMessage::LinkMode::LinkModeNone; break;
+		case AE_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
-				case T_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
+		case AE_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
-				case T_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
-				case T_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
-				case T_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
-				default: return nullptr;
-			}
-			break;
-		case Network::Type::AutomotiveEthernet:
-			switch(packet->mode) {
-				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;
-				case AE_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
-				default: return nullptr;
-			}
-			break;
 		default: return nullptr;
 	}
 	return std::make_shared<EthernetStatusMessage>(packet->network, packet->state, speed, packet->duplex, mode);

communication/message/ethphymessage.cpp

@@ -8,7 +8,7 @@ bool EthPhyMessage::appendPhyMessage(bool writeEnable, bool clause45, uint8_t ph
 	msg->Clause45Enable = clause45;
 	msg->Enabled = enabled;
 	msg->WriteEnable = writeEnable;
-	msg->Version = 1u;
+	msg->version = 1u;
 	if( (FiveBits < phyAddrOrPort) ||
 		(clause45 && (FiveBits < pageOrDevice)) ||
 		(!clause45 && (FiveBits < regAddr)) )
@@ -18,17 +18,17 @@ bool EthPhyMessage::appendPhyMessage(bool writeEnable, bool clause45, uint8_t ph
 
 	if(clause45)
 	{
-		msg->Clause45.port    = phyAddrOrPort;
+		msg->clause45.port    = phyAddrOrPort;
-		msg->Clause45.device  = pageOrDevice;
+		msg->clause45.device  = pageOrDevice;
-		msg->Clause45.regAddr = regAddr;
+		msg->clause45.regAddr = regAddr;
-		msg->Clause45.regVal  = regVal;
+		msg->clause45.regVal  = regVal;
 	}
 	else
 	{
-		msg->Clause22.phyAddr = phyAddrOrPort;
+		msg->clause22.phyAddr = phyAddrOrPort;
-		msg->Clause22.page    = pageOrDevice;
+		msg->clause22.page    = pageOrDevice;
-		msg->Clause22.regAddr = regAddr;
+		msg->clause22.regAddr = regAddr;
-		msg->Clause22.regVal  = regVal;
+		msg->clause22.regVal  = regVal;
 	}
 	return appendPhyMessage(msg);
 }

communication/message/flexray/control/flexraycontrolmessage.cpp

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

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

@@ -44,11 +44,10 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				can.status.canfdESI = canmsg->errorStateIndicator;
 				break;
 			}
-			case Network::Type::Ethernet:
+			case Network::Type::Ethernet: {
-			case Network::Type::AutomotiveEthernet: {
 				neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg;
 				auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
-				eth.preemptionFlags = ethmsg->preemptionFlags.value_or(0);
+				eth.preemptionFlags = ethmsg->preemptionFlags;
 				eth.status.incompleteFrame = ethmsg->frameTooShort;
 				// TODO Fill in extra status bits
 				//eth.status.xyz = ethmsg->preemptionEnabled;
@@ -143,8 +142,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 					canmsg->errorStateIndicator = can.status.canfdESI;
 					return canmsg;
 				}
-				case Network::Type::Ethernet:
+				case Network::Type::Ethernet: {
-				case Network::Type::AutomotiveEthernet: {
 					neomessage_eth_t& eth = *(neomessage_eth_t*)neomessage;
 					auto ethmsg = std::make_shared<EthernetMessage>();
 					ethmsg->network = network;

communication/message/networkmutexmessage.cpp

@@ -1,89 +0,0 @@
-#include "icsneo/communication/message/networkmutexmessage.h"
-#include "icsneo/communication/icspb.h"
-#include "icsneo/communication/command.h"
-#include "icsneo/communication/message/extendedresponsemessage.h"
-
-
-using namespace icsneo;
-
-std::shared_ptr<NetworkMutexMessage> NetworkMutexMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	NetworkMutexMessage decoded;
-	commands::network::v1::NetworkMutex msg;
-
-	if(!protoapi::processResponse(bytestream.data(), bytestream.size(), msg)) {
-		return nullptr;
-	}
-
-	if(msg.has_client_id()) {
-		decoded.owner_id.emplace(msg.client_id());
-	}
-	if(msg.has_type()) {
-		decoded.type.emplace(static_cast<NetworkMutexType>(msg.type()));
-	}
-	if(msg.has_priority()) {
-		decoded.priority.emplace(msg.priority());
-	}
-	if(msg.has_ttl()){
-		decoded.ttlMs.emplace(msg.ttl());
-	}
-	if(msg.has_event()){
-		decoded.event.emplace(static_cast<NetworkMutexEvent>(msg.event()));
-	}
-	for(int i = 0 ; i < msg.network_ids_size(); ++i){
-		decoded.networks.emplace(static_cast<Network::NetID>(msg.network_ids(i)));
-	}
-	return std::make_shared<NetworkMutexMessage>(decoded);
-}
-
-std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForLock(uint32_t client_id, NetworkMutexType type, uint32_t priority, uint32_t ttlMs, const std::set<Network::NetID>& networks, const device_eventhandler_t& /* report */) {
-	commands::network::v1::NetworkMutex msg;
-	for(auto&& network_id : networks) {
-		msg.add_network_ids(static_cast<commands::network::v1::NetworkId>(network_id));
-	}
-	msg.set_client_id(client_id);
-	msg.set_priority(priority);
-	msg.set_ttl(ttlMs);
-	msg.set_type(static_cast<commands::network::v1::MutexType>(type));
-
-	return protoapi::getPayload(protoapi::Command::PUT, msg);
-}
-
-std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForLockAll(uint32_t client_id, NetworkMutexType type, uint32_t priority, uint32_t ttlMs, const device_eventhandler_t& /* report */) {
-	commands::network::v1::NetworkMutex msg;
-	msg.set_client_id(client_id);
-	msg.set_priority(priority);
-	msg.set_ttl(ttlMs);
-	msg.set_type(static_cast<commands::network::v1::MutexType>(type));
-	msg.set_global(true);
-
-	return protoapi::getPayload(protoapi::Command::PUT, msg);
-}
-
-std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForUnlock(uint32_t client_id, const std::set<Network::NetID>& networks, const device_eventhandler_t& /* report */) {
-	commands::network::v1::NetworkMutex msg;
-	msg.Clear();
-	for(auto&& network_id : networks)
-	{
-		msg.add_network_ids(static_cast<commands::network::v1::NetworkId>(network_id));
-	}
-	msg.set_client_id(client_id);
-	msg.set_release(true);
-
-	return protoapi::getPayload(protoapi::Command::PUT, msg);
-}
-
-std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForUnlockAll(uint32_t client_id, const device_eventhandler_t& /* report */) {
-	commands::network::v1::NetworkMutex msg;
-	msg.Clear();
-	msg.set_client_id(client_id);
-	msg.set_release(true);
-	msg.set_global(true);
-
-	return protoapi::getPayload(protoapi::Command::PUT, msg);
-}
-
-std::vector<uint8_t> NetworkMutexMessage::EncodeArgumentsForStatus(Network::NetID network, const device_eventhandler_t& /* report */) {
-	commands::network::v1::NetworkMutex msg;
-	msg.add_network_ids(static_cast<commands::network::v1::NetworkId>(network));
-	return protoapi::getPayload(protoapi::Command::GET, msg);
-}

communication/message/transmitmessage.cpp

@@ -1,201 +0,0 @@
-#include "icsneo/communication/message/transmitmessage.h"
-
-// packet defs
-#include "icsneo/communication/packet/ethernetpacket.h"
-#include "icsneo/communication/packet/canpacket.h"
-#include "icsneo/communication/packet/linpacket.h"
-
-using namespace icsneo;
-
-static std::vector<uint8_t> EncodeFromMessageEthernet(std::shared_ptr<Frame> frame, const device_eventhandler_t& report) {
-	auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(frame);
-	if(!ethmsg) {
-		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-		return {};
-	}
-	std::vector<uint8_t> encoded;
-	size_t messageLen = ethmsg->data.size();
-	encoded.resize(sizeof(TransmitMessage) + messageLen);
-
-	TransmitMessage* const msg = (TransmitMessage*)encoded.data();
-	HardwareEthernetPacket* const ethpacket = (HardwareEthernetPacket*)(msg->commonHeader);
-	uint8_t* const payload = encoded.data() + sizeof(TransmitMessage);
-
-	ethpacket->header.ENABLE_PADDING = ethmsg->noPadding ? 0 : 1;
-	ethpacket->header.FCS_OVERRIDE = ethmsg->fcs ? 1 : 0;
-	ethpacket->eid.txlen = static_cast<uint16_t>(messageLen);
-	ethpacket->Length = static_cast<uint16_t>(messageLen);
-	ethpacket->stats = ethmsg->description;
-	ethpacket->NetworkID = static_cast<uint16_t>(ethmsg->network.getNetID());
-	std::copy(ethmsg->data.begin(), ethmsg->data.end(), payload);
-	return encoded;
-}
-
-static std::vector<uint8_t> EncodeFromMessageCAN(std::shared_ptr<Frame> frame, const device_eventhandler_t& report) {
-	auto canmsg = std::dynamic_pointer_cast<CANMessage>(frame);
-	if(!canmsg) {
-		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-		return {};
-	}
-	if(canmsg->isCANFD && canmsg->isRemote) {
-		report(APIEvent::Type::RTRNotSupported, APIEvent::Severity::Error);
-		return {}; // RTR frames can not be used with CAN FD
-	}
-	std::vector<uint8_t> encoded;
-	size_t messageLen = canmsg->data.size();
-	size_t extraLen = 0;
-	if(messageLen > 8) {
-		extraLen = messageLen - 8;
-	}
-	encoded.resize(sizeof(TransmitMessage) + extraLen);
-
-	TransmitMessage* const msg = (TransmitMessage*)encoded.data();
-	HardwareCANPacket* const canpacket = (HardwareCANPacket*)(msg->commonHeader);
-	uint8_t* const extra_payload = encoded.data() + sizeof(TransmitMessage);
-
-	const size_t dataSize = canmsg->data.size();
-	std::optional<uint8_t> dlc = CAN_LengthToDLC(dataSize, canmsg->isCANFD);
-	if(!dlc.has_value()) {
-		report(APIEvent::Type::MessageMaxLengthExceeded, APIEvent::Severity::Error);
-		return {}; // Too much data for the protocol
-	}
-	// arb id
-	if(canmsg->isExtended) {
-		canpacket->header.IDE = 1;
-		canpacket->header.SID = (canmsg->arbid >> 18) & 0x7FF;
-		canpacket->eid.EID = (canmsg->arbid >> 6) & 0xfff;
-		canpacket->dlc.EID2 = canmsg->arbid & 0x3f;
-	} else {
-		canpacket->header.IDE = 0;
-		canpacket->header.SID = canmsg->arbid & 0x7FF;
-	}
-
-	// DLC
-	canpacket->dlc.DLC = dlc.value();
-
-	// FDF/BRS or remote frames
-	if(canmsg->isCANFD) {
-		canpacket->header.EDL = 1;
-		canpacket->header.BRS = canmsg->baudrateSwitch ? 1 : 0;
-		canpacket->header.ESI = canmsg->errorStateIndicator ? 1 : 0;
-		canpacket->dlc.RTR = 0;
-		canpacket->timestamp.IsExtended = 1;
-
-	} else {
-		canpacket->header.EDL = 0;
-		canpacket->header.BRS = 0;
-		canpacket->header.ESI = 0;
-		canpacket->dlc.RTR = canmsg->isRemote ? 1 : 0;
-	}
-	// network
-	canpacket->NetworkID = static_cast<uint16_t>(canmsg->network.getNetID());
-	canpacket->Length = static_cast<uint16_t>(extraLen);
-	// description id
-	canpacket->stats = canmsg->description;
-	// first 8 bytes
-	std::copy(canmsg->data.begin(), canmsg->data.begin() + (messageLen > 8 ? 8 : messageLen), canpacket->data);
-	// extra bytes
-	if(extraLen > 0) {
-		// copy extra data after the can packet
-		std::copy(canmsg->data.begin() + 8, canmsg->data.end(), extra_payload);
-	}
-	return encoded;
-}
-
-static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> frame, const device_eventhandler_t& report) {
-	auto linmsg = std::dynamic_pointer_cast<LINMessage>(frame);
-	if(!linmsg) {
-		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-		return {};
-	}
-	if(linmsg->linMsgType == LINMessage::Type::NOT_SET) {
-		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
-		return {};
-	}
-
-	size_t dataLen = std::min<size_t>(8, linmsg->data.size());
-	std::vector<uint8_t> encoded;
-	encoded.resize(sizeof(TransmitMessage));
-
-	TransmitMessage* const msg = (TransmitMessage*)encoded.data();
-	HardwareLINPacket* const linpacket = (HardwareLINPacket*)(msg->commonHeader);
-	memset(linpacket, 0, sizeof(HardwareLINPacket));
-
-	// Protected ID and ID
-	linmsg->protectedID = linmsg->calcProtectedID(linmsg->ID);
-	linpacket->CoreMiniBitsLIN.ID = linmsg->protectedID & 0x3F;
-
-	// LIN message type flags
-	switch(linmsg->linMsgType) {
-		case LINMessage::Type::LIN_COMMANDER_MSG:
-			linpacket->CoreMiniBitsLIN.TXCommander = 1;
-			break;
-		case LINMessage::Type::LIN_HEADER_ONLY:
-			linpacket->CoreMiniBitsLIN.TXCommander = 1;
-			break;
-		case LINMessage::Type::LIN_UPDATE_RESPONDER:
-			linpacket->CoreMiniBitsLIN.TXResponder = 1;
-			break;
-		case LINMessage::Type::LIN_BREAK_ONLY:
-			linpacket->CoreMiniBitsLIN.BreakOnly = 1;
-			break;
-		default:
-			break;
-	}
-
-	// Enhanced checksum
-	linpacket->CoreMiniBitsLIN.TxChkSumEnhanced = linmsg->isEnhancedChecksum ? 1 : 0;
-
-	// Data and checksum
-	bool hasData = (linmsg->linMsgType == LINMessage::Type::LIN_COMMANDER_MSG ||
-	                linmsg->linMsgType == LINMessage::Type::LIN_UPDATE_RESPONDER) && dataLen > 0;
-
-	if(hasData) {
-		// len includes data bytes + 1 checksum byte
-		linpacket->CoreMiniBitsLIN.len = static_cast<uint16_t>(dataLen + 1);
-		std::copy(linmsg->data.begin(), linmsg->data.begin() + dataLen, linpacket->data);
-		// Checksum goes after data: in data[dataLen] if < 8, otherwise in LINByte9
-		if(dataLen < 8)
-			linpacket->data[dataLen] = linmsg->checksum;
-		else
-			linpacket->CoreMiniBitsLIN.LINByte9 = linmsg->checksum;
-	} else {
-		linpacket->CoreMiniBitsLIN.len = 0;
-	}
-
-	// Description/stats and network
-	linpacket->stats = linmsg->description;
-
-	return encoded;
-}
-
-std::vector<uint8_t> TransmitMessage::EncodeFromMessage(std::shared_ptr<Frame> frame, uint32_t client_id, const device_eventhandler_t& report) {
-	std::vector<uint8_t> result;
-	switch(frame->network.getType()) {
-		case Network::Type::Ethernet:
-		case Network::Type::AutomotiveEthernet:
-			result = EncodeFromMessageEthernet(frame, report);
-			break;
-		case Network::Type::Internal:
-		case Network::Type::CAN:
-			result = EncodeFromMessageCAN(frame, report);
-			break;
-		case Network::Type::LIN:
-			result = EncodeFromMessageLIN(frame, report);
-			break;
-		default:
-			report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
-			return result;
-	}
-	// common fields
-	if(result.empty())
-		return result;
-	TransmitMessage* const msg = (TransmitMessage*)result.data();
-	msg->options.clientId = client_id;
-	msg->options.networkId = static_cast<uint32_t>(frame->network.getNetID());
-	msg->options.reserved[0] = 0;
-	msg->options.reserved[1] = 0;
-	msg->options.reserved[2] = 0;
-
-	return result;
-}

communication/multichannelcommunication.cpp

@@ -9,7 +9,7 @@ using namespace icsneo;
 MultiChannelCommunication::MultiChannelCommunication(device_eventhandler_t err, std::unique_ptr<Driver> com,
 	std::function<std::unique_ptr<Packetizer>()> makeConfiguredPacketizer, std::unique_ptr<Encoder> e,
 	std::unique_ptr<Decoder> md, size_t vnetCount) :
-	Communication(err, std::move(com), makeConfiguredPacketizer, std::move(e), std::move(md)), numVnets(vnetCount), packetRB(2048) {
+	Communication(err, std::move(com), makeConfiguredPacketizer, std::move(e), std::move(md)), numVnets(vnetCount) {
 	vnetThreads.resize(numVnets);
 	vnetQueues.resize(numVnets);
 }
@@ -24,7 +24,6 @@ void MultiChannelCommunication::spawnThreads() {
 
 void MultiChannelCommunication::joinThreads() {
 	closing = true;
-	ringBufCV.notify_all();
 	if(hidReadThread.joinable())
 		hidReadThread.join();
 	for(auto& thread : vnetThreads) {
@@ -149,13 +148,9 @@ void MultiChannelCommunication::hidReadTask() {
 						break;
 					}
 
-                    {
+					if(!currentQueue->enqueue(std::move(payloadBytes)) && gotPacket)
-                        std::unique_lock lk(ringBufMutex);
+						EventManager::GetInstance().add(APIEvent(APIEvent::Type::FailedToRead, APIEvent::Severity::Error));
-                        if(!packetRB.write(std::move(payloadBytes)) && gotPacket)
+					payloadBytes.clear();
-                            EventManager::GetInstance().add(APIEvent(APIEvent::Type::FailedToRead, APIEvent::Severity::Error));
-                        payloadBytes.clear();
-                    }
-                    ringBufCV.notify_all();
 					gotPacket = true;
 					state = PreprocessState::SearchForCommand;
 					break;
@@ -165,6 +160,7 @@ void MultiChannelCommunication::hidReadTask() {
 }
 
 void MultiChannelCommunication::vnetReadTask(size_t vnetIndex) {
+	moodycamel::BlockingReaderWriterQueue< std::vector<uint8_t> >& queue = vnetQueues[vnetIndex];
 	std::vector<uint8_t> payloadBytes;
 	std::unique_ptr<Packetizer> packetizerLifetime;
 	Packetizer* vnetPacketizer;
@@ -178,19 +174,14 @@ void MultiChannelCommunication::vnetReadTask(size_t vnetIndex) {
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
 
 	while(!closing) {
-        std::unique_lock lk(ringBufMutex);
+		if(queue.wait_dequeue_timed(payloadBytes, std::chrono::milliseconds(250))) {
-        ringBufCV.wait(lk);
+			if(closing)
-		if(closing) {
+				break;
-			break;
-		}
-        if(vnetPacketizer->input(packetRB)) {
-            for(const auto& packet : vnetPacketizer->output()) {
-                std::shared_ptr<Message> msg;
-                if(!decoder->decode(msg, packet))
-                    continue;
 
-                dispatchMessage(msg);
+			auto& ringBuffer = driver->getReadBuffer();
-            }
+			ringBuffer.write(payloadBytes);
-        }
+
+			handleInput(*vnetPacketizer);
+		}
 	}
 }

communication/packet/canpacket.cpp

@@ -29,7 +29,8 @@ static std::optional<uint8_t> CAN_DLCToLength(uint8_t length, bool fd) {
 	return std::nullopt;
 }
 
-std::optional<uint8_t> icsneo::CAN_LengthToDLC(size_t dataLength, bool fd) {
+static std::optional<uint8_t> CAN_LengthToDLC(size_t dataLength, bool fd)
+{
 	if (dataLength <= 8)
 		return uint8_t(dataLength);
 
@@ -113,18 +114,13 @@ std::shared_ptr<Message> HardwareCANPacket::DecodeToMessage(const std::vector<ui
 			msg->data.insert(msg->data.end(), data->data, data->data + (length > 8 ? 8 : length));
 			if(length > 8) { // If there are more than 8 bytes, they come at the end of the message
 				// Messages with extra data are formatted as message, then uint16_t netid, then uint16_t length, then extra data
-				const auto extraDataStart = bytestream.begin() + sizeof(HardwareCANPacket);
+				const auto extraDataStart = bytestream.begin() + sizeof(HardwareCANPacket) + 2 + 2;
 				msg->data.insert(msg->data.end(), extraDataStart, extraDataStart + (length - 8));
 			}
 		}
 
 		msg->transmitted = data->eid.TXMSG;
-		// Set the generic frame error state
 		msg->error = data->eid.TXAborted || data->eid.TXError || data->eid.TXLostArb;
-		// Set specific error states for CANError
-		msg->txAborted = data->eid.TXAborted;
-		msg->txLostArb = data->eid.TXLostArb;
-		msg->txError = data->eid.TXError;
 		msg->description = data->stats;
 
 		return msg;

communication/packet/ethernetpacket.cpp

@@ -1,63 +1,54 @@
 #include "icsneo/communication/packet/ethernetpacket.h"
-#include <algorithm>
+#include <cstring> // memcpy
 #include <iostream>
-#include <optional>
 
 using namespace icsneo;
 
-std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const std::vector<uint8_t>& bytestream, const device_eventhandler_t& report) {
 	const HardwareEthernetPacket* packet = (const HardwareEthernetPacket*)((const void*)bytestream.data());
 	const uint16_t* rawWords = (const uint16_t*)bytestream.data();
+	
 	// Make sure we have enough to read the packet length first
 	if(bytestream.size() < sizeof(HardwareEthernetPacket))
 		return nullptr;
-	const size_t fcsSize = packet->header.FCS_AVAIL ? 4 : 0;
+
-	// Ensure Length is sufficient for FCS extraction to avoid invalid iterator arithmetic
+	// packet->Length will also encompass the two uint16_t's at the end of the struct, make sure that at least they are here
-	if(packet->Length < fcsSize)
+	if(packet->Length < 4)
 		return nullptr;
+	
+	const size_t fcsSize = packet->header.FCS_AVAIL ? 4 : 0;
 	const size_t bytestreamExpectedSize = sizeof(HardwareEthernetPacket) + packet->Length;
 	const size_t bytestreamActualSize = bytestream.size();
 	if(bytestreamActualSize < bytestreamExpectedSize)
 		return nullptr;
+
+	// Check for oversized packets, noting that some devices will send an extra byte to have an even number of bytes
+	if(bytestreamActualSize > bytestreamExpectedSize + 1)
+		report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::EventWarning);
+
 	auto messagePtr = std::make_shared<EthernetMessage>();
 	EthernetMessage& message = *messagePtr;
-	// Standard Ethernet fields
+
 	message.transmitted = packet->eid.TXMSG;
 	if(message.transmitted)
 		message.description = packet->stats;
-	message.frameTooShort = packet->header.RUNT_FRAME;
-	message.noPadding = !packet->header.ENABLE_PADDING;
-	message.fcsVerified = packet->header.FCS_VERIFIED;
-	message.txAborted = packet->eid.TXAborted;
-	message.crcError = packet->header.CRC_ERROR;
 
+	message.preemptionEnabled = packet->header.PREEMPTION_ENABLED;
+	if(message.preemptionEnabled)
+		message.preemptionFlags = (uint8_t)((rawWords[0] & 0x03F8) >> 4);
+
+	message.frameTooShort = packet->header.RUNT_FRAME;
 	if(message.frameTooShort)
 		message.error = true;
+
 	// This timestamp is raw off the device (in timestampResolution increments)
 	// Decoder will fix as it has information about the timestampResolution increments
 	message.timestamp = packet->timestamp.TS;
 
-	// Ethernet Frame Preemption for TSN
-	if(packet->header.PREEMPTION_ENABLED) {
-		message.preemptionFlags = static_cast<uint8_t>((rawWords[0] & 0x03F8) >> 4);
-	}
-
-	// Check if this is a T1S packet and populate T1S-specific fields
-	if(packet->header.T1S_ETHERNET) {
-		auto& t1s = message.t1s.emplace();
-
-		t1s.isSymbol = packet->eid.T1S_SYMBOL;
-		t1s.isBurst = packet->eid.T1S_BURST;
-		t1s.txCollision = packet->t1s_status.TXCollision;
-		t1s.isWake = packet->t1s_status.T1SWake;
-		t1s.nodeId = packet->t1s_node.T1S_NODE_ID;
-		t1s.burstCount = packet->t1s_node.T1S_BURST_COUNT;
-	}
-
 	const std::vector<uint8_t>::const_iterator databegin = bytestream.begin() + sizeof(HardwareEthernetPacket);
 	const std::vector<uint8_t>::const_iterator dataend = databegin + packet->Length - fcsSize;
 	message.data.insert(message.data.begin(), databegin, dataend);
-
+	
 	if(fcsSize) {
 		uint32_t& fcs = message.fcs.emplace();
 		std::copy(dataend, dataend + fcsSize, (uint8_t*)&fcs);
@@ -68,86 +59,41 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 
 bool HardwareEthernetPacket::EncodeFromMessage(const EthernetMessage& message, std::vector<uint8_t>& bytestream, const device_eventhandler_t&) {
 	const size_t unpaddedSize = message.data.size();
-	if(unpaddedSize == 0)
+	size_t paddedSize = unpaddedSize;
-		return false;
+	uint16_t description = message.description;
+
+	if(!message.noPadding && unpaddedSize < 60)
+		paddedSize = 60; // Pad out short messages
+
+	size_t sizeWithHeader = paddedSize + 4; // DescriptionID and Padded Count
 
 	// Description ID Most Significant bit is used to identify preemption frames
-	uint16_t description = message.description;
 	if(description & 0x8000)
 		return false;
 
-	const bool preempt = message.preemptionFlags.has_value();
+	if(message.preemptionEnabled) {
-	// full header including parent
+		sizeWithHeader++; // Make space for the preemption flags
-	const size_t headerByteCount = preempt ? 15 : 14;
-	// local header for netID, description, and flags
-	const size_t localHeader = preempt ? 10 : 9;
-	// allocate space for fcs override
-	const size_t fcsSize = message.fcs ? 4 : 0;
-
-	if(preempt)
 		description |= 0x8000;
-
-	size_t paddedSize = unpaddedSize;
-	if(!message.noPadding && unpaddedSize < 60)
-		paddedSize = 60;
-
-	// size of full payload including optional fcs
-	size_t payloadSize = paddedSize + fcsSize;
-
-
-	// totalBufferSize is local header + ethernet payload and option fcs
-	const size_t totalBufferSize = localHeader + paddedSize + fcsSize;
-
-	bytestream.clear();
-	bytestream.reserve(totalBufferSize);
-
-	// Header size field (little endian)
-	bytestream.push_back(static_cast<uint8_t>(payloadSize & 0xFF));
-	bytestream.push_back(static_cast<uint8_t>((payloadSize >> 8) & 0xFF));
-
-	// Description (big endian)
-	bytestream.push_back(static_cast<uint8_t>(description >> 8));
-	bytestream.push_back(static_cast<uint8_t>(description));
-
-	bytestream.push_back(0x00);
-	bytestream.push_back(static_cast<uint8_t>(headerByteCount));
-
-	// Network ID (little endian)
-	uint16_t realID = static_cast<uint16_t>(message.network.getNetID());
-	bytestream.push_back(static_cast<uint8_t>(realID & 0xFF));
-	bytestream.push_back(static_cast<uint8_t>((realID >> 8) & 0xFF));
-
-	// Flags
-	constexpr uint8_t FLAG_PADDING = 0x01;
-	constexpr uint8_t FLAG_FCS = 0x04;
-	constexpr uint8_t FLAG_PREEMPTION = 0x08;
-
-	uint8_t flags = 0x00;
-	if(!message.noPadding) flags |= FLAG_PADDING;
-	if(message.fcs) flags |= FLAG_FCS;
-	if(message.preemptionFlags.has_value()) {
-		flags |= FLAG_PREEMPTION;
 	}
+	
+	bytestream.reserve(sizeWithHeader + 8); // Also reserve space for the bytes we'll use later on
+	bytestream.resize(sizeWithHeader);
+	size_t index = 0;
 
-	bytestream.push_back(flags);
+	// Padded size, little endian
+	bytestream[index++] = uint8_t(paddedSize);
+	bytestream[index++] = uint8_t(paddedSize >> 8);
 
-	if(preempt) {
+	// Description ID, big endian
-		bytestream.push_back(message.preemptionFlags.value());
+	bytestream[index++] = uint8_t(description >> 8);
-	}
+	bytestream[index++] = uint8_t(description);
 
-	bytestream.insert(bytestream.end(), message.data.begin(), message.data.end());
+	// The header is one byte larger if preemption is enabled, shifting the data
+	if(message.preemptionEnabled)
+		bytestream[index++] = message.preemptionFlags;
 
-	// Only zero-fill when we want padding
+	// We only copy in the unpadded size, the rest will be 0
-	if(!message.noPadding && unpaddedSize < 60) {
+	memcpy(bytestream.data() + index, message.data.data(), unpaddedSize);
-		size_t paddingNeeded = 60 - unpaddedSize;
-		bytestream.insert(bytestream.end(), paddingNeeded, 0); // Zero-fill for padding
-	}
-
-	if(message.fcs) {
-		uint32_t fcs = message.fcs.value();
-		const uint8_t* fcsBytes = reinterpret_cast<const uint8_t*>(&fcs);
-		bytestream.insert(bytestream.end(), fcsBytes, fcsBytes + sizeof(fcs));
-	}
 
 	return true;
-}
+}

communication/packet/ethphyregpacket.cpp

@@ -34,12 +34,11 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 			phyMessage->Enabled = (pEntry->Enabled != 0u);
 			phyMessage->WriteEnable = (pEntry->WriteEnable != 0u);
 			phyMessage->Clause45Enable = (pEntry->Clause45Enable != 0u);
-			phyMessage->BusIndex = static_cast<uint8_t>(pEntry->BusIndex);
+			phyMessage->version = static_cast<uint8_t>(pEntry->version);
-			phyMessage->Version = static_cast<uint8_t>(pEntry->version);
 			if(phyMessage->Clause45Enable)
-				phyMessage->Clause45 = pEntry->clause45;
+				phyMessage->clause45 = pEntry->clause45;
 			else
-				phyMessage->Clause22 = pEntry->clause22;
+				phyMessage->clause22 = pEntry->clause22;
 			msg->messages.push_back(phyMessage);
 		}
 	}
@@ -70,35 +69,34 @@ bool HardwareEthernetPhyRegisterPacket::EncodeFromMessage(const EthPhyMessage& m
 		PhyRegisterPacket_t tempPacket;
 		tempPacket.Enabled = phyMessage->Enabled ? 0x1u : 0x0u;
 		tempPacket.WriteEnable = phyMessage->WriteEnable ? 0x1u : 0x0u;
-		tempPacket.BusIndex = (phyMessage->BusIndex & 0xF);
+		tempPacket.version = (phyMessage->version & 0xF);
-		tempPacket.version = (phyMessage->Version & 0xF);
 		if(phyMessage->Clause45Enable)
 		{
-			if( (FiveBits < phyMessage->Clause45.port) ||
+			if( (FiveBits < phyMessage->clause45.port) ||
-				(FiveBits < phyMessage->Clause45.device) )
+				(FiveBits < phyMessage->clause45.device) )
 			{
 				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
 				return false;
 			}
 			tempPacket.Clause45Enable = 0x1u;
-			tempPacket.clause45.port = phyMessage->Clause45.port;
+			tempPacket.clause45.port = phyMessage->clause45.port;
-			tempPacket.clause45.device = phyMessage->Clause45.device;
+			tempPacket.clause45.device = phyMessage->clause45.device;
-			tempPacket.clause45.regAddr = phyMessage->Clause45.regAddr;
+			tempPacket.clause45.regAddr = phyMessage->clause45.regAddr;
-			tempPacket.clause45.regVal = phyMessage->Clause45.regVal;
+			tempPacket.clause45.regVal = phyMessage->clause45.regVal;
 		}
 		else
 		{
-			if( (FiveBits < phyMessage->Clause22.phyAddr) ||
+			if( (FiveBits < phyMessage->clause22.phyAddr) ||
-				(FiveBits < phyMessage->Clause22.regAddr) )
+				(FiveBits < phyMessage->clause22.regAddr) )
 			{
 				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
 				return false;
 			}
 			tempPacket.Clause45Enable = 0x0u;
-			tempPacket.clause22.phyAddr = phyMessage->Clause22.phyAddr;
+			tempPacket.clause22.phyAddr = phyMessage->clause22.phyAddr;
-			tempPacket.clause22.page = phyMessage->Clause22.page;
+			tempPacket.clause22.page = phyMessage->clause22.page;
-			tempPacket.clause22.regAddr = phyMessage->Clause22.regAddr;
+			tempPacket.clause22.regAddr = phyMessage->clause22.regAddr;
-			tempPacket.clause22.regVal = phyMessage->Clause22.regVal;
+			tempPacket.clause22.regVal = phyMessage->clause22.regVal;
 		}
 		uint8_t* pktPtr = reinterpret_cast<uint8_t*>(&tempPacket);
 		bytestream.insert(bytestream.end(), pktPtr, pktPtr + sizeof(PhyRegisterPacket_t));

communication/packet/i2cpacket.cpp

@@ -49,7 +49,7 @@ namespace icsneo
 			report(APIEvent::Type::I2CMessageExceedsMaxLength, APIEvent::Severity::Error);
 			return false;
 		}
-		if(message.controlBytes.empty() && message.dataBytes.empty())
+		if(message.controlBytes.empty() || message.dataBytes.empty())
 		{
 			//You'll need to provide a target R/W register in controlBytes
 			//alternatively, you're expecting to read without providing a dataBytes payload

communication/packet/linpacket.cpp

@@ -9,7 +9,7 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 	size_t numDataBytes = packet->CoreMiniBitsLIN.len;
 	size_t numHeaderBytes = sizeof(HardwareLINPacket::CoreMiniBitsLIN);
 
-	if( (sizeof(HardwareLINPacket) > bytestream.size()) ||
+	if( (sizeof(HardwareLINPacket) != bytestream.size()) ||
 		((numDataBytes + numHeaderBytes) > bytestream.size()) )
 		return nullptr;
 
@@ -17,6 +17,7 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 		--numDataBytes; //If data is present, there will be a checksum included
 
 	auto msg = std::make_shared<LINMessage>(static_cast<uint8_t>(packet->CoreMiniBitsLIN.ID));
+	msg->network = Network::GetNetIDFromCoreMiniNetwork(static_cast<Network::CoreMini>(packet->networkID));
 	msg->isEnhancedChecksum = static_cast<bool>(packet->CoreMiniBitsLIN.TxChkSumEnhanced);
 
 	/* Minimum one responder byte and one checksum byte. */

communication/packet/livedatapacket.cpp

@@ -111,14 +111,14 @@ bool HardwareLiveDataPacket::EncodeFromMessage(LiveDataMessage& message, std::ve
 				if(!setValMsg->handle)
 					setValMsg->handle = LiveDataUtil::getNewHandle();
 				out->handle = setValMsg->handle;
-				out->numSetValues = (uint32_t)numArgs;
+				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(LiveDataValue::value);
+					out->values[i].value.header.length = sizeof(int64_t);
 				}
 			} else {
 				report(APIEvent::Type::LiveDataInvalidArgument, APIEvent::Severity::Error);

communication/packet/spipacket.cpp

@@ -1,82 +0,0 @@
-#include "icsneo/communication/packet/spipacket.h"
-#include "icsneo/communication/command.h"
-#include <cstring>
-#include <vector>
-
-using namespace icsneo;
-
-static size_t SPISubHeaderLength = 5u;
-
-std::shared_ptr<Message> HardwareSPIPacket::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	if(bytestream.size() < sizeof(HardwareSPIPacket)) {
-		return nullptr;
-	}
-	const HardwareSPIPacket* packet = (const HardwareSPIPacket*)bytestream.data();
-	size_t totalPackedLength = static_cast<size_t>(bytestream.size()) - sizeof(HardwareSPIPacket); // First 28 bytes are message header.
-	if(totalPackedLength < SPISubHeaderLength) {
-		return nullptr;
-	}
-	
-	const uint8_t* bytes = bytestream.data() + sizeof(HardwareSPIPacket);
-	std::shared_ptr<SPIMessage> msg = std::make_shared<SPIMessage>();
-	msg->direction = static_cast<SPIMessage::Direction>(bytes[0]);
-	msg->address = *reinterpret_cast<const uint16_t*>(&bytes[1]);
-	msg->mms = bytes[3];
-	msg->stats = packet->stats;
-	msg->timestamp = packet->timestamp.TS;
-	
-	size_t numWords = (totalPackedLength - SPISubHeaderLength) / 4;
-	msg->payload.reserve(numWords);
-	for(size_t offset = SPISubHeaderLength; offset < totalPackedLength; offset += 4) {
-		msg->payload.push_back(*reinterpret_cast<const uint32_t*>(bytes + offset));
-	}
-	return msg;
-}
-
-bool HardwareSPIPacket::EncodeFromMessage(const SPIMessage& message, std::vector<uint8_t>& bytestream, const device_eventhandler_t& /*report*/) {
-	// Payload length is everything excluding cmdHeader (note at the beginning there is an offset of 2)
-	uint16_t payloadLength = static_cast<uint16_t>(
-		2 + 
-		sizeof(HardwareSPIPacket) + 
-		SPISubHeaderLength + 
-		message.payload.size() * sizeof(uint32_t)
-	);
-	if(payloadLength % 2) {
-		// Pad payload to even number
-		payloadLength++;
-	}
-	// +1 for AA, another +1 for firmware nuance
-	uint16_t fullSize = 1 + sizeof(ExtendedCommandHeader) + payloadLength + 1;
-	uint16_t unwrappedSize = sizeof(ExtendedCommandHeader) + payloadLength; // fullSize without AA and firmware nuance
-
-	bytestream.resize(unwrappedSize, 0);
-	uint32_t offset = 0;
-	auto* cmdHeader = reinterpret_cast<ExtendedCommandHeader*>(bytestream.data() + offset);
-	cmdHeader->netid = static_cast<uint8_t>(Network::NetID::Main51);
-	cmdHeader->fullLength = fullSize;
-	cmdHeader->command = static_cast<uint8_t>(Command::Extended);
-	cmdHeader->extendedCommand = static_cast<uint16_t>(ExtendedCommand::TransmitCoreminiMessage);
-	cmdHeader->payloadLength = payloadLength;
-	
-	offset += sizeof(ExtendedCommandHeader) + 2; // Offset of 2 between header and packet
-	auto* packet = reinterpret_cast<HardwareSPIPacket*>(bytestream.data() + offset);
-	packet->header.frameLength = static_cast<uint16_t>(SPISubHeaderLength + message.payload.size() * sizeof(uint32_t));
-	packet->networkID = static_cast<uint16_t>(message.network.getNetID());
-	packet->length = packet->header.frameLength;
-	packet->timestamp.IsExtended = 1;
-
-	offset += sizeof(HardwareSPIPacket);
-	// Write the sub header details
-	bytestream[offset++] = static_cast<uint8_t>(message.direction);
-	bytestream[offset++] = static_cast<uint8_t>(message.address & 0xFF);
-	bytestream[offset++] = static_cast<uint8_t>((message.address >> 8) & 0xFF);
-	bytestream[offset++] = static_cast<uint8_t>(message.mms);
-	bytestream[offset++] = static_cast<uint8_t>(message.payload.size());
-
-	// Write the words
-	for(uint32_t word : message.payload) {
-		*reinterpret_cast<uint32_t*>(bytestream.data() + offset) = word;
-		offset += sizeof(uint32_t);
-	}
-	return true;
-}

communication/packet/wivicommandpacket.cpp

@@ -31,46 +31,24 @@ std::shared_ptr<WiVI::ResponseMessage> WiVI::CommandPacket::DecodeToMessage(cons
 			break;
 		}
 		case WiVI::Command::GetAll: {
-			if(bytestream.size() < sizeof(WiVI::CommandPacket::GetAllHeader))
+			if(bytestream.size() < sizeof(WiVI::CommandPacket::GetAll))
 				return {};
 
-			const auto& getAll = *reinterpret_cast<const WiVI::CommandPacket::GetAllHeader*>(bytestream.data());
+			const auto& getAll = *reinterpret_cast<const WiVI::CommandPacket::GetAll*>(bytestream.data());
 			msg->responseTo = WiVI::Command::GetAll;
 			msg->info.emplace();
 			msg->info->sleepRequest = getAll.sleepRequest;
 			msg->info->connectionTimeoutMinutes = getAll.connectionTimeoutMinutes;
 
 			// Check that we have enough data for the capture infos
-			size_t captureInfosSize = sizeof(WiVI::CaptureInfo) * getAll.numCaptureInfos;
+			if(bytestream.size() < sizeof(WiVI::CommandPacket::GetAll) + (sizeof(WiVI::CaptureInfo) * getAll.numCaptureInfos))
-			if(bytestream.size() < sizeof(WiVI::CommandPacket::GetAllHeader) + captureInfosSize)
 				return {};
 
-			const WiVI::CaptureInfo* const captureInfos = (const WiVI::CaptureInfo*)(bytestream.data() + sizeof(WiVI::CommandPacket::GetAllHeader));
 			msg->info->captures.resize(getAll.numCaptureInfos);
 			for(uint16_t i = 0; i < getAll.numCaptureInfos; i++)
-				msg->info->captures[i] = captureInfos[i];
+				msg->info->captures[i] = getAll.captureInfos[i];
-
-			
-			// New field vinAvail was added - check if it is present:
-			if(bytestream.size() >= sizeof(WiVI::CommandPacket::GetAllHeader) + captureInfosSize + 2) {
-				msg->info->vinAvailable = *(bytestream.data() + sizeof(WiVI::CommandPacket::GetAllHeader) + captureInfosSize);
-			} else {
-				msg->info->vinAvailable = 0;
-			}
-				
 			break;
 		}
-		case WiVI::Command::GetVIN: {
-			if (bytestream.size() < sizeof(WiVI::CommandPacket::GetVIN))
-				return {};
-
-			const auto& getVIN = *reinterpret_cast<const WiVI::CommandPacket::GetVIN*>(bytestream.data());
-			msg->responseTo = WiVI::Command::GetVIN;
-			msg->vin  = getVIN.VIN;
-
-			break;
-		}
-
 		default: // Unknown command response
 			return {};
 	}
@@ -100,9 +78,9 @@ std::vector<uint8_t> WiVI::CommandPacket::SetSignal::Encode(WiVI::SignalType typ
 	return ret;
 }
 
-std::vector<uint8_t> WiVI::CommandPacket::GetAllHeader::Encode() {
+std::vector<uint8_t> WiVI::CommandPacket::GetAll::Encode() {
-	std::vector<uint8_t> ret(sizeof(WiVI::CommandPacket::GetAllHeader));
+	std::vector<uint8_t> ret(sizeof(WiVI::CommandPacket::GetAll));
-	auto& frame = *reinterpret_cast<WiVI::CommandPacket::GetAllHeader*>(ret.data());
+	auto& frame = *reinterpret_cast<WiVI::CommandPacket::GetAll*>(ret.data());
 
 	frame.header.cmd = WiVI::Command::GetAll;
 	frame.header.length = sizeof(frame) - sizeof(frame.header);
@@ -120,15 +98,3 @@ std::vector<uint8_t> WiVI::CommandPacket::ClearUploads::Encode(const std::vector
 
 	return ret;
 }
-
-std::vector<uint8_t> WiVI::CommandPacket::GetVIN::Encode()
-{
-	std::vector<uint8_t> ret(sizeof(WiVI::CommandPacket::GetVIN));
-	auto& frame = *reinterpret_cast<WiVI::CommandPacket::GetVIN*>(ret.data());
-
-	frame.header.cmd = WiVI::Command::GetVIN;
-	frame.header.length = sizeof(frame) - sizeof(frame.header);
-
-	return ret;
-}
-

communication/ringbuffer.cpp

@@ -0,0 +1,91 @@
+#include "icsneo/communication/ringbuffer.h"
+#include <stdexcept>
+
+namespace icsneo {
+    
+RingBuffer::RingBuffer(size_t bufferSize) : readCursor(0), writeCursor(0) {
+    // round the buffer size to the nearest power of 2
+    bufferSize = RoundUp(bufferSize);
+    mask = bufferSize - 1;
+    buf = new uint8_t[bufferSize];
+}
+
+RingBuffer::~RingBuffer() {
+    delete[] buf;
+    buf = nullptr;
+}
+
+const uint8_t& RingBuffer::operator[](size_t offset) const { 
+    return get(offset); 
+}
+
+size_t RingBuffer::size() const { 
+    // The values in the cursors are monotonic, i.e. they only ever increment. They can be considered to be the total number of elements ever written or read
+    auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
+    auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
+    // Using unmasked values, writeCursor is guaranteed to be >= readCursor. If they are equal that means the buffer is empty
+    return currentWriteCursor - currentReadCursor; 
+}
+
+void RingBuffer::pop_front() {
+    pop(1);
+}
+
+void RingBuffer::pop(size_t count) {
+    if (size() < count) {
+        throw std::runtime_error("RingBuffer: Underflow");
+    }
+    readCursor.fetch_add(count, std::memory_order_release);
+}
+
+const uint8_t& RingBuffer::get(size_t offset) const {
+    if (offset >= size()) {
+        throw std::runtime_error("RingBuffer: Index out of range");
+    }
+    auto currentReadCursor = readCursor.load(std::memory_order_acquire);
+    return *resolve(currentReadCursor, offset);
+}
+
+bool RingBuffer::write(const uint8_t* addr, size_t length) {    
+    const auto freeSpace = (capacity() - size());
+    if (length > freeSpace) {
+        return false;
+    }
+    auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
+    auto spaceAtEnd = std::min(freeSpace, capacity() - (currentWriteCursor & mask)); // number of bytes from (masked) writeCursor to the end of the writable space (i.e. we reach the masked read cursor or the end of the buffer)
+    auto firstCopySize = std::min(spaceAtEnd, length);
+    (void)memcpy(resolve(currentWriteCursor, 0), addr, firstCopySize);
+    if (firstCopySize < length)
+    {
+        (void)memcpy(buf, &addr[firstCopySize], length - firstCopySize);
+    }
+
+    writeCursor.store(currentWriteCursor + length, std::memory_order_release);
+    return true;
+}
+
+bool RingBuffer::write(const std::vector<uint8_t>& source) {
+    return write(source.data(), source.size());
+}
+
+bool RingBuffer::read(uint8_t* dest, size_t startIndex, size_t length) const {
+    auto currentSize = size();
+    if ((startIndex >= currentSize) || ((startIndex + length) > size())) {
+        return false;
+    }
+    auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
+    auto bytesAtEnd = std::min<size_t>(capacity() - ((currentReadCursor + startIndex) & mask), length);
+    const auto bytesAtStart = (length - bytesAtEnd);
+
+    (void)memcpy(dest, resolve(currentReadCursor, startIndex), bytesAtEnd);
+    if (bytesAtStart > 0) {
+        (void)memcpy(&dest[bytesAtEnd], buf, bytesAtStart);
+    }
+    return true;
+}
+
+void RingBuffer::clear() {
+    pop(size());
+}
+
+}

core/macseccfg.cpp

@@ -1,832 +0,0 @@
-#include "icsneo/core/macseccfg.h"
-#include "icsneo/api/eventmanager.h"
-#include "icsneo/core/crc32.h"
-#include <cstring>
-
-namespace icsneo {
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4201) // nameless struct/union
-#endif
-
-#pragma pack(push, 1)
-
-typedef struct
-{
-	uint16_t VID; /*!< 12 bits */
-	uint8_t PRI_CFI; /*!< PRI - 3 bits, CFI - 1bit */
-} MACSEC_VLANTAG_t;
-/**
- * @brief Structure of MPLS
- *
- */
-typedef struct
-{
-	uint32_t MPLS_label; /*!< 20 bits */
-	uint8_t exp; /*!< 3 bits */
-} MACSEC_MPLS_OUTER_t;
-
-#define MACSEC_SETTINGS_RULE_SIZE (88)
-typedef union _MACSecRule
-{
-	struct
-	{
-		uint8_t index;
-		uint8_t key_MAC_DA[6]; /*!< MAC DA field extracted from the packet */
-		uint8_t mask_MAC_DA[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t key_MAC_SA[6]; /*!< MAC SA field extracted from the packet */
-		uint8_t mask_MAC_SA[6]; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint16_t key_Ethertype; /*!< First E-Type found in the packet that doesn't match one of the preconfigured custom tag. */
-		uint16_t mask_Ethertype; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACSEC_VLANTAG_t key_vlantag_outer1; /*!< outermost/1st VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
-		MACSEC_MPLS_OUTER_t key_MPLS_outer1;
-		MACSEC_VLANTAG_t mask_vlantag_outer1; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACSEC_MPLS_OUTER_t mask_MPLS_outer1;
-		MACSEC_VLANTAG_t key_vlantag_outer2; /*!< 2nd outermost VLAN ID {8'd0, VLAN_ID[11:0]}, or 20-bit MPLS label. */
-		MACSEC_MPLS_OUTER_t key_MPLS_outer2;
-		MACSEC_VLANTAG_t mask_vlantag_outer2; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACSEC_MPLS_OUTER_t mask_MPLS_outer2;
-		uint16_t key_bonus_data; /*!< 2 bytes of additional bonus data extracted from one of the custom tags. */
-		uint16_t mask_bonus_data; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t
-			key_tag_match_bitmap; /*!< 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 mask_tag_match_bitmap; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		MACsecPacketType key_packet_type; /*!< Encoded Packet Type, see MACSEC_PACKET_TYPE */
-		uint8_t mask_packet_type; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint16_t
-			key_inner_vlan_type; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the second outermost VLAN Tag. */
-		uint16_t mask_inner_vlan_type; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint16_t key_outer_vlan_type; /*!< 3 bits total. Encoded value indicating which VLAN TPID value matched for the outermost VLAN Tag. */
-		uint16_t mask_outer_vlan_type; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t
-			key_num_tags; /*!< 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 mask_num_tags; /*!< Set bits to 1 to mask/exclude corresponding flowid_tcam_data bit from compare */
-		uint8_t key_express; /*!< 1 bits. Express packet. */
-		uint8_t mask_express; /*!< 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 */
-#define MACSEC_SETTINGS_MAP_SIZE (20)
-typedef union _MACSecMap
-{
-	struct
-	{
-		uint8_t index;
-		uint64_t sectag_sci; /*!< 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 auxiliary_plcy; /*!< 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 */
-
-#define MACSEC_SETTINGS_SECY_SIZE (24)
-typedef union _MACSecSecY
-{
-	struct
-	{
-		uint8_t index; /*!< Identifies the SecY for this Flow. */
-		uint8_t controlled_port_enabled; /*!< Enable (or disable) operation of the Controlled port associated with this SecY */
-		MACsecValidation validate_frames; /*!< see MACSEC_VALIDATEFRAME */
-		MACsecStrip strip_sectag_icv; /*!< see MACSEC_STRIP_SECTAG_ICV */
-		MACsecCipherSuite cipher; /*!< Define the cipher suite to use for this SecY */
-		uint8_t confidential_offset; /*!< Define the number of bytes that are unencrypted following the SecTag. */
-		uint8_t icv_includes_da_sa; /*!< When set, the outer DA/SA bytes are included in the authentication GHASH calculation */
-		uint8_t replay_protect; /*!< Enables Anti-Replay protection */
-		uint32_t replay_window; /*!< Unsigned value indicating the size of the anti-replay window. */
-		uint8_t
-			protect_frames; /*!< 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
-			sectag_offset; /*!< Define the offset in bytes from either the start of the packet or a matching Etype depending on SecTag_Insertion_Mode. */
-		uint8_t sectag_tci; /*!< 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 */
-#define 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 sa_index0; /*!< Define the 1st SA to use */
-		uint8_t sa_index1; /*!< Define the 2nd SA to use */
-		uint8_t sa_index0_in_use; /*!< Specifies whether 1st SA is in use or not. */
-		uint8_t sa_index1_in_use; /*!< Specifies whether 2nd SA is in use or not.  */
-		uint8_t enable_auto_rekey; /*!< 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 */
-#define MACSEC_SETTINGS_SA_SIZE (80)
-typedef union _MACSecSa
-{
-	struct
-	{
-		uint8_t index; /*!< SA index */
-		uint8_t
-			sak[32]; /*!< SAK: All 32 bytes are written to the firmware. For AES-128 the firmware requires bytes [0..15] == bytes [16..31] (mirrored); serialize() handles this automatically. */
-		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 */
-#define MACSEC_SETTINGS_FLAGS_SIZE (4)
-typedef union _MACSecFlags
-{
-	struct
-	{
-		uint32_t en : 1; // '1' = enable; '0' = disable
-		uint32_t reserved : 31;
-	};
-	uint32_t flags_32b;
-} MACSecFlags_t;
-/* MACSec Settings for 1 port/phy */
-#define MACSEC_NUM_FLAGS_PER_CONFIG (1)
-#define MACSEC_NUM_RULES_PER_CONFIG (2)
-#define MACSEC_NUM_MAPS_PER_CONFIG (2)
-#define MACSEC_NUM_SECY_PER_CONFIG (2)
-#define MACSEC_NUM_SC_PER_CONFIG (2)
-#define MACSEC_NUM_SA_PER_CONFIG (4)
-typedef struct MACSEC_CONFIG_t
-{
-	MACSecFlags_t flags;
-	MACSecRule_t rule[MACSEC_NUM_RULES_PER_CONFIG];
-	MACSecMap_t map[MACSEC_NUM_MAPS_PER_CONFIG];
-	MACSecSecY_t secy[MACSEC_NUM_SECY_PER_CONFIG];
-	MACSecSc_t sc[MACSEC_NUM_SC_PER_CONFIG];
-	MACSecSa_t sa[MACSEC_NUM_SA_PER_CONFIG];
-} 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
-typedef struct MACSEC_SETTINGS_W_HDR
-{
-	uint16_t version;
-	uint16_t len;
-	uint32_t crc32;
-	MACSEC_SETTINGS macsec;
-} MACSEC_SETTINGS_W_HDR;
-#define MACSEC_SETTINGS_W_HDR_SIZE (2048)
-
-#pragma pack(pop)
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-static void ReportEvent(APIEvent::Type event, APIEvent::Severity severity) {
-	auto& em = EventManager::GetInstance();
-	em.add(APIEvent(event, severity));
-}
-
-MACsecConfig::MACsecConfig(const DeviceType& deviceType) : type(deviceType) {
-	switch(deviceType.getDeviceType()) {
-		case icsneo::DeviceType::Enum::RADMoon2:
-		case icsneo::DeviceType::Enum::RADMoon3:
-		case icsneo::DeviceType::Enum::RADEpsilon:
-		case icsneo::DeviceType::Enum::RADGigastar2:
-			maxSecY = 2;
-			maxRule = 2;
-			maxSa = 4;
-			binIndex = 0;
-			break;
-		default:
-			maxSecY = 0;
-			maxSa = 0;
-			maxRule = 0;
-			binIndex = 0;
-			ReportEvent(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
-			return;
-	}
-}
-
-int MACsecConfig::addRxSecY(const MACsecRxSecY& secY, uint8_t saIndex) {
-	if(rxSecY.size() >= maxSecY) {
-		ReportEvent(APIEvent::Type::MACsecSecYLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	if(saIndex >= rxSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	int ret = static_cast<int>(rxSecY.size());
-	rxSecY.emplace_back(secY);
-	rxSecYSaIndices.emplace_back(saIndex, saIndex + 1);
-	rxSecYRekey.emplace_back(false);
-	rxRuleIndices.emplace_back(0);
-
-	return ret;
-}
-
-int MACsecConfig::addTxSecY(const MACsecTxSecY& secY, uint8_t saIndex) {
-	if(txSecY.size() >= maxSecY) {
-		ReportEvent(APIEvent::Type::MACsecSecYLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	if(saIndex >= txSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	int ret = static_cast<int>(txSecY.size());
-	txSecY.emplace_back(secY);
-	txSecYSaIndices.emplace_back(saIndex, saIndex + 1);
-	txSecYRekey.emplace_back(false);
-
-	return ret;
-}
-
-int MACsecConfig::addRxSa(const MACsecRxSa& sa) {
-	// Validate AN is in valid range
-	if(sa.an > 3) {
-		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	// Check if we've exceeded the maximum SA count
-	if(rxSa.size() >= maxSa) {
-		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	// Ensure vector is large enough to hold index sa.an (sparse array)
-	// This allows SA index to match the AN value from the MACsec SecTAG
-	if(rxSa.size() <= sa.an) {
-		rxSa.resize(sa.an + 1);
-	}
-
-	// Mark it enabled; padding slots created by resize() above default to enabled=false.
-	rxSa[sa.an] = sa;
-	rxSa[sa.an].enabled = true;
-	
-	return sa.an;
-}
-
-int MACsecConfig::addTxSa(const MACsecTxSa& sa) {
-	if(txSa.size() >= maxSa) {
-		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	int ret = static_cast<int>(txSa.size());
-	txSa.emplace_back(sa);
-	return ret;
-}
-
-int MACsecConfig::addRxRule(const MACsecRxRule& rule, uint8_t secYIndex) {
-	if(rxRule.size() >= maxRule) {
-		ReportEvent(APIEvent::Type::MACsecSaLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	if(maxSecY >= rxRule.size()) {
-		ReportEvent(APIEvent::Type::MACsecSecYLimit, APIEvent::Severity::Error);
-		return -1;
-	}
-
-	int ret = static_cast<int>(rxRule.size());
-	rxRuleIndices[secYIndex] = static_cast<uint8_t>(rxRule.size());
-	rxRule.emplace_back(rule);
-	return ret;
-}
-
-MACsecRxRule& MACsecConfig::getRxRule(uint8_t ruleIndex) {
-	return rxRule[ruleIndex];
-}
-
-const MACsecRxRule& MACsecConfig::getRxRule(uint8_t ruleIndex) const {
-	return rxRule[ruleIndex];
-}
-
-MACsecRxSecY& MACsecConfig::getRxSecY(uint8_t secYIndex) {
-	return rxSecY[secYIndex];
-}
-
-const MACsecRxSecY& MACsecConfig::getRxSecY(uint8_t secYIndex) const {
-	return rxSecY[secYIndex];
-}
-
-MACsecTxSecY& MACsecConfig::getTxSecY(uint8_t secYIndex) {
-	return txSecY[secYIndex];
-}
-
-const MACsecTxSecY& MACsecConfig::getTxSecY(uint8_t secYIndex) const {
-	return txSecY[secYIndex];	
-}
-
-MACsecRxSa& MACsecConfig::getRxSa(uint8_t saIndex) {
-	return rxSa[saIndex];
-}
-
-const MACsecRxSa& MACsecConfig::getRxSa(uint8_t saIndex) const {
-	return rxSa[saIndex];
-}
-
-MACsecTxSa& MACsecConfig::getTxSa(uint8_t saIndex) {
-	return txSa[saIndex];
-}
-
-const MACsecTxSa& MACsecConfig::getTxSa(uint8_t saIndex) const {
-	return txSa[saIndex];
-}
-
-bool MACsecConfig::setTxSaIndex(uint8_t secYIndex, uint8_t saIndex) {
-	if(secYIndex >= txSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
-		return false;
-	}
-	if(saIndex >= txSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return false;
-	}
-
-	txSecYSaIndices[secYIndex].first = saIndex;
-	return true;
-}
-
-bool MACsecConfig::enableTxRekey(uint8_t secYIndex, uint8_t rekeySaIndex) {
-	if(secYIndex >= txSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
-		return false;
-	}
-	if(rekeySaIndex >= txSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return false;
-	}
-
-	txSecYSaIndices[secYIndex].second = rekeySaIndex;
-	txSecYRekey[secYIndex] = true;
-	return true;
-}
-
-bool MACsecConfig::setTxSaRekeyIndex(uint8_t secYIndex, uint8_t saIndex) {
-	if(secYIndex >= txSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
-		return false;
-	}
-	if(saIndex >= txSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return false;
-	}
-
-	txSecYSaIndices[secYIndex].second = saIndex;
-	return true;
-}
-
-void MACsecConfig::disableTxRekey(uint8_t secYIndex) {
-	if(secYIndex >= txSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::EventWarning);
-		return;
-	}
-	txSecYRekey[secYIndex] = false;
-}
-
-bool MACsecConfig::setRxSaIndex(uint8_t secYIndex, uint8_t saIndex) {
-	if(secYIndex >= rxSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
-		return false;
-	}
-	if(saIndex >= rxSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return false;
-	}
-
-	rxSecYSaIndices[secYIndex].first = saIndex;
-	return true;
-}
-
-bool MACsecConfig::enableRxRekey(uint8_t secYIndex, uint8_t rekeySaIndex) {
-	if(secYIndex >= rxSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
-		return false;
-	}
-	if(rekeySaIndex >= rxSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return false;
-	}
-
-	rxSecYSaIndices[secYIndex].second = rekeySaIndex;
-	rxSecYRekey[secYIndex] = true;
-	return true;
-}
-
-bool MACsecConfig::setRxSaRekeyIndex(uint8_t secYIndex, uint8_t saIndex) {
-	if(secYIndex >= rxSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::Error);
-		return false;
-	}
-	if(saIndex >= rxSa.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSaIndex, APIEvent::Severity::Error);
-		return false;
-	}
-
-	rxSecYSaIndices[secYIndex].second = saIndex;
-	return true;
-}
-
-void MACsecConfig::disableRxRekey(uint8_t secYIndex) {
-	if(secYIndex >= rxSecY.size()) {
-		ReportEvent(APIEvent::Type::MACsecInvalidSecYIndex, APIEvent::Severity::EventWarning);
-		return;
-	}
-	rxSecYRekey[secYIndex] = false;
-}
-
-void MACsecConfig::setRxEnable(bool newRxEnable) {
-	enableRx = newRxEnable;
-}
-
-void MACsecConfig::setTxEnable(bool newTxEnable) {
-	enableTx = newTxEnable;
-}
-
-void MACsecConfig::setStorage(bool temporary) {
-	nvm = !temporary;
-}
-
-
-void MACsecConfig::clear() {
-	// Set everything back to default, except device maximums
-	rxSecY.clear();
-	txSecY.clear();
-	rxSa.clear();
-	txSa.clear();
-	rxRule.clear();
-	rxSecYRekey.clear();
-	txSecYRekey.clear();
-	rxSecYSaIndices.clear();
-	txSecYSaIndices.clear();
-	rxRuleIndices.clear();
-	enableRx = false;
-	enableTx = false;
-	nvm = false;
-}
-
-MACsecConfig::operator bool() const {
-	return (maxSa != 0) || (maxSecY != 0) || (maxRule != 0);
-}
-
-uint16_t MACsecConfig::getBinIndex() const {
-	return binIndex;
-}
-
-DeviceType MACsecConfig::getType() const {
-	return type;
-}
-
-uint8_t MACsecConfig::getMaxNumRule() const {
-	return maxRule;	
-}
-
-uint8_t MACsecConfig::getMaxNumSecY() const {
-	return maxSecY;
-}
-
-uint8_t MACsecConfig::getMaxNumSa() const {
-	return maxSa;
-}
-
-
-static uint8_t TCItoInt(const MACsecTci& tci) {
-	uint8_t res = 0;
-	res |= tci.c ? 0x01u : 0;
-	res |= tci.e ? 0x02u : 0;
-	res |= tci.scb ? 0x04u : 0;
-	res |= tci.sc ? 0x08u : 0;
-	res |= tci.es ? 0x10u : 0;
-	return res;
-}
-
-static void SetHardwareTxSecY(
-	MACSEC_SETTINGS_W_HDR* hwSettings,
-	const MACsecTxSecY& secY,
-	bool rekeyEnabled,
-	const std::pair<uint8_t, uint8_t>& saIndices,
-	uint8_t index
-) {
-
-	MACSecSecY_t* hwSecY = &hwSettings->macsec.tx.secy[index];
-	MACSecSc_t* hwSc = &hwSettings->macsec.tx.sc[index];
-	MACSecMap_t* hwMap = &hwSettings->macsec.tx.map[index]; 
-
-	hwSecY->index = index;
-	hwSecY->enable = true;
-	hwSecY->controlled_port_enabled = secY.enableControlPort ? 0x1u : 0x0u;
-	hwSecY->cipher = secY.cipher;
-	hwSecY->confidential_offset = secY.confidentialityOffset;
-	hwSecY->icv_includes_da_sa = secY.icvIncludesDaSa ? 0x1u : 0x0u;
-	hwSecY->mtu = secY.mtu;
-	hwSecY->sectag_tci = TCItoInt(secY.tci);
-	hwSecY->sectag_offset = secY.secTagOffset;
-	hwSecY->protect_frames = secY.protectFrames;
-
-	hwSc->index = index;
-	hwSc->enable = true;
-	hwSc->secYIndex = index;
-	hwSc->enable_auto_rekey = rekeyEnabled ? 0x1u : 0x0u;
-	hwSc->sa_index0 = saIndices.first;
-	hwSc->sa_index1 = saIndices.second;
-	hwSc->sa_index0_in_use = true;
-	hwSc->sa_index1_in_use = rekeyEnabled ? true : false;
-	hwSc->isActiveSA1 = rekeyEnabled ? true : false;
-	hwSc->sci = secY.sci;
-
-	hwMap->index = index;
-	hwMap->enable = true;
-	hwMap->auxiliary_plcy = secY.auxiliaryPolicy;
-	hwMap->secYIndex = index;
-	hwMap->isControlPacket = secY.isControlPacket ? 0x1u : 0x0u;
-	hwMap->scIndex = index;
-	hwMap->sectag_sci = secY.sci;
-
-}
-
-static void SetHardwareRxSecY(
-	MACSEC_SETTINGS_W_HDR* hwSettings,
-	const MACsecRxSecY& secY,
-	bool rekeyEnabled,
-	uint8_t ruleIndex,
-	const std::pair<uint8_t, uint8_t>& saIndices,
-	uint8_t index
-) {
-
-	MACSecSecY_t* hwSecY = &hwSettings->macsec.rx.secy[index];
-	MACSecSc_t* hwSc = &hwSettings->macsec.rx.sc[index];
-	MACSecMap_t* hwMap = &hwSettings->macsec.rx.map[index]; 
-
-	hwSecY->index = index;
-	hwSecY->enable = 0x1u;
-	hwSecY->controlled_port_enabled = secY.enableControlPort ? 0x1u : 0x0u;
-	hwSecY->cipher = secY.cipher;
-	hwSecY->confidential_offset = secY.confidentialityOffset;
-	hwSecY->icv_includes_da_sa = secY.icvIncludesDaSa ? 0x1u : 0x0u;
-	hwSecY->replay_protect = secY.replayProtect ? 0x1u : 0x0u;
-	hwSecY->replay_window = secY.replayWindow;
-	hwSecY->validate_frames = secY.frameValidation;
-	hwSecY->strip_sectag_icv = secY.frameStrip;
-	hwSecY->sectag_offset = 12;
-
-	hwSc->index = index;
-	hwSc->enable = 0x1u;
-	hwSc->secYIndex = index;
-	hwSc->enable_auto_rekey = rekeyEnabled ? 0x1u : 0x0u;
-	hwSc->sci = secY.sci;
-
-
-	if(saIndices.first & 0x1u) {
-		hwSc->sa_index0 = rekeyEnabled ? saIndices.second : saIndices.first;
-		hwSc->sa_index1 = saIndices.first;
-		hwSc->sa_index0_in_use = rekeyEnabled ? 0x1u : 0x0u;
-		hwSc->sa_index1_in_use = 0x1u;
-		hwSc->isActiveSA1 = rekeyEnabled ? 0x0u : 0x1u;
-	} else {
-		hwSc->sa_index0 = saIndices.first;
-		hwSc->sa_index1 = saIndices.second;
-		hwSc->sa_index0_in_use = 0x1u;
-		hwSc->sa_index1_in_use = rekeyEnabled ? 0x1u : 0x0u;
-		hwSc->isActiveSA1 = rekeyEnabled ? 0x1u : 0x0u;
-	}
-
-	hwMap->index = index;
-	hwMap->enable = 0x1u;
-	hwMap->secYIndex = index;
-	hwMap->ruleId = ruleIndex;
-	hwMap->isControlPacket = secY.isControlPacket ? 0x1u : 0x0u;
-	hwMap->scIndex = index;
-	hwMap->sectag_sci = secY.sci;
-
-}
-
-static void SetHardwareTxSa(MACSEC_SETTINGS_W_HDR* hwSettings, const MACsecTxSa& sa, uint8_t index) {
-	MACSecSa_t* hwSa = &hwSettings->macsec.tx.sa[index];
-
-	hwSa->index = index;
-	hwSa->enable = 0x1u;
-	memcpy(hwSa->sak, sa.sak.data(), 32);
-	memcpy(hwSa->hashKey, sa.hashKey.data(), 16);
-	memcpy(hwSa->salt, sa.salt.data(), 12);
-	hwSa->ssci = sa.ssci;
-	hwSa->AN = sa.an;
-	hwSa->nextPN = sa.nextPn;
-
-}
-
-static void SetHardwareRxSa(MACSEC_SETTINGS_W_HDR* hwSettings, const MACsecRxSa& sa, uint8_t index) {
-	MACSecSa_t* hwSa = &hwSettings->macsec.rx.sa[index];
-
-	hwSa->index = index;
-	hwSa->enable = sa.enabled ? 0x1u : 0x0u;
-	if(!sa.enabled)
-		return;
-	memcpy(hwSa->sak, sa.sak.data(), 32);
-	memcpy(hwSa->hashKey, sa.hashKey.data(), 16);
-	memcpy(hwSa->salt, sa.salt.data(), 12);
-	hwSa->ssci = sa.ssci;
-	hwSa->nextPN = sa.nextPn;
-
-}
-
-static void SetHardwareRxRule(MACSecRule_t* hwRule, const MACsecRxRule& rule, uint8_t index) {
-
-	hwRule->enable = 0x1u;
-	hwRule->index = index;
-	memcpy(hwRule->key_MAC_DA, rule.keyMacDa.data(), 6);
-	memcpy(hwRule->mask_MAC_DA, rule.maskMacDa.data(), 6);
-	memcpy(hwRule->key_MAC_SA, rule.keyMacSa.data(), 6);
-	memcpy(hwRule->mask_MAC_SA, rule.maskMacSa.data(), 6);
-	hwRule->key_Ethertype = rule.keyEthertype;
-	hwRule->mask_Ethertype =  rule.maskEthertype;
-	hwRule->key_vlantag_outer1.PRI_CFI = rule.keyVlanTagOuter1.priCfi;
-	hwRule->key_vlantag_outer1.VID = rule.keyVlanTagOuter1.vid;
-	hwRule->key_MPLS_outer1.exp = rule.keyMplsOuter1.exp;
-	hwRule->key_MPLS_outer1.MPLS_label = rule.keyMplsOuter1.mplsLabel;
-	hwRule->mask_vlantag_outer1.PRI_CFI = rule.maskVlanTagOuter1.priCfi;
-	hwRule->mask_vlantag_outer1.VID = rule.maskVlanTagOuter1.vid;
-	hwRule->mask_MPLS_outer1.exp = rule.maskMplsOuter1.exp;
-	hwRule->mask_MPLS_outer1.MPLS_label = rule.maskMplsOuter1.mplsLabel;
-	hwRule->key_vlantag_outer2.PRI_CFI = rule.keyVlanTagOuter2.priCfi;
-	hwRule->key_vlantag_outer2.VID = rule.keyVlanTagOuter2.vid;
-	hwRule->key_MPLS_outer2.exp = rule.keyMplsOuter2.exp;
-	hwRule->key_MPLS_outer2.MPLS_label = rule.keyMplsOuter2.mplsLabel;
-	hwRule->mask_vlantag_outer2.PRI_CFI = rule.maskVlanTagOuter2.priCfi;
-	hwRule->mask_vlantag_outer2.VID = rule.maskVlanTagOuter2.vid;
-	hwRule->mask_MPLS_outer2.exp = rule.maskMplsOuter2.exp;
-	hwRule->mask_MPLS_outer2.MPLS_label = rule.maskMplsOuter2.mplsLabel;
-	hwRule->key_bonus_data = rule.keyBonusData;
-	hwRule->mask_bonus_data = rule.maskBonusData;
-	hwRule->key_tag_match_bitmap = rule.keyTagMatchBitmap;
-	hwRule->mask_tag_match_bitmap = rule.maskTagMatchBitmap;
-	hwRule->key_packet_type = rule.keyPacketType;
-	hwRule->mask_packet_type = rule.maskPacketType;
-	hwRule->key_inner_vlan_type = rule.keyInnerVlanType;
-	hwRule->mask_inner_vlan_type = rule.maskInnerVlanType;
-	hwRule->key_outer_vlan_type = rule.keyOuterVlanType;
-	hwRule->mask_outer_vlan_type = rule.maskOuterVlanType;
-	hwRule->key_num_tags = rule.keyNumTags;
-	hwRule->mask_num_tags = rule.maskNumTags;
-	hwRule->key_express = rule.keyExpress ? 0x1u : 0x0u;
-	hwRule->mask_express = rule.maskExpress ? 0x1u : 0x0u;
-	hwRule->isMPLS = rule.isMpls ? 0x1u : 0x0u;
-
-}
-
-std::vector<uint8_t> MACsecConfig::serialize() const {
-	std::vector<uint8_t> res(sizeof(MACSEC_SETTINGS_W_HDR), 0);
-	MACSEC_SETTINGS_W_HDR* hwSettings = (MACSEC_SETTINGS_W_HDR*)(res.data());
-
-	for(uint8_t i = 0; i < maxSecY; i++) {
-		if(i < rxSecY.size()) {
-			SetHardwareRxSecY(
-				hwSettings, 
-				rxSecY[i],
-				rxSecYRekey[i],
-				rxRuleIndices[i],
-				rxSecYSaIndices[i],
-				i
-			);
-		} else {
-			hwSettings->macsec.rx.secy[i].enable = false;
-			hwSettings->macsec.rx.map[i].enable = false;
-			hwSettings->macsec.rx.sc[i].enable = false;
-		}
-
-		if(i < txSecY.size()) {
-			SetHardwareTxSecY(
-				hwSettings, 
-				txSecY[i],
-				txSecYRekey[i],
-				txSecYSaIndices[i],
-				i
-			);
-		} else {
-			hwSettings->macsec.tx.secy[i].enable = false;
-			hwSettings->macsec.tx.map[i].enable = false;
-			hwSettings->macsec.tx.sc[i].enable = false;
-		}
-	}
-
-	for(uint8_t i = 0; i < maxSa; i++) {
-		if(i < rxSa.size()) {
-			SetHardwareRxSa(hwSettings, rxSa[i], i);
-		} else {
-			hwSettings->macsec.rx.sa[i].enable = false;
-		}
-		
-		if(i < txSa.size()) {
-			SetHardwareTxSa(hwSettings, txSa[i], i);
-		} else {
-			hwSettings->macsec.tx.sa[i].enable = false;
-		}
-	}
-
-	// AES-128 SAK normalization: the firmware expects the 16-byte SAK mirrored
-	// into both halves of the 32-byte hardware SAK field.  Callers only populate
-	// bytes [0..15]; copy them into [16..31] here, transparent to all callers.
-	for(uint8_t i = 0; i < static_cast<uint8_t>(rxSecY.size()); i++) {
-		if(rxSecY[i].cipher == MACsecCipherSuite::GcmAes128 || rxSecY[i].cipher == MACsecCipherSuite::GcmAes128Xpn) {
-			uint8_t primaryIdx = rxSecYSaIndices[i].first;
-			if(primaryIdx < maxSa)
-				memcpy(hwSettings->macsec.rx.sa[primaryIdx].sak + 16, hwSettings->macsec.rx.sa[primaryIdx].sak, 16);
-			if(rxSecYRekey[i]) {
-				uint8_t rekeyIdx = rxSecYSaIndices[i].second;
-				if(rekeyIdx < maxSa)
-					memcpy(hwSettings->macsec.rx.sa[rekeyIdx].sak + 16, hwSettings->macsec.rx.sa[rekeyIdx].sak, 16);
-			}
-		}
-	}
-	for(uint8_t i = 0; i < static_cast<uint8_t>(txSecY.size()); i++) {
-		if(txSecY[i].cipher == MACsecCipherSuite::GcmAes128 || txSecY[i].cipher == MACsecCipherSuite::GcmAes128Xpn) {
-			uint8_t primaryIdx = txSecYSaIndices[i].first;
-			if(primaryIdx < maxSa)
-				memcpy(hwSettings->macsec.tx.sa[primaryIdx].sak + 16, hwSettings->macsec.tx.sa[primaryIdx].sak, 16);
-			if(txSecYRekey[i]) {
-				uint8_t rekeyIdx = txSecYSaIndices[i].second;
-				if(rekeyIdx < maxSa)
-					memcpy(hwSettings->macsec.tx.sa[rekeyIdx].sak + 16, hwSettings->macsec.tx.sa[rekeyIdx].sak, 16);
-			}
-		}
-	}
-
-	if(rxRule.size() == 0) {
-		MACsecRxRule defaultRule;
-		MACSecRule_t* hwRxRule = &hwSettings->macsec.rx.rule[0];
-		MACSecRule_t* hwTxRule = &hwSettings->macsec.tx.rule[0];
-		SetHardwareRxRule(hwRxRule, defaultRule, 0);
-		SetHardwareRxRule(hwTxRule, defaultRule, 0);
-		//hwSettings->macsec.tx.rule[0].enable = false;
-		for(uint8_t i = 1; i < maxRule; i++) {
-			hwSettings->macsec.rx.rule[i].enable = false;
-			hwSettings->macsec.tx.rule[i].enable = false;
-		}
-	} else  {
-		for(uint8_t i = 0; i < maxRule; i++) {
-			if(i < rxRule.size()) {
-				auto* hwRxRule = &hwSettings->macsec.rx.rule[i];
-				SetHardwareRxRule(hwRxRule, rxRule[i], i);
-			} else {
-				hwSettings->macsec.rx.rule[i].enable = false;
-				hwSettings->macsec.tx.rule[i].enable = false;
-			}
-		}
-	}
-
-	hwSettings->len = sizeof(MACSEC_SETTINGS_W_HDR);
-	hwSettings->version = MACSEC_SETTINGS_VERSION;
-	hwSettings->macsec.flags.en = (enableRx || enableTx) ? 1u : 0u;
-	hwSettings->macsec.flags.nvm = nvm ? 1u : 0u;
-	hwSettings->macsec.rx.flags.en = enableRx ? 1u : 0u;
-	hwSettings->macsec.tx.flags.en = enableTx ? 1u : 0u;
-	hwSettings->crc32 = crc32(0, (uint8_t*)&hwSettings->macsec, sizeof(MACSEC_SETTINGS));
-
-	return res;
-}
-}

core/ringbuffer.cpp

@@ -1,91 +0,0 @@
-#include "icsneo/core/ringbuffer.h"
-#include <stdexcept>
-
-namespace icsneo {
-	
-RingBuffer::RingBuffer(size_t bufferSize) : readCursor(0), writeCursor(0) {
-	// round the buffer size to the nearest power of 2
-	bufferSize = RoundUp(bufferSize);
-	mask = bufferSize - 1;
-	buf = new uint8_t[bufferSize];
-}
-
-RingBuffer::~RingBuffer() {
-	delete[] buf;
-	buf = nullptr;
-}
-
-const uint8_t& RingBuffer::operator[](size_t offset) const { 
-	return get(offset); 
-}
-
-size_t RingBuffer::size() const { 
-	// The values in the cursors are monotonic, i.e. they only ever increment. They can be considered to be the total number of elements ever written or read
-	auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
-	auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
-	// Using unmasked values, writeCursor is guaranteed to be >= readCursor. If they are equal that means the buffer is empty
-	return currentWriteCursor - currentReadCursor; 
-}
-
-void RingBuffer::pop_front() {
-	pop(1);
-}
-
-void RingBuffer::pop(size_t count) {
-	if (size() < count) {
-		throw std::runtime_error("RingBuffer: Underflow");
-	}
-	readCursor.fetch_add(count, std::memory_order_release);
-}
-
-const uint8_t& RingBuffer::get(size_t offset) const {
-	if (offset >= size()) {
-		throw std::runtime_error("RingBuffer: Index out of range");
-	}
-	auto currentReadCursor = readCursor.load(std::memory_order_acquire);
-	return *resolve(currentReadCursor, offset);
-}
-
-bool RingBuffer::write(const uint8_t* addr, size_t length) {    
-	const auto freeSpace = (capacity() - size());
-	if (length > freeSpace) {
-		return false;
-	}
-	auto currentWriteCursor = writeCursor.load(std::memory_order_relaxed);
-	auto spaceAtEnd = std::min(freeSpace, capacity() - (currentWriteCursor & mask)); // number of bytes from (masked) writeCursor to the end of the writable space (i.e. we reach the masked read cursor or the end of the buffer)
-	auto firstCopySize = std::min(spaceAtEnd, length);
-	(void)memcpy(resolve(currentWriteCursor, 0), addr, firstCopySize);
-	if (firstCopySize < length)
-	{
-		(void)memcpy(buf, &addr[firstCopySize], length - firstCopySize);
-	}
-
-	writeCursor.store(currentWriteCursor + length, std::memory_order_release);
-	return true;
-}
-
-bool RingBuffer::write(const std::vector<uint8_t>& source) {
-	return write(source.data(), source.size());
-}
-
-bool RingBuffer::read(uint8_t* dest, size_t startIndex, size_t length) const {
-	auto currentSize = size();
-	if ((startIndex >= currentSize) || ((startIndex + length) > size())) {
-		return false;
-	}
-	auto currentReadCursor = readCursor.load(std::memory_order_relaxed);
-	auto bytesAtEnd = std::min<size_t>(capacity() - ((currentReadCursor + startIndex) & mask), length);
-	const auto bytesAtStart = (length - bytesAtEnd);
-
-	(void)memcpy(dest, resolve(currentReadCursor, startIndex), bytesAtEnd);
-	if (bytesAtStart > 0) {
-		(void)memcpy(&dest[bytesAtEnd], buf, bytesAtStart);
-	}
-	return true;
-}
-
-void RingBuffer::clear() {
-	pop(size());
-}
-
-}

device/device.cpp

@@ -1,14 +1,10 @@
 #include <sstream>
-#include <iomanip>
 #include "icsneo/api/eventmanager.h"
 #include "icsneo/communication/message/filter/main51messagefilter.h"
 #include "icsneo/communication/message/extendedresponsemessage.h"
 #include "icsneo/device/device.h"
 #include "icsneo/device/extensions/deviceextension.h"
 #include "icsneo/disk/fat.h"
-#include "icsneo/communication/message/filter/extendedresponsefilter.h"
-#include "icsneo/communication/message/networkmutexmessage.h"
-#include "icsneo/communication/message/transmitmessage.h"
 
 #ifdef _MSC_VER
 #pragma warning(disable : 4996) // STL time functions
@@ -108,21 +104,15 @@ std::string Device::describe() const {
 	return ss.str();
 }
 
-bool Device::enableMessagePolling(std::optional<MessageFilter> filter) {
+bool Device::enableMessagePolling() {
 	if(isMessagePollingEnabled()) {// We are already polling
 		report(APIEvent::Type::DeviceCurrentlyPolling, APIEvent::Severity::Error);
 		return false;
 	}
-	if(!filter.has_value()) {
+	messagePollingCallbackID = com->addMessageCallback(std::make_shared<MessageCallback>([this](std::shared_ptr<Message> message) {
-		// If no filter is provided, use a default that includes all messages
-		filter.emplace(MessageFilter());
-		filter->includeInternalInAny = true;
-	}
-	auto callback = std::make_shared<MessageCallback>(*filter, [this](std::shared_ptr<Message> message) {
 		pollingContainer.enqueue(message);
 		enforcePollingMessageLimit();
-	});
+	}));
-	messagePollingCallbackID = com->addMessageCallback(callback);
 	return true;
 }
 
@@ -182,11 +172,12 @@ bool Device::getMessages(std::vector<std::shared_ptr<Message>>& container, size_
 	if(container.size() < limit)
 		container.resize(limit);
 
-	size_t actuallyRead = 0;
+	size_t actuallyRead;
-	if(pollingContainer.wait_dequeue_timed(container.front(), timeout)) {
+	if(timeout != std::chrono::milliseconds(0))
-		actuallyRead = 1; // Account for the first message we already dequeued
+		actuallyRead = pollingContainer.wait_dequeue_bulk_timed(container.data(), limit, timeout);
-		actuallyRead += pollingContainer.try_dequeue_bulk(container.data() + 1, limit - 1);
+	else
-	}
+		actuallyRead = pollingContainer.try_dequeue_bulk(container.data(), limit);
+
 	if(container.size() > actuallyRead)
 		container.resize(actuallyRead);
 
@@ -209,75 +200,6 @@ bool Device::refreshComponentVersions() {
 	return false;
 }
 
-std::vector<VersionReport> Device::getChipVersions(bool refreshComponents) {
-	if(refreshComponents) {
-		refreshComponentVersions();
-	}
-	std::vector<VersionReport> chipVersions;
-
-	if (supportsComponentVersions()) {
-		const auto& compVersions = getComponentVersions();
-		auto disectVersion = [](uint32_t dotVersion) {
-			std::array<uint8_t, 4> result = {0,0,0,0};
-			size_t i = 0;
-
-			if(dotVersion & 0xFF000000ul) {
-				result[i++] = (uint8_t)((dotVersion & 0xFF000000ul) >> 24);
-				result[i++] = (uint8_t)((dotVersion & 0x00FF0000ul) >> 16);
-			} else if(dotVersion & 0x00FF0000ul) {
-				result[i++] = (uint8_t)((dotVersion & 0x00FF0000ul) >> 16);
-			}
-			result[i++] = (uint8_t)((dotVersion & 0x0000FF00ul) >> 8);
-			result[i] = (uint8_t)((dotVersion & 0x000000FFul) >> 0);
-			return result;
-		};
-
-		for(const auto& chipInfo : getChipInfo()) {
-			for(const auto& component : compVersions) {
-				if(!component.valid) {
-					continue;
-				}
-				if(component.identifier == (uint32_t)chipInfo.id) {
-					chipVersions.emplace_back();
-					auto& version = chipVersions.back();
-
-					auto disectedVersion = disectVersion(component.dotVersion);
-					version.id          = chipInfo.id;
-					version.name        = chipInfo.name;
-					version.major       = disectedVersion[0];
-					version.minor       = disectedVersion[1];
-					version.maintenance = disectedVersion[2];
-					version.build       = disectedVersion[3];
-				}
-			}
-		}
-	} else {
-		const auto& appVersions = getVersions();
-		for(const auto& chipInfo : getChipInfo()) {
-			if(!chipInfo.defaultEnabled) {
-				continue;
-			}
-			if(appVersions.size() <= chipInfo.versionIndex) {
-				continue;
-			}
-			const auto& appVer = appVersions[chipInfo.versionIndex];
-			if(!appVer) {
-				continue;
-			}
-			chipVersions.emplace_back();
-			auto& version = chipVersions.back();
-
-			version.id          = chipInfo.id;
-			version.name        = chipInfo.name;
-			version.major       = appVer->major;
-			version.minor       = appVer->minor;
-			version.maintenance = 0;
-			version.build       = 0;
-		}			
-	}
-	return chipVersions;
-}
-
 bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	if(!com) {
 		report(APIEvent::Type::Unknown, APIEvent::Severity::Error);
@@ -355,7 +277,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 		std::condition_variable heartbeatCV;
 		std::mutex receivedMessageMutex;
 		bool receivedMessage = false;
-		auto messageReceivedCallbackID = com->addMessageCallback(std::make_shared<MessageCallback>(filter, [&](std::shared_ptr<Message>) {
+		auto messageReceivedCallbackID = com->addMessageCallback(std::make_shared<MessageCallback>(filter, [&](std::shared_ptr<Message> message) {
 			{
 				std::scoped_lock<std::mutex> lk(receivedMessageMutex);
 				receivedMessage = true;
@@ -395,7 +317,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 				if(heartbeatCV.wait_for(recvLk, std::chrono::milliseconds(3500), [&](){ return receivedMessage; })) {
 					receivedMessage = false;
 				} else {
-					if(!stopHeartbeatThread) {
+					if(!stopHeartbeatThread && !isDisconnected()) {
 						close();
 						report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 					}
@@ -413,44 +335,6 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	return true;
 }
 
-bool Device::reconnect(std::chrono::milliseconds timeout, std::chrono::milliseconds interval) {
-	if(isOnline()) {
-		goOffline();
-	}
-	bool readsArePaused = com->readsArePaused();
-	if(!com->close()) {
-		return false;
-	}
-
-	std::vector<FoundDevice> foundDevices;
-	auto findAll = com->driver->getFinder();
-	auto start = std::chrono::system_clock::now();
-	while((std::chrono::system_clock::now() - start) < timeout) {
-		foundDevices.clear();
-		findAll(foundDevices);
-		for(auto& fd : foundDevices) {
-			if(!memcmp(fd.serial, data.serial, 6)) {
-				com->driver = fd.makeDriver(report, getWritableNeoDevice());
-				if(readsArePaused) {
-					// Pause reads again
-					com->pauseReads();
-				}
-				if(com->open()) {
-					return true;
-				} else {
-					if(readsArePaused) {
-						com->resumeReads();
-					}
-				} 
-			}
-		}
-		std::this_thread::sleep_for(interval);
-	}
-
-	return false;
-}
-
-
 APIEvent::Type Device::attemptToBeginCommunication() {
 	versions.clear();
 
@@ -530,8 +414,7 @@ bool Device::disableLogData() {
 }
 
 bool Device::goOnline() {
-	static constexpr uint32_t onlineTimeoutMs = 5000;
+	if(!enableNetworkCommunication(true))
-	if(!enableNetworkCommunication(true, onlineTimeoutMs))
 		return false;
 
 	auto startTime = std::chrono::system_clock::now();
@@ -560,52 +443,13 @@ bool Device::goOnline() {
 			return false;
 	}
 
-	if(supportsNetworkMutex) {
-		assignedClientId = com->getClientIDSync();
-		if(assignedClientId) {
-			std::set<Network::NetID> nets;
-			for(auto&& net : getSupportedTXNetworks()) {
-				nets.insert(net.getNetID());
-			}
-			// firmware supports clientid/mutex
-			networkMutexCallbackHandle = lockNetworks(nets, std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint32_t>::max(), NetworkMutexType::Shared, [this](std::shared_ptr<Message> message) {
-				auto netMutexMsg = std::static_pointer_cast<NetworkMutexMessage>(message);
-				if(netMutexMsg->networks.size() && netMutexMsg->event.has_value()) {
-					switch(*netMutexMsg->event) {
-						case NetworkMutexEvent::Acquired:
-							lockedNetworks.emplace(*netMutexMsg->networks.begin());
-							break;
-						case NetworkMutexEvent::Released: {
-							auto it = lockedNetworks.find(*netMutexMsg->networks.begin());
-							if (it != lockedNetworks.end())
-								lockedNetworks.erase(it);
-							break;
-						}
-					}
-				}
-			});
-		}
-	}
-
-	// (re)start the keeponline
-	keeponline = std::make_unique<Periodic>([this] {
-		static std::vector<uint8_t> timeoutBytes = std::vector<uint8_t>((uint8_t*)&onlineTimeoutMs, (uint8_t*)&onlineTimeoutMs + sizeof(onlineTimeoutMs));
-		return com->sendCommand(Command::KeepAlive, timeoutBytes);
-	}, std::chrono::milliseconds(onlineTimeoutMs / 4));
-
 	online = true;
 
 	forEachExtension([](const std::shared_ptr<DeviceExtension>& ext) { ext->onGoOnline(); return true; });
-
 	return true;
 }
 
 bool Device::goOffline() {
-	keeponline.reset();
-
-	if(networkMutexCallbackHandle)
-		removeMessageCallback(*networkMutexCallbackHandle);
-
 	forEachExtension([](const std::shared_ptr<DeviceExtension>& ext) { ext->onGoOffline(); return true; });
 
 	if(isDisconnected()) {
@@ -613,11 +457,6 @@ bool Device::goOffline() {
 		return true;
 	}
 
-	if(assignedClientId.has_value()) {
-		unlockAllNetworks();
-		assignedClientId.reset();
-	}
-	
 	if(!enableNetworkCommunication(false))
 		return false;
 
@@ -941,12 +780,9 @@ bool Device::transmit(std::shared_ptr<Frame> frame) {
 		return transmitStatusFromExtension;
 
 	std::vector<uint8_t> packet;
-	if(assignedClientId.has_value()) {
-		packet = TransmitMessage::EncodeFromMessage(frame, *assignedClientId, report);
-		return packet.size() && com->sendCommand(ExtendedCommand::TransmitMessage, packet);
-	}
 	if(!com->encoder->encode(*com->packetizer, packet, frame))
 		return false;
+
 	return com->sendPacket(packet);
 }
 
@@ -1328,7 +1164,7 @@ void Device::wiviThreadBody() {
 
 		// Use the command GetAll to get a WiVI::Info structure from the device
 		const auto generic = com->waitForMessageSync([this]() {
-			return com->sendCommand(Command::WiVICommand, WiVI::CommandPacket::GetAllHeader::Encode());
+			return com->sendCommand(Command::WiVICommand, WiVI::CommandPacket::GetAll::Encode());
 		}, filter, std::chrono::milliseconds(1000));
 
 		if(!generic || generic->type != Message::Type::WiVICommandResponse) {
@@ -1440,22 +1276,6 @@ void Device::wiviThreadBody() {
 			for(auto& cb : sleepRequestedCallbacks)
 				cb.second = false;
 		}
-
-		// Process vin available callbacks
-		if (resp->info->vinAvailable & 1) {
-			for (auto& cb : vinAvailableCallbacks) {
-				if (!cb.second && cb.first) {
-					cb.second = true;
-					lk.unlock();
-					try {
-						cb.first();
-					} catch(...) {
-						report(APIEvent::Type::Unknown, APIEvent::Severity::Error);
-					}
-					lk.lock();
-				}
-			}
-		}
 	}
 }
 
@@ -1630,110 +1450,6 @@ bool Device::allowSleep(bool remoteWakeup) {
 	return true;
 }
 
-Lifetime Device::addVINAvailableCallback(VINAvailableCallback cb)
-{
-	if(!isOpen()) {
-		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
-		return {};
-	}
-
-	if(!supportsWiVI()) {
-		report(APIEvent::Type::WiVINotSupported, APIEvent::Severity::Error);
-		return {};
-	}
-
-	std::lock_guard<std::mutex> lk(wiviMutex);
-	if(!wiviThread.joinable()) {
-		// Start the thread
-		stopWiVIThread = false;
-		wiviThread = std::thread([this]() { wiviThreadBody(); });
-	}
-
-	size_t idx = 0;
-	for(; idx < vinAvailableCallbacks.size(); idx++) {
-		if(!vinAvailableCallbacks[idx].first) // Empty space (previously erased callback)
-			break;
-	}
-
-	if(idx == vinAvailableCallbacks.size()) // Create a new space
-		vinAvailableCallbacks.emplace_back(std::move(cb), false);
-	else
-		vinAvailableCallbacks[idx] = { std::move(cb), false };
-
-	// Cleanup function to remove this sleep requested callback
-	return Lifetime([this, idx]() {
-		// TODO: Hold a weak ptr to the `this` instead of relying on the user to keep `this` valid
-		std::unique_lock<std::mutex> lk2(wiviMutex);
-		vinAvailableCallbacks[idx].first = VINAvailableCallback();
-		stopWiVIThreadIfNecessary(std::move(lk2));
-	});
-}
-
-std::optional<bool> Device::isVINEnabled() const
-{
-	if(!isOpen()) {
-		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	if(!supportsWiVI()) {
-		report(APIEvent::Type::WiVINotSupported, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	static std::shared_ptr<MessageFilter> filter = std::make_shared<MessageFilter>(Message::Type::WiVICommandResponse);
-	// Hold this lock so the WiVI stack doesn't issue a WiVICommand at the same time as us
-	std::lock_guard<std::mutex> lk(wiviMutex);
-	const auto generic = com->waitForMessageSync([this]() {
-		return com->sendCommand(Command::WiVICommand, WiVI::CommandPacket::GetSignal::Encode(WiVI::SignalType::VINEnabled));
-	}, filter, std::chrono::milliseconds(1000));
-
-	if(!generic || generic->type != Message::Type::WiVICommandResponse) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	const auto resp = std::static_pointer_cast<WiVI::ResponseMessage>(generic);
-	if(!resp->success || !resp->value.has_value()) {
-		report(APIEvent::Type::ValueNotYetPresent, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	return *resp->value;
-}
-
-std::optional<std::string> Device::getVIN() const
-{
-	if(!isOpen()) {
-		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	if(!supportsWiVI()) {
-		report(APIEvent::Type::WiVINotSupported, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	static std::shared_ptr<MessageFilter> filter = std::make_shared<MessageFilter>(Message::Type::WiVICommandResponse);
-	std::lock_guard<std::mutex> lk(wiviMutex);
-	const auto generic = com->waitForMessageSync([this]() {
-		return com->sendCommand(Command::WiVICommand, WiVI::CommandPacket::GetVIN::Encode());
-	}, filter, std::chrono::milliseconds(1000));
-
-	if(!generic || generic->type != Message::Type::WiVICommandResponse) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	const auto resp = std::static_pointer_cast<WiVI::ResponseMessage>(generic);
-	if(!resp->success || !resp->vin.has_value()) {
-		report(APIEvent::Type::ValueNotYetPresent, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	return *resp->vin;
-}
-
 void Device::scriptStatusThreadBody()
 {
 	std::unique_lock<std::mutex> lk(scriptStatusMutex);
@@ -2020,15 +1736,6 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 		case Message::Type::RawMessage: {
 			auto rawMessage = std::static_pointer_cast<RawMessage>(message);
 			switch(rawMessage->network.getNetID()) {
-				case Network::NetID::Device: {
-					// Device is not guaranteed to be a CANMessage, it might be a RawMessage
-					// if it couldn't be decoded to a CANMessage. We only care about the
-					// CANMessage decoding right now.
-					auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
-					if(canmsg)
-						handleNeoVIMessage(std::move(canmsg));
-					break;
-				}
 				case Network::NetID::DeviceStatus:
 					// Device Status format is unique per device, so the devices need to decode it themselves
 					handleDeviceStatus(rawMessage);
@@ -2038,6 +1745,15 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 			}
 			break;
 		}
+		case Message::Type::Frame: {
+			// Device is not guaranteed to be a CANMessage, it might be a RawMessage
+			// if it couldn't be decoded to a CANMessage. We only care about the
+			// CANMessage decoding right now.
+			auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
+			if(canmsg)
+				handleNeoVIMessage(std::move(canmsg));
+			break;
+		}
 		default: break;
 	}
 	forEachExtension([&](const std::shared_ptr<DeviceExtension>& ext) {
@@ -2107,12 +1823,16 @@ std::optional<EthPhyMessage> Device::sendEthPhyMsg(const EthPhyMessage& message,
 		report(APIEvent::Type::EthPhyRegisterControlNotAvailable, APIEvent::Severity::Error);
 		return std::nullopt;
 	}
+	if(!isOnline()) {
+		report(APIEvent::Type::DeviceCurrentlyOffline, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
 
 	std::vector<uint8_t> bytes;
 	HardwareEthernetPhyRegisterPacket::EncodeFromMessage(message, bytes, report);
 	std::shared_ptr<Message> response = com->waitForMessageSync(
 		[this, bytes](){ return com->sendCommand(Command::PHYControlRegisters, bytes); },
-		std::make_shared<MessageFilter>(Message::Type::EthernetPhyRegister), timeout);
+		std::make_shared<MessageFilter>(Network::NetID::EthPHYControl), timeout);
 
 	if(!response) {
 		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
@@ -2254,24 +1974,6 @@ bool Device::setRTC(const std::chrono::time_point<std::chrono::system_clock>& ti
 	return m51msg->data.front();
 }
 
-std::optional<std::vector<uint8_t>> Device::getPCBSerial() {
-	auto serialMsg = com->getSerialNumberSync();
-	if(!serialMsg || !serialMsg->hasPCBSerial) {
-		return std::nullopt;
-	}
-
-	return std::vector<uint8_t>(serialMsg->pcbSerial, serialMsg->pcbSerial + sizeof(serialMsg->pcbSerial));
-}
-
-std::optional<std::vector<uint8_t>> Device::getMACAddress() {
-	auto serialMsg = com->getSerialNumberSync();
-	if(!serialMsg || !serialMsg->hasMacAddress) {
-		return std::nullopt;
-	}
-
-	return std::vector<uint8_t>(serialMsg->macAddress, serialMsg->macAddress + sizeof(serialMsg->macAddress));
-}
-
 std::optional<std::set<SupportedFeature>> Device::getSupportedFeatures() {
 	auto timeout = std::chrono::milliseconds(100);
 	std::shared_ptr<Message> msg = com->waitForMessageSync(
@@ -3084,6 +2786,7 @@ std::optional<bool> Device::isVSAOverlapped(std::optional<VSAMetadata> optMetada
 			   lastSectorRecord->getTimestamp() > metadata.coreMiniTimestamp;
 	} else if(lastSectorStatus == VSAParser::RecordParseStatus::NotARecordStart) {
 		// The vsa record buffer is not full
+		report(APIEvent::Type::VSAOtherError, APIEvent::Severity::Error);
 		return false;
 	}
 	report(APIEvent::Type::VSABufferFormatError, APIEvent::Severity::Error);
@@ -3598,18 +3301,10 @@ std::optional<uint64_t> Device::vsaReadLogicalDisk(uint64_t pos, uint8_t* into,
 		return readLogicalDisk(pos, into, amount);
 	}
 	uint64_t firstReadAmount = diskSize - pos;
-	uint64_t bytesRead = 0;
+	if(!readLogicalDisk(pos, into, firstReadAmount)) {
-	if(auto optBytesReadFirst = readLogicalDisk(pos, into, firstReadAmount)) {
-		bytesRead = *optBytesReadFirst;
-	} else {
 		return std::nullopt;
 	}
-	if(auto optBytesReadSecond = readLogicalDisk(VSA::RecordStartOffset, into + firstReadAmount, amount - firstReadAmount)) {
+	return readLogicalDisk(VSA::RecordStartOffset, into + firstReadAmount, amount - firstReadAmount);
-		bytesRead += *optBytesReadSecond;
-	} else {
-		return std::nullopt;
-	}
-	return bytesRead;
 }
 
 bool Device::dispatchVSAMessages(VSAParser& parser) {
@@ -3771,355 +3466,24 @@ std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeou
 	return *retMsg;
 }
 
-bool Device::writeMACsecConfig(const MACsecConfig& cfg) {
+bool Device::writeMACsecConfig(const MACsecMessage& message, uint16_t binaryIndex)
-	if(!cfg) {
+{
-		report(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
+	std::vector<uint8_t> raw;
-		return false;
-	}
 
-	if(getType() != cfg.getType()) {
+	message.EncodeFromMessage(raw, report);
-		report(APIEvent::Type::MACsecConfigMismatch, APIEvent::Severity::Error);
-		return false;
-	}
 
-	std::vector<uint8_t> raw = cfg.serialize();
+	return writeBinaryFile(raw, binaryIndex);
-	return writeBinaryFile(raw, cfg.getBinIndex());
 }
 
-bool Device::enableNetworkCommunication(bool enable, uint32_t timeout) {
+bool Device::enableNetworkCommunication(bool enable) {
 	bool sendMsg = false;
 	if(!com->driver->enableCommunication(enable, sendMsg)) {
 		return false;
 	}
 	if(sendMsg) {
-		const uint8_t* i = (uint8_t*)&timeout;
+		if(!com->sendCommand(Command::EnableNetworkCommunication, enable)) {
-		if(!com->sendCommand(Command::EnableNetworkCommunication, {enable, 0, 0, 0, i[0], i[1], i[2], i[3]})) {
 			return false;
 		}
 	}
 	return true;
 }
-
-
-
-bool Device::formatDisk(const DiskDetails& config, const DiskFormatProgress& handler, std::chrono::milliseconds interval) {
-#pragma pack(push, 2)
-	struct DiskFormatProgressResponse {
-		uint16_t state;
-		uint64_t sectorsRemaining;
-	};
-#pragma pack(pop)
-
-	auto diskCount = getDiskCount();
-	
-	if(!diskCount) {
-		report(APIEvent::Type::DiskFormatNotSupported, APIEvent::Severity::Error);
-		return false;
-	}
-	if(config.disks.size() != diskCount) {
-		report(APIEvent::Type::DiskFormatInvalidCount, APIEvent::Severity::Error);
-		return false;
-	}
-
-	std::vector<uint8_t> payload = DiskDetails::Encode(config);
-	if(!com->sendCommand(ExtendedCommand::DiskFormatStart, payload)) {
-		return false;
-	}
-
-	uint64_t sectorsFormatted = 0;
-	uint64_t sectorsTotal = 0;
-	uint16_t lastState = 1;
-	do {
-		std::shared_ptr<Message> response = com->waitForMessageSync(
-			[this](){ 
-				return com->sendCommand(ExtendedCommand::DiskFormatProgress, {}); 
-			},
-			std::make_shared<ExtendedResponseFilter>(ExtendedCommand::DiskFormatProgress),
-			std::chrono::milliseconds(5000)
-		);
-
-		if(!response) {
-			report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-			return false;
-		}
-
-		auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
-		if(!extResponse) {
-			// Should never happen
-			return false;
-		}
-		
-		if(extResponse->data.size() < sizeof(DiskFormatProgressResponse)) {
-			report(APIEvent::Type::BufferInsufficient, APIEvent::Severity::Error);
-			return false;
-		}
-
-		auto* progress = reinterpret_cast<DiskFormatProgressResponse*>(extResponse->data.data());
-		lastState = progress->state;
-
-		if(sectorsTotal == 0) {
-			sectorsTotal = progress->sectorsRemaining;
-		} else {
-			sectorsFormatted = sectorsTotal - progress->sectorsRemaining;
-
-			if(handler) {
-				auto directive = handler(sectorsFormatted, sectorsTotal);
-
-				if(directive == DiskFormatDirective::Stop) {
-					return com->sendCommand(ExtendedCommand::DiskFormatCancel);
-				}
-			}
-		}
-
-		std::this_thread::sleep_for(interval);
-	} while(lastState);
-
-	return true;
-}
-
-bool Device::forceDiskConfigUpdate(const DiskDetails& config) {
-	auto diskCount = getDiskCount();
-	
-	if(!diskCount) {
-		report(APIEvent::Type::DiskFormatNotSupported, APIEvent::Severity::Error);
-		return false;
-	}
-	if(config.disks.size() != diskCount) {
-		report(APIEvent::Type::DiskFormatInvalidCount, APIEvent::Severity::Error);
-		return false;
-	}
-
-	return com->sendCommand(ExtendedCommand::DiskFormatUpdate, DiskDetails::Encode(config));
-}
-
-std::shared_ptr<DiskDetails> Device::getDiskDetails(std::chrono::milliseconds timeout) {
-	if(!supportsDiskFormatting()) {
-		report(APIEvent::Type::DiskFormatNotSupported, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	if(!isOpen()) {
-		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	std::shared_ptr<Message> response = com->waitForMessageSync(
-		[this](){ 
-			return com->sendCommand(ExtendedCommand::GetDiskDetails, {}); 
-		},
-		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::GetDiskDetails),
-		timeout
-	);
-
-	if(!response) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
-	if(!extResponse) {
-		// Should never happen
-		return nullptr;
-	}
-
-	return DiskDetails::Decode(extResponse->data, getDiskCount(), report);
-}
-
-[[nodiscard]] std::optional<int> Device::lockNetworks(const std::set<Network::NetID>& networks, uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event)
-{
-	if(!supportsNetworkMutex) {
-		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-	if(!assignedClientId.has_value()) {
-		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	constexpr auto timeout = std::chrono::milliseconds(250);
-
-	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForLock(*assignedClientId, type, priority, ttlMs, networks, report);
-	
-	std::optional<int> handle = std::nullopt;
-	if(on_event) {
-		handle.emplace(addMessageCallback(
-			std::make_shared<MessageCallback>(
-				on_event,
-				std::make_shared<MessageFilter>(Message::Type::NetworkMutex)
-			)
-		));
-	}
-	std::shared_ptr<Message> response = com->waitForMessageSync(
-		[this, payload](){
-			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
-		timeout
-	);
-
-	if(!response) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
-	if(!extResponse) {
-		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	if(extResponse->response != ExtendedResponse::OK && extResponse->response != ExtendedResponse::OperationPending) {
-		return std::nullopt;
-	}
-
-	return handle;
-}
-
-bool Device::unlockNetworks(const std::set<Network::NetID>& networks)
-{
-	if(!supportsNetworkMutex) {
-		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
-		return false;
-	}
-	if(!assignedClientId.has_value()) {
-		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
-		return false;
-	}
-	constexpr auto timeout = std::chrono::milliseconds(250);
-
-	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForUnlock(*assignedClientId, networks, report);
-
-	std::shared_ptr<Message> response = com->waitForMessageSync(
-		[this, payload](){
-			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
-		timeout
-	);
-
-	if(!response) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return false;
-	}
-
-	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
-	if(!extResponse) {
-		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
-		return false;
-	}
-
-	if(extResponse->response != ExtendedResponse::OK) {
-		return false;
-	}
-
-	return true;
-}
-
-std::shared_ptr<NetworkMutexMessage> Device::getNetworkMutexStatus(Network::NetID network)
-{
-	if(!supportsNetworkMutex) {
-		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	constexpr auto timeout = std::chrono::milliseconds(1000);
-
-	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForStatus(network, report);
-	
-	std::shared_ptr<Message> response = com->waitForMessageSync(
-		[this, payload](){
-			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<MessageFilter>(Message::Type::NetworkMutex),
-		timeout
-	);
-
-	return std::dynamic_pointer_cast<NetworkMutexMessage>(response);
-}
-
-[[nodiscard]] std::optional<int> Device::lockAllNetworks(uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event)
-{
-	if(!supportsNetworkMutex) {
-		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-	if(!assignedClientId.has_value()) {
-		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-	constexpr auto timeout = std::chrono::milliseconds(1000);
-
-	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForLockAll(*assignedClientId, type, priority, ttlMs, report);
-	
-	int handle = addMessageCallback(
-		std::make_shared<MessageCallback>(
-			on_event,
-			std::make_shared<MessageFilter>(Message::Type::NetworkMutex)
-		)
-	);
-	
-	std::shared_ptr<Message> response = com->waitForMessageSync(
-		[this, payload](){
-			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
-		timeout
-	);
-
-	if(!response) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
-	if(!extResponse) {
-		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
-		return std::nullopt;
-	}
-
-	if(extResponse->response != ExtendedResponse::OK && extResponse->response != ExtendedResponse::OperationPending) {
-		return std::nullopt;
-	}
-
-	return std::make_optional(handle);
-}
-
-bool Device::unlockAllNetworks() 
-{
-	if(!supportsNetworkMutex) {
-		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
-		return false;
-	}
-	if(!assignedClientId.has_value()) {
-		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
-		return false;
-	}
-	constexpr auto timeout = std::chrono::milliseconds(1000);
-
-	std::vector<uint8_t> payload = NetworkMutexMessage::EncodeArgumentsForUnlockAll(*assignedClientId, report);
-
-	std::shared_ptr<Message> response = com->waitForMessageSync(
-		[this, payload](){
-			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<ExtendedResponseFilter>(ExtendedCommand::ProtobufAPI),
-		timeout
-	);
-
-	if(!response) {
-		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-		return false;
-	}
-
-	auto extResponse = std::dynamic_pointer_cast<ExtendedResponseMessage>(response);
-	if(!extResponse) {
-		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
-		return false;
-	}
-
-	if(extResponse->response != ExtendedResponse::OK) {
-		return false;
-	}
-
-	return true;
-}

device/devicefinder.cpp

@@ -16,8 +16,12 @@
 #include "icsneo/platform/cdcacm.h"
 #endif
 
-#ifdef ICSNEO_ENABLE_DXX
+#ifdef ICSNEO_ENABLE_FTDI
-#include "icsneo/platform/dxx.h"
+#include "icsneo/platform/ftdi.h"
+#endif
+
+#ifdef ICSNEO_ENABLE_FTD3XX
+#include "icsneo/platform/ftd3xx.h"
 #endif
 
 #ifdef ICSNEO_ENABLE_TCP
@@ -35,6 +39,15 @@ static void makeIfSerialMatches(const FoundDevice& dev, std::vector<std::shared_
 		into.push_back(std::make_shared<T>(dev));
 }
 
+template<typename T>
+static void makeIfPIDMatches(const FoundDevice& dev, std::vector<std::shared_ptr<Device>>& into) {
+	// Relies on the subclass to have a `static constexpr uint16_t PRODUCT_ID = 0x1111`
+	// and also a public constructor `T(const FoundDevice& dev)`
+	// Use macro ICSNEO_FINDABLE_DEVICE_BY_PID() to create these
+	if(dev.productId == T::PRODUCT_ID)
+		into.push_back(std::make_shared<T>(dev));
+}
+
 template<typename T>
 static void makeIfSerialRangeMatches(const FoundDevice& dev, std::vector<std::shared_ptr<Device>>& into) {
 	// Relies on the subclass to have 
@@ -70,8 +83,12 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		CDCACM::Find(newDriverFoundDevices);
 		#endif
 	
-		#ifdef ICSNEO_ENABLE_DXX
+		#ifdef ICSNEO_ENABLE_FTDI
-		DXX::Find(newDriverFoundDevices);
+		FTDI::Find(newDriverFoundDevices);
+		#endif
+	
+		#ifdef ICSNEO_ENABLE_FTD3XX
+		FTD3XX::Find(newDriverFoundDevices);
 		#endif
 	}
 
@@ -130,7 +147,7 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		#endif
 
 		#ifdef __NEOVIFIRE_H_
-		makeIfSerialRangeMatches<NeoVIFIRE>(dev, newFoundDevices);
+		makeIfPIDMatches<NeoVIFIRE>(dev, newFoundDevices);
 		#endif
 
 		#ifdef __NEOVIFIRE2_H_
@@ -145,20 +162,16 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<NeoVIFIRE3FlexRay>(dev, newFoundDevices);
 		#endif
 
-		#ifdef __NEOVIFIRE3T1SLIN_H_
-		makeIfSerialMatches<NeoVIFIRE3T1SLIN>(dev, newFoundDevices);
-		#endif
-
 		#ifdef __NEOVIRED2_H_
 		makeIfSerialMatches<NeoVIRED2>(dev, newFoundDevices);
 		#endif
 
 		#ifdef __NEOVIION_H_
-		makeIfSerialMatches<NeoVIION>(dev, newFoundDevices);
+		makeIfPIDMatches<NeoVIION>(dev, newFoundDevices);
 		#endif
 
 		#ifdef __NEOVIPLASMA_H_
-		makeIfSerialMatches<NeoVIPLASMA>(dev, newFoundDevices);
+		makeIfPIDMatches<NeoVIPLASMA>(dev, newFoundDevices);
 		#endif
 
 		#ifdef __RADA2B_H_
@@ -225,10 +238,6 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADMoon3>(dev, newFoundDevices);
 		#endif
 
-		#ifdef __RADGEMINI_H_
-		makeIfSerialMatches<RADGemini>(dev, newFoundDevices);
-		#endif
-
 		#ifdef __RADMOONDUO_H_
 		makeIfSerialMatches<RADMoonDuo>(dev, newFoundDevices);
 		#endif
@@ -246,7 +255,7 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		#endif
 
 		#ifdef __VALUECAN3_H_
-		makeIfSerialRangeMatches<ValueCAN3>(dev, newFoundDevices);
+		makeIfPIDMatches<ValueCAN3>(dev, newFoundDevices);
 		#endif
 
 		#ifdef __VALUECAN4_1_H_
@@ -324,10 +333,6 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		NeoVIFIRE3FlexRay::DEVICE_TYPE,
 		#endif
 
-		#ifdef __NEOVIFIRE3T1SLIN_H_
-		NeoVIFIRE3T1SLIN::DEVICE_TYPE,
-		#endif
-
 		#ifdef __NEOVIION_H_
 		NeoVIION::DEVICE_TYPE,
 		#endif
@@ -388,10 +393,6 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADMoon3::DEVICE_TYPE,
 		#endif
 
-		#ifdef __RADGEMINI_H_
-		RADGemini::DEVICE_TYPE,
-		#endif
-
 		#ifdef __RADMOONDUO_H_
 		RADMoonDuo::DEVICE_TYPE,
 		#endif

device/extensions/flexray/controller.cpp

@@ -3,6 +3,16 @@
 
 using namespace icsneo;
 
+void FlexRay::Controller::_setStatus(std::shared_ptr<FlexRayControlMessage> msg) {
+	std::lock_guard<std::mutex> lk(statusLock);
+	status = msg;
+}
+
+std::shared_ptr<FlexRayControlMessage> FlexRay::Controller::getStatus() const {
+	std::lock_guard<std::mutex> lk(statusLock);
+	return status;
+}
+
 std::pair<const FlexRay::Cluster::Configuration&, const FlexRay::Controller::Configuration&> FlexRay::Controller::getConfiguration() const {
 	return { clusterConfig, controllerConfig };
 }
@@ -64,7 +74,7 @@ bool FlexRay::Controller::configure(std::chrono::milliseconds timeout) {
 		((controllerConfig.KeySlotUsedForStartup & 0x1) << 8) | // TXST
 		((controllerConfig.KeySlotUsedForSync & 0x1) << 9) | // TXSY
 		((clusterConfig.ColdStartAttempts & 0x1f) << 11) | // CSA
-		((controllerConfig.AllowPassiveToActiveCyclePairs & 0x1F) << 16) | // PTA
+		((controllerConfig.AllowPassiveToActiveCyclePairs & 0x1f) << 16) | // PTA
 		((controllerConfig.WakeupOnChannelB & 0x1) << 21) | // WUCS
 		((controllerConfig.KeySlotOnlyEnabled & 0x1) << 22) | // TSM
 		((controllerConfig.AllowHaltDueToClock & 0x1) << 23) | // HCSE
@@ -75,100 +85,99 @@ bool FlexRay::Controller::configure(std::chrono::milliseconds timeout) {
 	});
 
 	registerWrites.push_back({ ERAYRegister::SUCC2,
-		((controllerConfig.ListenTimeout & 0x1FFFFF)) |
+		((controllerConfig.ListenTimeout & 0x1fffff)) |
-		(((clusterConfig.ListenNoiseMacroticks - 1) & 0xF) << 24)
+		((clusterConfig.ListenNoiseMacroticks - 1) << 24)
 	});
 
 	registerWrites.push_back({ ERAYRegister::SUCC3,
 		(clusterConfig.MaxWithoutClockCorrectionPassive & 0xF) |
-		((clusterConfig.MaxWithoutClockCorrectionFatal & 0xF) << 4)
+		((clusterConfig.MaxWithoutClockCorrectionFatal) << 4)
 	});
 
 	registerWrites.push_back({ ERAYRegister::NEMC,
-		clusterConfig.NetworkManagementVectorLengthBytes & 0xF
+		clusterConfig.NetworkManagementVectorLengthBytes
 	});
 
 	registerWrites.push_back({ ERAYRegister::PRTC1,
 		(clusterConfig.TransmissionStartSequenceDurationBits & 0xF) |
-		((clusterConfig.CASRxLowMax & 0x1F) << 4) |
+		((clusterConfig.CASRxLowMax & 0x3F) << 4) |
-        (0x1 << 10) | // Most significant bit of CASRxLowMax. Hardwired to 1 and cannot be modified
 		((clusterConfig.StrobePointPosition & 0x3) << 12) |
 		((clusterConfig.Speed & 0x3) << 14) |
-		((clusterConfig.WakeupRxWindowBits & 0x1FF) << 16) |
+		((clusterConfig.WakeupRxWindowBits & 0x1ff) << 16) |
-		((controllerConfig.WakeupPattern & 0x3F) << 26)
+		((controllerConfig.WakeupPattern) << 26)
 	});
 
 	registerWrites.push_back({ ERAYRegister::PRTC2,
-		(clusterConfig.WakeupRxIdleBits & 0x3F) |
+		(clusterConfig.WakeupRxIdleBits) |
-		((clusterConfig.WakeupRxLowBits & 0x3F) << 8) |
+		((clusterConfig.WakeupRxLowBits) << 8) |
 		((clusterConfig.WakeupTxIdleBits) << 16) |
-		((clusterConfig.WakeupTxActiveBits & 0x3F) << 24)
+		((clusterConfig.WakeupTxActiveBits) << 24)
 	});
 
 	registerWrites.push_back({ ERAYRegister::MHDC,
-		(clusterConfig.PayloadLengthOfStaticSlotInWords & 0x7F) |
+		(clusterConfig.PayloadLengthOfStaticSlotInWords) |
-		((controllerConfig.LatestTxMinislot & 0x1FFF) << 16)
+		((controllerConfig.LatestTxMinislot) << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC1,
-		controllerConfig.MicroPerCycle & 0xFFFFF
+		controllerConfig.MicroPerCycle
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC2,
 		(clusterConfig.SyncFrameIDCountMax << 16) |
-		(clusterConfig.MacroticksPerCycle & 0x3FFF)
+		clusterConfig.MacroticksPerCycle
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC3,
 		(controllerConfig.MicroInitialOffsetA) |
 		((controllerConfig.MicroInitialOffsetB) << 8) |
-		((controllerConfig.MacroInitialOffsetA & 0x7F) << 16) |
+		((controllerConfig.MacroInitialOffsetA) << 16) |
-		((controllerConfig.MacroInitialOffsetB & 0x7F) << 24)
+		((controllerConfig.MacroInitialOffsetB) << 24)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC4,
-		((clusterConfig.MacroticksPerCycle - clusterConfig.NetworkIdleTimeMacroticks - 1) & 0x3FFF) |
+		((clusterConfig.MacroticksPerCycle - clusterConfig.NetworkIdleTimeMacroticks - 1) & 0xFFFF) |
-		(((clusterConfig.OffsetCorrectionStartMacroticks - 1) & 0x3FFF) << 16)
+		((clusterConfig.OffsetCorrectionStartMacroticks - 1) << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC5,
 		controllerConfig.DelayCompensationAMicroticks |
 		(controllerConfig.DelayCompensationBMicroticks << 8) |
-		((controllerConfig.ClusterDriftDamping & 0x1F) << 16) |
+		(controllerConfig.ClusterDriftDamping << 16) |
 		(controllerConfig.DecodingCorrectionMicroticks << 24)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC6,
-		(controllerConfig.AcceptStartupRangeMicroticks & 0x7FF) |
+		controllerConfig.AcceptStartupRangeMicroticks |
-		((controllerConfig.RateCorrectionOutMicroticks & 0x7FF) << 16)
+		(controllerConfig.RateCorrectionOutMicroticks << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC7,
-		(clusterConfig.StaticSlotMacroticks & 0x3FF) |
+		(clusterConfig.StaticSlotMacroticks) |
-		((clusterConfig.NumberOfStaticSlots & 0x3FF) << 16)
+		(clusterConfig.NumberOfStaticSlots << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC8,
-		(clusterConfig.MinislotDurationMacroticks & 0x3F) |
+		clusterConfig.MinislotDurationMacroticks |
-		((clusterConfig.NumberOfMinislots & 0x1FFF) << 16)
+		(clusterConfig.NumberOfMinislots << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC9,
-		(clusterConfig.ActionPointOffset & 0x3F) |
+		clusterConfig.ActionPointOffset |
-		((clusterConfig.MinislotActionPointOffsetMacroticks & 0x1F) << 8) |
+		(clusterConfig.MinislotActionPointOffsetMacroticks << 8) |
-		((clusterConfig.DynamicSlotIdlePhaseMinislots & 0x03) << 16)
+		(clusterConfig.DynamicSlotIdlePhaseMinislots << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC10,
-		(controllerConfig.OffsetCorrectionOutMicroticks & 0x3FFF) |
+		controllerConfig.OffsetCorrectionOutMicroticks |
-		((controllerConfig.RateCorrectionOutMicroticks & 0x7FF) << 16)
+		(controllerConfig.RateCorrectionOutMicroticks << 16)
 	});
 
 	registerWrites.push_back({ ERAYRegister::GTUC11,
-		(controllerConfig.ExternOffsetCorrectionControl & 0x3) |
+		controllerConfig.ExternOffsetCorrectionControl |
-		((controllerConfig.ExternRateCorrectionControl & 0x3) << 8) |
+		(controllerConfig.ExternRateCorrectionControl << 8) |
-		((controllerConfig.ExternOffsetCorrectionMicroticks & 0x7) << 16) |
+		(controllerConfig.ExternOffsetCorrectionMicroticks << 16) |
-		((controllerConfig.ExternRateCorrectionMicroticks & 0x7) << 24)
+		(controllerConfig.ExternRateCorrectionMicroticks << 24)
 	});
 
 	std::vector<std::shared_ptr<MessageBuffer>> staticTx;
@@ -201,7 +210,7 @@ bool FlexRay::Controller::configure(std::chrono::milliseconds timeout) {
 			second->isStartup = controllerConfig.KeySlotUsedForStartup;
 			second->isSync = controllerConfig.KeySlotUsedForSync;
 			second->isTransmit = true;
-			second->channelB = true;
+			second->channelB =true;
 			second->frameID = controllerConfig.SecondKeySlotID;
 			second->frameLengthBytes = clusterConfig.PayloadLengthOfStaticSlotInWords * 2;
 			second->baseCycle = 0;
@@ -257,7 +266,7 @@ bool FlexRay::Controller::configure(std::chrono::milliseconds timeout) {
 		totalBuffers = 128;
 
 	registerWrites.push_back({ ERAYRegister::MRC,
-		(static_cast<uint8_t>(staticTx.size())) | // FDB[7:0] message buffers exclusively for the static segment
+		(uint8_t(staticTx.size())) | // FDB[7:0] message buffers exclusively for the static segment
 		// FFB[7:0] set to 0x80, No message buffer assigned to the FIFO
 		(0x80 << 8) |
 		(uint8_t(totalBuffers - 1) << 16) |
@@ -278,12 +287,12 @@ bool FlexRay::Controller::configure(std::chrono::milliseconds timeout) {
 			buf.frameID = static_cast<uint16_t>(i | (1 << 10));
 
 		uint32_t hs1 = (
-			(buf.frameID) | // FID
+			(buf.frameID) |
-			(CalculateCycleFilter(buf.baseCycle, buf.cycleRepetition) << 16) | // CYA
+			(CalculateCycleFilter(buf.baseCycle, buf.cycleRepetition) << 16) |
-			((buf.channelA & 0x1) << 24) | // CHA
+			((buf.channelA & 0x1) << 24) |
-			((buf.channelB & 0x1) << 25) | // CHB
+			((buf.channelB & 0x1) << 25) |
 			((buf.isTransmit & 0x1) << 26) | // CFG
-			((buf.isNetworkManagementFrame & 0x1) << 27) | // PPIT
+			((buf.isNMFrame & 0x1) << 27) | // PPIT
 			((!buf.continuousMode & 0x1) << 28) | // TXM
 			((0 & 0x1) << 29) // MBI, disabled for now but we might want confirmations in the future
 		);
@@ -601,8 +610,7 @@ uint16_t FlexRay::Controller::CalculateCycleFilter(uint8_t baseCycle, uint8_t cy
 }
 
 std::pair<bool, uint32_t> FlexRay::Controller::readRegister(ERAYRegister reg, std::chrono::milliseconds timeout) const {
-	static const std::shared_ptr<MessageFilter> filter = std::make_shared<MessageFilter>();
+	static const std::shared_ptr<MessageFilter> filter = std::make_shared<MessageFilter>(icsneo::Network::NetID::FlexRayControl);
-    filter->includeInternalInAny = true;
 	if(timeout.count() <= 20)
 		return {false, 0}; // Out of time!
 

device/extensions/flexray/extension.cpp

@@ -25,6 +25,26 @@ void FlexRay::Extension::onGoOffline() {
 		controller->halt();
 }
 
+void FlexRay::Extension::handleMessage(const std::shared_ptr<Message>& message) {
+	switch(message->type) {
+		case Message::Type::FlexRayControl: {
+			auto msg = std::dynamic_pointer_cast<FlexRayControlMessage>(message);
+			if(!msg || !msg->decoded)
+				return;
+			switch(msg->opcode) {
+				case FlexRay::Opcode::ReadCCStatus:
+					if(msg->controller >= controllers.size())
+						return; // TODO error
+					controllers[msg->controller]->_setStatus(msg);
+					break;
+			}
+			break;
+		}
+		default:
+			break;
+	}
+}
+
 bool FlexRay::Extension::transmitHook(const std::shared_ptr<Frame>& frame, bool& success) {
 	if(!frame || frame->network.getType() != Network::Type::FlexRay)
 		return true; // Don't hook non-FlexRay messages

device/idevicesettings.cpp

@@ -4,9 +4,9 @@
 
 using namespace icsneo;
 
-std::optional<uint16_t> IDeviceSettings::CalculateGSChecksum(const std::vector<uint8_t>& settings) {
+std::optional<uint16_t> IDeviceSettings::CalculateGSChecksum(const std::vector<uint8_t>& settings, std::optional<size_t> knownSize) {
 	const uint16_t* p = reinterpret_cast<const uint16_t*>(settings.data());
-	size_t words = settings.size();
+	size_t words = std::min(knownSize.value_or(0), settings.size());
 	if(words % 2 == 1)
 		return std::nullopt; // Somehow settings is not word aligned
 	words /= 2;
@@ -159,12 +159,15 @@ bool IDeviceSettings::ValidateLINBaudrate(int64_t baudrate) {
 	}
 }
 
-bool IDeviceSettings::refresh() {
+bool IDeviceSettings::refresh(bool ignoreChecksum) {
 	if(disabled) {
 		report(APIEvent::Type::SettingsNotAvailable, APIEvent::Severity::Error);
 		return false;
 	}
 
+	if(disableGSChecksumming)
+		ignoreChecksum = true;
+
 	std::vector<uint8_t> rxSettings;
 	bool ret = com->getSettingsSync(rxSettings);
 	if(!ret) {
@@ -172,14 +175,24 @@ bool IDeviceSettings::refresh() {
 		return false;
 	}
 
-	constexpr size_t GsSize = 3 * sizeof(uint16_t); // <version> <length> <checksum>
+	constexpr size_t GsSize = 3 * sizeof(uint16_t);
 	if(rxSettings.size() < GsSize) { // We need to at least have the header of GLOBAL_SETTINGS
 		report(APIEvent::Type::SettingsReadError, APIEvent::Severity::Error);
 		return false;
 	}
 
+	// The length of the settings structure sent to us
+	// This is the length the firmware thinks the current version of the structure is
+	const size_t rxLen = rxSettings.size() - GsSize;
+
 	const uint16_t gsVersion = rxSettings[0] | (rxSettings[1] << 8);
 
+	// The length of the settings last saved
+	// If the firmware is updated, it will have either extended (with zeros) or truncated
+	// the structure, but this value will continue to be set to the last saved value
+	const uint16_t gsLen = rxSettings[2] | (rxSettings[3] << 8);
+
+	const uint16_t gsChecksum = rxSettings[4] | (rxSettings[5] << 8);
 	rxSettings.erase(rxSettings.begin(), rxSettings.begin() + GsSize);
 
 	if(gsVersion != GS_VERSION) {
@@ -187,6 +200,19 @@ bool IDeviceSettings::refresh() {
 		return false;
 	}
 
+	if(rxLen < gsLen) {
+		// We got less data, i.e. the firmware thinks the strucure is smaller than what
+		// was last saved. Usually this is due to a firmware downgrade. We'll ignore the
+		// checksum for now, because it will definitely be wrong.
+		ignoreChecksum = true;
+	}
+
+	// We check the checksum against the data last saved
+	if(!ignoreChecksum && gsChecksum != CalculateGSChecksum(rxSettings, gsLen)) {
+		report(APIEvent::Type::SettingsChecksumError, APIEvent::Severity::Error);
+		return false;
+	}
+
 	settings = std::move(rxSettings);
 	settingsInDeviceRAM = settings;
 	settingsLoaded = true;
@@ -235,7 +261,7 @@ bool IDeviceSettings::apply(bool temporary) {
 
 	std::shared_ptr<Main51Message> msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this, &bytestream]() {
 		return com->sendCommand(Command::SetSettings, bytestream);
-	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(5000)));
+	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(1000)));
 
 	if(!msg || msg->data[0] != 1) { // We did not receive a response
 		// Attempt to get the settings from the device so we're up to date if possible
@@ -246,7 +272,7 @@ bool IDeviceSettings::apply(bool temporary) {
 		return false;
 	}
 
-	refresh();
+	refresh(true); // Refresh ignoring checksum
 	// The device might modify the settings once they are applied, however in this case it does not update the checksum
 	// We refresh to get these updates, update the checksum, and send it back so it's all in sync
 	gsChecksum = CalculateGSChecksum(settings);
@@ -261,7 +287,7 @@ bool IDeviceSettings::apply(bool temporary) {
 
 	msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this, &bytestream]() {
 		return com->sendCommand(Command::SetSettings, bytestream);
-	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(5000)));
+	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(1000)));
 	if(!msg || msg->data[0] != 1) {
 		// Attempt to get the settings from the device so we're up to date if possible
 		if(refresh()) {
@@ -303,7 +329,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
 
 	std::shared_ptr<Main51Message> msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this]() {
 		return com->sendCommand(Command::SetDefaultSettings);
-	}, std::make_shared<Main51MessageFilter>(Command::SetDefaultSettings), std::chrono::milliseconds(5000)));
+	}, std::make_shared<Main51MessageFilter>(Command::SetDefaultSettings), std::chrono::milliseconds(1000)));
 	if(!msg || msg->data[0] != 1) {
 		// Attempt to get the settings from the device so we're up to date if possible
 		if(refresh()) {
@@ -316,7 +342,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
 	// This short wait helps on FIRE devices, otherwise the checksum might be wrong!
 	std::this_thread::sleep_for(std::chrono::milliseconds(3));
 
-	refresh();
+	refresh(true); // Refresh ignoring checksum
 	// The device might modify the settings once they are applied, however in this case it does not update the checksum
 	// We refresh to get these updates, update the checksum, and send it back so it's all in sync
 	std::vector<uint8_t> bytestream;
@@ -338,7 +364,7 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
 
 	msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this, &bytestream]() {
 		return com->sendCommand(Command::SetSettings, bytestream);
-	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(5000)));
+	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(1000)));
 	if(!msg || msg->data[0] != 1) {
 		// Attempt to get the settings from the device so we're up to date if possible
 		if(refresh()) {
@@ -945,18 +971,4 @@ template<typename T> bool IDeviceSettings::applyStructure(const T& newStructure)
 
 	memcpy(settings.data(), &newStructure, structSize);
 	return apply();
-}
-
-bool IDeviceSettings::setMiscIOAnalogOutputEnabled(uint8_t pin, bool enabled) {
-	(void)pin;
-	(void)enabled;
-	report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::Error);
-	return false;
-}
-
-bool IDeviceSettings::setMiscIOAnalogOutput(uint8_t pin, MiscIOAnalogVoltage voltage) {
-	(void)pin;
-	(void)voltage;
-	report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::Error);
-	return false;
 }

disk/diskdetails.cpp

@@ -1,81 +0,0 @@
-#include <icsneo/disk/diskdetails.h>
-#include <icsneo/device/idevicesettings.h>
-
-using namespace icsneo;
-
-#pragma pack(push, 2)
-
-struct DISK_STATUS {
-	uint16_t status;
-	uint64_t sectors;
-	uint32_t bytesPerSector;
-};
-
-struct DISK_DETAILS {
-	DISK_SETTINGS settings;
-	uint16_t options;
-	DISK_STATUS status[12];
-};
-
-#pragma pack(pop)
-
-static constexpr uint8_t DISK_FORMAT_FAT32 = 0x01u;
-static constexpr uint8_t DISK_STATUS_PRESENT = 0x01u;
-static constexpr uint8_t DISK_STATUS_INITIALIZED = 0x02u;
-static constexpr uint16_t DISK_DETAILS_FULL_FORMAT = 0x01u;
-
-std::vector<uint8_t> DiskDetails::Encode(const DiskDetails& config) {
-	std::vector<uint8_t> result(sizeof(DISK_DETAILS), 0);
-	DISK_DETAILS* details = reinterpret_cast<DISK_DETAILS*>(result.data());
-	details->settings.disk_layout = static_cast<uint8_t>(config.layout);
-	details->settings.disk_format = DISK_FORMAT_FAT32; // Always FAT32
-	details->options = config.fullFormat ? DISK_DETAILS_FULL_FORMAT : 0;
-	uint32_t& enables = details->settings.disk_enables;
-	enables = 0u;
-	for(size_t i = 0; i < config.disks.size(); i++) {
-		auto& disk = config.disks[i];
-		details->status[i].sectors = disk.sectors;
-		details->status[i].bytesPerSector = disk.bytesPerSector;
-
-		uint16_t& status = details->status[i].status;
-		status = 0u;
-		if(disk.initialized) {
-			status |= DISK_STATUS_INITIALIZED;
-		}
-		if(disk.present) {
-			status |= DISK_STATUS_PRESENT;
-		}
-		if(disk.formatted) {
-			enables |= (1u << i);
-		}
-	}
-
-	return result;
-}
-
-std::shared_ptr<DiskDetails> DiskDetails::Decode(const std::vector<uint8_t>& bytes, size_t diskCount, device_eventhandler_t report) {
-	if(bytes.size() < sizeof(DISK_DETAILS)) {
-		report(APIEvent::Type::BufferInsufficient, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	auto result = std::make_shared<DiskDetails>();
-	const DISK_DETAILS* details = reinterpret_cast<const DISK_DETAILS*>(bytes.data());
-	result->layout = static_cast<DiskLayout>(details->settings.disk_layout);
-	result->fullFormat = details->options & DISK_DETAILS_FULL_FORMAT;
-
-	result->disks.reserve(diskCount);
-
-	for(size_t i = 0; i < diskCount; i++) {
-		auto& disk = details->status[i];
-		result->disks.emplace_back();
-		auto& info = result->disks.back();
-		info.present = static_cast<bool>(disk.status & DISK_STATUS_PRESENT);
-		info.initialized = static_cast<bool>(disk.status & DISK_STATUS_INITIALIZED);
-		info.formatted = static_cast<bool>(details->settings.disk_enables & (1u << i));  
-		info.sectors = disk.sectors;
-		info.bytesPerSector = disk.bytesPerSector;
-	}
-
-	return result;
-}

disk/extextractordiskreaddriver.cpp

@@ -32,7 +32,7 @@ std::optional<uint64_t> ExtExtractorDiskReadDriver::readLogicalDiskAligned(Commu
 	return ret;
 }
 
-std::optional<uint64_t> ExtExtractorDiskReadDriver::attemptReadLogicalDiskAligned(Communication& com, device_eventhandler_t,
+std::optional<uint64_t> ExtExtractorDiskReadDriver::attemptReadLogicalDiskAligned(Communication& com, device_eventhandler_t report,
 	uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType) {
 	static std::shared_ptr<MessageFilter> NeoMemorySDRead = std::make_shared<MessageFilter>(Network::NetID::NeoMemorySDRead);
 

disk/neomemorydiskdriver.cpp

@@ -58,7 +58,7 @@ std::optional<uint64_t> NeoMemoryDiskDriver::readLogicalDiskAligned(Communicatio
 	return SectorSize;
 }
 
-std::optional<uint64_t> NeoMemoryDiskDriver::writeLogicalDiskAligned(Communication& com, device_eventhandler_t,
+std::optional<uint64_t> NeoMemoryDiskDriver::writeLogicalDiskAligned(Communication& com, device_eventhandler_t report,
 	uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType) {
 
 	static std::shared_ptr<MessageFilter> NeoMemoryDone = std::make_shared<MessageFilter>(Network::NetID::NeoMemoryWriteDone);

disk/plasiondiskreaddriver.cpp

@@ -6,7 +6,7 @@
 using namespace icsneo;
 using namespace icsneo::Disk;
 
-std::optional<uint64_t> PlasionDiskReadDriver::readLogicalDiskAligned(Communication& com, device_eventhandler_t,
+std::optional<uint64_t> PlasionDiskReadDriver::readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
 	uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType) {
 	static std::shared_ptr<MessageFilter> NeoMemorySDRead = std::make_shared<MessageFilter>(Network::NetID::NeoMemorySDRead);
 

disk/vsa/vsa.cpp

@@ -25,4 +25,19 @@ void VSAExtendedMessage::appendPacket(std::shared_ptr<Packet> packet) const
 	if(packet->network.getNetID() == Network::NetID::Invalid) {
 		packet->network = network;
 	}
+}
+
+void VSAExtendedMessage::truncatePacket(std::shared_ptr<Packet> packet)
+{
+	static constexpr auto EthernetLengthOffset = 26u;
+	switch(packet->network.getType()) {
+		case Network::Type::Ethernet:
+			{
+				const auto& packetLength = *reinterpret_cast<uint16_t*>(packet->data.data() + EthernetLengthOffset);
+				const size_t ethernetFrameSize = packetLength - (sizeof(uint16_t) * 2);
+				const size_t bytestreamExpectedSize = sizeof(HardwareEthernetPacket) + ethernetFrameSize;
+				packet->data.resize(bytestreamExpectedSize);
+			}	
+			break;
+	}
 }

disk/vsa/vsa02.cpp

@@ -9,7 +9,7 @@ VSA02::VSA02(uint8_t* const recordBytes)
 	constantIndex = *reinterpret_cast<uint16_t*>(recordBytes + 2);
 	flags = *reinterpret_cast<Flags*>(recordBytes + 4);
 	pieceCount = recordBytes[5];
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6) & UINT63_MAX;
 	samples.insert(samples.end(), recordBytes + 14, recordBytes + 30);
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 30);
 	doChecksum(recordBytes);

disk/vsa/vsa03.cpp

@@ -8,7 +8,7 @@ VSA03::VSA03(uint8_t* const recordBytes)
 	setType(VSA::Type::AA03);
 	eventType = static_cast<EventType>(*reinterpret_cast<uint16_t*>(recordBytes + 2));
 	eventData = *reinterpret_cast<uint16_t*>(recordBytes + 4);
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 14);
 	doChecksum(recordBytes);
 }

disk/vsa/vsa04.cpp

@@ -8,7 +8,7 @@ VSA04::VSA04(uint8_t* const recordBytes)
 	setType(VSA::Type::AA04);
 	flags = *reinterpret_cast<Flags*>(recordBytes + 2);
 	partitionIndex = *reinterpret_cast<uint16_t*>(recordBytes + 4);
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 14);
 	doChecksum(recordBytes);
 }

disk/vsa/vsa05.cpp

@@ -8,7 +8,7 @@ VSA05::VSA05(uint8_t* const recordBytes)
 	setType(VSA::Type::AA05);
 	errorType = static_cast<ErrorType>(*reinterpret_cast<uint16_t*>(recordBytes + 2));
 	errorNetwork = *reinterpret_cast<uint16_t*>(recordBytes + 4);
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 6) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 14);
 }
 

disk/vsa/vsa06.cpp

@@ -9,7 +9,7 @@ VSA06::VSA06(uint8_t* const recordBytes)
 	savedSectors.insert(savedSectors.end(), reinterpret_cast<uint32_t*>(recordBytes + 2), reinterpret_cast<uint32_t*>(recordBytes + 18));
 	error = *reinterpret_cast<uint16_t*>(recordBytes + 18);
 	savedSectorsHigh = *reinterpret_cast<uint16_t*>(recordBytes + 20);
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 30);
 	doChecksum(recordBytes);
 }

disk/vsa/vsa07.cpp

@@ -9,7 +9,7 @@ VSA07::VSA07(uint8_t* const recordBytes)
 	lastSector = *reinterpret_cast<uint32_t*>(recordBytes + 2);
 	currentSector = *reinterpret_cast<uint32_t*>(recordBytes + 6);
 	reserved.insert(reserved.end(), recordBytes + 10, recordBytes + 22);
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 30);
 	doChecksum(recordBytes);
 }

disk/vsa/vsa08.cpp

@@ -7,8 +7,8 @@ VSA08::VSA08(uint8_t* const recordBytes)
 {
 	setType(VSA::Type::AA08);
 	troubleSramCount.insert(troubleSramCount.end(), recordBytes + 2, recordBytes + 6);
-	troubleSectors.insert(troubleSectors.end(), reinterpret_cast<uint32_t*>(recordBytes + 6), reinterpret_cast<uint32_t*>(recordBytes + 22));
+	troubleSectors.insert(troubleSectors.end(), reinterpret_cast<uint32_t*>(recordBytes + 6), reinterpret_cast<uint32_t*>(recordBytes + 20));
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 30);
 	doChecksum(recordBytes);
 }

disk/vsa/vsa09.cpp

@@ -16,7 +16,7 @@ VSA09::VSA09(uint8_t* const recordBytes)
 	reserved0.insert(reserved0.end(), recordBytes + 12, recordBytes + 18);
 	hardwareID = static_cast<HardwareID>(recordBytes[18]);
 	reserved1.insert(reserved1.end(), recordBytes + 19, recordBytes + 22);
-	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22);
+	timestamp = *reinterpret_cast<uint64_t*>(recordBytes + 22) & UINT63_MAX;
 	checksum = *reinterpret_cast<uint16_t*>(recordBytes + 30);
 	doChecksum(recordBytes);
 }