Merge branch 'intrepidcs:master' into Npcap-fix

2025-01-11 23:15:28 +01:00 · 2025-01-11 23:15:28 +01:00 · 739ff4d637
parent e233233b94 2acf248583
commit 739ff4d637
124 changed files with 7785 additions and 1271 deletions
--- a/.gitignore
+++ b/.gitignore
@ -14,4 +14,4 @@ third-party/concurrentqueue/tests
 *.orig
 examples/csharp/bin
 examples/csharp/obj
-test/system
+test/system
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -5,6 +5,7 @@ stages:
  - build
  - unit_test
  - hardware_test
+  - deploy

 #-------------------------------------------------------------------------------
 # Windows
@ -318,57 +319,213 @@ unit_test linux/fedora/39/amd64/clang:
    - /opt/libvirt-driver/run.sh
  after_script:
    - /opt/libvirt-driver/cleanup.sh
+  allow_failure: true

-hardware_test system-test-fedora38-red2:
-  <<: *hw_test
-  variables:
-    GUEST_OS_TAG: fedora38
-    DEVICE_PORT: ETH_A
+.fedora38_needs: &fedora38_needs
  needs:
    - job: build linux/fedora/38/amd64/clang
      artifacts: true

-hardware_test system-test-fedora38-vcan42:
+hardware_test fedora38-red2:
  <<: *hw_test
+  <<: *fedora38_needs
+  variables:
+    GUEST_OS_TAG: fedora38
+    DEVICE_PORT: ETH_A
+
+hardware_test fedora38-vcan42:
+  <<: *hw_test
+  <<: *fedora38_needs
  variables:
    GUEST_OS_TAG: fedora38
    DEVICE_PORT: USB_D
-  needs:
-    - job: build linux/fedora/38/amd64/clang
-      artifacts: true

-hardware_test system-test-ubuntu2204-red2:
+hardware_test fedora38-fire3:
  <<: *hw_test
+  <<: *fedora38_needs
  variables:
-    GUEST_OS_TAG: ubuntu22.04
-    DEVICE_PORT: ETH_A
+    GUEST_OS_TAG: fedora38
+    DEVICE_PORT: ETH_B
+
+hardware_test fedora38-vcan42-EL:
+  <<: *hw_test
+  <<: *fedora38_needs
+  variables:
+    GUEST_OS_TAG: fedora38
+    DEVICE_PORT: USB_C
+
+.ubuntu2204_needs: &ubuntu2204_needs
  needs:
    - job: build linux/ubuntu/2204/amd64/clang
      artifacts: true

-hardware_test system-test-ubuntu2204-vcan42:
+hardware_test ubuntu2204-red2:
  <<: *hw_test
+  <<: *ubuntu2204_needs
+  variables:
+    GUEST_OS_TAG: ubuntu22.04
+    DEVICE_PORT: ETH_A
+
+hardware_test ubuntu2204-vcan42:
+  <<: *hw_test
+  <<: *ubuntu2204_needs
  variables:
    GUEST_OS_TAG: ubuntu22.04
    DEVICE_PORT: USB_D
+
+hardware_test ubuntu2204-fire3:
+  <<: *hw_test
+  <<: *ubuntu2204_needs
+  variables:
+    GUEST_OS_TAG: ubuntu22.04
+    DEVICE_PORT: ETH_B
+
+hardware_test ubuntu2204-vcan42-EL:
+  <<: *hw_test
+  <<: *ubuntu2204_needs
+  variables:
+    GUEST_OS_TAG: ubuntu22.04
+    DEVICE_PORT: USB_C
+
+.win10_needs: &win10_needs
  needs:
-    - job: build linux/ubuntu/2204/amd64/clang
+    - job: build windows/x64
      artifacts: true

-hardware_test system-test-win10-red2:
+hardware_test win10-red2:
  <<: *hw_test
+  <<: *win10_needs
  variables:
    GUEST_OS_TAG: win10
    DEVICE_PORT: ETH_A
-  needs:
-    - job: build windows/x64
-      artifacts: true

-hardware_test system-test-win10-vcan42:
+hardware_test win10-vcan42:
  <<: *hw_test
+  <<: *win10_needs
  variables:
    GUEST_OS_TAG: win10
    DEVICE_PORT: USB_D
+
+hardware_test win10-fire3:
+  <<: *hw_test
+  <<: *win10_needs
+  variables:
+    GUEST_OS_TAG: win10
+    DEVICE_PORT: ETH_B
+
+hardware_test win10-vcan42-EL:
+  <<: *hw_test
+  <<: *win10_needs
+  variables:
+    GUEST_OS_TAG: win10
+    DEVICE_PORT: USB_C
+
+#-------------------------------------------------------------------------------
+# Python Module
+#-------------------------------------------------------------------------------
+
+build python/linux/amd64:
+  stage: build
+  tags:
+    - linux-build
+  image: python:3.12
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
+  variables:
+    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
+    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:
+      - wheelhouse
+
+build python/linux/arm64:
+  stage: build
+  tags:
+    - arm64-linux-build
+  variables:
+    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:/project/libusb/install
+  script:
+    - sh ci/build-wheel-posix.sh
+  artifacts:
+    paths:
+      - wheelhouse
+
+build python/macos:
+  stage: build
+  tags:
+    - macos-arm64
+  variables:
+    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:$CI_PROJECT_DIR/libusb/install
+    MACOSX_DEPLOYMENT_TARGET: 10.14
+  script:
+    - sh ci/build-wheel-posix.sh
+  artifacts:
+    paths:
+      - wheelhouse
+
+build python/windows:
+  stage: build
+  tags:
+    - libicsneo-win-x64
+  variables:
+    CIBW_ARCHS: AMD64
+    CIBW_ENVIRONMENT: CMAKE_GENERATOR=Ninja
+  script:
+    - cmd /c ci\build-wheel-windows.bat
+  artifacts:
+    paths:
+      - wheelhouse
+
+deploy python/pypi:
+  stage: deploy
+  variables:
+    TWINE_USERNAME: __token__
+    TWINE_PASSWORD: $PYPI_TOKEN
+  tags:
+    - linux-build
+  image: python:3.12
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  script:
+    - python3 -m pip install -U twine
+    - twine upload wheelhouse/*
+  dependencies:
+    - build python/linux/amd64
+    - build python/linux/arm64
+    - build python/macos
+    - build python/windows
  needs:
-    - job: build windows/x64
-      artifacts: true
+    - build python/linux/amd64
+    - build python/linux/arm64
+    - build python/macos
+    - build python/windows
+
+push github:
+  stage: deploy
+  tags:
+    - linux-build
+  image: alpine:latest
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  dependencies:
+    - deploy python/pypi
+  needs:
+    - deploy python/pypi
+  script:
+    - apk add git
+    - git push https://$LIBICSNEO_GITHUB_USERNAME:$LIBICSNEO_GITHUB_TOKEN@github.com/intrepidcs/libicsneo.git HEAD:master
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@ -0,0 +1,15 @@
+version: 2
+
+build:
+  os: "ubuntu-24.04"
+  tools:
+    python: "3.12"
+  apt_packages:
+    - doxygen
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+sphinx:
+  configuration: docs/conf.py
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -27,6 +27,8 @@ option(LIBICSNEO_ENABLE_FTDI "Enable devices which communicate over USB FTDI2XX"
 option(LIBICSNEO_ENABLE_TCP "Enable devices which communicate over TCP" OFF)
 option(LIBICSNEO_ENABLE_FTD3XX "Enable devices which communicate over USB FTD3XX" ON)

+option(LIBICSNEO_ENABLE_BINDINGS_PYTHON "Enable Python library" OFF)
+
 if(NOT CMAKE_CXX_STANDARD)
 	set(CMAKE_CXX_STANDARD 17)
 endif()
@ -172,27 +174,27 @@ 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/23.28.0/libftd3xx-1.3.0.4-win-x64.zip")
-			set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=ee1289cdd5023de67275aaa1712e8e32e73e825a8392efb0a76f161e357fbdc9")
+			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/23.28.0/libftd3xx-1.3.0.4-win-i686.zip")
-			set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=bcd31f5c3cb39ecb9b09db5ce722bd79de6e0f813130e7b8f2c86879a60d8ff0")
+			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/23.28.0/libftd3xx-1.0.14-macos-universal2.zip")
-			set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=74c0d35f04242d0841532c6325eb2932b8f627e3c395382a15d9f39974d27a90")
+			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/23.28.0/libftd3xx-1.0.14-linux-x64.zip")
-					set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=a9dc7eb6948c8977fbd79f6700bec6f882d3da5667aea8f2175b8d1f6f08e456")
+					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/23.28.0/libftd3xx-1.0.14-linux-aarch64.zip")
-					set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=da4b90ea1cbb905874cd159ad2ab8c1bdde65cc22b3aa55bf2b5fd85ca6efd22")
+					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/23.28.0/libftd3xx-1.0.14-linux-armhf.zip")
-					set(LIBICSNEO_FTD3XX_URL_HASH "SHA256=d813008117422cae958f7c71a065cdac0d31dca3b24809d3ab5e13604a9c3fb1")
+					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()
@ -238,11 +240,14 @@ set(SRC_FILES
 	communication/message/flexray/control/flexraycontrolmessage.cpp
 	communication/message/callback/streamoutput/a2bwavoutput.cpp
 	communication/message/a2bmessage.cpp
+	communication/message/apperrormessage.cpp
 	communication/message/neomessage.cpp
 	communication/message/ethphymessage.cpp
 	communication/message/linmessage.cpp
 	communication/message/livedatamessage.cpp
 	communication/message/tc10statusmessage.cpp
+	communication/message/gptpstatusmessage.cpp
+	communication/message/ethernetstatusmessage.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp
@ -493,6 +498,8 @@ if(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC)
 	target_compile_definitions(icsneolegacy-static PUBLIC ICSNEOC_BUILD_STATIC)
 endif()

+add_subdirectory(bindings)
+
 # googletest
 if(LIBICSNEO_BUILD_UNIT_TESTS)
 	if(WIN32)
@ -519,6 +526,7 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 		test/unit/mdioencoderdecodertest.cpp
 		test/unit/livedataencoderdecodertest.cpp
 		test/unit/ringbuffertest.cpp
+		test/unit/apperrordecodertest.cpp
 	)

 	target_link_libraries(libicsneo-unit-tests gtest gtest_main)
--- a/HARDWARE.md
+++ b/HARDWARE.md
@ -1,60 +0,0 @@
-# Hardware Support
-
- Connecting over Ethernet
-	- neoVI FIRE 2
-		- CAN works
-		- CAN FD works
-	- ValueCAN 4-2EL
-		- CAN works
-		- CAN FD works
-		- Ethernet works
-	- RADGalaxy
-		- CAN works
-		- Ethernet works
-	- RADStar 2
-		- CAN works
-		- Ethernet works
-	- RADA2B
-		- CAN works
-		- Ethernet works
-	- RADComet
-		- CAN works
-		- CAN FD works
-		- Ethernet works
-	- RADComet3
-		- CAN works
-		- Ethernet works
-	- neoVI Connect
-		- CAN works
-		- CAN FD works
-		- Ethernet works
-
- Connecting over USB
-	- ValueCAN 4 series
-		- CAN works
-		- CAN FD works
-		- Ethernet works (on 4-2EL)
-	- neoOBD2 PRO
-		- CAN works
-	- neoVI FIRE
-		- CAN works
-	- neoVI FIRE 2
-		- CAN works
-		- CAN FD works
-		- Ethernet works
-	- ValueCAN 3
-		- CAN works
-	- RADStar 2
-		- CAN works
-		- Ethernet works
-	- neoVI PLASMA
-		- CAN works
-	- neoVI ION
-		- CAN works
-	- RADA2B
-		- CAN works
-		- Ethernet works
-	- RADMoon3
-	- RADComet3
-		- CAN works
-		- Ethernet works
--- a/README.md
+++ b/README.md
@ -1,176 +1,43 @@
 # libicsneo
-### The Intrepid Control Systems Open Source Cross-Platform Device Communication API

-An open source solution to integrate Intrepid Control Systems vehicle networking hardware with your application.
+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.

-[Read the Full Documentation](https://libicsneo.readthedocs.io/)
+## Documentation

-## Getting Started
-There are two major ways to write a new application using libicsneo. You can use the C++ interface, which will be compiled with your project and statically linked, or you can use the C interface, which can be either statically or dynamically linked.
-### Integration with CMake (Static Linking)
-Integrating the library with your current CMake project is extremely easy.
-1. Checkout the library (or add as a submodule) into a subdirectory of your project.
-2. Within your `CMakeLists.txt` you can add the line `add_subdirectory("third-party/libicsneo")` to bring in the libicsneo targets. Replace `third-party` with any subdirectory you choose.
-3. The libicsneo library include paths should automatically be added to your include path.
-4. Link the library with your target by adding `target_link_libraries(libicsneocpp-example icsneocpp)` after your target, substituting `libicsneocpp-example` with your target application.
+- [C++](https://libicsneo.readthedocs.io/en/latest/icsneocpp/)
+- [Python](https://libicsneo.readthedocs.io/en/latest/icsneopy/)
+- [C](https://libicsneo.readthedocs.io/en/latest/icsneoc/)

-You can now include either the C++ API with `#include <icsneo/icsneocpp.h>` or the C API with `#include <icsneo/icsneoc.h>`
+## Hardware Support

-### DLL / SO / DYLIB Releases (Dynamic Linking)
-It is also possible to use the precompiled binaries with runtime linking. It is not recommended or supported to attempt to use the C++ interface with dynamic linking due to the complexities of C++ compilers.
-1. Add this repository's `/include` to your include path
-2. Add `#define ICSNEOC_DYNAMICLOAD` to the top of your source file
-2. Add `#import <icsneo/icsneoc.h>` below that line
-3. Call `icsneo_init();` to import the library before using any other libicsneo functions.
-4. Use the library as normal.
-5. Call `icsneo_close();` to unload the library.
+- EtherBADGE
+- neoVI Connect
+- neoVI FIRE
+- neoVI FIRE 2
+- neoVI FIRE 3
+- neoVI ION
+- neoVI PLASMA
+- neoVI RED 2
+- RAD-A2B
+- RAD-Comet 2
+- RAD-Comet 3
+- RAD-Galaxy
+- RAD-Galaxy 2
+- RAD-Gigastar
+- RAD-Gigastar 2
+- RAD-Moon 2
+- RAD-Moon 3
+- RAD-Moon T1S
+- RAD-Pluto
+- RAD-Star 2
+- RAD-SuperMoon
+- RADComet
+- ValueCAN 3
+- ValueCAN 4

-## Usage
-### Using the C++ API
-The C++ API is designed to be modern and easy to use. All library functions and classes are in the namespace `icsneo`. Most applications will start by calling `icsneo::FindAllDevices()`. This will return an `std::vector` of `std::shared_ptr<icsneo::Device>` objects. You will want to keep a copy of the `shared_ptr` to any devices you want to use, as allowing it to go out of scope will automatically close the device and free all memory associated with it.
+## License

-Any time you get bus traffic from the API, you will receive it as an `std::shared_ptr<icsneo::Message>`. The message will be valid as long as the `shared_ptr` stays in scope. Checking the type of the message allows you to cast it accordingly and access extra data for certain protocols. For instance, casting an `icsneo::Message` to an `icsneo::CANMessage` allows you to access the arbitration ID.
-
-A barebones example is provided. For a more complete example, check the included `examples`.
-``` c++
-std::vector<std::shared_ptr<icsneo::Device>> devices = icsneo::FindAllDevices();
-std::cout << devices.size() << " found!" << std::endl;
-for(auto& device : devices)
-    std::cout << "Found " << device->describe() << std::endl; // "Found neoVI FIRE 2 CY2345"
-std::shared_ptr<icsneo::Device> myDevice = devices[0];
-
-if(!myDevice->open()) // Device tried and failed to open, print the last error
-    std::cout << icsneo::GetLastError() << std::endl;
-
-myDevice->goOnline(); // Start receiving messages
-myDevice->enableMessagePolling(); // Allow the use of myDevice->getMessages() later
-// Alternatively, assign a callback for new messages
-std::this_thread::wait_for(std::chrono::seconds(5));
-std::vector<std::shared_ptr<icsneo::Message>> messages = myDevice->getMessages();
-std::cout << "We got " << messages.size() << " messages!" << std::endl;
-for(auto& msg : messages) {
-    switch(msg->network.getType()) {
-        case icsneo::Network::Type::CAN:
-        case icsneo::Network::Type::SWCAN:
-        case icsneo::Network::Type::LSFTCAN: {
-            // A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
-            auto canmsg = std::static_pointer_cast<icsneo::CANMessage>(msg);
-            // canmsg->arbid is valid here
-            // canmsg->data is an std::vector<uint8_t>, you can check .size() for the DLC of the message
-            // canmsg->timestamp is the time recorded by the hardware in nanoseconds since (1/1/2007 12:00:00 GMT)
-        }
-        default:
-            // Handle others
-    }
-}
-myDevice->close();
-```
-
-### Using the C API
-The C API is designed to be a robust and fault tolerant interface which allows easy integration with other languages as well as existing C applications. When calling `icsneo_findAllDevices()` you will provide a buffer of `neodevice_t` structures, which will be written with the found devices. These `neodevice_t` structures can be uses to interface with the API from then on. Once you call `icsneo_close()` with a device, that device and all associated memory will be freed. You will need to run `icsneo_findAllDevices()` again to reconnect.
-
-Messages are passed in the form of `neomessage_t` structures when calling `icsneo_getMessages()`. These structures contain a `uint8_t*` to the payload data, and this pointer will be valid until the next call to `icsneo_getMessages()` or the device is closed.
-
-A barebones example is provided. For a more complete example, check the included `examples`.
-``` c
-size_t deviceCount = 10; // Pre-set to the size of your buffer before the icsneo_findAllDevices() call
-neodevice_t devices[10];
-icsneo_findAllDevices(devices, &deviceCount);
-printf("We found %ull devices\n", deviceCount);
-for(size_t i = 0; i < deviceCount; i++) {
-    neodevice_t* myDevice = &devices[i];
-    char desc[ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION];
-    size_t sz = ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
-    icsneo_describeDevice(myDevice, desc, &sz);
-    printf("Found %s\n", desc); // "Found neoVI FIRE 2 CY2345"
-}
-
-neodevice_t* myDevice = &devices[0];
-if(!icsneo_openDevice(myDevice)) {
-    neoevent_t error;
-    if(icsneo_getLastError(&error))
-        printf("Error! %s\n", error.description);
-}
-icsneo_goOnline(myDevice); // Start receiving messages
-icsneo_enableMessagePolling(myDevice); // Allow the use of icsneo_getMessages() later
-sleep(5);
-neomessage_t messages[50];
-size_t messageCount = 50;
-icsneo_getMessages(myDevice, messages, &messageCount, 0 /* non-blocking */);
-printf("We got %ull messages!\n", messageCount);
-for(size_t i = 0; i < messageCount; i++) {
-    if(messages[i].type == ICSNEO_NETWORK_TYPE_CAN) {
-        // A message of type CAN should be interperated a neomessage_can_t, so we can cast safely
-        neomessage_can_t* canmsg = (neomessage_can_t*)&messages[i];
-        // canmsg->arbid is valid here
-        // canmsg->data is an uint8_t*, you can check canmsg->length for the length of the payload
-        // canmsg->timestamp is the time recorded by the hardware in nanoseconds since (1/1/2007 12:00:00 GMT)
-    }
-}
-icsneo_closeDevice(myDevice);
-```
-
-### Debugging
-
-To enable debug printing set the `LIBICSNEO_PRINT_EVENTS` environmental variable to the desired `APIEvent::Severity` level, all `Event`s greater than or equal to that level will be printed to stderr. For example, to print all warnings and errors: `LIBICSNEO_PRINT_EVENTS=32`.
-
-## Building from Source
-### FTD3XX
-Some devices require FTD3XX for USB communication so the [FTDI D3XX library](https://ftdichip.com/drivers/d3xx-drivers/) will be automatically downloaded and included. If you would like to use a system copy of D3XX instead you can set `FTD3XX_ROOT` to the path containing `f3d3xx.h` (`-DFTD3XX_ROOT=<path to directory containing ftd3xx.h>`).
-### Windows
-
- Open a terminal and install the following:
-```
-winget install Microsoft.VisualStudio.2022.Community
-winget install Kitware.CMake
-winget install Git.Git
-winget install Ninja-build.Ninja
-```
- Reboot so cmake is in the system path
- Open a developer Powershell for VS2022 and run the following:
-```
-git clone https://github.com/intrepidcs/libicsneo
-cd libicsneo
-cmake -S . -B build -G "Ninja"
-cmake --build build
-# All dlls and libs are now inside the build directory
-```
-
-
-Building will require MSVC 2017 version 15.7 or newer and CMake to be installed.
-### macOS
-Getting the dependencies is easiest with the Homebrew package manager. You will also need XCode installed. You can then install CMake, an up-to-date version of GCC or Clang, and `libusb-1.0`.
-### Linux
-#### General Dependencies
- - CMake 3.12 or above
- - GCC 7 or above
- - `libusb-1.0-0-dev`
- - `libpcap0.8-dev`
- - `build-essential` is recommended
-
-#### Fedora
-```
-dnf install git @development-tools gcc-c++ libpcap-devel libusb1-devel cmake
-```
-#### Debian/Ubuntu
-```
-apt install git build-essential libpcap0.8-dev libusb-1.0-0-dev cmake
-```
-
-#### Building
-```
-git clone https://github.com/intrepidcs/libicsneo
-cd libicsneo
-cmake -S . -B build
-cmake --build build
-# Optional: Install globally:
-cp *.so /usr/local/lib/
-```
-
-#### udev
-If you'd like to be able to run programs that use this library without being root, consider using the included udev rules:
-
-```
-cp 99-intrepidcs.rules /etc/udev/rules.d/
-udevadm control --reload-rules && udevadm trigger
-```
+libicsneo is licensed as BSD-3 with an extra clause, see [LICENSE](LICENSE)
+for more details.
--- a/api/icsneocpp/event.cpp
+++ b/api/icsneocpp/event.cpp
@ -120,6 +120,7 @@ static constexpr const char* DISK_NOT_CONNECTED = "The program tried to access a
 static constexpr const char* UNEXPECTED_RESPONSE = "Received an unexpected or invalid response from the device.";
 static constexpr const char* LIN_SETTINGS_NOT_AVAILABLE = "LIN settings are not available for this device.";
 static constexpr const char* MODE_NOT_FOUND = "The mode was not found.";
+static constexpr const char* GPTP_NOT_SUPPORTED = "GPTP clock synchronization is not supported on this device.";

 // Transport Errors
 static constexpr const char* FAILED_TO_READ = "A read operation failed.";
@ -185,6 +186,7 @@ static constexpr const char* VSA_OTHER_ERROR = "Unknown error in VSA read API.";
 static constexpr const char* TOO_MANY_EVENTS = "Too many events have occurred. The list has been truncated.";
 static constexpr const char* UNKNOWN = "An unknown internal error occurred.";
 static constexpr const char* INVALID = "An invalid internal error occurred.";
+
 const char* APIEvent::DescriptionForType(Type type) {
 	switch(type) {
 		// API Errors
@ -345,6 +347,8 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return GETIFADDRS_ERROR;
 		case Type::SendToError:
 			return SEND_TO_ERROR;
+		case Type::GPTPNotSupported:
+			return GPTP_NOT_SUPPORTED;
 	
 		// FTD3XX
 		case Type::FTOK:
--- a/bindings/CMakeLists.txt
+++ b/bindings/CMakeLists.txt
@ -0,0 +1,3 @@
+if(LIBICSNEO_ENABLE_BINDINGS_PYTHON)
+	add_subdirectory(python)
+endif()
--- a/bindings/python/CMakeLists.txt
+++ b/bindings/python/CMakeLists.txt
@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.20)
+
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+
+pybind11_add_module(icsneopy
+    icsneopy/api/event.cpp
+    icsneopy/api/eventcallback.cpp
+    icsneopy/api/eventmanager.cpp
+    icsneopy/api/version.cpp
+    icsneopy/device/devicetype.cpp
+    icsneopy/communication/network.cpp
+    icsneopy/communication/message/message.cpp
+    icsneopy/communication/message/canmessage.cpp
+    icsneopy/communication/message/canerrorcountmessage.cpp
+    icsneopy/communication/message/ethernetmessage.cpp
+    icsneopy/communication/message/linmessage.cpp
+    icsneopy/communication/message/tc10statusmessage.cpp
+    icsneopy/communication/message/mdiomessage.cpp
+    icsneopy/communication/message/gptpstatusmessage.cpp
+    icsneopy/communication/message/ethernetstatusmessage.cpp
+    icsneopy/communication/message/callback/messagecallback.cpp
+    icsneopy/communication/message/filter/messagefilter.cpp
+    icsneopy/device/device.cpp
+    icsneopy/icsneocpp.cpp
+)
+target_link_libraries(icsneopy PRIVATE icsneocpp)
+
+install(TARGETS icsneopy LIBRARY DESTINATION icsneopy)
+
+add_custom_command(TARGET icsneopy POST_BUILD COMMAND stubgen -m icsneopy -o .)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi __init__.py py.typed DESTINATION icsneopy)
--- a/bindings/python/init.py
+++ b/bindings/python/init.py
@ -0,0 +1 @@
+from .icsneopy import *
--- a/bindings/python/icsneopy/api/event.cpp
+++ b/bindings/python/icsneopy/api/event.cpp
@ -0,0 +1,170 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/api/event.h"
+
+namespace icsneo {
+
+void init_event(pybind11::module_& m) {
+	pybind11::class_<APIEvent, std::shared_ptr<APIEvent>> apiEvent(m, "APIEvent");
+	pybind11::enum_<APIEvent::Type>(apiEvent, "Type")
+		.value("Any", APIEvent::Type::Any)
+		.value("InvalidNeoDevice", APIEvent::Type::InvalidNeoDevice)
+		.value("RequiredParameterNull", APIEvent::Type::RequiredParameterNull)
+		.value("BufferInsufficient", APIEvent::Type::BufferInsufficient)
+		.value("OutputTruncated", APIEvent::Type::OutputTruncated)
+		.value("ParameterOutOfRange", APIEvent::Type::ParameterOutOfRange)
+		.value("DeviceCurrentlyOpen", APIEvent::Type::DeviceCurrentlyOpen)
+		.value("DeviceCurrentlyClosed", APIEvent::Type::DeviceCurrentlyClosed)
+		.value("DeviceCurrentlyOnline", APIEvent::Type::DeviceCurrentlyOnline)
+		.value("DeviceCurrentlyOffline", APIEvent::Type::DeviceCurrentlyOffline)
+		.value("DeviceCurrentlyPolling", APIEvent::Type::DeviceCurrentlyPolling)
+		.value("DeviceNotCurrentlyPolling", APIEvent::Type::DeviceNotCurrentlyPolling)
+		.value("UnsupportedTXNetwork", APIEvent::Type::UnsupportedTXNetwork)
+		.value("MessageMaxLengthExceeded", APIEvent::Type::MessageMaxLengthExceeded)
+		.value("ValueNotYetPresent", APIEvent::Type::ValueNotYetPresent)
+		.value("Timeout", APIEvent::Type::Timeout)
+		.value("WiVINotSupported", APIEvent::Type::WiVINotSupported)
+		.value("RestrictedEntryFlag", APIEvent::Type::RestrictedEntryFlag)
+		.value("NotSupported", APIEvent::Type::NotSupported)
+		.value("PollingMessageOverflow", APIEvent::Type::PollingMessageOverflow)
+		.value("NoSerialNumber", APIEvent::Type::NoSerialNumber)
+		.value("IncorrectSerialNumber", APIEvent::Type::IncorrectSerialNumber)
+		.value("SettingsReadError", APIEvent::Type::SettingsReadError)
+		.value("SettingsVersionError", APIEvent::Type::SettingsVersionError)
+		.value("SettingsLengthError", APIEvent::Type::SettingsLengthError)
+		.value("SettingsChecksumError", APIEvent::Type::SettingsChecksumError)
+		.value("SettingsNotAvailable", APIEvent::Type::SettingsNotAvailable)
+		.value("SettingsReadOnly", APIEvent::Type::SettingsReadOnly)
+		.value("CANSettingsNotAvailable", APIEvent::Type::CANSettingsNotAvailable)
+		.value("CANFDSettingsNotAvailable", APIEvent::Type::CANFDSettingsNotAvailable)
+		.value("LSFTCANSettingsNotAvailable", APIEvent::Type::LSFTCANSettingsNotAvailable)
+		.value("SWCANSettingsNotAvailable", APIEvent::Type::SWCANSettingsNotAvailable)
+		.value("BaudrateNotFound", APIEvent::Type::BaudrateNotFound)
+		.value("UnexpectedNetworkType", APIEvent::Type::UnexpectedNetworkType)
+		.value("DeviceFirmwareOutOfDate", APIEvent::Type::DeviceFirmwareOutOfDate)
+		.value("SettingsStructureMismatch", APIEvent::Type::SettingsStructureMismatch)
+		.value("SettingsStructureTruncated", APIEvent::Type::SettingsStructureTruncated)
+		.value("NoDeviceResponse", APIEvent::Type::NoDeviceResponse)
+		.value("MessageFormattingError", APIEvent::Type::MessageFormattingError)
+		.value("CANFDNotSupported", APIEvent::Type::CANFDNotSupported)
+		.value("RTRNotSupported", APIEvent::Type::RTRNotSupported)
+		.value("DeviceDisconnected", APIEvent::Type::DeviceDisconnected)
+		.value("OnlineNotSupported", APIEvent::Type::OnlineNotSupported)
+		.value("TerminationNotSupportedDevice", APIEvent::Type::TerminationNotSupportedDevice)
+		.value("TerminationNotSupportedNetwork", APIEvent::Type::TerminationNotSupportedNetwork)
+		.value("AnotherInTerminationGroupEnabled", APIEvent::Type::AnotherInTerminationGroupEnabled)
+		.value("NoSerialNumberFW", APIEvent::Type::NoSerialNumberFW)
+		.value("NoSerialNumber12V", APIEvent::Type::NoSerialNumber12V)
+		.value("NoSerialNumberFW12V", APIEvent::Type::NoSerialNumberFW12V)
+		.value("EthPhyRegisterControlNotAvailable", APIEvent::Type::EthPhyRegisterControlNotAvailable)
+		.value("DiskNotSupported", APIEvent::Type::DiskNotSupported)
+		.value("EOFReached", APIEvent::Type::EOFReached)
+		.value("SettingsDefaultsUsed", APIEvent::Type::SettingsDefaultsUsed)
+		.value("AtomicOperationRetried", APIEvent::Type::AtomicOperationRetried)
+		.value("AtomicOperationCompletedNonatomically", APIEvent::Type::AtomicOperationCompletedNonatomically)
+		.value("WiVIStackRefreshFailed", APIEvent::Type::WiVIStackRefreshFailed)
+		.value("WiVIUploadStackOverflow", APIEvent::Type::WiVIUploadStackOverflow)
+		.value("I2CMessageExceedsMaxLength", APIEvent::Type::I2CMessageExceedsMaxLength)
+		.value("A2BMessageIncompleteFrame", APIEvent::Type::A2BMessageIncompleteFrame)
+		.value("CoreminiUploadVersionMismatch", APIEvent::Type::CoreminiUploadVersionMismatch)
+		.value("DiskNotConnected", APIEvent::Type::DiskNotConnected)
+		.value("UnexpectedResponse", APIEvent::Type::UnexpectedResponse)
+		.value("LiveDataInvalidHandle", APIEvent::Type::LiveDataInvalidHandle)
+		.value("LiveDataInvalidCommand", APIEvent::Type::LiveDataInvalidCommand)
+		.value("LiveDataInvalidArgument", APIEvent::Type::LiveDataInvalidArgument)
+		.value("LiveDataVersionMismatch", APIEvent::Type::LiveDataVersionMismatch)
+		.value("LiveDataNoDeviceResponse", APIEvent::Type::LiveDataNoDeviceResponse)
+		.value("LiveDataMaxSignalsReached", APIEvent::Type::LiveDataMaxSignalsReached)
+		.value("LiveDataCommandFailed", APIEvent::Type::LiveDataCommandFailed)
+		.value("LiveDataEncoderError", APIEvent::Type::LiveDataEncoderError)
+		.value("LiveDataDecoderError", APIEvent::Type::LiveDataDecoderError)
+		.value("LiveDataNotSupported", APIEvent::Type::LiveDataNotSupported)
+		.value("LINSettingsNotAvailable", APIEvent::Type::LINSettingsNotAvailable)
+		.value("ModeNotFound", APIEvent::Type::ModeNotFound)
+		.value("AppErrorParsingFailed", APIEvent::Type::AppErrorParsingFailed)
+		.value("FailedToRead", APIEvent::Type::FailedToRead)
+		.value("FailedToWrite", APIEvent::Type::FailedToWrite)
+		.value("DriverFailedToOpen", APIEvent::Type::DriverFailedToOpen)
+		.value("DriverFailedToClose", APIEvent::Type::DriverFailedToClose)
+		.value("PacketChecksumError", APIEvent::Type::PacketChecksumError)
+		.value("TransmitBufferFull", APIEvent::Type::TransmitBufferFull)
+		.value("DeviceInUse", APIEvent::Type::DeviceInUse)
+		.value("PCAPCouldNotStart", APIEvent::Type::PCAPCouldNotStart)
+		.value("PCAPCouldNotFindDevices", APIEvent::Type::PCAPCouldNotFindDevices)
+		.value("PacketDecodingError", APIEvent::Type::PacketDecodingError)
+		.value("SocketFailedToOpen", APIEvent::Type::SocketFailedToOpen)
+		.value("FailedToBind", APIEvent::Type::FailedToBind)
+		.value("ErrorSettingSocketOption", APIEvent::Type::ErrorSettingSocketOption)
+		.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)
+		.value("VSAMaxReadAttemptsReached", APIEvent::Type::VSAMaxReadAttemptsReached)
+		.value("VSAByteParseFailure", APIEvent::Type::VSAByteParseFailure)
+		.value("VSAExtendedMessageError", APIEvent::Type::VSAExtendedMessageError)
+		.value("VSAOtherError", APIEvent::Type::VSAOtherError)
+		.value("NoErrorFound", APIEvent::Type::NoErrorFound)
+		.value("TooManyEvents", APIEvent::Type::TooManyEvents)
+		.value("Unknown", APIEvent::Type::Unknown);
+	
+	pybind11::enum_<APIEvent::Severity>(apiEvent, "Severity")
+		.value("Any", APIEvent::Severity::Any)
+		.value("EventInfo", APIEvent::Severity::EventInfo)
+		.value("EventWarning", APIEvent::Severity::EventWarning)
+		.value("Error", APIEvent::Severity::Error);
+	
+	apiEvent
+		.def("get_type", &APIEvent::getType)
+		.def("get_severity", &APIEvent::getSeverity)
+		.def("get_description", &APIEvent::getDescription)
+		.def("describe", &APIEvent::describe)
+		.def("__repr__", &APIEvent::describe);
+
+	pybind11::class_<EventFilter, std::shared_ptr<EventFilter>>(m, "EventFilter")
+		.def(pybind11::init())
+		.def(pybind11::init<APIEvent::Type>())
+		.def(pybind11::init<APIEvent::Severity>())
+		.def_readwrite("type", &EventFilter::type)
+		.def_readwrite("severity", &EventFilter::severity)
+		.def_readwrite("serial", &EventFilter::serial);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/api/eventcallback.cpp
+++ b/bindings/python/icsneopy/api/eventcallback.cpp
@ -0,0 +1,16 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/api/eventcallback.h"
+
+namespace icsneo {
+
+void init_eventcallback(pybind11::module_& m) {
+	pybind11::class_<EventCallback>(m, "EventCallback")
+		.def(pybind11::init<EventCallback::fn_eventCallback, EventFilter>())
+		.def(pybind11::init<EventCallback::fn_eventCallback>());
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/api/eventmanager.cpp
+++ b/bindings/python/icsneopy/api/eventmanager.cpp
@ -0,0 +1,18 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/api/eventmanager.h"
+
+namespace icsneo {
+
+void init_eventmanager(pybind11::module_& m) {
+	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)
+		.def("get_last_error", &EventManager::getLastError);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/api/version.cpp
+++ b/bindings/python/icsneopy/api/version.cpp
@ -0,0 +1,28 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/api/version.h"
+
+#include <sstream>
+
+namespace icsneo {
+
+void init_version(pybind11::module_& m) {
+	pybind11::class_<neoversion_t>(m, "NeoVersion")
+		.def_readonly("major", &neoversion_t::major)
+		.def_readonly("minor", &neoversion_t::minor)
+		.def_readonly("patch", &neoversion_t::patch)
+		.def_readonly("metadata", &neoversion_t::metadata)
+		.def_readonly("buildBranch", &neoversion_t::buildBranch)
+		.def_readonly("buildTag", &neoversion_t::buildTag)
+		.def("__repr__", [](const neoversion_t& self) -> std::string {
+			std::stringstream ss;
+			ss << self;
+			return ss.str();
+		});
+	m.def("get_version", &GetVersion);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/callback/messagecallback.cpp
+++ b/bindings/python/icsneopy/communication/message/callback/messagecallback.cpp
@ -0,0 +1,15 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/callback/messagecallback.h"
+
+namespace icsneo {
+
+void init_messagecallback(pybind11::module_& m) {
+	pybind11::class_<MessageCallback, std::shared_ptr<MessageCallback>>(m, "MessageCallback")
+		.def(pybind11::init<MessageCallback::fn_messageCallback, std::shared_ptr<MessageFilter>>());
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/canerrorcountmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/canerrorcountmessage.cpp
@ -0,0 +1,18 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/canerrorcountmessage.h"
+
+namespace icsneo {
+
+void init_canerrorcountmessage(pybind11::module_& m) {
+	pybind11::class_<CANErrorCountMessage, std::shared_ptr<CANErrorCountMessage>, Message>(m, "CANErrorCountMessage")
+		.def_readonly("network", &CANErrorCountMessage::network)
+		.def_readonly("transmitErrorCount", &CANErrorCountMessage::transmitErrorCount)
+		.def_readonly("receiveErrorCount", &CANErrorCountMessage::receiveErrorCount)
+		.def_readonly("busOff", &CANErrorCountMessage::busOff);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/canmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/canmessage.cpp
@ -0,0 +1,22 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/canmessage.h"
+
+namespace icsneo {
+
+void init_canmessage(pybind11::module_& m) {
+	pybind11::class_<CANMessage, std::shared_ptr<CANMessage>, Frame>(m, "CANMessage")
+		.def(pybind11::init())
+		.def_readwrite("arbid", &CANMessage::arbid)
+		.def_readwrite("dlcOnWire", &CANMessage::dlcOnWire)
+		.def_readwrite("isRemote", &CANMessage::isRemote)
+		.def_readwrite("isExtended", &CANMessage::isExtended)
+		.def_readwrite("isCANFD", &CANMessage::isCANFD)
+		.def_readwrite("baudrateSwitch", &CANMessage::baudrateSwitch)
+		.def_readwrite("errorStateIndicator", &CANMessage::errorStateIndicator);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/ethernetmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/ethernetmessage.cpp
@ -0,0 +1,27 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/ethernetmessage.h"
+
+namespace icsneo {
+
+void init_ethernetmessage(pybind11::module_& m) {
+	pybind11::class_<MACAddress>(m, "MACAddress")
+		.def("to_string", &MACAddress::toString)
+		.def("__repr__", &MACAddress::toString);
+	
+	pybind11::class_<EthernetMessage, std::shared_ptr<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("get_destination_mac", &EthernetMessage::getDestinationMAC, pybind11::return_value_policy::reference)
+		.def("get_source_mac", &EthernetMessage::getSourceMAC, pybind11::return_value_policy::reference)
+		.def("get_ether_type", &EthernetMessage::getEtherType);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/ethernetstatusmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/ethernetstatusmessage.cpp
@ -0,0 +1,35 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/ethernetstatusmessage.h"
+
+namespace icsneo {
+
+void init_ethernetstatusmessage(pybind11::module_& m) {
+	pybind11::class_<EthernetStatusMessage, std::shared_ptr<EthernetStatusMessage>, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
+
+	pybind11::enum_<EthernetStatusMessage::LinkSpeed>(ethernetStatusMessage, "LinkSpeed")
+		.value("LinkSpeedAuto", EthernetStatusMessage::LinkSpeed::LinkSpeedAuto)
+		.value("LinkSpeed10", EthernetStatusMessage::LinkSpeed::LinkSpeed10)
+		.value("LinkSpeed100", EthernetStatusMessage::LinkSpeed::LinkSpeed100)
+		.value("LinkSpeed1000", EthernetStatusMessage::LinkSpeed::LinkSpeed1000)
+		.value("LinkSpeed2500", EthernetStatusMessage::LinkSpeed::LinkSpeed2500)
+		.value("LinkSpeed5000", EthernetStatusMessage::LinkSpeed::LinkSpeed5000)
+		.value("LinkSpeed10000", EthernetStatusMessage::LinkSpeed::LinkSpeed10000);
+
+	pybind11::enum_<EthernetStatusMessage::LinkMode>(ethernetStatusMessage, "LinkMode")
+		.value("LinkModeAuto", EthernetStatusMessage::LinkMode::LinkModeAuto)
+		.value("LinkModeMaster", EthernetStatusMessage::LinkMode::LinkModeMaster)
+		.value("LinkModeSlave", EthernetStatusMessage::LinkMode::LinkModeSlave)
+		.value("LinkModeInvalid", EthernetStatusMessage::LinkMode::LinkModeInvalid);
+
+	ethernetStatusMessage
+		.def_readonly("network", &EthernetStatusMessage::network)
+		.def_readonly("state", &EthernetStatusMessage::state)
+		.def_readonly("speed", &EthernetStatusMessage::speed)
+		.def_readonly("duplex", &EthernetStatusMessage::duplex)
+		.def_readonly("mode", &EthernetStatusMessage::mode);
+}
+
+} // namespace icsneo
--- a/bindings/python/icsneopy/communication/message/filter/messagefilter.cpp
+++ b/bindings/python/icsneopy/communication/message/filter/messagefilter.cpp
@ -0,0 +1,17 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/filter/messagefilter.h"
+
+namespace icsneo {
+
+void init_messagefilter(pybind11::module_& m) {
+	pybind11::class_<MessageFilter, std::shared_ptr<MessageFilter>>(m, "MessageFilter")
+		.def(pybind11::init())
+		.def(pybind11::init<Message::Type>())
+		.def(pybind11::init<Network::NetID>());
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/gptpstatusmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/gptpstatusmessage.cpp
@ -0,0 +1,79 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/gptpstatusmessage.h"
+
+namespace icsneo {
+
+void init_gptpstatusmessage(pybind11::module_& m) {
+	pybind11::class_<GPTPStatus, std::shared_ptr<GPTPStatus>, Message> gptpStatus(m, "GPTPStatus");
+	
+	pybind11::class_<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
+		.def_readonly("seconds", &GPTPStatus::Timestamp::seconds)
+		.def_readonly("nanoseconds", &GPTPStatus::Timestamp::nanoseconds)
+		.def("to_seconds", &GPTPStatus::Timestamp::toSeconds, pybind11::call_guard<pybind11::gil_scoped_release>());
+	
+	pybind11::class_<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
+		.def_readonly("nanosecondsMSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
+		.def_readonly("nanosecondsLSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
+		.def_readonly("fractionalNanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
+	
+	pybind11::class_<GPTPStatus::PortID>(gptpStatus, "PortID")
+		.def_readonly("clockIdentity", &GPTPStatus::PortID::clockIdentity)
+		.def_readonly("portNumber", &GPTPStatus::PortID::portNumber);
+	
+	pybind11::class_<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
+		.def_readonly("clockClass", &GPTPStatus::ClockQuality::clockClass)
+		.def_readonly("clockAccuracy", &GPTPStatus::ClockQuality::clockAccuracy)
+		.def_readonly("offsetScaledLogVariance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
+	
+	pybind11::class_<GPTPStatus::SystemID>(gptpStatus, "SystemID")
+		.def_readonly("priority1", &GPTPStatus::SystemID::priority1)
+		.def_readonly("clockQuality", &GPTPStatus::SystemID::clockQuality)
+		.def_readonly("priority2", &GPTPStatus::SystemID::priority2)
+		.def_readonly("clockID", &GPTPStatus::SystemID::clockID);
+	
+	pybind11::class_<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
+		.def_readonly("sysID", &GPTPStatus::PriorityVector::sysID)
+		.def_readonly("stepsRemoved", &GPTPStatus::PriorityVector::stepsRemoved)
+		.def_readonly("portID", &GPTPStatus::PriorityVector::portID)
+		.def_readonly("portNumber", &GPTPStatus::PriorityVector::portNumber);
+	
+	pybind11::class_<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
+		.def_readonly("parentPortIdentity", &GPTPStatus::ParentDS::parentPortIdentity)
+		.def_readonly("cumulativeRateRatio", &GPTPStatus::ParentDS::cumulativeRateRatio)
+		.def_readonly("grandmasterIdentity", &GPTPStatus::ParentDS::grandmasterIdentity)
+		.def_readonly("gmClockQualityClockClass", &GPTPStatus::ParentDS::gmClockQualityClockClass)
+		.def_readonly("gmClockQualityClockAccuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
+		.def_readonly("gmClockQualityOffsetScaledLogVariance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
+		.def_readonly("gmPriority1", &GPTPStatus::ParentDS::gmPriority1)
+		.def_readonly("gmPriority2", &GPTPStatus::ParentDS::gmPriority2);
+
+	pybind11::class_<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
+		.def_readonly("stepsRemoved", &GPTPStatus::CurrentDS::stepsRemoved)
+		.def_readonly("offsetFromMaster", &GPTPStatus::CurrentDS::offsetFromMaster)
+		.def_readonly("lastgmPhaseChange", &GPTPStatus::CurrentDS::lastgmPhaseChange)
+		.def_readonly("lastgmFreqChange", &GPTPStatus::CurrentDS::lastgmFreqChange)
+		.def_readonly("gmTimeBaseIndicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
+		.def_readonly("gmChangeCount", &GPTPStatus::CurrentDS::gmChangeCount)
+		.def_readonly("timeOfLastgmChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
+		.def_readonly("timeOfLastgmPhaseChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
+		.def_readonly("timeOfLastgmFreqChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
+
+	gptpStatus.def_readonly("currentTime", &GPTPStatus::currentTime)
+		.def_readonly("gmPriority", &GPTPStatus::gmPriority)
+		.def_readonly("msOffsetNs", &GPTPStatus::msOffsetNs)
+		.def_readonly("isSync", &GPTPStatus::isSync)
+		.def_readonly("linkStatus", &GPTPStatus::linkStatus)
+		.def_readonly("linkDelayNS", &GPTPStatus::linkDelayNS)
+		.def_readonly("selectedRole", &GPTPStatus::selectedRole)
+		.def_readonly("asCapable", &GPTPStatus::asCapable)
+		.def_readonly("isSyntonized", &GPTPStatus::isSyntonized)
+		.def_readonly("lastRXSyncTS", &GPTPStatus::lastRXSyncTS)
+		.def_readonly("currentDS", &GPTPStatus::currentDS)
+		.def_readonly("parentDS", &GPTPStatus::parentDS);
+
+}
+
+} // namespace icsneo
--- a/bindings/python/icsneopy/communication/message/linmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/linmessage.cpp
@ -0,0 +1,59 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/linmessage.h"
+
+namespace icsneo {
+
+void init_linmessage(pybind11::module_& m) {
+	pybind11::class_<LINErrorFlags>(m, "LINErrorFlags")
+		.def_readwrite("ErrRxBreakOnly", &LINErrorFlags::ErrRxBreakOnly)
+		.def_readwrite("ErrRxBreakSyncOnly", &LINErrorFlags::ErrRxBreakSyncOnly)
+		.def_readwrite("ErrTxRxMismatch", &LINErrorFlags::ErrTxRxMismatch)
+		.def_readwrite("ErrRxBreakNotZero", &LINErrorFlags::ErrRxBreakNotZero)
+		.def_readwrite("ErrRxBreakTooShort", &LINErrorFlags::ErrRxBreakTooShort)
+		.def_readwrite("ErrRxSyncNot55", &LINErrorFlags::ErrRxSyncNot55)
+		.def_readwrite("ErrRxDataLenOver8", &LINErrorFlags::ErrRxDataLenOver8)
+		.def_readwrite("ErrFrameSync", &LINErrorFlags::ErrFrameSync)
+		.def_readwrite("ErrFrameMessageID", &LINErrorFlags::ErrFrameMessageID)
+		.def_readwrite("ErrFrameResponderData", &LINErrorFlags::ErrFrameResponderData)
+		.def_readwrite("ErrChecksumMatch", &LINErrorFlags::ErrChecksumMatch);
+
+	pybind11::class_<LINStatusFlags>(m, "LINStatusFlags")
+		.def_readwrite("TxChecksumEnhanced", &LINStatusFlags::TxChecksumEnhanced)
+		.def_readwrite("TxCommander", &LINStatusFlags::TxCommander)
+		.def_readwrite("TxResponder", &LINStatusFlags::TxResponder)
+		.def_readwrite("TxAborted", &LINStatusFlags::TxAborted)
+		.def_readwrite("UpdateResponderOnce", &LINStatusFlags::UpdateResponderOnce)
+		.def_readwrite("HasUpdatedResponderOnce", &LINStatusFlags::HasUpdatedResponderOnce)
+		.def_readwrite("BusRecovered", &LINStatusFlags::BusRecovered)
+		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly);
+
+	pybind11::class_<LINMessage, std::shared_ptr<LINMessage>, Frame> linMessage(m, "LINMessage");
+
+	pybind11::enum_<LINMessage::Type>(linMessage, "Type")
+		.value("NOT_SET", LINMessage::Type::NOT_SET)
+		.value("LIN_COMMANDER_MSG", LINMessage::Type::LIN_COMMANDER_MSG)
+		.value("LIN_HEADER_ONLY", LINMessage::Type::LIN_HEADER_ONLY)
+		.value("LIN_BREAK_ONLY", LINMessage::Type::LIN_BREAK_ONLY)
+		.value("LIN_SYNC_ONLY", LINMessage::Type::LIN_SYNC_ONLY)
+		.value("LIN_UPDATE_RESPONDER", LINMessage::Type::LIN_UPDATE_RESPONDER)
+		.value("LIN_ERROR", LINMessage::Type::LIN_ERROR);
+
+	linMessage
+		.def(pybind11::init<>())
+		.def(pybind11::init<uint8_t>())
+		.def_static("calc_checksum", &LINMessage::calcChecksum)
+		.def("calc_protected_id", &LINMessage::calcProtectedID)
+		.def_readwrite("ID", &LINMessage::ID)
+		.def_readwrite("protectedID", &LINMessage::protectedID)
+		.def_readwrite("checksum", &LINMessage::checksum)
+		.def_readwrite("linMsgType", &LINMessage::linMsgType)
+		.def_readwrite("isEnhancedChecksum", &LINMessage::isEnhancedChecksum)
+		.def_readwrite("errFlags", &LINMessage::errFlags)
+		.def_readwrite("statusFlags", &LINMessage::statusFlags);
+}
+
+} // namespace icsneo
+
--- a/bindings/python/icsneopy/communication/message/mdiomessage.cpp
+++ b/bindings/python/icsneopy/communication/message/mdiomessage.cpp
@ -0,0 +1,35 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/mdiomessage.h"
+
+namespace icsneo {
+
+void init_mdiomessage(pybind11::module_& m) {
+	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);
+	pybind11::enum_<MDIOMessage::Direction>(mdioMessage, "Direction")
+		.value("Write", MDIOMessage::Direction::Write)
+		.value("Read", MDIOMessage::Direction::Read);
+	mdioMessage
+		.def(pybind11::init())
+		.def_readwrite("isTXMsg", &MDIOMessage::isTXMsg)
+		.def_readwrite("txTimeout", &MDIOMessage::txTimeout)
+		.def_readwrite("txAborted", &MDIOMessage::txAborted)
+		.def_readwrite("txInvalidBus", &MDIOMessage::txInvalidBus)
+		.def_readwrite("txInvalidPhyAddr", &MDIOMessage::txInvalidPhyAddr)
+		.def_readwrite("txInvalidRegAddr", &MDIOMessage::txInvalidRegAddr)
+		.def_readwrite("txInvalidClause", &MDIOMessage::txInvalidClause)
+		.def_readwrite("txInvalidOpcode", &MDIOMessage::txInvalidOpcode)
+		.def_readwrite("phyAddress", &MDIOMessage::phyAddress)
+		.def_readwrite("devAddress", &MDIOMessage::devAddress)
+		.def_readwrite("regAddress", &MDIOMessage::regAddress)
+		.def_readwrite("direction", &MDIOMessage::direction)
+		.def_readwrite("clause", &MDIOMessage::clause);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/communication/message/message.cpp
+++ b/bindings/python/icsneopy/communication/message/message.cpp
@ -0,0 +1,53 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/message.h"
+
+namespace icsneo {
+
+void init_message(pybind11::module_& m) {
+	pybind11::class_<Message, std::shared_ptr<Message>> message(m, "Message");
+	pybind11::enum_<Message::Type>(message, "Type")
+		.value("Frame", Message::Type::Frame)
+		.value("CANErrorCount", Message::Type::CANErrorCount)
+		.value("LINHeaderOnly", Message::Type::LINHeaderOnly)
+		.value("LINBreak", Message::Type::LINBreak)
+		.value("Invalid", Message::Type::Invalid)
+		.value("RawMessage", Message::Type::RawMessage)
+		.value("ReadSettings", Message::Type::ReadSettings)
+		.value("ResetStatus", Message::Type::ResetStatus)
+		.value("DeviceVersion", Message::Type::DeviceVersion)
+		.value("Main51", Message::Type::Main51)
+		.value("FlexRayControl", Message::Type::FlexRayControl)
+		.value("EthernetPhyRegister", Message::Type::EthernetPhyRegister)
+		.value("LogicalDiskInfo", Message::Type::LogicalDiskInfo)
+		.value("ExtendedResponse", Message::Type::ExtendedResponse)
+		.value("WiVICommandResponse", Message::Type::WiVICommandResponse)
+		.value("ScriptStatus", Message::Type::ScriptStatus)
+		.value("ComponentVersions", Message::Type::ComponentVersions)
+		.value("SupportedFeatures", Message::Type::SupportedFeatures)
+		.value("GenericBinaryStatus", Message::Type::GenericBinaryStatus)
+		.value("LiveData", Message::Type::LiveData)
+		.value("HardwareInfo", Message::Type::HardwareInfo)
+		.value("TC10Status", Message::Type::TC10Status)
+		.value("AppError", Message::Type::AppError)
+		.value("GPTPStatus", Message::Type::GPTPStatus)
+		.value("EthernetStatus", Message::Type::EthernetStatus);
+
+	message.def(pybind11::init<Message::Type>());
+	message.def_readonly("type", &Message::type);
+	message.def_readwrite("timestamp", &Message::timestamp);
+
+	pybind11::class_<RawMessage, std::shared_ptr<RawMessage>, Message>(m, "RawMessage")
+		.def_readwrite("network", &RawMessage::network)
+		.def_readwrite("data", &RawMessage::data);
+
+	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);
+}
+
+} // namespace icsneo
+
--- a/bindings/python/icsneopy/communication/message/tc10statusmessage.cpp
+++ b/bindings/python/icsneopy/communication/message/tc10statusmessage.cpp
@ -0,0 +1,25 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/tc10statusmessage.h"
+
+namespace icsneo {
+
+void init_tc10statusmessage(pybind11::module_& m) {
+	pybind11::enum_<TC10WakeStatus>(m, "TC10WakeStatus")
+		.value("NoWakeReceived", TC10WakeStatus::NoWakeReceived)
+		.value("WakeReceived", TC10WakeStatus::WakeReceived);
+
+	pybind11::enum_<TC10SleepStatus>(m, "TC10SleepStatus")
+		.value("NoSleepReceived", TC10SleepStatus::NoSleepReceived)
+		.value("SleepReceived", TC10SleepStatus::SleepReceived)
+		.value("SleepFailed", TC10SleepStatus::SleepFailed)
+		.value("SleepAborted", TC10SleepStatus::SleepAborted);
+
+	pybind11::class_<TC10StatusMessage, std::shared_ptr<TC10StatusMessage>, Message>(m, "TC10StatusMessage")
+		.def_readonly("wakeStatus", &TC10StatusMessage::wakeStatus)
+		.def_readonly("sleepStatus", &TC10StatusMessage::sleepStatus);
+}
+
+} // namespace icsneo
--- a/bindings/python/icsneopy/communication/network.cpp
+++ b/bindings/python/icsneopy/communication/network.cpp
@ -0,0 +1,197 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/network.h"
+
+namespace icsneo {
+
+void init_network(pybind11::module_& m) {
+	pybind11::class_<Network> network(m, "Network");
+
+	pybind11::enum_<Network::NetID>(network, "NetID")
+		.value("Device", Network::NetID::Device)
+		.value("HSCAN", Network::NetID::HSCAN)
+		.value("MSCAN", Network::NetID::MSCAN)
+		.value("SWCAN", Network::NetID::SWCAN)
+		.value("LSFTCAN", Network::NetID::LSFTCAN)
+		.value("FordSCP", Network::NetID::FordSCP)
+		.value("J1708", Network::NetID::J1708)
+		.value("Aux", Network::NetID::Aux)
+		.value("J1850VPW", Network::NetID::J1850VPW)
+		.value("ISO9141", Network::NetID::ISO9141)
+		.value("DiskData", Network::NetID::DiskData)
+		.value("Main51", Network::NetID::Main51)
+		.value("RED", Network::NetID::RED)
+		.value("SCI", Network::NetID::SCI)
+		.value("ISO9141_2", Network::NetID::ISO9141_2)
+		.value("ISO14230", Network::NetID::ISO14230)
+		.value("LIN", Network::NetID::LIN)
+		.value("OP_Ethernet1", Network::NetID::OP_Ethernet1)
+		.value("OP_Ethernet2", Network::NetID::OP_Ethernet2)
+		.value("OP_Ethernet3", Network::NetID::OP_Ethernet3)
+		.value("RED_EXT_MEMORYREAD", Network::NetID::RED_EXT_MEMORYREAD)
+		.value("RED_INT_MEMORYREAD", Network::NetID::RED_INT_MEMORYREAD)
+		.value("RED_DFLASH_READ", Network::NetID::RED_DFLASH_READ)
+		.value("NeoMemorySDRead", Network::NetID::NeoMemorySDRead)
+		.value("CAN_ERRBITS", Network::NetID::CAN_ERRBITS)
+		.value("NeoMemoryWriteDone", Network::NetID::NeoMemoryWriteDone)
+		.value("RED_WAVE_CAN1_LOGICAL", Network::NetID::RED_WAVE_CAN1_LOGICAL)
+		.value("RED_WAVE_CAN2_LOGICAL", Network::NetID::RED_WAVE_CAN2_LOGICAL)
+		.value("RED_WAVE_LIN1_LOGICAL", Network::NetID::RED_WAVE_LIN1_LOGICAL)
+		.value("RED_WAVE_LIN2_LOGICAL", Network::NetID::RED_WAVE_LIN2_LOGICAL)
+		.value("RED_WAVE_LIN1_ANALOG", Network::NetID::RED_WAVE_LIN1_ANALOG)
+		.value("RED_WAVE_LIN2_ANALOG", Network::NetID::RED_WAVE_LIN2_ANALOG)
+		.value("RED_WAVE_MISC_ANALOG", Network::NetID::RED_WAVE_MISC_ANALOG)
+		.value("RED_WAVE_MISCDIO2_LOGICAL", Network::NetID::RED_WAVE_MISCDIO2_LOGICAL)
+		.value("RED_NETWORK_COM_ENABLE_EX", Network::NetID::RED_NETWORK_COM_ENABLE_EX)
+		.value("RED_NEOVI_NETWORK", Network::NetID::RED_NEOVI_NETWORK)
+		.value("RED_READ_BAUD_SETTINGS", Network::NetID::RED_READ_BAUD_SETTINGS)
+		.value("RED_OLDFORMAT", Network::NetID::RED_OLDFORMAT)
+		.value("RED_SCOPE_CAPTURE", Network::NetID::RED_SCOPE_CAPTURE)
+		.value("RED_HARDWARE_EXCEP", Network::NetID::RED_HARDWARE_EXCEP)
+		.value("RED_GET_RTC", Network::NetID::RED_GET_RTC)
+		.value("ISO9141_3", Network::NetID::ISO9141_3)
+		.value("HSCAN2", Network::NetID::HSCAN2)
+		.value("HSCAN3", Network::NetID::HSCAN3)
+		.value("OP_Ethernet4", Network::NetID::OP_Ethernet4)
+		.value("OP_Ethernet5", Network::NetID::OP_Ethernet5)
+		.value("ISO9141_4", Network::NetID::ISO9141_4)
+		.value("LIN2", Network::NetID::LIN2)
+		.value("LIN3", Network::NetID::LIN3)
+		.value("LIN4", Network::NetID::LIN4)
+		.value("RED_App_Error", Network::NetID::RED_App_Error)
+		.value("CGI", Network::NetID::CGI)
+		.value("Reset_Status", Network::NetID::Reset_Status)
+		.value("FB_Status", Network::NetID::FB_Status)
+		.value("App_Signal_Status", Network::NetID::App_Signal_Status)
+		.value("Read_Datalink_Cm_Tx_Msg", Network::NetID::Read_Datalink_Cm_Tx_Msg)
+		.value("Read_Datalink_Cm_Rx_Msg", Network::NetID::Read_Datalink_Cm_Rx_Msg)
+		.value("Logging_Overflow", Network::NetID::Logging_Overflow)
+		.value("ReadSettings", Network::NetID::ReadSettings)
+		.value("HSCAN4", Network::NetID::HSCAN4)
+		.value("HSCAN5", Network::NetID::HSCAN5)
+		.value("RS232", Network::NetID::RS232)
+		.value("UART", Network::NetID::UART)
+		.value("UART2", Network::NetID::UART2)
+		.value("UART3", Network::NetID::UART3)
+		.value("UART4", Network::NetID::UART4)
+		.value("SWCAN2", Network::NetID::SWCAN2)
+		.value("Ethernet_DAQ", Network::NetID::Ethernet_DAQ)
+		.value("Data_To_Host", Network::NetID::Data_To_Host)
+		.value("TextAPI_To_Host", Network::NetID::TextAPI_To_Host)
+		.value("SPI1", Network::NetID::SPI1)
+		.value("OP_Ethernet6", Network::NetID::OP_Ethernet6)
+		.value("Red_VBat", Network::NetID::Red_VBat)
+		.value("OP_Ethernet7", Network::NetID::OP_Ethernet7)
+		.value("OP_Ethernet8", Network::NetID::OP_Ethernet8)
+		.value("OP_Ethernet9", Network::NetID::OP_Ethernet9)
+		.value("OP_Ethernet10", Network::NetID::OP_Ethernet10)
+		.value("OP_Ethernet11", Network::NetID::OP_Ethernet11)
+		.value("FlexRay1a", Network::NetID::FlexRay1a)
+		.value("FlexRay1b", Network::NetID::FlexRay1b)
+		.value("FlexRay2a", Network::NetID::FlexRay2a)
+		.value("FlexRay2b", Network::NetID::FlexRay2b)
+		.value("LIN5", Network::NetID::LIN5)
+		.value("FlexRay", Network::NetID::FlexRay)
+		.value("FlexRay2", Network::NetID::FlexRay2)
+		.value("OP_Ethernet12", Network::NetID::OP_Ethernet12)
+		.value("I2C", Network::NetID::I2C)
+		.value("MOST25", Network::NetID::MOST25)
+		.value("MOST50", Network::NetID::MOST50)
+		.value("MOST150", Network::NetID::MOST150)
+		.value("Ethernet", Network::NetID::Ethernet)
+		.value("GMFSA", Network::NetID::GMFSA)
+		.value("TCP", Network::NetID::TCP)
+		.value("HSCAN6", Network::NetID::HSCAN6)
+		.value("HSCAN7", Network::NetID::HSCAN7)
+		.value("LIN6", Network::NetID::LIN6)
+		.value("LSFTCAN2", Network::NetID::LSFTCAN2)
+		.value("LogicalDiskInfo", Network::NetID::LogicalDiskInfo)
+		.value("WiVICommand", Network::NetID::WiVICommand)
+		.value("ScriptStatus", Network::NetID::ScriptStatus)
+		.value("EthPHYControl", Network::NetID::EthPHYControl)
+		.value("ExtendedCommand", Network::NetID::ExtendedCommand)
+		.value("ExtendedData", Network::NetID::ExtendedData)
+		.value("FlexRayControl", Network::NetID::FlexRayControl)
+		.value("CoreMiniPreLoad", Network::NetID::CoreMiniPreLoad)
+		.value("HW_COM_Latency_Test", Network::NetID::HW_COM_Latency_Test)
+		.value("DeviceStatus", Network::NetID::DeviceStatus)
+		.value("UDP", Network::NetID::UDP)
+		.value("ForwardedMessage", Network::NetID::ForwardedMessage)
+		.value("I2C2", Network::NetID::I2C2)
+		.value("I2C3", Network::NetID::I2C3)
+		.value("I2C4", Network::NetID::I2C4)
+		.value("Ethernet2", Network::NetID::Ethernet2)
+		.value("A2B1", Network::NetID::A2B1)
+		.value("A2B2", Network::NetID::A2B2)
+		.value("Ethernet3", Network::NetID::Ethernet3)
+		.value("WBMS", Network::NetID::WBMS)
+		.value("DWCAN9", Network::NetID::DWCAN9)
+		.value("DWCAN10", Network::NetID::DWCAN10)
+		.value("DWCAN11", Network::NetID::DWCAN11)
+		.value("DWCAN12", Network::NetID::DWCAN12)
+		.value("DWCAN13", Network::NetID::DWCAN13)
+		.value("DWCAN14", Network::NetID::DWCAN14)
+		.value("DWCAN15", Network::NetID::DWCAN15)
+		.value("DWCAN16", Network::NetID::DWCAN16)
+		.value("LIN7", Network::NetID::LIN7)
+		.value("LIN8", Network::NetID::LIN8)
+		.value("SPI2", Network::NetID::SPI2)
+		.value("MDIO1", Network::NetID::MDIO1)
+		.value("MDIO2", Network::NetID::MDIO2)
+		.value("MDIO3", Network::NetID::MDIO3)
+		.value("MDIO4", Network::NetID::MDIO4)
+		.value("MDIO5", Network::NetID::MDIO5)
+		.value("MDIO6", Network::NetID::MDIO6)
+		.value("MDIO7", Network::NetID::MDIO7)
+		.value("MDIO8", Network::NetID::MDIO8)
+		.value("OP_Ethernet13", Network::NetID::OP_Ethernet13)
+		.value("OP_Ethernet14", Network::NetID::OP_Ethernet14)
+		.value("OP_Ethernet15", Network::NetID::OP_Ethernet15)
+		.value("OP_Ethernet16", Network::NetID::OP_Ethernet16)
+		.value("SPI3", Network::NetID::SPI3)
+		.value("SPI4", Network::NetID::SPI4)
+		.value("SPI5", Network::NetID::SPI5)
+		.value("SPI6", Network::NetID::SPI6)
+		.value("SPI7", Network::NetID::SPI7)
+		.value("SPI8", Network::NetID::SPI8)
+		.value("LIN9", Network::NetID::LIN9)
+		.value("LIN10", Network::NetID::LIN10)
+		.value("LIN11", Network::NetID::LIN11)
+		.value("LIN12", Network::NetID::LIN12)
+		.value("LIN13", Network::NetID::LIN13)
+		.value("LIN14", Network::NetID::LIN14)
+		.value("LIN15", Network::NetID::LIN15)
+		.value("LIN16", Network::NetID::LIN16)
+		.value("Any", Network::NetID::Any)
+		.value("Invalid", Network::NetID::Invalid);
+	
+	pybind11::enum_<Network::Type>(network, "Type")
+		.value("Invalid", Network::Type::Invalid)
+		.value("Internal", Network::Type::Internal)
+		.value("CAN", Network::Type::CAN)
+		.value("LIN", Network::Type::LIN)
+		.value("FlexRay", Network::Type::FlexRay)
+		.value("MOST", Network::Type::MOST)
+		.value("Ethernet", Network::Type::Ethernet)
+		.value("LSFTCAN", Network::Type::LSFTCAN)
+		.value("SWCAN", Network::Type::SWCAN)
+		.value("ISO9141", Network::Type::ISO9141)
+		.value("I2C", Network::Type::I2C)
+		.value("A2B", Network::Type::A2B)
+		.value("SPI", Network::Type::SPI)
+		.value("MDIO", Network::Type::MDIO)
+		.value("Any", Network::Type::Any)
+		.value("Other", Network::Type::Other);
+
+    network
+		.def(pybind11::init<Network::NetID>())
+		.def("__repr__", [](Network& self) { return Network::GetNetIDString(self.getNetID()); })
+		.def_static("get_net_id_string", &Network::GetNetIDString, pybind11::arg("netid"), pybind11::arg("expand") = true)
+		.def("get_net_id", &Network::getNetID)
+		.def("get_type", &Network::getType);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/device/device.cpp
+++ b/bindings/python/icsneopy/device/device.cpp
@ -0,0 +1,47 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+#include <pybind11/chrono.h>
+
+#include "icsneo/device/device.h"
+
+namespace icsneo {
+
+void init_device(pybind11::module_& m) {
+	pybind11::class_<Device, std::shared_ptr<Device>>(m, "Device")
+		.def("get_type", &Device::getType)
+		.def("get_serial", &Device::getSerial)
+		.def("get_serial_number", &Device::getSerialNumber)
+		.def("get_product_name", &Device::getProductName)
+		.def("open", [](Device& device) { return device.open(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("close", &Device::close, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("is_open", &Device::isOpen)
+		.def("go_online", &Device::goOnline, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("go_offline", &Device::goOffline, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("is_online", &Device::isOnline)
+		.def("enable_message_polling", &Device::enableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("disable_message_polling", &Device::disableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("is_message_polling_enabled", &Device::isMessagePollingEnabled)
+		.def("get_messages", [](Device& device) { return device.getMessages(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_current_message_count", &Device::getCurrentMessageCount)
+		.def("get_polling_message_limit", &Device::getPollingMessageLimit)
+		.def("set_polling_message_limit", &Device::setPollingMessageLimit)
+		.def("add_message_callback", &Device::addMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("remove_message_callback", &Device::removeMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
+		.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
+		.def("get_rtc", &Device::getRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_rtc", &Device::setRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("describe", &Device::describe)
+		.def("is_online_supported", &Device::isOnlineSupported)
+		.def("supports_tc10", &Device::supportsTC10)
+		.def("request_tc10_wake", &Device::requestTC10Wake, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("request_tc10_sleep", &Device::requestTC10Sleep, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_gptp_status", &Device::getGPTPStatus, pybind11::arg("timeout") = std::chrono::milliseconds(100), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("__repr__", &Device::describe);
+}
+
+} // namespace icsneo
+
--- a/bindings/python/icsneopy/device/devicetype.cpp
+++ b/bindings/python/icsneopy/device/devicetype.cpp
@ -0,0 +1,76 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/device/devicetype.h"
+
+namespace icsneo {
+
+void init_devicetype(pybind11::module_& m) {
+	pybind11::class_<DeviceType> deviceType(m, "DeviceType");
+	pybind11::enum_<DeviceType::Enum>(deviceType, "Enum")
+		.value("Unknown", DeviceType::Enum::Unknown)
+		.value("BLUE", DeviceType::Enum::BLUE)
+		.value("ECU_AVB", DeviceType::Enum::ECU_AVB)
+		.value("RADSupermoon", DeviceType::Enum::RADSupermoon)
+		.value("DW_VCAN", DeviceType::Enum::DW_VCAN)
+		.value("RADMoon2", DeviceType::Enum::RADMoon2)
+		.value("RADMars", DeviceType::Enum::RADMars)
+		.value("VCAN4_1", DeviceType::Enum::VCAN4_1)
+		.value("FIRE", DeviceType::Enum::FIRE)
+		.value("RADPluto", DeviceType::Enum::RADPluto)
+		.value("VCAN4_2EL", DeviceType::Enum::VCAN4_2EL)
+		.value("RADIO_CANHUB", DeviceType::Enum::RADIO_CANHUB)
+		.value("NEOECU12", DeviceType::Enum::NEOECU12)
+		.value("OBD2_LCBADGE", DeviceType::Enum::OBD2_LCBADGE)
+		.value("RADMoonDuo", DeviceType::Enum::RADMoonDuo)
+		.value("FIRE3", DeviceType::Enum::FIRE3)
+		.value("VCAN3", DeviceType::Enum::VCAN3)
+		.value("RADJupiter", DeviceType::Enum::RADJupiter)
+		.value("VCAN4_IND", DeviceType::Enum::VCAN4_IND)
+		.value("RADGigastar", DeviceType::Enum::RADGigastar)
+		.value("RED2", DeviceType::Enum::RED2)
+		.value("EtherBADGE", DeviceType::Enum::EtherBADGE)
+		.value("RAD_A2B", DeviceType::Enum::RAD_A2B)
+		.value("RADEpsilon", DeviceType::Enum::RADEpsilon)
+		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
+		.value("RADMoon3", DeviceType::Enum::RADMoon3)
+		.value("RADComet", DeviceType::Enum::RADComet)
+		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)
+		.value("Connect", DeviceType::Enum::Connect)
+		.value("RADComet3", DeviceType::Enum::RADComet3)
+		.value("RADMoonT1S", DeviceType::Enum::RADMoonT1S)
+		.value("RADGigastar2", DeviceType::Enum::RADGigastar2)
+		.value("RED", DeviceType::Enum::RED)
+		.value("ECU", DeviceType::Enum::ECU)
+		.value("IEVB", DeviceType::Enum::IEVB)
+		.value("Pendant", DeviceType::Enum::Pendant)
+		.value("OBD2_PRO", DeviceType::Enum::OBD2_PRO)
+		.value("ECUChip_UART", DeviceType::Enum::ECUChip_UART)
+		.value("PLASMA", DeviceType::Enum::PLASMA)
+		.value("DONT_REUSE0", DeviceType::Enum::DONT_REUSE0)
+		.value("NEOAnalog", DeviceType::Enum::NEOAnalog)
+		.value("CT_OBD", DeviceType::Enum::CT_OBD)
+		.value("DONT_REUSE1", DeviceType::Enum::DONT_REUSE1)
+		.value("DONT_REUSE2", DeviceType::Enum::DONT_REUSE2)
+		.value("ION", DeviceType::Enum::ION)
+		.value("RADStar", DeviceType::Enum::RADStar)
+		.value("DONT_REUSE3", DeviceType::Enum::DONT_REUSE3)
+		.value("VCAN4_4", DeviceType::Enum::VCAN4_4)
+		.value("VCAN4_2", DeviceType::Enum::VCAN4_2)
+		.value("CMProbe", DeviceType::Enum::CMProbe)
+		.value("EEVB", DeviceType::Enum::EEVB)
+		.value("VCANrf", DeviceType::Enum::VCANrf)
+		.value("FIRE2", DeviceType::Enum::FIRE2)
+		.value("Flex", DeviceType::Enum::Flex)
+		.value("RADGalaxy", DeviceType::Enum::RADGalaxy)
+		.value("RADStar2", DeviceType::Enum::RADStar2)
+		.value("VividCAN", DeviceType::Enum::VividCAN)
+		.value("OBD2_SIM", DeviceType::Enum::OBD2_SIM);
+	deviceType.def(pybind11::init<DeviceType::Enum>());
+	deviceType.def("get_device_type", &DeviceType::getDeviceType);
+	deviceType.def("get_generic_product_name", &DeviceType::getGenericProductName);
+}
+
+} // namespace icsneo 
+
--- a/bindings/python/icsneopy/icsneocpp.cpp
+++ b/bindings/python/icsneopy/icsneocpp.cpp
@ -0,0 +1,57 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/icsneocpp.h"
+
+namespace icsneo {
+
+void init_event(pybind11::module_&);
+void init_eventcallback(pybind11::module_&);
+void init_eventmanager(pybind11::module_&);
+void init_network(pybind11::module_&);
+void init_devicetype(pybind11::module_&);
+void init_message(pybind11::module_&);
+void init_canmessage(pybind11::module_&);
+void init_canerrorcountmessage(pybind11::module_&);
+void init_ethernetmessage(pybind11::module_&);
+void init_linmessage(pybind11::module_&);
+void init_tc10statusmessage(pybind11::module_&);
+void init_gptpstatusmessage(pybind11::module_&);
+void init_mdiomessage(pybind11::module_&);
+void init_ethernetstatusmessage(pybind11::module_&);
+void init_device(pybind11::module_&);
+void init_messagefilter(pybind11::module_&);
+void init_messagecallback(pybind11::module_&);
+void init_version(pybind11::module_&);
+
+PYBIND11_MODULE(icsneopy, m) {
+	pybind11::options options;
+	options.disable_enum_members_docstring();
+	m.doc() = "libicsneo Python module";
+
+	init_event(m);
+	init_eventcallback(m);
+	init_eventmanager(m);
+	init_version(m);
+	init_devicetype(m);
+	init_network(m);
+	init_message(m);
+	init_canmessage(m);
+	init_canerrorcountmessage(m);
+	init_ethernetmessage(m);
+	init_linmessage(m);
+	init_tc10statusmessage(m);
+	init_gptpstatusmessage(m);
+	init_mdiomessage(m);
+	init_ethernetstatusmessage(m);
+	init_messagefilter(m);
+	init_messagecallback(m);
+	init_device(m);
+
+	m.def("find_all_devices", &FindAllDevices);
+	m.def("get_supported_devices", &GetSupportedDevices);
+	m.def("get_last_error", &GetLastError);
+}
+
+} // namespace icsneo 
--- a/bindings/python/py.typed
+++ b/bindings/python/py.typed
--- a/ci/bootstrap-libpcap.sh
+++ b/ci/bootstrap-libpcap.sh
@ -0,0 +1,18 @@
+#!/bin/sh
+
+VERSION="1.10.5"
+ROOT="$PWD/libpcap"
+SOURCE="$ROOT/source"
+BUILD="$ROOT/build"
+INSTALL="$ROOT/install"
+
+mkdir -p "$ROOT"
+cd "$ROOT" || exit 1
+
+curl -LO "https://www.tcpdump.org/release/libpcap-$VERSION.tar.xz" || exit 1
+tar -xf "libpcap-$VERSION.tar.xz" || exit 1
+mv "libpcap-$VERSION" "$SOURCE" || exit 1
+
+cmake -D CMAKE_POSITION_INDEPENDENT_CODE=ON -D CMAKE_INSTALL_PREFIX="$INSTALL" -D BUILD_SHARED_LIBS=OFF -D BUILD_WITH_LIBNL=OFF -D DISABLE_DBUS=ON -D DISABLE_LINUX_USBMON=ON -D DISABLE_BLUETOOTH=ON -D DISABLE_NETMAP=ON -D DISABLE_DPDK=ON -D DISABLE_RDMA=ON -D DISABLE_DAG=ON -D DISABLE_SEPTEL=ON -D DISABLE_SNF=ON -D DISABLE_TC=ON -B "$BUILD" -S "$SOURCE" || exit 1
+cmake --build "$BUILD" || exit 1
+cmake --install "$BUILD" || exit 1
--- a/ci/bootstrap-libusb.sh
+++ b/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
+
--- a/ci/build-wheel-posix.sh
+++ b/ci/build-wheel-posix.sh
@ -0,0 +1,7 @@
+#!/bin/sh
+
+python3 -m venv env || exit 1
+. env/bin/activate || exit 1
+python3 -m pip install cibuildwheel || exit 1
+python3 -m cibuildwheel --output-dir wheelhouse || exit 1
+
--- a/ci/build-wheel-windows.bat
+++ b/ci/build-wheel-windows.bat
@ -0,0 +1,9 @@
+@setlocal
+@echo off
+
+call "%VCVARS64_2022%"
+
+python.exe -m venv env || exit /b 1
+call env\Scripts\Activate.bat || exit /b 1
+python.exe -m pip install cibuildwheel || exit /b 1
+python.exe -m cibuildwheel --output-dir wheelhouse --platform windows || exit /b 1
--- a/communication/communication.cpp
+++ b/communication/communication.cpp
@ -276,7 +276,7 @@ void Communication::readTask() {
 			std::unique_lock<std::mutex> lk(pauseReadTaskMutex);
 			pauseReadTaskCv.wait(lk, [this]() { return !pauseReadTask; });
 		}
-		if(driver->readAvailable()) {
+		if(driver->waitForRx(readTaskWakeLimit, readTaskWakeTimeout)) {
 			if(pauseReadTask) {
 				/**
 				 * Reads could have paused while the driver was not available
--- a/communication/decoder.cpp
+++ b/communication/decoder.cpp
@ -5,6 +5,7 @@
 #include "icsneo/communication/message/readsettingsmessage.h"
 #include "icsneo/communication/message/canerrorcountmessage.h"
 #include "icsneo/communication/message/neoreadmemorysdmessage.h"
+#include "icsneo/communication/message/flashmemorymessage.h"
 #include "icsneo/communication/message/extendedresponsemessage.h"
 #include "icsneo/communication/message/wiviresponsemessage.h"
 #include "icsneo/communication/message/scriptstatusmessage.h"
@ -18,6 +19,9 @@
 #include "icsneo/communication/message/diskdatamessage.h"
 #include "icsneo/communication/message/hardwareinfo.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
+#include "icsneo/communication/message/gptpstatusmessage.h"
+#include "icsneo/communication/message/apperrormessage.h"
+#include "icsneo/communication/message/ethernetstatusmessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@ -176,6 +180,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac

 			LINMessage& msg = *static_cast<LINMessage*>(result.get());
 			msg.network = packet->network;
+			msg.timestamp *= timestampResolution;
 			return true;
 		}
 		case Network::Type::MDIO: {
@ -234,21 +239,26 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						return true;
 					}

-					result = HardwareCANPacket::DecodeToMessage(packet->data);
-					if(!result) {
+					const auto can = std::dynamic_pointer_cast<CANMessage>(HardwareCANPacket::DecodeToMessage(packet->data));
+					if(!can) {
 						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-						return false; // A nullptr was returned, the packet was malformed
+						return false;
+					}
+					
+					if(can->arbid == 0x162) {
+						result = EthernetStatusMessage::DecodeToMessage(can->data);
+
+						if(!result) {
+							report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+							return false;
+						}
+					} else {
+						// TODO: move more handleNeoVIMessage handling here, the Decoder layer will parse the message and the Device layer can cache the values
+						can->network = packet->network;
+						result = can;
 					}

-					// Timestamps are in (resolution) ns increments since 1/1/2007 GMT 00:00:00.0000
-					// The resolution depends on the device
-					auto* raw = dynamic_cast<RawMessage*>(result.get());
-					if(raw == nullptr) {
-						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-						return false; // A nullptr was returned, the packet was malformed
-					}
-					raw->timestamp *= timestampResolution;
-					raw->network = packet->network;
+					result->timestamp *= timestampResolution;
 					return true;
 				}
 				case Network::NetID::DeviceStatus: {
@ -256,6 +266,18 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 					result = std::make_shared<RawMessage>(packet->network, packet->data);
 					return true;
 				}
+				case Network::NetID::RED_INT_MEMORYREAD: {
+					if(packet->data.size() != 512 + sizeof(uint16_t)) {
+						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+						return false; // Should get enough data for a start address and sector
+					}
+
+					const auto msg = std::make_shared<FlashMemoryMessage>();
+					result = msg;
+					msg->startAddress = *reinterpret_cast<uint16_t*>(packet->data.data());
+					msg->data.insert(msg->data.end(), packet->data.begin() + 2, packet->data.end());
+					return true;
+				}
 				case Network::NetID::NeoMemorySDRead: {
 					if(packet->data.size() != 512 + sizeof(uint32_t)) {
 						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
@ -270,11 +292,11 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 				}
 				case Network::NetID::ExtendedCommand: {

-					if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
+					if(packet->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
 						break; // Handle as a raw message, might not be a generic response

-					const auto& resp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
-					switch(resp.header.command) {
+					const auto& resp = *reinterpret_cast<ExtendedResponseMessage::ResponseHeader*>(packet->data.data());
+					switch(resp.command) {
 						case ExtendedCommand::GetComponentVersions:
 							result = ComponentVersionPacket::DecodeToMessage(packet->data);
 							return true;
@ -284,15 +306,23 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::GenericBinaryInfo:
 							result = GenericBinaryStatusPacket::DecodeToMessage(packet->data);
 							return true;
-						case ExtendedCommand::GenericReturn:
-							result = std::make_shared<ExtendedResponseMessage>(resp.command, resp.returnCode);
+						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);
 							return true;
+						}
 						case ExtendedCommand::LiveData:
 							result = HardwareLiveDataPacket::DecodeToMessage(packet->data, report);
 							return true;
 						case ExtendedCommand::GetTC10Status:
 							result = TC10StatusMessage::DecodeToMessage(packet->data);
 							return true;
+						case ExtendedCommand::GetGPTPStatus: {
+							result = GPTPStatus::DecodeToMessage(packet->data, report);
+							return true;
+						}
 						default:
 							// No defined handler, treat this as a RawMessage
 							break;
@ -398,6 +428,14 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						packet->data.resize(length);
 					return decode(result, packet);
 				}
+				case Network::NetID::RED_App_Error: {
+					result = AppErrorMessage::DecodeToMessage(packet->data, report);
+					if(!result) {
+						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::EventWarning);
+						return false;
+					}
+					return true;
+				}
 				case Network::NetID::ReadSettings: {
 					auto msg = std::make_shared<ReadSettingsMessage>();
 					msg->response = ReadSettingsMessage::Response(packet->data[0]);
--- a/communication/driver.cpp
+++ b/communication/driver.cpp
@ -11,13 +11,21 @@ using namespace icsneo;
 bool Driver::pushRx(const uint8_t* buf, size_t numReceived) {
 	bool ret = readBuffer.write(buf, numReceived);

-	if(hasRxWaitRequest) {
-		rxWaitRequestCv.notify_one();
-	}
+	rxWaitCv.notify_all();

 	return ret;
 }

+void Driver::clearBuffers()
+{
+	WriteOperation flushop;
+
+	readBuffer.clear();
+	rxWaitCv.notify_all();
+
+	while (writeQueue.try_dequeue(flushop)) {}
+}
+
 bool Driver::waitForRx(size_t limit, std::chrono::milliseconds timeout) {
 	return waitForRx([limit, this]() {
 		return readBuffer.size() >= limit;
@ -26,13 +34,7 @@ bool Driver::waitForRx(size_t limit, std::chrono::milliseconds timeout) {

 bool Driver::waitForRx(std::function<bool()> predicate, std::chrono::milliseconds timeout) {
 	std::unique_lock<std::mutex> lk(rxWaitMutex);
-	hasRxWaitRequest = true;
-
-	auto ret = rxWaitRequestCv.wait_for(lk, timeout, predicate);
-
-	hasRxWaitRequest = false;
-
-	return ret;
+	return rxWaitCv.wait_for(lk, timeout, predicate);
 }

 bool Driver::readWait(std::vector<uint8_t>& bytes, std::chrono::milliseconds timeout, size_t limit) {
@ -92,4 +94,4 @@ bool Driver::write(const std::vector<uint8_t>& bytes) {
 		report(APIEvent::Type::Unknown, APIEvent::Severity::Error);

 	return ret;
-}
+}
--- a/communication/message/apperrormessage.cpp
+++ b/communication/message/apperrormessage.cpp
@ -0,0 +1,148 @@
+#include <icsneo/communication/message/apperrormessage.h>
+
+namespace icsneo {
+
+#pragma pack(push, 2)
+
+typedef struct {
+	uint16_t error_type;
+	uint16_t network_id;
+	uint32_t uiTimeStamp10uS;
+	uint32_t uiTimeStamp10uSMSB;
+} AppErrorData;
+
+#pragma pack(pop)
+
+std::shared_ptr<Message> AppErrorMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream, const device_eventhandler_t& report) {
+	const AppErrorData* data = reinterpret_cast<const AppErrorData*>(bytestream.data());
+	if(!data) {
+		report(APIEvent::Type::AppErrorParsingFailed, APIEvent::Severity::Error);
+		return nullptr;
+	}
+	auto appErr = std::make_shared<AppErrorMessage>();
+	appErr->errorType = data->error_type;
+	appErr->errorNetID = static_cast<Network::NetID>(data->network_id);
+	appErr->timestamp10us = data->uiTimeStamp10uS;
+	appErr->timestamp10usMSB = data->uiTimeStamp10uSMSB;
+	appErr->network = Network::NetID::RED_App_Error;
+	return appErr;
+}
+
+AppErrorType AppErrorMessage::getAppErrorType() {
+	AppErrorType errType = static_cast<AppErrorType>(errorType);
+	if(errType > AppErrorType::AppNoError) {
+		return AppErrorType::AppNoError;
+	}
+	return errType;
+}
+
+std::string AppErrorMessage::getAppErrorString() {
+	auto netIDString = Network::GetNetIDString(errorNetID);
+	AppErrorType errType = static_cast<AppErrorType>(errorType);
+	switch (errType) {
+		case AppErrorType::AppErrorRxMessagesFull:
+			return std::string(netIDString) + ": RX message buffer full";
+		case AppErrorType::AppErrorTxMessagesFull:
+			return std::string(netIDString) + ": TX message buffer full";
+		case AppErrorType::AppErrorTxReportMessagesFull:
+			return std::string(netIDString) + ": TX report buffer full";
+		case AppErrorType::AppErrorBadCommWithDspIC:
+			return "Received bad packet from DSP IC";
+		case AppErrorType::AppErrorDriverOverflow:
+			return std::string(netIDString) + ": Driver overflow";
+		case AppErrorType::AppErrorPCBuffOverflow:
+			return "PC buffer overflow";
+		case AppErrorType::AppErrorPCChksumError:
+			return "PC checksum error";
+		case AppErrorType::AppErrorPCMissedByte:
+			return "PC missed byte";
+		case AppErrorType::AppErrorPCOverrunError:
+			return "PC overrun error";
+		case AppErrorType::AppErrorSettingFailure:
+			return std::string(netIDString) + ": Settings incorrectly set";
+		case AppErrorType::AppErrorTooManySelectedNetworks:
+			return "Too many selected networks";
+		case AppErrorType::AppErrorNetworkNotEnabled:
+			return std::string(netIDString) + ": Network not enabled";
+		case AppErrorType::AppErrorRtcNotCorrect:
+			return "RTC not correct";
+		case AppErrorType::AppErrorLoadedDefaultSettings:
+			return "Loaded default settings";
+		case AppErrorType::AppErrorFeatureNotUnlocked:
+			return "Feature not unlocked";
+		case AppErrorType::AppErrorFeatureRtcCmdDropped:
+			return "RTC command dropped";
+		case AppErrorType::AppErrorTxMessagesFlushed:
+			return "TX message buffer flushed";
+		case AppErrorType::AppErrorTxMessagesHalfFull:
+			return "TX message buffer half full";
+		case AppErrorType::AppErrorNetworkNotValid:
+			return "Network is not valid";
+		case AppErrorType::AppErrorTxInterfaceNotImplemented:
+			return "TX interface is not implemented";
+		case AppErrorType::AppErrorTxMessagesCommEnableIsOff:
+			return "TX message communication is disabled";
+		case AppErrorType::AppErrorRxFilterMatchCountExceeded:
+			return "RX filter match count exceeded";
+		case AppErrorType::AppErrorEthPreemptionNotEnabled:
+			return std::string(netIDString) + ": Ethernet preemption not enabled";
+		case AppErrorType::AppErrorTxNotSupportedInMode:
+			return std::string(netIDString) + ": Transmit is not supported in this mode";
+		case AppErrorType::AppErrorJumboFramesNotSupported:
+			return std::string(netIDString) + ": Jumbo frames not supported";
+		case AppErrorType::AppErrorEthernetIpFragment:
+			return "Ethernet IP fragment received";
+		case AppErrorType::AppErrorTxMessagesUnderrun:
+			return std::string(netIDString) + ": Transmit buffer underrun";
+		case AppErrorType::AppErrorDeviceFanFailure:
+			return "Device fan failure";
+		case AppErrorType::AppErrorDeviceOvertemperature:
+			return "Device overtemperature";
+		case AppErrorType::AppErrorTxMessageIndexOutOfRange:
+			return "Transmit message index out of range";
+		case AppErrorType::AppErrorUndersizedFrameDropped:
+			return std::string(netIDString) + ": Undersized frame dropped";
+		case AppErrorType::AppErrorOversizedFrameDropped:
+			return std::string(netIDString) + ": Oversized frame dropped";
+		case AppErrorType::AppErrorWatchdogEvent:
+			return "Watchdog event occured";
+		case AppErrorType::AppErrorSystemClockFailure:
+			return "Device clock failed";
+		case AppErrorType::AppErrorSystemClockRecovered:
+			return "Device clock recovered";
+		case AppErrorType::AppErrorSystemPeripheralReset:
+			return "Device peripheral reset";
+		case AppErrorType::AppErrorSystemCommunicationFailure:
+			return "Device communication failure";
+		case AppErrorType::AppErrorTxMessagesUnsupportedSourceOrPacketId:
+			return std::string(netIDString) + ": Transmit unsupported source or packet ID";
+		case AppErrorType::AppErrorWbmsManagerConnectFailed:
+			return std::string(netIDString) + ": Failed to connect to managers with settings";
+		case AppErrorType::AppErrorWbmsManagerConnectBadState:
+			return std::string(netIDString) + ": Connected to managers in a invalid state";
+		case AppErrorType::AppErrorWbmsManagerConnectTimeout:
+			return std::string(netIDString) + ": Timeout while attempting to connect to managers";
+		case AppErrorType::AppErrorFailedToInitializeLoggerDisk:
+			return "Device failed to initialize storage disk";
+		case AppErrorType::AppErrorInvalidSetting:
+			return std::string(netIDString) + ": Invalid settings";
+		case AppErrorType::AppErrorSystemFailureRequestedReset:
+			return "Device rebooted to recover from an unexpected error condition";
+		case AppErrorType::AppErrorPortKeyMistmatch:
+			return std::string(netIDString) + ": Mismatch between key in manager and stored key";
+		case AppErrorType::AppErrorBusFailure:
+			return std::string(netIDString) + ": Bus failure";
+		case AppErrorType::AppErrorTapOverflow:
+			return std::string(netIDString) + ": Tap overflow";
+		case AppErrorType::AppErrorEthTxNoLink:
+			return std::string(netIDString) + ": Attempted Ethernet transmit without link";
+		case AppErrorType::AppErrorErrorBufferOverflow:
+			return "Device error buffer overflow";
+		case AppErrorType::AppNoError:
+			return "No error";
+		default:
+			return "Unknown error";
+	}
+}
+
+} // namespace icsneo
--- a/communication/message/ethernetstatusmessage.cpp
+++ b/communication/message/ethernetstatusmessage.cpp
@ -0,0 +1,57 @@
+#include "icsneo/communication/message/ethernetstatusmessage.h"
+
+using namespace icsneo;
+
+#pragma pack(push, 1)
+enum LinkSpeed {
+	ethSpeed10,
+	ethSpeed100,
+	ethSpeed1000,
+	ethSpeedAutoNeg,
+	ethSpeed2500,
+	ethSpeed5000,
+	ethSpeed10000,
+};
+
+enum LinkMode {
+	OPETH_LINK_AUTO,
+	OPETH_LINK_MASTER,
+	OPETH_LINK_SLAVE,
+	OPETH_LINK_INVALID = 255,
+};
+
+struct Packet {
+	uint8_t state;
+	uint8_t speed;
+	uint8_t duplex;
+	uint16_t network;
+	uint8_t mode;
+};
+#pragma pack(pop)
+
+std::shared_ptr<Message> EthernetStatusMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	if(bytestream.size() < sizeof(Packet)) {
+		return nullptr;
+	}
+	Packet* packet = (Packet*)bytestream.data();
+	LinkSpeed speed;
+	switch(packet->speed) {
+		case ethSpeed10: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed10; break;
+		case ethSpeed100: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed100; break;
+		case ethSpeed1000: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed1000; break;
+		case ethSpeedAutoNeg: speed = EthernetStatusMessage::LinkSpeed::LinkSpeedAuto; break;
+		case ethSpeed2500: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed2500; break;
+		case ethSpeed5000: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed5000; break;
+		case ethSpeed10000: speed = EthernetStatusMessage::LinkSpeed::LinkSpeed10000; break;
+		default: return nullptr;
+	}
+	LinkMode mode;
+	switch(packet->mode) {
+		case OPETH_LINK_INVALID: mode = EthernetStatusMessage::LinkMode::LinkModeInvalid; break;
+		case OPETH_LINK_AUTO: mode = EthernetStatusMessage::LinkMode::LinkModeAuto; break;
+		case OPETH_LINK_MASTER: mode = EthernetStatusMessage::LinkMode::LinkModeMaster; break;
+		case OPETH_LINK_SLAVE: mode = EthernetStatusMessage::LinkMode::LinkModeSlave; break;
+		default: return nullptr;
+	}
+	return std::make_shared<EthernetStatusMessage>(packet->network, packet->state, speed, packet->duplex, mode);
+}
--- a/communication/message/gptpstatusmessage.cpp
+++ b/communication/message/gptpstatusmessage.cpp
@ -0,0 +1,219 @@
+#include <icsneo/communication/message/gptpstatusmessage.h>
+#include <icsneo/communication/message/extendedresponsemessage.h>
+#include <cstring>
+
+namespace icsneo {
+typedef double float64;
+typedef int64_t time_interval;
+typedef uint64_t _clock_identity;
+
+
+#pragma pack(push, 1)
+
+struct port_identity {
+	_clock_identity clock_identity;
+	uint16_t port_number;
+};
+
+struct _scaled_ns {
+	int16_t nanoseconds_msb;
+	int64_t nanoseconds_lsb;
+	int16_t fractional_nanoseconds;
+};
+
+struct _clock_quality {
+	uint8_t clock_class;
+	uint8_t clock_accuracy;
+	uint16_t offset_scaled_log_variance;
+};
+
+struct system_identity {
+	uint8_t priority_1;
+	struct _clock_quality clock_quality;
+	uint8_t priority_2;
+	_clock_identity clock_identity;
+};
+
+struct _timestamp {
+	uint16_t seconds_msb;
+	uint32_t seconds_lsb;
+	uint32_t nanoseconds;
+};
+
+struct priority_vector {
+	struct system_identity sysid;
+	uint16_t steps_removed;
+	struct port_identity portid;
+	uint16_t port_number;
+};
+
+
+// IEEE 802.1AS-2020 14.3
+// This is a read-only data structure
+struct _current_ds {
+	uint16_t steps_removed;
+	time_interval offset_from_master;
+	struct _scaled_ns last_gm_phase_change;
+	float64 last_gm_freq_change;
+	uint16_t gm_time_base_indicator;
+	uint32_t gm_change_count;
+	uint32_t time_of_last_gm_change_event;
+	uint32_t time_of_last_gm_phase_change_event;
+	uint32_t time_of_last_gm_freq_change_event;
+};
+
+// IEEE 802.1AS-2020 14.4
+// This is a read-only data structure
+struct _parent_ds {
+	struct port_identity parent_port_identity;
+	int32_t cumulative_rate_ratio;
+	_clock_identity grandmaster_identity;
+	uint8_t gm_clock_quality_clock_class;
+	uint8_t gm_clock_quality_clock_accuracy;
+	uint16_t gm_clock_quality_offset_scaled_log_variance;
+	uint8_t gm_priority1;
+	uint8_t gm_priority2;
+};
+
+struct _GPTPStatus
+{
+	struct _timestamp current_time;
+	struct priority_vector gm_priority;
+	int64_t ms_offset_ns;
+	uint8_t is_sync;
+	uint8_t link_status;
+	int64_t link_delay_ns;
+	uint8_t selected_role;
+	uint8_t as_capable;
+	uint8_t is_syntonized;
+	struct _timestamp last_rx_sync_ts; // t2 in IEEE 1588-2019 Figure-16
+	struct _current_ds current_ds;
+	struct _parent_ds parent_ds;
+};
+
+#pragma pack(pop)
+
+static void SetField(GPTPStatus::Timestamp& output, const _timestamp& input) {
+	output.seconds = ((uint64_t)(input.seconds_msb) << 32) | ((uint64_t)input.seconds_lsb);
+	output.nanoseconds = input.nanoseconds;
+}
+
+static void SetField(GPTPStatus::PortID& output, const port_identity& input) {
+	output.clockIdentity = input.clock_identity;
+	output.portNumber = input.port_number;	
+}
+static void SetField(GPTPStatus::ClockQuality& output, const _clock_quality& input) {
+	output.clockClass = input.clock_class;
+	output.clockAccuracy = input.clock_accuracy;
+	output.offsetScaledLogVariance = input.offset_scaled_log_variance;
+}
+
+static void SetField(GPTPStatus::SystemID& output, const system_identity& input) {
+	output.priority1 = input.priority_1;
+	SetField(output.clockQuality, input.clock_quality);
+	output.priority2 = input.priority_2;
+	output.clockID = input.clock_identity;
+}
+
+static void SetField(GPTPStatus::ScaledNanoSeconds& output, const _scaled_ns& input) {
+	output.nanosecondsMSB = input.nanoseconds_msb;
+	output.nanosecondsLSB = input.nanoseconds_lsb;
+	output.fractionalNanoseconds = input.fractional_nanoseconds;
+}
+
+static void SetField(GPTPStatus::PriorityVector& output, const priority_vector& input) {
+	SetField(output.sysID, input.sysid);
+	output.stepsRemoved = input.steps_removed;
+	SetField(output.portID, input.portid);
+	output.portNumber = input.port_number;
+}
+
+static void SetField(GPTPStatus::CurrentDS& output, const _current_ds& input) {
+	output.stepsRemoved = input.steps_removed;
+	output.offsetFromMaster = input.offset_from_master;
+	SetField(output.lastgmPhaseChange, input.last_gm_phase_change);
+	output.lastgmFreqChange = input.last_gm_freq_change;	
+	output.gmTimeBaseIndicator = input.gm_time_base_indicator;
+	output.gmChangeCount = input.gm_change_count;
+	output.timeOfLastgmChangeEvent = input.time_of_last_gm_change_event;
+	output.timeOfLastgmPhaseChangeEvent = input.time_of_last_gm_phase_change_event;
+	output.timeOfLastgmFreqChangeEvent = input.time_of_last_gm_freq_change_event;
+}
+
+static void SetField(GPTPStatus::ParentDS& output, const _parent_ds& input) {
+	SetField(output.parentPortIdentity, input.parent_port_identity);
+	output.cumulativeRateRatio = input.cumulative_rate_ratio;
+	output.grandmasterIdentity = input.grandmaster_identity;
+	output.gmClockQualityClockClass = input.gm_clock_quality_clock_class;
+	output.gmClockQualityClockAccuracy = input.gm_clock_quality_clock_accuracy;
+	output.gmClockQualityOffsetScaledLogVariance = input.gm_clock_quality_offset_scaled_log_variance;
+	output.gmPriority1 = input.gm_priority1;
+	output.gmPriority2 = input.gm_priority2;
+}
+
+[[maybe_unused]] static void SetField(uint8_t& output, const uint8_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint16_t& output, const uint16_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint32_t& output, const uint32_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint64_t& output, const uint64_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int8_t& output, const int8_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int16_t& output, const int16_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int32_t& output, const int32_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int64_t& output, const int64_t& input) {
+	output = input;
+}
+
+std::shared_ptr<GPTPStatus> GPTPStatus::DecodeToMessage(std::vector<uint8_t>& bytes, const device_eventhandler_t&) {
+
+	// The following does not lead to overflow since we only call this function if it has at least ResponseHeader length bytes
+	std::shared_ptr<GPTPStatus> res = std::make_shared<GPTPStatus>();
+	auto* header = reinterpret_cast<ExtendedResponseMessage::ResponseHeader*>(bytes.data());
+	uint16_t length = header->length;
+	_GPTPStatus* input = reinterpret_cast<_GPTPStatus*>(bytes.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
+
+#define CheckLengthAndSet(output, input) if(length >= sizeof(decltype(input))) { \
+		SetField(output, input); \
+		length -= sizeof(decltype(input)); \
+	} else {\
+		memset(&output, 0, sizeof(decltype(output))); \
+		length = 0; \
+		res->shortFormat = true; \
+	}
+
+	CheckLengthAndSet(res->currentTime, input->current_time);
+	CheckLengthAndSet(res->gmPriority, input->gm_priority);
+	CheckLengthAndSet(res->msOffsetNs, input->ms_offset_ns);
+	CheckLengthAndSet(res->isSync, input->is_sync);
+	CheckLengthAndSet(res->linkStatus, input->link_status);
+	CheckLengthAndSet(res->linkDelayNS, input->link_delay_ns);
+	CheckLengthAndSet(res->selectedRole, input->selected_role);
+	CheckLengthAndSet(res->asCapable, input->as_capable);
+	CheckLengthAndSet(res->isSyntonized, input->is_syntonized);
+	CheckLengthAndSet(res->lastRXSyncTS, input->last_rx_sync_ts);
+	CheckLengthAndSet(res->currentDS, input->current_ds);
+	CheckLengthAndSet(res->parentDS, input->parent_ds);
+
+	return res;
+}
+
+}
--- a/communication/message/neomessage.cpp
+++ b/communication/message/neomessage.cpp
@ -51,7 +51,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				eth.status.incompleteFrame = ethmsg->frameTooShort;
 				// TODO Fill in extra status bits
 				//eth.status.xyz = ethmsg->preemptionEnabled;
-				//eth.status.xyz = ethmsg->fcsAvailable;
+				//eth.status.xyz = ethmsg->fcs;
 				//eth.status.xyz = ethmsg->noPadding;
 				break;
 			}
--- a/communication/packet/ethernetpacket.cpp
+++ b/communication/packet/ethernetpacket.cpp
@ -16,8 +16,8 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	if(packet->Length < 4)
 		return nullptr;
 	
-	const size_t ethernetFrameSize = packet->Length - (sizeof(uint16_t) * 2);
-	const size_t bytestreamExpectedSize = sizeof(HardwareEthernetPacket) + ethernetFrameSize;
+	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;
@ -36,8 +36,6 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	message.preemptionEnabled = packet->header.PREEMPTION_ENABLED;
 	if(message.preemptionEnabled)
 		message.preemptionFlags = (uint8_t)((rawWords[0] & 0x03F8) >> 4);
-	
-	message.fcsAvailable = packet->header.FCS_AVAIL;

 	message.frameTooShort = packet->header.RUNT_FRAME;
 	if(message.frameTooShort)
@ -47,11 +45,14 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	// Decoder will fix as it has information about the timestampResolution increments
 	message.timestamp = packet->timestamp.TS;

-	// Network ID is also not set, this will be fixed in the Decoder as well
-
-	const std::vector<uint8_t>::const_iterator databegin = bytestream.begin() + (sizeof(HardwareEthernetPacket) - (sizeof(uint16_t) * 2));
-	const std::vector<uint8_t>::const_iterator dataend = databegin + ethernetFrameSize;
+	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);
+	}

 	return messagePtr;
 }
--- a/device/device.cpp
+++ b/device/device.cpp
@ -218,8 +218,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 	if(block) // Extensions say no
 		return false;

-	// Get component versions *after* the extension "onDeviceOpen" hooks (e.g. device reflashes)
-	
+	// Get component versions again *after* the extension "onDeviceOpen" hooks (e.g. device reflashes)
 	if(supportsComponentVersions()) {
 		if(auto compVersions = com->getComponentVersionsSync())
 			componentVersions = std::move(*compVersions);
@ -348,6 +347,15 @@ APIEvent::Type Device::attemptToBeginCommunication() {
 	else
 		versions = std::move(*maybeVersions);

+
+	// Get component versions before the extension "onDeviceOpen" hooks so that we can properly check verisons
+	if(supportsComponentVersions()) {
+		if(auto compVersions = com->getComponentVersionsSync())
+			componentVersions = std::move(*compVersions);
+		else
+			return getCommunicationNotEstablishedError();
+	}
+
 	return APIEvent::Type::NoErrorFound;
 }

@ -656,6 +664,85 @@ bool Device::clearScript(Disk::MemoryType memType)
 	return true;
 }

+std::optional<CoreminiHeader> Device::readCoreminiHeader(Disk::MemoryType memType) {
+	if(!isOpen()) {
+		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	auto startAddress = getCoreminiStartAddress(memType);
+	if(!startAddress) {
+		return std::nullopt;
+	}
+
+	auto connected = isLogicalDiskConnected();
+	
+	if(!connected) {
+		return std::nullopt; // Already added an API error
+	}
+
+	#pragma pack(push, 2)
+	struct RawCoreminiHeader {
+		uint16_t fileType;
+		uint16_t fileVersion;
+		uint32_t storedFileSize;
+		uint32_t fileChecksum;
+		union
+		{
+			struct
+			{
+				uint32_t skipDecompression : 1;
+				uint32_t encryptedMode : 1;
+				uint32_t reserved : 30;
+			} bits;
+			uint32_t word;
+		} flags;
+		uint8_t fileHash[32];
+		union
+		{
+			struct
+			{
+				uint32_t lsb;
+				uint32_t msb;
+			} words;
+			uint64_t time64;
+		} createTime;
+		uint8_t reserved[8];
+	};
+	#pragma pack(pop)
+
+	RawCoreminiHeader header = {};
+	auto numRead = readLogicalDisk(*startAddress, (uint8_t*)&header, sizeof(header), std::chrono::milliseconds(2000), memType);
+
+	if(!numRead) {
+		return std::nullopt; // Already added an API error
+	}
+	
+	if(*numRead != sizeof(header)) {
+		report(APIEvent::Type::FailedToRead, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	if(header.fileType != 0x0907) {
+		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	std::optional<CoreminiHeader> ret;
+	ret.emplace();
+	ret->coreminiVersion = header.fileVersion;
+	ret->storedFileSize = header.storedFileSize;
+	ret->fileChecksum = header.fileChecksum;
+	ret->skipDecompression = static_cast<bool>(header.flags.bits.skipDecompression);
+	ret->encryptedMode = static_cast<bool>(header.flags.bits.encryptedMode);
+	std::copy(std::begin(header.fileHash), std::end(header.fileHash), ret->fileHash.begin());
+	static constexpr std::chrono::seconds icsEpochDelta(1167609600);
+	static constexpr uint8_t timestampResolution = 25;
+	static constexpr uint16_t nsInUs = 1'000;
+	ret->timestamp += icsEpochDelta + std::chrono::microseconds(header.createTime.time64 * timestampResolution / nsInUs);
+	return ret;
+}
+
 bool Device::transmit(std::shared_ptr<Frame> frame) {
 	if(!isOpen()) {
 		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
@ -1642,15 +1729,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);
@ -1660,6 +1738,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) {
@ -1872,7 +1959,7 @@ bool Device::setRTC(const std::chrono::time_point<std::chrono::system_clock>& ti
 	}

 	auto m51msg = std::dynamic_pointer_cast<Main51Message>(generic);
-	if(!m51msg || m51msg->data.size() != 1) {
+	if(!m51msg || m51msg->data.empty() || m51msg->data.size() > 2) {
 		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
 		return false;
 	}
@ -2116,7 +2203,7 @@ bool Device::readVSA(const VSAExtractionSettings& extractionSettings) {
 	if(isOnline()) {
 		goOffline();
 	}
-	auto innerReadVSA = [&](uint64_t diskSize) -> const bool {
+	auto innerReadVSA = [&](uint64_t diskSize) -> bool {
 		// Adjust driver to offset to start of VSA file
 		const auto& offset = getVSAOffsetInLogicalDisk();
 		if(!offset) {
@ -3256,3 +3343,34 @@ std::optional<TC10StatusMessage> Device::getTC10Status(Network::NetID network) {

 	return *typed;
 }
+
+std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeout) {
+	if(!supportsGPTP()) {
+		report(APIEvent::Type::GPTPNotSupported, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	if(!isOpen()) {
+		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this](){ 
+			return com->sendCommand(ExtendedCommand::GetGPTPStatus, {}); 
+		},
+		std::make_shared<MessageFilter>(Message::Type::GPTPStatus),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	auto retMsg = std::static_pointer_cast<GPTPStatus>(response);
+	if(!retMsg) {
+		return std::nullopt;
+	}
+
+	return *retMsg;
+}
--- a/device/devicefinder.cpp
+++ b/device/devicefinder.cpp
@ -185,6 +185,10 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADComet3>(dev, newFoundDevices);
 		#endif

+		#ifdef __RADMOONT1S_H_
+		makeIfSerialMatches<RADMoonT1S>(dev, newFoundDevices);
+		#endif
+
 		#ifdef __RADEPSILON_H_
 		makeIfSerialMatches<RADEpsilon>(dev, newFoundDevices);
 		#endif
@ -193,6 +197,10 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADGalaxy>(dev, newFoundDevices);
 		#endif

+		#ifdef __RADGALAXY2_H_
+		makeIfSerialMatches<RADGalaxy2>(dev, newFoundDevices);
+		#endif
+
 		#ifdef __RADMARS_H_
 		makeIfSerialMatches<RADMars>(dev, newFoundDevices);
 		#endif
@ -200,6 +208,10 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		#ifdef __RADGIGASTAR_H_
 		makeIfSerialMatches<RADGigastar>(dev, newFoundDevices);
 		#endif
+		
+		#ifdef __RADGIGASTAR2_H_
+		makeIfSerialMatches<RADGigastar2>(dev, newFoundDevices);
+		#endif

 		#ifdef __RADJUPITER_H_
 		makeIfSerialMatches<RADJupiter>(dev, newFoundDevices);
@ -332,6 +344,10 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADComet3::DEVICE_TYPE,
 		#endif
 		
+		#ifdef __RADMOONT1S_H_
+		RADMoonT1S::DEVICE_TYPE,
+		#endif
+
 		#ifdef __RADEPSILON_H_
 		RADEpsilon::DEVICE_TYPE,
 		#endif
@ -340,6 +356,10 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADGalaxy::DEVICE_TYPE,
 		#endif

+		#ifdef __RADGALAXY2_H_
+		RADGalaxy2::DEVICE_TYPE,
+		#endif
+
 		#ifdef __RADMARS_H_
 		RADMars::DEVICE_TYPE,
 		#endif
@ -348,6 +368,10 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADGigastar::DEVICE_TYPE,
 		#endif

+		#ifdef __RADGIGASTAR2_H_
+		RADGigastar2::DEVICE_TYPE,
+		#endif
+
 		#if defined __RADMOON2_H_ || defined __RADMOON2ZL_H_
 		RADMoon2::DEVICE_TYPE,
 		#endif
--- a/disk/neomemorydiskdriver.cpp
+++ b/disk/neomemorydiskdriver.cpp
@ -1,5 +1,6 @@
 #include "icsneo/disk/neomemorydiskdriver.h"
 #include "icsneo/communication/message/neoreadmemorysdmessage.h"
+#include "icsneo/communication/message/flashmemorymessage.h"
 #include <cstring>
 #include <iostream>

@ -8,7 +9,8 @@ using namespace icsneo::Disk;

 std::optional<uint64_t> NeoMemoryDiskDriver::readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
 	uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType) {
-	static std::shared_ptr<MessageFilter> NeoMemorySDRead = std::make_shared<MessageFilter>(Network::NetID::NeoMemorySDRead);
+	const auto filter = std::make_shared<MessageFilter>((memType == MemoryType::SD ? Network::NetID::NeoMemorySDRead : Network::NetID::RED_INT_MEMORYREAD));
+	filter->includeInternalInAny = true;

 	if(pos % SectorSize != 0)
 		return std::nullopt;
@ -20,7 +22,7 @@ std::optional<uint64_t> NeoMemoryDiskDriver::readLogicalDiskAligned(Communicatio
 	const uint8_t memLocation = (uint8_t)memType;

 	uint64_t numWords = amount / 2;
-	
+
 	auto msg = com.waitForMessageSync([&currentSector, &memLocation, &com, &numWords] {
 		return com.sendCommand(Command::NeoReadMemory, {
 			memLocation,
@ -33,18 +35,26 @@ std::optional<uint64_t> NeoMemoryDiskDriver::readLogicalDiskAligned(Communicatio
 			uint8_t((numWords >> 16) & 0xFF),
 			uint8_t((numWords >> 24) & 0xFF)
 		});
-	}, NeoMemorySDRead, timeout);
+	}, filter, timeout);

 	if(!msg)
 		return 0;

-	const auto sdmsg = std::dynamic_pointer_cast<NeoReadMemorySDMessage>(msg);
-	if(!sdmsg || sdmsg->data.size() != SectorSize) {
-		report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-		return std::nullopt;
+	if(memType == MemoryType::SD) {
+		const auto mem = std::dynamic_pointer_cast<NeoReadMemorySDMessage>(msg);
+		if(!mem || mem->data.size() != SectorSize) {
+			report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		memcpy(into, mem->data.data(), SectorSize);
+	} else { // flash
+		const auto mem = std::dynamic_pointer_cast<FlashMemoryMessage>(msg);
+		if(!mem || mem->data.size() != SectorSize) {
+			report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		memcpy(into, mem->data.data(), SectorSize);
 	}
-
-	memcpy(into, sdmsg->data.data(), SectorSize);
 	return SectorSize;
 }

--- a/docs/conf.py
+++ b/docs/conf.py
@ -1,188 +1,36 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
+# Configuration file for the Sphinx documentation builder.
 #
-# NOTE: The conf.py file is automatically updated by CMake when there are
-# changes to the version. Update the conf.py.template and then build to
-# propagate changes here. This file should be committed so that
-# ReadTheDocs can use it.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html

-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-import os
 import subprocess
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))

+subprocess.call('cd ..; doxygen docs/icsneocpp/Doxyfile', shell=True)
+subprocess.call('cd ..; doxygen docs/icsneoc/Doxyfile', shell=True)

-# -- General configuration ------------------------------------------------
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information

-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = ['sphinx.ext.imgmath', 'sphinx.ext.todo', 'breathe' ]
-
-breathe_projects = { "libicsneo": "build/doxygen/xml" }
-breathe_default_project = "libicsneo"
-
-try:
-    os.makedirs('build/sphinx')
-except FileExistsError:
-    pass
-try:
-    os.makedirs('build/doxygen')
-except FileExistsError:
-    pass
-
-subprocess.call('cd ..; doxygen docs/Doxyfile', shell=True)
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
 project = 'libicsneo'
-copyright = '2018-2024, Intrepid Control Systems, Inc.'
+copyright = '2024, Intrepid Control Systems, Inc.'
 author = 'Intrepid Control Systems, Inc.'

-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '0.2.0'
-# The full version, including alpha/beta/rc tags.
-release = '0.2.0 '
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
+extensions = ['breathe', 'sphinx.ext.autodoc']

-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
+templates_path = ['_templates']
 exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']

-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+breathe_projects = {
+    'icsneocpp': 'icsneocpp/doxygen/xml',
+    'icsneoc': 'icsneoc/doxygen/xml',
+}

-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
+breathe_default_project = 'icsneocpp'

+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output

-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
 html_theme = 'sphinx_rtd_theme'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-html_theme_options = {
-
-}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Custom sidebar templates, must be a dictionary that maps document names
-# to template names.
-#
-# This is required for the alabaster theme
-# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
-html_sidebars = {
-    '**': [
-        'relations.html',  # needs 'show_related': True theme option to display
-        'searchbox.html',
-    ]
-}
-
-
-# -- Options for HTMLHelp output ------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'libicsneodoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    #
-    # 'papersize': 'letterpaper',
-
-    # The font size ('10pt', '11pt' or '12pt').
-    #
-    # 'pointsize': '10pt',
-
-    # Additional stuff for the LaTeX preamble.
-    #
-    # 'preamble': '',
-
-    # Latex figure (float) alignment
-    #
-    # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'libicsneo.tex', 'libicsneo Documentation',
-     'Intrepid Control Systems, Inc.', 'manual'),
-]
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'libicsneo', 'libicsneo Documentation',
-     [author], 1)
-]
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'libicsneo', 'libicsneo Documentation',
-     author, 'libicsneo', 'One line description of project.',
-     'Miscellaneous'),
-]
-
-
-
--- a/docs/conf.py.template
+++ b/docs/conf.py.template
@ -1,188 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# NOTE: The conf.py file is automatically updated by CMake when there are
-# changes to the version. Update the conf.py.template and then build to
-# propagate changes here. This file should be committed so that
-# ReadTheDocs can use it.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-import os
-import subprocess
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = ['sphinx.ext.imgmath', 'sphinx.ext.todo', 'breathe' ]
-
-breathe_projects = { "libicsneo": "build/doxygen/xml" }
-breathe_default_project = "libicsneo"
-
-try:
-    os.makedirs('build/sphinx')
-except FileExistsError:
-    pass
-try:
-    os.makedirs('build/doxygen')
-except FileExistsError:
-    pass
-
-subprocess.call('cd ..; doxygen docs/Doxyfile', shell=True)
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = 'libicsneo'
-copyright = '2018-2024, Intrepid Control Systems, Inc.'
-author = 'Intrepid Control Systems, Inc.'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@'
-# The full version, including alpha/beta/rc tags.
-release = '@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@ @BUILD_METADATA@'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'sphinx_rtd_theme'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-html_theme_options = {
-
-}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Custom sidebar templates, must be a dictionary that maps document names
-# to template names.
-#
-# This is required for the alabaster theme
-# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
-html_sidebars = {
-    '**': [
-        'relations.html',  # needs 'show_related': True theme option to display
-        'searchbox.html',
-    ]
-}
-
-
-# -- Options for HTMLHelp output ------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'libicsneodoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    #
-    # 'papersize': 'letterpaper',
-
-    # The font size ('10pt', '11pt' or '12pt').
-    #
-    # 'pointsize': '10pt',
-
-    # Additional stuff for the LaTeX preamble.
-    #
-    # 'preamble': '',
-
-    # Latex figure (float) alignment
-    #
-    # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'libicsneo.tex', 'libicsneo Documentation',
-     'Intrepid Control Systems, Inc.', 'manual'),
-]
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'libicsneo', 'libicsneo Documentation',
-     [author], 1)
-]
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'libicsneo', 'libicsneo Documentation',
-     author, 'libicsneo', 'One line description of project.',
-     'Miscellaneous'),
-]
-
-
-
--- a/docs/icsneoc.rst
+++ b/docs/icsneoc.rst
@ -1,44 +0,0 @@
-********************
-**C API** (icsneoc)
-********************
-
-.. Usage
-.. ======
-
-.. Finding Devices
-.. ~~~~~~~~~~~~~~~~
-.. Finding a device is simple
-
-.. Connecting to Devices
-.. ~~~~~~~~~~~~~~~~~~~~~~
-
-Reference
-==========
-
-Typedefs
-~~~~~~~~~
-.. doxygentypedef:: devicehandle_t
-.. doxygentypedef:: neodevice_handle_t
-.. doxygentypedef:: devicetype_t
-
-Structures
-~~~~~~~~~~~
-.. doxygenstruct:: neoversion_t
-   :members:
-   :undoc-members:
-
-.. doxygenstruct:: neodevice_t
-   :members:
-   :undoc-members:
-
-.. doxygenstruct:: neomessage_t
-   :members:
-   :undoc-members:
-
-.. doxygenstruct:: neomessage_can_t
-   :members:
-   :undoc-members:
-
-Functions
-~~~~~~~~~~
-.. doxygenfile:: icsneoc.h
--- a/docs/icsneoc/Doxyfile
+++ b/docs/icsneoc/Doxyfile
--- a/docs/icsneoc/api.rst
+++ b/docs/icsneoc/api.rst
@ -0,0 +1,14 @@
+=====
+C API
+=====
+
+.. doxygenfile:: icsneoc.h
+   :project: icsneoc
+.. doxygenfile:: device/neodevice.h
+   :project: icsneoc
+.. doxygenfile:: communication/message/neomessage.h
+   :project: icsneoc
+.. doxygenfile:: api/version.h
+   :project: icsneoc
+.. doxygenfile:: api/event.h
+   :project: icsneoc
--- a/docs/icsneoc/examples.rst
+++ b/docs/icsneoc/examples.rst
@ -0,0 +1,43 @@
+==========
+C Examples
+==========
+
+A variety of examples can be found within ``examples/c``, see below for an
+example that uses the polling API to receive CAN frames.
+
+.. code-block:: c
+
+   size_t deviceCount = 10; // Pre-set to the size of your buffer before the icsneo_findAllDevices() call
+   neodevice_t devices[10];
+   icsneo_findAllDevices(devices, &deviceCount);
+   printf("We found %ull devices\n", deviceCount);
+   for(size_t i = 0; i < deviceCount; i++) {
+       neodevice_t* myDevice = &devices[i];
+       char desc[ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION];
+       size_t sz = ICSNEO_DEVICETYPE_LONGEST_DESCRIPTION;
+       icsneo_describeDevice(myDevice, desc, &sz);
+       printf("Found %s\n", desc); // "Found neoVI FIRE 2 CY2345"
+   }
+   neodevice_t* myDevice = &devices[0];
+   if(!icsneo_openDevice(myDevice)) {
+       neoevent_t error;
+       if(icsneo_getLastError(&error))
+           printf("Error! %s\n", error.description);
+   }
+   icsneo_goOnline(myDevice); // Start receiving messages
+   icsneo_enableMessagePolling(myDevice); // Allow the use of icsneo_getMessages() later
+   sleep(5);
+   neomessage_t messages[50];
+   size_t messageCount = 50;
+   icsneo_getMessages(myDevice, messages, &messageCount, 0 /* non-blocking */);
+   printf("We got %ull messages!\n", messageCount);
+   for(size_t i = 0; i < messageCount; i++) {
+       if(messages[i].type == ICSNEO_NETWORK_TYPE_CAN) {
+           // A message of type CAN should be interperated a neomessage_can_t, so we can cast safely
+           neomessage_can_t* canmsg = (neomessage_can_t*)&messages[i];
+           // canmsg->arbid is valid here
+           // canmsg->data is an uint8_t*, you can check canmsg->length for the length of the payload
+           // canmsg->timestamp is the time recorded by the hardware in nanoseconds since (1/1/2007 12:00:00 GMT)
+       }
+   }
+   icsneo_closeDevice(myDevice);
--- a/docs/icsneoc/index.rst
+++ b/docs/icsneoc/index.rst
@ -0,0 +1,9 @@
+icsneoc
+=======
+
+.. toctree::
+   :maxdepth: 2
+
+   installation
+   examples
+   api
--- a/docs/icsneoc/installation.rst
+++ b/docs/icsneoc/installation.rst
@ -0,0 +1,7 @@
+============
+Installation
+============
+
+The installation steps for the C API are the same as the C++ API as the C API is
+a wrapper for the C++ library. The ``LIBICSNEO_BUILD_ICSNEOC`` CMake option is
+default ``ON`` but note that the C API depends on this flag to build.
--- a/docs/icsneocpp.rst
+++ b/docs/icsneocpp.rst
@ -1,31 +0,0 @@
-************************
-**C++ API** (icsneocpp)
-************************
-
-.. Usage
-.. ======
-
-.. Finding Devices
-.. ~~~~~~~~~~~~~~~~
-.. Finding a device is simple
-
-.. Connecting to Devices
-.. ~~~~~~~~~~~~~~~~~~~~~~
-
-Reference
-==========
-
-.. Classes
-.. ~~~~~~~~
-
-.. Structures
-.. ~~~~~~~~~~~
-
-.. Functions
-.. ~~~~~~~~~~
-
-.. doxygennamespace:: icsneo
-
-.. doxygenclass:: icsneo::Device
-   :members:
-   :undoc-members:
--- a/docs/icsneocpp/Doxyfile
+++ b/docs/icsneocpp/Doxyfile
--- a/docs/icsneocpp/api.rst
+++ b/docs/icsneocpp/api.rst
@ -0,0 +1,8 @@
+=======
+C++ API
+=======
+
+.. doxygennamespace:: icsneo
+   :members:
+   :undoc-members:
+   :content-only:
--- a/docs/icsneocpp/apiconcepts.rst
+++ b/docs/icsneocpp/apiconcepts.rst
@ -0,0 +1,55 @@
+============
+API Concepts
+============
+
+Overview
+~~~~~~~~~~~~~~~~~~~~
+
+Events convey information about the API's inner workings to the user. There are 3 severity levels: ``EventInfo``, ``EventWarning``, and ``Error``.
+**However, the API treats events of severities** ``EventInfo`` **and** ``EventWarning`` **differently than those of severity** ``Error`` **.**
+From here on out, when we (and the API functions) refer to "events", we refer exclusively to those of severities ``EventInfo`` and ``EventWarning``, which use the events_ system.
+Those of severity ``Error`` are referred to as "errors", which use a separate errors_ system.
+
+Events should periodically be read out in order to avoid overflowing, and the last error should be read out immediately after an API function fails.
+
+Additionally, `event callbacks`_ can be registered, which may remove the need to periodically read events in some cases.
+
+.. _events:
+
+Events
+~~~~~~~~~~~~~~~~~~~~
+
+The API stores events in a single buffer that can has a default size of 10,000 events.
+This limit includes 1 reserved slot at the end of the buffer for a potential Event of type ``TooManyEvents`` and severity ``EventWarning``, which is added when there are too many events for the buffer to hold.
+This could occur if the events aren't read out by the user often enough, or if the user sets the size of the buffer to a value smaller than the number of existing events.
+There will only ever be one of these ``TooManyEvents`` events, and it will always be located at the very end of the buffer if it exists.
+Because of this reserved slot, the buffer by default is able to hold 9,999 events. If capacity is exceeded, the oldest events in the buffer are automatically discarded until the buffer is exactly at capacity again.
+When events are read out by the user, they are removed from the buffer. If an event filter is used, only the filtered events will be removed from the buffer.
+
+In a multithreaded environment, all threads will log their events to the same buffer. In this case, the order of events will largely be meaningless, although the behavior of ``TooManyEvents`` is still guaranteed to be as described above.
+
+.. _event callbacks:
+
+Event Callbacks
+~~~~~~~~~~~~~~~~~~~~
+
+Users may register event callbacks, which are automatically called whenever a matching event is logged.
+Message callbacks consist of a user-defined ``std::function< void( std::shared_ptr<APIEvent> ) >`` and optional EventFilter used for matching.
+If no EventFilter is provided, the default-constructed one will be used, which matches any event.
+Registering a callback returns an ``int`` representing the id of the callback, which should be stored by the user and later used to remove the callback when desired.
+Note that this functionality is only available in C and C++. C does not currently support filters.
+
+Event callbacks are run after the event has been added to the buffer of events. The buffer of events may be safely modified within the callback, such as getting (flushing) the type and severity of the triggering event.
+Using event callbacks in this manner means that periodically reading events is unnecessary.
+
+.. _errors:
+
+Errors
+~~~~~~~~~
+
+The error system is threadsafe and separate from the events_ system.
+Each thread keeps track of the last error logged on it, and getting the last error will return the last error from the calling thread, removing it in the process.
+Trying to get the last error when there is none will return an event of type ``NoErrorFound`` and severity ``EventInfo``.
+
+The API also contains some threads for internal use which may potentially log errors of their own and are inaccessible to the user.
+These threads have been marked to downgrade any errors that occur on them to severity ``EventWarning`` and will log the corresponding event in the events_ system described above.
--- a/docs/icsneocpp/deviceconcepts.rst
+++ b/docs/icsneocpp/deviceconcepts.rst
@ -1,64 +1,6 @@
-****************
-**API Usage**
-****************
-
-API Concepts
-================
-
-Overview
-~~~~~~~~~~~~~~~~~~~~
-
-Events convey information about the API's inner workings to the user. There are 3 severity levels: ``EventInfo``, ``EventWarning``, and ``Error``.
-**However, the API treats events of severities** ``EventInfo`` **and** ``EventWarning`` **differently than those of severity** ``Error`` **.**
-From here on out, when we (and the API functions) refer to "events", we refer exclusively to those of severities ``EventInfo`` and ``EventWarning``, which use the events_ system.
-Those of severity ``Error`` are referred to as "errors", which use a separate errors_ system.
-
-Events should periodically be read out in order to avoid overflowing, and the last error should be read out immediately after an API function fails.
-
-Additionally, `event callbacks`_ can be registered, which may remove the need to periodically read events in some cases.
-
-.. _events:
-
-Events
-~~~~~~~~~~~~~~~~~~~~
-
-The API stores events in a single buffer that can has a default size of 10,000 events.
-This limit includes 1 reserved slot at the end of the buffer for a potential Event of type ``TooManyEvents`` and severity ``EventWarning``, which is added when there are too many events for the buffer to hold.
-This could occur if the events aren't read out by the user often enough, or if the user sets the size of the buffer to a value smaller than the number of existing events.
-There will only ever be one of these ``TooManyEvents`` events, and it will always be located at the very end of the buffer if it exists.
-Because of this reserved slot, the buffer by default is able to hold 9,999 events. If capacity is exceeded, the oldest events in the buffer are automatically discarded until the buffer is exactly at capacity again.
-When events are read out by the user, they are removed from the buffer. If an event filter is used, only the filtered events will be removed from the buffer.
-
-In a multithreaded environment, all threads will log their events to the same buffer. In this case, the order of events will largely be meaningless, although the behavior of ``TooManyEvents`` is still guaranteed to be as described above.
-
-.. _event callbacks:
-
-Event Callbacks
-~~~~~~~~~~~~~~~~~~~~
-
-Users may register event callbacks, which are automatically called whenever a matching event is logged.
-Message callbacks consist of a user-defined ``std::function< void( std::shared_ptr<APIEvent> ) >`` and optional EventFilter used for matching.
-If no EventFilter is provided, the default-constructed one will be used, which matches any event.
-Registering a callback returns an ``int`` representing the id of the callback, which should be stored by the user and later used to remove the callback when desired.
-Note that this functionality is only available in C and C++. C does not currently support filters.
-
-Event callbacks are run after the event has been added to the buffer of events. The buffer of events may be safely modified within the callback, such as getting (flushing) the type and severity of the triggering event.
-Using event callbacks in this manner means that periodically reading events is unnecessary.
-
-.. _errors:
-
-Errors
-~~~~~~~~~
-
-The error system is threadsafe and separate from the events_ system.
-Each thread keeps track of the last error logged on it, and getting the last error will return the last error from the calling thread, removing it in the process.
-Trying to get the last error when there is none will return an event of type ``NoErrorFound`` and severity ``EventInfo``.
-
-The API also contains some threads for internal use which may potentially log errors of their own and are inaccessible to the user.
-These threads have been marked to downgrade any errors that occur on them to severity ``EventWarning`` and will log the corresponding event in the events_ system described above.
-
+===============
 Device Concepts
-================
+===============

 Open/Close Status
 ~~~~~~~~~~~~~~~~~~~~~~~
--- a/docs/icsneocpp/examples.rst
+++ b/docs/icsneocpp/examples.rst
@ -0,0 +1,52 @@
+============
+C++ Examples
+============
+
+A variety of examples can be found within ``examples/cpp``, see below for an
+example that uses the polling API to receive CAN frames.
+
+The C++ API is designed to be modern and easy to use. All library functions and
+classes are in the namespace ``icsneo``. Most applications will start by calling
+``icsneo::FindAllDevices()``. This will return an ``std::vector`` of
+``std::shared_ptr<icsneo::Device>`` objects. You will want to keep a copy of the
+``shared_ptr`` to any devices you want to use, as allowing it to go out of scope
+will automatically close the device and free all memory associated with it.
+
+Any time you get bus traffic from the API, you will receive it as an
+``std::shared_ptr<icsneo::Message>``. The message will be valid as long as the
+``shared_ptr`` stays in scope. Checking the type of the message allows you to
+cast it accordingly and access extra data for certain protocols. For instance,
+casting an ``icsneo::Message`` to an ``icsneo::CANMessage`` allows you to access
+the arbitration ID.
+
+.. code-block:: cpp
+
+   std::vector<std::shared_ptr<icsneo::Device>> devices = icsneo::FindAllDevices();
+   std::cout << devices.size() << " found!" << std::endl;
+   for(auto& device : devices)
+       std::cout << "Found " << device->describe() << std::endl; // "Found neoVI FIRE 2 CY2345"
+   std::shared_ptr<icsneo::Device> myDevice = devices[0];
+   if(!myDevice->open()) // Device tried and failed to open, print the last error
+       std::cout << icsneo::GetLastError() << std::endl;
+   myDevice->goOnline(); // Start receiving messages
+   myDevice->enableMessagePolling(); // Allow the use of myDevice->getMessages() later
+   // Alternatively, assign a callback for new messages
+   std::this_thread::wait_for(std::chrono::seconds(5));
+   std::vector<std::shared_ptr<icsneo::Message>> messages = myDevice->getMessages();
+   std::cout << "We got " << messages.size() << " messages!" << std::endl;
+   for(auto& msg : messages) {
+       switch(msg->network.getType()) {
+           case icsneo::Network::Type::CAN:
+           case icsneo::Network::Type::SWCAN:
+           case icsneo::Network::Type::LSFTCAN: {
+               // A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
+               auto canmsg = std::static_pointer_cast<icsneo::CANMessage>(msg);
+               // canmsg->arbid is valid here
+               // canmsg->data is an std::vector<uint8_t>, you can check .size() for the DLC of the message
+               // canmsg->timestamp is the time recorded by the hardware in nanoseconds since (1/1/2007 12:00:00 GMT)
+           }
+           default:
+               // Handle others
+       }
+   }
+   myDevice->close();
--- a/docs/icsneocpp/index.rst
+++ b/docs/icsneocpp/index.rst
@ -0,0 +1,11 @@
+icsneocpp
+=========
+
+.. toctree::
+   :maxdepth: 2
+
+   installation
+   deviceconcepts
+   apiconcepts
+   examples
+   api
--- a/docs/icsneocpp/installation.rst
+++ b/docs/icsneocpp/installation.rst
@ -0,0 +1,39 @@
+============
+Installation
+============
+
+Dependencies
+============
+
+The minimum requirements to build libicsneo are:
+- CMake version 3.12 or newer
+- A C++17 compiler
+- libusb and libpcap on Linux and macOS
+
+
+Building library & examples
+===========================
+
+For a list of available configuration options, see the ``option()`` entries in
+``CMakeLists.txt``.
+
+To build libicsneo with default options:
+#. ``cmake -B build``
+#. ``cmake --build build``
+
+Adding to existing projects
+===========================
+
+libicsneo supports being added as a sub-projects with CMake's
+``add_subdirectory()``.
+
+#. Clone libicsneo into the desired location within the project
+#. Add ``add_subdirectory(path/to/libicsneo)`` to ``CMakeLists.txt``
+#. Link the project to libicsneo with ``target_link_libraries(app icsneocpp)``
+
+Linux udev Rules
+================
+
+Linux users may want to install the included udev rules to run libicsneo based
+applications without root, this can be done with:
+``cp 99-intrepidcs.rules /etc/udev/rules.d/``
--- a/docs/icsneopy/api.rst
+++ b/docs/icsneopy/api.rst
@ -0,0 +1,9 @@
+==========
+Python API
+==========
+
+.. automodule:: icsneopy
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :special-members: __init__
--- a/docs/icsneopy/examples.rst
+++ b/docs/icsneopy/examples.rst
@ -0,0 +1,90 @@
+===============
+Python Examples
+===============
+
+Transmit CAN frames on HSCAN
+============================
+
+.. code-block:: python
+
+   import icsneopy
+
+   devices: list[icsneopy.Device] = icsneopy.find_all_devices()
+
+   # grab the first/only device found
+   device: icsneopy.Device = devices[0]
+
+   message = icsneopy.CANMessage()
+   message.network = icsneopy.Network(icsneopy.Network.NetID.HSCAN)
+   message.arbid = 0x56
+   message.data = (0x11, 0x22, 0x33)
+
+   device.open()
+
+   device.go_online()
+
+   device.transmit(message)
+     
+Receive CAN frames on HSCAN
+===========================
+
+.. code-block:: python
+
+   import icsneopy
+   import time
+
+   devices: list[icsneopy.Device] = icsneopy.find_all_devices()
+
+   # grab the first/only device found
+   device: icsneopy.Device = devices[0]
+
+   def on_message(message: icsneopy.CANMessage):
+       print(message.arbid, message.data)
+   message_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.HSCAN)
+   callback = icsneopy.MessageCallback(on_message, message_filter)
+
+   device.add_message_callback(callback)
+
+   device.open()
+   device.go_online()
+
+   # rx for 10s
+   time.sleep(10)
+
+
+Monitor Ethernet Status
+=======================
+
+.. code-block:: python
+
+   import icsneopy
+   import time
+
+   def main():
+      devices = icsneopy.find_all_devices()
+      if len(devices) == 0:
+         print("error: no devices found")
+         return False
+
+      device = devices[0]
+      print(f"info: monitoring Ethernet status on {device}")
+
+      def on_message(message):
+         print(f"info: network: {message.network}, state: {message.state}, speed: {message.speed}, duplex: {message.duplex}, mode: {message.mode}")
+
+      filter = icsneopy.MessageFilter(icsneopy.Message.Type.EthernetStatus)
+      callback = icsneopy.MessageCallback(on_message, filter)
+      device.add_message_callback(callback)
+
+      if not device.open():
+         print("error: unable to open device")
+         return False
+
+      if not device.go_online():
+         print("error: unable to go online")
+         return False
+
+      while True:
+         time.sleep(1)
+
+   main()
--- a/docs/icsneopy/index.rst
+++ b/docs/icsneopy/index.rst
@ -0,0 +1,9 @@
+========
+icsneopy
+========
+
+.. toctree::
+   :maxdepth: 2
+
+   examples
+   api
--- a/docs/index.rst
+++ b/docs/index.rst
@ -1,10 +1,15 @@
-Welcome to libicsneo's documentation!
-=======================================
+=========
+libicsneo
+=========
+
+libicsneo is the `Intrepid Control Systems <https://intrepidcs.com/>`_ device
+communication library. The source code for libicsneo can be found on GitHub: 
+`https://github.com/intrepidcs/libicsneo <https://github.com/intrepidcs/libicsneo>`_

 .. toctree::
-   :maxdepth: 3
+   :maxdepth: 1
   :caption: Documentation

-   Usage
-   icsneocpp
-   icsneoc
+   icsneocpp/index
+   icsneopy/index
+   icsneoc/index
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@ -1 +1,4 @@
-breathe==4.12.0
+sphinx
+icsneopy
+breathe
+sphinx_rtd_theme
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@ -9,6 +9,7 @@ option(LIBICSNEO_BUILD_CPP_LIVEDATA_EXAMPLE "Build the Live Data example." ON)
 option(LIBICSNEO_BUILD_CPP_COREMINI_EXAMPLE "Build the Coremini example." ON)
 option(LIBICSNEO_BUILD_CPP_MDIO_EXAMPLE "Build the MDIO example." ON)
 option(LIBICSNEO_BUILD_CPP_VSA_EXAMPLE "Build the VSA example." ON)
+option(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE "Build the app error example." ON)

 # Disabled until we properly build these in-tree
 # option(LIBICSNEO_BUILD_CSHARP_INTERACTIVE_EXAMPLE "Build the command-line interactive C# example." OFF)
@ -58,6 +59,10 @@ if(LIBICSNEO_BUILD_CPP_VSA_EXAMPLE)
 	add_subdirectory(cpp/vsa)
 endif()

+if(LIBICSNEO_BUILD_CPP_APP_ERROR_EXAMPLE)
+	add_subdirectory(cpp/apperror)
+endif()
+
 # if(LIBICSNEO_BUILD_CSHARP_INTERACTIVE_EXAMPLE)
 # 	add_subdirectory(csharp)
 # endif()
--- a/examples/cpp/apperror/CMakeLists.txt
+++ b/examples/cpp/apperror/CMakeLists.txt
@ -0,0 +1,2 @@
+add_executable(libicsneocpp-app-error src/AppErrorExample.cpp)
+target_link_libraries(libicsneocpp-app-error icsneocpp)
--- a/examples/cpp/apperror/src/AppErrorExample.cpp
+++ b/examples/cpp/apperror/src/AppErrorExample.cpp
@ -0,0 +1,85 @@
+#include <iostream>
+#include <iomanip>
+#include <thread>
+#include <chrono>
+
+#include "icsneo/icsneocpp.h"
+#include "icsneo/communication/message/apperrormessage.h"
+#include "icsneo/communication/message/message.h"
+/*
+ * App errors are responses from the device indicating internal runtime errors
+ * NOTE: To trigger the app error in this example, disable the HSCAN network on the device 
+ * (e.g. with neoVI Explorer)
+ */
+int main() {
+	std::cout << "Running libicsneo " << icsneo::GetVersion() << std::endl;
+	std::cout << "\nFinding devices... " << std::flush;
+	auto devices = icsneo::FindAllDevices();
+	std::cout << "OK, " << devices.size() << " device" << (devices.size() == 1 ? "" : "s") << " found" << std::endl;
+
+	// List off the devices
+	for(auto& device : devices)
+		std::cout << '\t' << device->describe() << " @ Handle " << device->getNeoDevice().handle << std::endl;
+	std::cout << std::endl;
+
+	for(auto device : devices) {
+		std::cout << "Connecting to " << device->describe() << "... ";
+		bool ret = device->open();
+		if(!ret) { // Failed to open
+			std::cout << "FAIL" << std::endl;
+			std::cout << icsneo::GetLastError() << std::endl << std::endl;
+			continue;
+		}
+		std::cout << "OK" << std::endl << std::endl;
+
+		// Create an app error message filter, including "internal" messages
+		auto filter = std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::AppError);
+		filter->includeInternalInAny = true;
+
+		// ...and register a callback with it.
+		// Add your error handling here
+		auto handler = device->addMessageCallback(std::make_shared<icsneo::MessageCallback>(filter, [](std::shared_ptr<icsneo::Message> message) {
+			auto msg = std::static_pointer_cast<icsneo::AppErrorMessage>(message);
+			if(icsneo::Network::NetID::RED_App_Error == msg->network.getNetID()) {
+				std::cout << std::endl << "App error reported:" << std::endl;
+				std::cout << msg->getAppErrorString() << std::endl << std::endl;
+			}
+		}));
+
+		std::cout << "Going online... ";
+		ret = device->goOnline();
+		if(!ret) {
+			std::cout << "FAIL" << std::endl;
+			device->close();
+			continue;
+		}
+		std::cout << "OK" << std::endl;
+
+		// Prepare a CAN message
+		std::cout << std::endl << "Transmitting a CAN frame... ";
+		auto txMessage = std::make_shared<icsneo::CANMessage>();
+		txMessage->network = icsneo::Network::NetID::HSCAN;
+		txMessage->arbid = 0x22;
+		txMessage->data.insert(txMessage->data.end(), {0xaa, 0xbb, 0xcc});
+		// The DLC will come from the length of the data vector
+		txMessage->isExtended = false;
+		txMessage->isCANFD = false;
+
+		// Transmit a CAN message on HSCAN, even though HSCAN is disabled on the device!
+		// Expect to see an app error caught in the callback defined above
+		ret = device->transmit(txMessage); 
+		std::cout << (ret ? "OK" : "FAIL") << std::endl;
+
+		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+		// Go offline, stop sending and receiving traffic
+		device->removeMessageCallback(handler);
+		std::cout << "Going offline... ";
+		ret = device->goOffline();
+		std::cout << (ret ? "OK" : "FAIL") << std::endl;
+		std::cout << "Disconnecting... ";
+		ret = device->close();
+		std::cout << (ret ? "OK\n" : "FAIL\n") << std::endl;
+	}
+	return 0;
+}
--- a/include/icsneo/api/event.h
+++ b/include/icsneo/api/event.h
@ -108,6 +108,8 @@ public:
 		LiveDataNotSupported = 0x2052,
 		LINSettingsNotAvailable = 0x2053,
 		ModeNotFound = 0x2054,
+		AppErrorParsingFailed = 0x2055,
+		GPTPNotSupported = 0x2056,

 		// Transport Events
 		FailedToRead = 0x3000,
--- a/include/icsneo/communication/command.h
+++ b/include/icsneo/communication/command.h
@ -51,6 +51,7 @@ enum class ExtendedCommand : uint16_t {
 	StartDHCPServer = 0x0016,
 	StopDHCPServer = 0x0017,
 	GetSupportedFeatures = 0x0018,
+	GetGPTPStatus = 0x0019,
 	GetComponentVersions = 0x001A,
 	Reboot = 0x001C,
 	SetRootFSEntryFlags = 0x0027,
--- a/include/icsneo/communication/communication.h
+++ b/include/icsneo/communication/communication.h
@ -87,6 +87,9 @@ public:
 	std::unique_ptr<Driver> driver;
 	device_eventhandler_t report;

+	size_t readTaskWakeLimit = 1;
+	std::chrono::milliseconds readTaskWakeTimeout = std::chrono::milliseconds(1000);
+
 protected:
 	static int messageCallbackIDCounter;
 	std::mutex messageCallbacksLock;
--- a/include/icsneo/communication/driver.h
+++ b/include/icsneo/communication/driver.h
@ -24,9 +24,11 @@ public:
 	virtual bool isOpen() = 0;
 	virtual void modeChangeIncoming() {}
 	virtual void awaitModeChangeComplete() {}
-	virtual bool isDisconnected() { return disconnected; };
 	virtual bool close() = 0;

+	inline bool isDisconnected() const { return disconnected; };
+	inline bool isClosing() const { return closing; }
+
 	bool waitForRx(size_t limit, std::chrono::milliseconds timeout);
 	bool waitForRx(std::function<bool()> predicate, std::chrono::milliseconds timeout);
 	bool readWait(std::vector<uint8_t>& bytes, std::chrono::milliseconds timeout = std::chrono::milliseconds(100), size_t limit = 0);
@ -52,8 +54,8 @@ protected:
 		WAIT
 	};

-	virtual void readTask() = 0;
-	virtual void writeTask() = 0;
+	inline void setIsClosing(bool isClosing) { closing = isClosing; }
+	inline void setIsDisconnected(bool isDisconnected) { disconnected = isDisconnected; }

 	// Overridable in case the driver doesn't want to use writeTask and writeQueue
 	virtual bool writeQueueFull() { return writeQueue.size_approx() > writeQueueSize; }
@ -61,13 +63,15 @@ protected:
 	virtual bool writeInternal(const std::vector<uint8_t>& b) { return writeQueue.enqueue(WriteOperation(b)); }

 	bool pushRx(const uint8_t* buf, size_t numReceived);
-	RingBuffer readBuffer = RingBuffer(ICSNEO_DRIVER_RINGBUFFER_SIZE);
-	std::atomic<bool> hasRxWaitRequest = false;
-	std::condition_variable rxWaitRequestCv;
-	std::mutex rxWaitMutex;
+	void clearBuffers();

 	moodycamel::BlockingConcurrentQueue<WriteOperation> writeQueue;
-	std::thread readThread, writeThread;
+
+private:
+	RingBuffer readBuffer = RingBuffer(ICSNEO_DRIVER_RINGBUFFER_SIZE);
+	std::condition_variable rxWaitCv;
+	std::mutex rxWaitMutex;
+
 	std::atomic<bool> closing{false};
 	std::atomic<bool> disconnected{false};
 };
--- a/include/icsneo/communication/message/apperrormessage.h
+++ b/include/icsneo/communication/message/apperrormessage.h
@ -0,0 +1,83 @@
+#ifndef __APPERRORMESSAGE_H_
+#define __APPERRORMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+#include <unordered_set>
+#include <memory>
+#include "icsneo/api/eventmanager.h"
+
+
+namespace icsneo {
+
+enum class AppErrorType : uint16_t {
+	AppErrorRxMessagesFull = 0,
+	AppErrorTxMessagesFull = 1,
+	AppErrorTxReportMessagesFull = 2,
+	AppErrorBadCommWithDspIC = 3,
+	AppErrorDriverOverflow = 4,
+	AppErrorPCBuffOverflow = 5,
+	AppErrorPCChksumError = 6,
+	AppErrorPCMissedByte = 7,
+	AppErrorPCOverrunError = 8,
+	AppErrorSettingFailure = 9,
+	AppErrorTooManySelectedNetworks = 10,
+	AppErrorNetworkNotEnabled = 11,
+	AppErrorRtcNotCorrect = 12,
+	AppErrorLoadedDefaultSettings = 13,
+	AppErrorFeatureNotUnlocked = 14,
+	AppErrorFeatureRtcCmdDropped = 15,
+	AppErrorTxMessagesFlushed = 16,
+	AppErrorTxMessagesHalfFull = 17,
+	AppErrorNetworkNotValid = 18,
+	AppErrorTxInterfaceNotImplemented = 19,
+	AppErrorTxMessagesCommEnableIsOff = 20,
+	AppErrorRxFilterMatchCountExceeded = 21,
+	AppErrorEthPreemptionNotEnabled = 22,
+	AppErrorTxNotSupportedInMode = 23,
+	AppErrorJumboFramesNotSupported = 24,
+	AppErrorEthernetIpFragment = 25,
+	AppErrorTxMessagesUnderrun = 26,
+	AppErrorDeviceFanFailure = 27,
+	AppErrorDeviceOvertemperature = 28,
+	AppErrorTxMessageIndexOutOfRange = 29,
+	AppErrorUndersizedFrameDropped = 30,
+	AppErrorOversizedFrameDropped = 31,
+	AppErrorWatchdogEvent = 32,
+	AppErrorSystemClockFailure = 33,
+	AppErrorSystemClockRecovered = 34,
+	AppErrorSystemPeripheralReset = 35,
+	AppErrorSystemCommunicationFailure = 36,
+	AppErrorTxMessagesUnsupportedSourceOrPacketId = 37,
+	AppErrorWbmsManagerConnectFailed = 38,
+	AppErrorWbmsManagerConnectBadState = 39,
+	AppErrorWbmsManagerConnectTimeout = 40,
+	AppErrorFailedToInitializeLoggerDisk = 41,
+	AppErrorInvalidSetting = 42,
+	AppErrorSystemFailureRequestedReset = 43,
+	AppErrorPortKeyMistmatch = 45,
+	AppErrorBusFailure = 46,
+	AppErrorTapOverflow = 47,
+	AppErrorEthTxNoLink = 48,
+	AppErrorErrorBufferOverflow = 254,
+	AppNoError = 255
+};
+
+class AppErrorMessage : public RawMessage {
+public:
+	AppErrorMessage() : RawMessage(Message::Type::AppError, Network::NetID::RED_App_Error) {}
+	uint16_t errorType;
+	Network::NetID errorNetID;
+	uint32_t timestamp10us;
+	uint32_t timestamp10usMSB;
+
+	static std::shared_ptr<Message> DecodeToMessage(const std::vector<uint8_t>& bytestream, const device_eventhandler_t& report);
+	AppErrorType getAppErrorType();
+	std::string getAppErrorString();
+};
+
+} // namespace icsneo
+
+#endif // __cplusplus
+#endif
--- a/include/icsneo/communication/message/ethernetmessage.h
+++ b/include/icsneo/communication/message/ethernetmessage.h
@ -35,7 +35,7 @@ class EthernetMessage : public Frame {
 public:
 	bool preemptionEnabled = false;
 	uint8_t preemptionFlags = 0;
-	bool fcsAvailable = false;
+	std::optional<uint32_t> fcs;
 	bool frameTooShort = false;
 	bool noPadding = false;

--- a/include/icsneo/communication/message/ethernetstatusmessage.h
+++ b/include/icsneo/communication/message/ethernetstatusmessage.h
@ -0,0 +1,43 @@
+#ifndef __ETHERNETSTATUSMESSAGE_H__
+#define __ETHERNETSTATUSMESSAGE_H__
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+
+#include <memory>
+
+namespace icsneo {
+
+class EthernetStatusMessage : public Message {
+public:
+	enum class LinkSpeed {
+		LinkSpeedAuto,
+		LinkSpeed10,
+		LinkSpeed100,
+		LinkSpeed1000,
+		LinkSpeed2500,
+		LinkSpeed5000,
+		LinkSpeed10000,
+	};
+	enum class LinkMode {
+		LinkModeAuto,
+		LinkModeMaster,
+		LinkModeSlave,
+		LinkModeInvalid,
+	};
+	EthernetStatusMessage(Network net, bool state, LinkSpeed speed, bool duplex, LinkMode mode) : Message(Type::EthernetStatus),
+		network(net), state(state), speed(speed), duplex(duplex), mode(mode) {}
+	Network network;
+	bool state;
+	LinkSpeed speed;
+	bool duplex;
+	LinkMode mode;
+	static std::shared_ptr<Message> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+};
+
+}; // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __ETHERNETSTATUSMESSAGE_H__
--- a/include/icsneo/communication/message/flashmemorymessage.h
+++ b/include/icsneo/communication/message/flashmemorymessage.h
@ -0,0 +1,20 @@
+#ifndef __FLASHMEMORYMESSAGE_H_
+#define __FLASHMEMORYMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+
+namespace icsneo {
+
+class FlashMemoryMessage : public RawMessage {
+public:
+	FlashMemoryMessage() : RawMessage(Message::Type::RawMessage, Network::NetID::RED_INT_MEMORYREAD) {}
+	uint16_t startAddress = 0;
+};
+
+}
+
+#endif // __cplusplus
+
+#endif
--- a/include/icsneo/communication/message/gptpstatusmessage.h
+++ b/include/icsneo/communication/message/gptpstatusmessage.h
@ -0,0 +1,103 @@
+#ifndef __GPTPSTATUSMESSAGE_H_
+#define __GPTPSTATUSMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/command.h"
+#include "icsneo/api/eventmanager.h"
+
+
+namespace icsneo {
+
+class GPTPStatus : public Message {
+public:
+	typedef uint64_t TimeInterval;
+	typedef uint64_t ClockID;
+
+	struct Timestamp {
+		uint64_t seconds;
+		uint32_t nanoseconds;
+
+		double toSeconds() const {
+			static constexpr double billion = 1e9;
+			return (double)seconds + ((double)nanoseconds) / billion;
+		}
+	};
+
+	struct ScaledNanoSeconds {
+		int16_t nanosecondsMSB; // The most significant bits
+		int64_t nanosecondsLSB; // The least significant bits
+		int16_t fractionalNanoseconds; // Fractional part
+	};
+
+	struct PortID {
+		ClockID clockIdentity;
+		uint16_t portNumber;
+	};
+	struct ClockQuality {
+		uint8_t clockClass;
+		uint8_t clockAccuracy;
+		uint16_t offsetScaledLogVariance;
+	};
+
+	struct SystemID {
+		uint8_t priority1;
+		ClockQuality clockQuality;
+		uint8_t priority2;
+		ClockID clockID;
+	};
+
+	struct PriorityVector {
+		SystemID sysID;
+		uint16_t stepsRemoved;
+		PortID portID;
+		uint16_t portNumber;
+	};
+
+	struct ParentDS {
+		PortID parentPortIdentity;
+		int32_t cumulativeRateRatio;
+		ClockID grandmasterIdentity;
+		uint8_t gmClockQualityClockClass;
+		uint8_t gmClockQualityClockAccuracy;
+		uint16_t gmClockQualityOffsetScaledLogVariance;
+		uint8_t gmPriority1;
+		uint8_t gmPriority2;
+	};
+
+	struct CurrentDS {
+		uint16_t stepsRemoved;
+		TimeInterval offsetFromMaster;
+		ScaledNanoSeconds lastgmPhaseChange;
+		double lastgmFreqChange;
+		uint16_t gmTimeBaseIndicator;
+		uint32_t gmChangeCount;
+		uint32_t timeOfLastgmChangeEvent;
+		uint32_t timeOfLastgmPhaseChangeEvent;
+		uint32_t timeOfLastgmFreqChangeEvent;
+	};
+
+	GPTPStatus() : Message(Message::Type::GPTPStatus) {}
+	static std::shared_ptr<GPTPStatus> DecodeToMessage(std::vector<uint8_t>& bytes, const device_eventhandler_t& report);
+
+	Timestamp currentTime;
+	PriorityVector gmPriority;
+	int64_t msOffsetNs;
+	uint8_t isSync;
+	uint8_t linkStatus;
+	int64_t linkDelayNS;
+	uint8_t selectedRole;
+	uint8_t asCapable;
+	uint8_t isSyntonized;
+	Timestamp lastRXSyncTS; // t2 in IEEE 1588-2019 Figure-16
+	CurrentDS currentDS;
+	ParentDS parentDS;
+	
+	bool shortFormat = false; // Set to true if the above variables weren't set (some firmware versions do not contain all the above variables)
+};
+
+}
+
+#endif
+#endif
--- a/include/icsneo/communication/message/message.h
+++ b/include/icsneo/communication/message/message.h
@ -40,6 +40,9 @@ public:
 		LiveData = 0x800f,
 		HardwareInfo = 0x8010,
 		TC10Status = 0x8011,
+		AppError = 0x8012,
+		GPTPStatus = 0x8013,
+		EthernetStatus = 0x8014,
 	};

 	Message(Type t) : type(t) {}
--- a/include/icsneo/communication/network.h
+++ b/include/icsneo/communication/network.h
@ -166,6 +166,24 @@ public:
 		MDIO6 = 550,
 		MDIO7 = 551,
 		MDIO8 = 552,
+		OP_Ethernet13 = 553,
+		OP_Ethernet14 = 554,
+		OP_Ethernet15 = 555,
+		OP_Ethernet16 = 556,
+		SPI3 = 557,
+		SPI4 = 558,
+		SPI5 = 559,
+		SPI6 = 560,
+		SPI7 = 561,
+		SPI8 = 562,
+		LIN9 = 563,
+		LIN10 = 564,
+		LIN11 = 565,
+		LIN12 = 566,
+		LIN13 = 567,
+		LIN14 = 568,
+		LIN15 = 569,
+		LIN16 = 570,
 		Any = 0xfffe, // Never actually set as type, but used as flag for filtering
 		Invalid = 0xffff
 	};
@ -270,6 +288,24 @@ public:
 		MDIO6 = 80,
 		MDIO7 = 81,
 		MDIO8 = 82,
+		OP_Ethernet13 = 83,
+		OP_Ethernet14 = 84,
+		OP_Ethernet15 = 85,
+		OP_Ethernet16 = 86,
+		SPI3 = 87,
+		SPI4 = 88,
+		SPI5 = 89,
+		SPI6 = 90,
+		SPI7 = 91,
+		SPI8 = 92,
+		LIN9 = 93,
+		LIN10 = 94,
+		LIN11 = 95,
+		LIN12 = 96,
+		LIN13 = 97,
+		LIN14 = 98,
+		LIN15 = 99,
+		LIN16 = 100,
 	};
 	static const char* GetTypeString(Type type) {
 		switch(type) {
@ -506,6 +542,14 @@ public:
 		case NetID::LIN6:
 		case NetID::LIN7:
 		case NetID::LIN8:
+		case NetID::LIN9:
+		case NetID::LIN10:
+		case NetID::LIN11:
+		case NetID::LIN12:
+		case NetID::LIN13:
+		case NetID::LIN14:
+		case NetID::LIN15:
+		case NetID::LIN16:
 			return Type::LIN;
 		case NetID::FlexRay:
 		case NetID::FlexRay1a:
@ -533,10 +577,12 @@ public:
 		case NetID::CoreMiniPreLoad:
 		case NetID::ExtendedCommand:
 		case NetID::ExtendedData:
+		case NetID::RED_INT_MEMORYREAD:
 		case NetID::NeoMemorySDRead:
 		case NetID::NeoMemoryWriteDone:
 		case NetID::RED_GET_RTC:
 		case NetID::DiskData:
+		case NetID::RED_App_Error:
 			return Type::Internal;
 		case NetID::Invalid:
 		case NetID::Any:
@ -557,6 +603,10 @@ public:
 		case NetID::OP_Ethernet10:
 		case NetID::OP_Ethernet11:
 		case NetID::OP_Ethernet12:
+		case NetID::OP_Ethernet13:
+		case NetID::OP_Ethernet14:
+		case NetID::OP_Ethernet15:
+		case NetID::OP_Ethernet16:
 			return Type::Ethernet;
 		case NetID::LSFTCAN:
 		case NetID::LSFTCAN2:
@ -579,6 +629,12 @@ public:
 			return Type::A2B;
 		case NetID::SPI1:
 		case NetID::SPI2:
+		case NetID::SPI3:
+		case NetID::SPI4:
+		case NetID::SPI5:
+		case NetID::SPI6:
+		case NetID::SPI7:
+		case NetID::SPI8:
 			return Type::SPI;
 		case NetID::MDIO1:
 		case NetID::MDIO2:
@ -768,6 +824,14 @@ public:
 			return "FlexRay 2";
 		case NetID::OP_Ethernet12:
 			return "OP (BR) Ethernet 12";
+		case NetID::OP_Ethernet13:
+			return "OP (BR) Ethernet 13";
+		case NetID::OP_Ethernet14:
+			return "OP (BR) Ethernet 14";
+		case NetID::OP_Ethernet15:
+			return "OP (BR) Ethernet 15";
+		case NetID::OP_Ethernet16:
+			return "OP (BR) Ethernet 16";
 		case NetID::I2C:
 			return "I2C";
 		case NetID::MOST25:
@ -848,12 +912,40 @@ public:
 			return "LIN 07";
 		case NetID::LIN8:
 			return "LIN 08";
+		case NetID::LIN9:
+			return "LIN 09";
+		case NetID::LIN10:
+			return "LIN 10";
+		case NetID::LIN11:
+			return "LIN 11";
+		case NetID::LIN12:
+			return "LIN 12";
+		case NetID::LIN13:
+			return "LIN 13";
+		case NetID::LIN14:
+			return "LIN 14";
+		case NetID::LIN15:
+			return "LIN 15";
+		case NetID::LIN16:
+			return "LIN 16";
 		case NetID::WBMS:
 			return "WBMS";
 		case NetID::SPI1:
 			return "SPI 1";
 		case NetID::SPI2:
 			return "SPI 2";
+		case NetID::SPI3:
+			return "SPI 3";
+		case NetID::SPI4:
+			return "SPI 4";
+		case NetID::SPI5:
+			return "SPI 5";
+		case NetID::SPI6:
+			return "SPI 6";
+		case NetID::SPI7:
+			return "SPI 7";
+		case NetID::SPI8:
+			return "SPI 8";
 		case NetID::MDIO1:
 			return "MDIO 1";
 		case NetID::MDIO2:
@ -974,6 +1066,14 @@ public:
 			return CoreMini::OP_Ethernet11;
 		case NetID::OP_Ethernet12:
 			return CoreMini::OP_Ethernet12;
+		case NetID::OP_Ethernet13:
+			return CoreMini::OP_Ethernet13;
+		case NetID::OP_Ethernet14:
+			return CoreMini::OP_Ethernet14;
+		case NetID::OP_Ethernet15:
+			return CoreMini::OP_Ethernet15;
+		case NetID::OP_Ethernet16:
+			return CoreMini::OP_Ethernet16;
 		case NetID::TCP:
 			return CoreMini::TCPVirtual;
 		case NetID::UDP:
@ -1022,10 +1122,38 @@ public:
 			return CoreMini::LIN7;
 		case NetID::LIN8:
 			return CoreMini::LIN8;
+		case NetID::LIN9:
+			return CoreMini::LIN9;
+		case NetID::LIN10:
+			return CoreMini::LIN10;
+		case NetID::LIN11:
+			return CoreMini::LIN11;
+		case NetID::LIN12:
+			return CoreMini::LIN12;
+		case NetID::LIN13:
+			return CoreMini::LIN13;
+		case NetID::LIN14:
+			return CoreMini::LIN14;
+		case NetID::LIN15:
+			return CoreMini::LIN15;
+		case NetID::LIN16:
+			return CoreMini::LIN16;
 		case NetID::SPI1:
 			return CoreMini::SPI1;
 		case NetID::SPI2:
 			return CoreMini::SPI2;
+		case NetID::SPI3:
+			return CoreMini::SPI3;
+		case NetID::SPI4:
+			return CoreMini::SPI4;
+		case NetID::SPI5:
+			return CoreMini::SPI5;
+		case NetID::SPI6:
+			return CoreMini::SPI6;
+		case NetID::SPI7:
+			return CoreMini::SPI7;
+		case NetID::SPI8:
+			return CoreMini::SPI8;
 		case NetID::MDIO1:
 			return CoreMini::MDIO1;
 		case NetID::MDIO2:
@ -1144,6 +1272,14 @@ public:
 			return NetID::OP_Ethernet11;
 		case CoreMini::OP_Ethernet12:
 			return NetID::OP_Ethernet12;
+		case CoreMini::OP_Ethernet13:
+			return NetID::OP_Ethernet13;
+		case CoreMini::OP_Ethernet14:
+			return NetID::OP_Ethernet14;
+		case CoreMini::OP_Ethernet15:
+			return NetID::OP_Ethernet15;
+		case CoreMini::OP_Ethernet16:
+			return NetID::OP_Ethernet16;
 		case CoreMini::TCPVirtual:
 			return NetID::TCP;
 		case CoreMini::UDPVirtual:
@ -1192,10 +1328,38 @@ public:
 			return NetID::LIN7;
 		case CoreMini::LIN8:
 			return NetID::LIN8;
+		case CoreMini::LIN9:
+			return NetID::LIN9;
+		case CoreMini::LIN10:
+			return NetID::LIN10;
+		case CoreMini::LIN11:
+			return NetID::LIN11;
+		case CoreMini::LIN12:
+			return NetID::LIN12;
+		case CoreMini::LIN13:
+			return NetID::LIN13;
+		case CoreMini::LIN14:
+			return NetID::LIN14;
+		case CoreMini::LIN15:
+			return NetID::LIN15;
+		case CoreMini::LIN16:
+			return NetID::LIN16;
 		case CoreMini::SPI1:
 			return NetID::SPI1;
 		case CoreMini::SPI2:
 			return NetID::SPI2;
+		case CoreMini::SPI3:
+			return NetID::SPI3;
+		case CoreMini::SPI4:
+			return NetID::SPI4;
+		case CoreMini::SPI5:
+			return NetID::SPI5;
+		case CoreMini::SPI6:
+			return NetID::SPI6;
+		case CoreMini::SPI7:
+			return NetID::SPI7;
+		case CoreMini::SPI8:
+			return NetID::SPI8;
 		case CoreMini::MDIO1:
 			return NetID::MDIO1;
 		case CoreMini::MDIO2:
--- a/include/icsneo/communication/packet/ethernetpacket.h
+++ b/include/icsneo/communication/packet/ethernetpacket.h
@ -10,6 +10,8 @@

 namespace icsneo {

+#pragma pack(push, 2)
+
 typedef uint16_t icscm_bitfield;

 struct HardwareEthernetPacket {
@ -42,6 +44,8 @@ struct HardwareEthernetPacket {
 	uint16_t Length;
 };

+#pragma pack(pop)
+
 }

 #endif // __cplusplus
--- a/include/icsneo/device/coremini.h
+++ b/include/icsneo/device/coremini.h
@ -0,0 +1,28 @@
+#ifndef __COREMINI_H_
+#define __COREMINI_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+#include <array>
+#include <chrono>
+
+namespace icsneo {
+
+struct CoreminiHeader {
+	uint16_t coreminiVersion;
+	uint32_t storedFileSize;
+	// 32-bit word checksum on the entire (decompressed) binary, with the checksum and hash fields set to 0
+	uint32_t fileChecksum;
+	// SHA256 hash of the entire (decompressed) binary, with the checksum, hash, and create time fields set to 0
+	bool skipDecompression;
+	bool encryptedMode;
+	std::array<uint8_t, 32> fileHash;
+	std::chrono::time_point<std::chrono::system_clock> timestamp;
+};
+
+}
+
+#endif // __cplusplus
+
+#endif
--- a/include/icsneo/device/device.h
+++ b/include/icsneo/device/device.h
@ -13,6 +13,7 @@
 #include <optional>
 #include <unordered_map>
 #include <set>
+#include <chrono>
 #include "icsneo/api/eventmanager.h"
 #include "icsneo/api/lifetime.h"
 #include "icsneo/device/neodevice.h"
@ -21,6 +22,7 @@
 #include "icsneo/device/devicetype.h"
 #include "icsneo/device/deviceversion.h"
 #include "icsneo/device/founddevice.h"
+#include "icsneo/device/coremini.h"
 #include "icsneo/disk/diskreaddriver.h"
 #include "icsneo/disk/diskwritedriver.h"
 #include "icsneo/disk/nulldiskdriver.h"
@ -48,6 +50,7 @@
 #include "icsneo/disk/vsa/vsa.h"
 #include "icsneo/disk/vsa/vsaparser.h"
 #include "icsneo/communication/message/versionmessage.h"
+#include "icsneo/communication/message/gptpstatusmessage.h"


 #define ICSNEO_FINDABLE_DEVICE_BASE(className, type) \
@ -163,6 +166,7 @@ public:
 	bool stopScript();
 	bool clearScript(Disk::MemoryType memType = Disk::MemoryType::SD);
 	bool uploadCoremini(std::istream& stream, Disk::MemoryType memType = Disk::MemoryType::SD);
+	std::optional<CoreminiHeader> readCoreminiHeader(Disk::MemoryType memType = Disk::MemoryType::SD);

 	bool eraseScriptMemory(Disk::MemoryType memType, uint64_t amount);

@ -226,7 +230,7 @@ public:
 	virtual size_t getNetworkCountByType(Network::Type) const;
 	virtual Network getNetworkByNumber(Network::Type, size_t) const;

-	std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(2));
+	std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));


 	/**
@ -724,12 +728,15 @@ public:
 	virtual bool supportsComponentVersions() const { return false; }

 	virtual bool supportsTC10() const { return false; }
+	
+	virtual bool supportsGPTP() const { return false; }

 	bool requestTC10Wake(Network::NetID network);

 	bool requestTC10Sleep(Network::NetID network);

 	std::optional<TC10StatusMessage> getTC10Status(Network::NetID network);
+	std::optional<GPTPStatus> getGPTPStatus(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));

 protected:
 	bool online = false;
--- a/include/icsneo/device/devicetype.h
+++ b/include/icsneo/device/devicetype.h
@ -47,11 +47,14 @@ public:
 		EtherBADGE = (0x00000016),
 		RAD_A2B = (0x00000017),
 		RADEpsilon = (0x00000018),
+		RADGalaxy2 = (0x00000021),
 		RADMoon3 = (0x00000023),
 		RADComet = (0x00000024),
 		FIRE3_FlexRay = (0x00000025),
 		Connect = (0x00000026),
 		RADComet3 = (0x00000027),
+		RADMoonT1S = (0x00000028),
+		RADGigastar2 = (0x00000029),
 		RED = (0x00000040),
 		ECU = (0x00000080),
 		IEVB = (0x00000100),
@ -180,6 +183,8 @@ public:
 				return "neoVI Flex";
 			case RADGalaxy:
 				return "RAD-Galaxy";
+			case RADGalaxy2:
+				return "RAD-Galaxy 2";
 			case RADStar2:
 				return "RAD-Star 2";
 			case VividCAN:
@ -190,8 +195,12 @@ public:
 				return "neoVI FIRE3 FlexRay";
 			case RADComet3:
 				return "RAD-Comet 3";
+			case RADMoonT1S:
+				return "RAD-Moon T1S";
 			case Connect:
 				return "neoVI Connect";
+			case RADGigastar2:
+				return "RAD-Gigastar 2";
 			case DONT_REUSE0:
 			case DONT_REUSE1:
 			case DONT_REUSE2:
@ -242,11 +251,14 @@ private:
 #define ICSNEO_DEVICETYPE_ETHERBADGE ((devicetype_t)0x00000016)
 #define ICSNEO_DEVICETYPE_RAD_A2B ((devicetype_t)0x00000017)
 #define ICSNEO_DEVICETYPE_RADEPSILON ((devicetype_t)0x00000018)
+#define ICSNEO_DEVICETYPE_RADGALAXY2 ((devicetype_t)0x00000021)
 #define ICSNEO_DEVICETYPE_RADMoon3 ((devicetype_t)0x00000023)
 #define ICSNEO_DEVICETYPE_RADCOMET ((devicetype_t)0x00000024)
 #define ICSNEO_DEVICETYPE_FIRE3FLEXRAY ((devicetype_t)0x00000025)
 #define ICSNEO_DEVICETYPE_CONNECT ((devicetype_t)0x00000026)
 #define ICSNEO_DEVICETYPE_RADCOMET3 ((devicetype_t)0x00000027)
+#define ICSNEO_DEVICETYPE_RADMOONT1S ((devicetype_t)0x00000028)
+#define ICSNEO_DEVICETYPE_RADGIGASTAR2 ((devicetype_t)0x00000029)
 #define ICSNEO_DEVICETYPE_RED ((devicetype_t)0x00000040)
 #define ICSNEO_DEVICETYPE_ECU ((devicetype_t)0x00000080)
 #define ICSNEO_DEVICETYPE_IEVB ((devicetype_t)0x00000100)
@ -275,4 +287,4 @@ private:
 #define ICSNEO_DEVICETYPE_OBD2_SIM ((devicetype_t)0x80000000)
 #endif

-#endif
+#endif
--- a/include/icsneo/device/idevicesettings.h
+++ b/include/icsneo/device/idevicesettings.h
@ -395,6 +395,16 @@ typedef struct ETHERNET10T1S_SETTINGS_t

 #define ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA 0x01
 #define ETHERNET10T1S_SETTINGS_FLAG_TERMINATION 0x02
+#define ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS 0x04
+#define ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL 0x08
+
+typedef struct ETHERNET10T1S_SETTINGS_EXT_t
+{
+	uint8_t enable_multi_id; // Mask representing whether ID at corresponding bit enabled or not
+	uint8_t multi_id[7];
+	uint8_t rsvd[8];
+} ETHERNET10T1S_SETTINGS_EXT;
+#define ETHERNET10T1S_SETTINGS_EXT_SIZE 16

 #define ETHERNET_SETTINGS10G_FLAG_FULL_DUPLEX  0x01
 #define ETHERNET_SETTINGS10G_FLAG_AUTO_NEG     0x02
@ -434,20 +444,21 @@ typedef struct LOGGER_SETTINGS_t
 #define RAD_GPTP_NUM_PORTS 1 // 1 because only supported as gPTP endpoint
 typedef struct RAD_GPTP_SETTINGS_t
 {
-	uint32_t neighborPropDelayThresh;//ns
-	uint32_t sys_phc_sync_interval;//ns
-	int8_t logPDelayReqInterval;// log2ms
-	int8_t logSyncInterval;// log2ms
-	int8_t logAnnounceInterval;// log2ms
+	uint32_t neighborPropDelayThresh; //ns
+	uint32_t sys_phc_sync_interval; //ns
+	int8_t logPDelayReqInterval; // log2ms
+	int8_t logSyncInterval; // log2ms
+	int8_t logAnnounceInterval; // log2ms
 	uint8_t profile;
 	uint8_t priority1;
 	uint8_t clockclass;
 	uint8_t clockaccuracy;
 	uint8_t priority2;
 	uint16_t offset_scaled_log_variance;
-	uint8_t gPTPportRole[RAD_GPTP_NUM_PORTS];
-	uint8_t portEnable[RAD_GPTP_NUM_PORTS];
-	uint8_t rsvd[16];
+	uint8_t gptpPortRole;
+	uint8_t gptpEnabledPort;
+	uint8_t enableClockSyntonization;
+	uint8_t rsvd[15];
 } RAD_GPTP_SETTINGS;//36 Bytes with RAD_GPTP_NUM_PORTS = 1
 #define RAD_GPTP_SETTINGS_SIZE 36

--- a/include/icsneo/device/tree/neoviconnect/neoviconnect.h
+++ b/include/icsneo/device/tree/neoviconnect/neoviconnect.h
@ -68,6 +68,10 @@ protected:
 	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
 		return 0;
 	}
+
+	bool supportsComponentVersions() const override { return true; }
+	bool supportsGPTP() const override { return true; }
+
 };

 }
--- a/include/icsneo/device/tree/neovifire3/neovifire3.h
+++ b/include/icsneo/device/tree/neovifire3/neovifire3.h
@ -79,6 +79,8 @@ protected:

 	bool supportsLiveData() const override { return true; }

+	bool supportsGPTP() const override { return true; }
+
 	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
 		return 33*1024*1024;
 	}
@ -90,6 +92,7 @@ protected:
 	bool supportsEraseMemory() const override {
 		return true;
 	}
+
 };

 }
--- a/include/icsneo/device/tree/neovired2/neovired2.h
+++ b/include/icsneo/device/tree/neovired2/neovired2.h
@ -36,6 +36,7 @@ public:
 	}

 	bool supportsComponentVersions() const override { return true; }
+	bool supportsGPTP() const override { return true; }

 protected:
 	NeoVIRED2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
--- a/include/icsneo/device/tree/rada2b/rada2b.h
+++ b/include/icsneo/device/tree/rada2b/rada2b.h
@ -40,6 +40,7 @@ public:
 	}

 	size_t getEthernetActivationLineCount() const override { return 1; }
+	bool supportsGPTP() const override { return true; }

 protected:
 	RADA2B(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
@ -77,6 +78,7 @@ protected:
 	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
 		return 0;
 	}
+
 };

 }
--- a/include/icsneo/device/tree/radcomet/radcomet2.h
+++ b/include/icsneo/device/tree/radcomet/radcomet2.h
@ -27,6 +27,8 @@ public:
 		return supportedNetworks;
 	}

+	bool supportsTC10() const override { return true; }
+
 protected:
 	RADComet2(neodevice_t neodevice, const driver_factory_t& makeDriver) : RADCometBase(neodevice) {
 		initialize<RADCometSettings>(makeDriver);
--- a/include/icsneo/device/tree/radcomet/radcometbase.h
+++ b/include/icsneo/device/tree/radcomet/radcometbase.h
@ -31,6 +31,7 @@ public:
 	}

 	bool getEthPhyRegControlSupported() const override { return true; }
+	bool supportsGPTP() const override { return true; }

 protected:
 	using Device::Device;
--- a/include/icsneo/device/tree/radcomet/radcometsettings.h
+++ b/include/icsneo/device/tree/radcomet/radcometsettings.h
@ -71,6 +71,9 @@ typedef struct {
 	ETHERNET10T1S_SETTINGS t1s2;
 	uint64_t network_enables_5;
 	LIN_SETTINGS lin1;
+	// 10T1S Extended settings
+	ETHERNET10T1S_SETTINGS_EXT t1s1Ext;
+	ETHERNET10T1S_SETTINGS_EXT t1s2Ext;
 } radcomet_settings_t;
 #pragma pack(pop)

@ -80,7 +83,7 @@ typedef struct {

 #ifdef __cplusplus

-static_assert(sizeof(radcomet_settings_t) == 466, "RADComet settings size mismatch");
+static_assert(sizeof(radcomet_settings_t) == 498, "RADComet settings size mismatch");

 #include <iostream>

--- a/include/icsneo/device/tree/radcomet3/radcomet3.h
+++ b/include/icsneo/device/tree/radcomet3/radcomet3.h
@ -44,6 +44,9 @@ public:

 	bool getEthPhyRegControlSupported() const override { return true; }

+	bool supportsTC10() const override { return true; }
+	bool supportsGPTP() const override { return true; }
+
 protected:
 	RADComet3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADComet3Settings>(makeDriver);
--- a/include/icsneo/device/tree/radcomet3/radcomet3settings.h
+++ b/include/icsneo/device/tree/radcomet3/radcomet3settings.h
@ -68,11 +68,20 @@ typedef struct {
 	ETHERNET_SETTINGS2 ethT1s6;
 	ETHERNET10T1S_SETTINGS t1s6;
 	LIN_SETTINGS lin1;
+	// 10T1S Extended Settings
+	ETHERNET10T1S_SETTINGS_EXT t1s1Ext;
+	ETHERNET10T1S_SETTINGS_EXT t1s2Ext;
+	ETHERNET10T1S_SETTINGS_EXT t1s3Ext;
+	ETHERNET10T1S_SETTINGS_EXT t1s4Ext;
+	ETHERNET10T1S_SETTINGS_EXT t1s5Ext;
+	ETHERNET10T1S_SETTINGS_EXT t1s6Ext;
 } radcomet3_settings_t;
 #pragma pack(pop)

 #ifdef __cplusplus

+static_assert(sizeof(radcomet3_settings_t) == 674, "RADComet3 settings size mismatch");
+
 #include <iostream>

 class RADComet3Settings : public IDeviceSettings {
--- a/include/icsneo/device/tree/radgalaxy/radgalaxy.h
+++ b/include/icsneo/device/tree/radgalaxy/radgalaxy.h
@ -61,6 +61,7 @@ public:
 	}

 	size_t getEthernetActivationLineCount() const override { return 1; }
+	bool supportsGPTP() const override { return true; }

 protected:
 	RADGalaxy(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
--- a/include/icsneo/device/tree/radgalaxy2/radgalaxy2.h
+++ b/include/icsneo/device/tree/radgalaxy2/radgalaxy2.h
@ -0,0 +1,121 @@
+#ifndef __RADGALAXY2_H_
+#define __RADGALAXY2_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/device.h"
+#include "icsneo/device/devicetype.h"
+#include "icsneo/communication/packetizer.h"
+#include "icsneo/communication/decoder.h"
+#include "icsneo/disk/extextractordiskreaddriver.h"
+#include "icsneo/disk/neomemorydiskdriver.h"
+#include "icsneo/device/tree/radgalaxy2/radgalaxy2settings.h"
+
+namespace icsneo {
+
+class RADGalaxy2 : public Device {
+public:
+	// Serial numbers start with G2
+	// Ethernet MAC allocation is 0x17, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE(RADGalaxy2, DeviceType::RADGalaxy2, "G2");
+
+	static const std::vector<Network>& GetSupportedNetworks() {
+		static std::vector<Network> supportedNetworks = {
+			Network::NetID::HSCAN,
+			Network::NetID::MSCAN,
+			Network::NetID::HSCAN2,
+			Network::NetID::HSCAN3,
+			Network::NetID::HSCAN4,
+			Network::NetID::HSCAN5,
+			Network::NetID::HSCAN6,
+			Network::NetID::HSCAN7,
+
+			Network::NetID::LIN,
+			Network::NetID::LIN2,
+
+			Network::NetID::Ethernet,
+			Network::NetID::Ethernet2,
+			Network::NetID::Ethernet3,
+
+			Network::NetID::OP_Ethernet1,
+			Network::NetID::OP_Ethernet2,
+			Network::NetID::OP_Ethernet3,
+			Network::NetID::OP_Ethernet4,
+			Network::NetID::OP_Ethernet5,
+			Network::NetID::OP_Ethernet6,
+			Network::NetID::OP_Ethernet7,
+			Network::NetID::OP_Ethernet8,
+			Network::NetID::OP_Ethernet9,
+			Network::NetID::OP_Ethernet10,
+			Network::NetID::OP_Ethernet11,
+			Network::NetID::OP_Ethernet12,
+
+			Network::NetID::ISO9141,
+			Network::NetID::ISO9141_2,
+
+			Network::NetID::MDIO1,
+			Network::NetID::MDIO2,
+			Network::NetID::MDIO3,
+			Network::NetID::MDIO4,
+			Network::NetID::MDIO5,
+		};
+		return supportedNetworks;
+	}
+
+	size_t getEthernetActivationLineCount() const override { return 1; }
+
+	bool supportsTC10() const override { return true; }
+	bool supportsGPTP() const override { return true; }
+
+protected:
+	RADGalaxy2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		initialize<RADGalaxy2Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
+	}
+
+	void setupPacketizer(Packetizer& packetizer) override {
+		Device::setupPacketizer(packetizer);
+		packetizer.disableChecksum = true;
+		packetizer.align16bit = false;
+	}
+
+	void setupEncoder(Encoder& encoder) override {
+		Device::setupEncoder(encoder);
+		encoder.supportCANFD = true;
+		encoder.supportEthPhy = true;
+	}
+
+	void setupDecoder(Decoder& decoder) override {
+		Device::setupDecoder(decoder);
+		decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns
+	}
+
+	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
+		for(auto& netid : GetSupportedNetworks())
+			rxNetworks.emplace_back(netid);
+	}
+
+	// The supported TX networks are the same as the supported RX networks for this device
+	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
+
+	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+		if(message->data.size() < sizeof(radgalaxy2_status_t))
+			return;
+		std::lock_guard<std::mutex> lk(ioMutex);
+		const radgalaxy2_status_t* status = reinterpret_cast<const radgalaxy2_status_t*>(message->data.data());
+		ethActivationStatus = status->ethernetActivationLineEnabled;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
+};
+
+}
+
+#endif // __cplusplus
+
+#endif
--- a/include/icsneo/device/tree/radgalaxy2/radgalaxy2settings.h
+++ b/include/icsneo/device/tree/radgalaxy2/radgalaxy2settings.h
@ -0,0 +1,192 @@
+#ifndef __RADGALAXY2SETTINGS_H_
+#define __RADGALAXY2SETTINGS_H_
+
+#include "icsneo/device/idevicesettings.h"
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+namespace icsneo {
+
+#endif
+
+#pragma pack(push, 2)
+
+typedef struct {
+	uint32_t ecu_id;
+	uint16_t perf_en;
+
+	/* CAN */
+	CAN_SETTINGS can1;
+	CANFD_SETTINGS canfd1;
+	CAN_SETTINGS can2;
+	CANFD_SETTINGS canfd2;
+	CAN_SETTINGS can3;
+	CANFD_SETTINGS canfd3;
+	CAN_SETTINGS can4;
+	CANFD_SETTINGS canfd4;
+	CAN_SETTINGS can5;
+	CANFD_SETTINGS canfd5;
+	CAN_SETTINGS can6;
+	CANFD_SETTINGS canfd6;
+	CAN_SETTINGS can7;
+	CANFD_SETTINGS canfd7;
+	CAN_SETTINGS can8;
+	CANFD_SETTINGS canfd8;
+
+	// SWCAN_SETTINGS swcan1;	G2 does not have SWCAN.
+	uint16_t network_enables;
+	// SWCAN_SETTINGS swcan2;	G2 does not have SWCAN.
+	uint16_t network_enables_2;
+
+	uint32_t pwr_man_timeout;
+	uint16_t pwr_man_enable;
+
+	uint16_t network_enabled_on_boot;
+
+	/* ISO15765-2 Transport Layer */
+	uint16_t iso15765_separation_time_offset;
+
+	/* ISO9141 - Keyword */
+	uint16_t iso_9141_kwp_enable_reserved;
+	ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_1;
+	uint16_t iso_parity_1;
+
+	uint16_t iso_msg_termination_1;
+
+	uint16_t idle_wakeup_network_enables_1;
+	uint16_t idle_wakeup_network_enables_2;
+
+	/* reserved for T1 networks such as BR1, BR2, etc.. */
+	uint16_t network_enables_3;
+	uint16_t idle_wakeup_network_enables_3;
+
+	STextAPISettings text_api;
+
+	uint64_t termination_enables; // New feature unlike Galaxy.
+
+	TIMESYNC_ICSHARDWARE_SETTINGS timeSyncSettings;
+	struct
+	{
+		uint16_t hwComLatencyTestEn : 1;
+		uint16_t reserved : 15;
+	} flags;
+
+	LIN_SETTINGS lin1;
+
+	OP_ETH_GENERAL_SETTINGS opEthGen;
+	OP_ETH_SETTINGS opEth1;
+	OP_ETH_SETTINGS opEth2;
+	OP_ETH_SETTINGS opEth3;
+	OP_ETH_SETTINGS opEth4;
+	OP_ETH_SETTINGS opEth5;
+	OP_ETH_SETTINGS opEth6;
+	OP_ETH_SETTINGS opEth7;
+	OP_ETH_SETTINGS opEth8;
+	OP_ETH_SETTINGS opEth9;
+	OP_ETH_SETTINGS opEth10;
+	OP_ETH_SETTINGS opEth11;
+	OP_ETH_SETTINGS opEth12;
+	OP_ETH_SETTINGS opEth13;
+	OP_ETH_SETTINGS opEth14;
+	OP_ETH_SETTINGS opEth15;
+	OP_ETH_SETTINGS opEth16;
+
+	ETHERNET10G_SETTINGS ethernet10g;
+	ETHERNET10G_SETTINGS ethernet10g_2;
+	ETHERNET10G_SETTINGS ethernet10g_3;
+
+	uint16_t network_enables_4;
+	RAD_REPORTING_SETTINGS reporting;
+	RAD_GPTP_SETTINGS gPTP;
+
+	uint64_t network_enables_5;
+
+	LIN_SETTINGS lin2;
+} radgalaxy2_settings_t;
+
+typedef struct {
+	uint8_t unused[3];
+	uint8_t ethernetActivationLineEnabled;
+} radgalaxy2_status_t;
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+
+#include <iostream>
+
+class RADGalaxy2Settings : public IDeviceSettings {
+public:
+	RADGalaxy2Settings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(radgalaxy2_settings_t)) {}
+	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radgalaxy2_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::HSCAN:
+				return &(cfg->can1);
+			case Network::NetID::MSCAN:
+				return &(cfg->can2);
+			case Network::NetID::HSCAN2:
+				return &(cfg->can3);
+			case Network::NetID::HSCAN3:
+				return &(cfg->can4);
+			case Network::NetID::HSCAN4:
+				return &(cfg->can5);
+			case Network::NetID::HSCAN5:
+				return &(cfg->can6);
+			case Network::NetID::HSCAN6:
+				return &(cfg->can7);
+			case Network::NetID::HSCAN7:
+				return &(cfg->can8);
+			default:
+				return nullptr;
+		}
+	}
+	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radgalaxy2_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::HSCAN:
+				return &(cfg->canfd1);
+			case Network::NetID::MSCAN:
+				return &(cfg->canfd2);
+			case Network::NetID::HSCAN2:
+				return &(cfg->canfd3);
+			case Network::NetID::HSCAN3:
+				return &(cfg->canfd4);
+			case Network::NetID::HSCAN4:
+				return &(cfg->canfd5);
+			case Network::NetID::HSCAN5:
+				return &(cfg->canfd6);
+			case Network::NetID::HSCAN6:
+				return &(cfg->canfd7);
+			case Network::NetID::HSCAN7:
+				return &(cfg->canfd8);
+			default:
+				return nullptr;
+		}
+	}
+
+	const LIN_SETTINGS* getLINSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radgalaxy2_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::LIN:
+				return &(cfg->lin1);
+			case Network::NetID::LIN2:
+				return &(cfg->lin2);
+			default:
+				return nullptr;
+		}
+	}
+};
+
+}
+
+#endif // __cplusplus
+
+#endif
--- a/include/icsneo/device/tree/radgigastar/radgigastar.h
+++ b/include/icsneo/device/tree/radgigastar/radgigastar.h
@ -21,6 +21,8 @@ public:
 	size_t getEthernetActivationLineCount() const override { return 1; }

 	bool getEthPhyRegControlSupported() const override { return true; }
+	bool supportsTC10() const override { return true; }
+	bool supportsGPTP() const override { return true; }

 protected:
 	RADGigastar(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
--- a/include/icsneo/device/tree/radgigastar2/radgigastar2.h
+++ b/include/icsneo/device/tree/radgigastar2/radgigastar2.h
@ -0,0 +1,140 @@
+#ifndef __RADGIGASTAR2_H_
+#define __RADGIGASTAR2_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/device.h"
+#include "icsneo/device/devicetype.h"
+#include "icsneo/disk/extextractordiskreaddriver.h"
+#include "icsneo/disk/neomemorydiskdriver.h"
+#include "icsneo/device/tree/radgigastar2/radgigastar2settings.h"
+
+namespace icsneo
+{
+
+	class RADGigastar2 : public Device
+	{
+	public:
+		// Serial numbers start with GT
+		// USB PID is 0x1210, standard driver is FTDI3
+		// Ethernet MAC allocation is 0x22, standard driver is Raw
+		ICSNEO_FINDABLE_DEVICE(RADGigastar2, DeviceType::RADGigastar2, "GT");
+
+		static const std::vector<Network> &GetSupportedNetworks()
+		{
+			static std::vector<Network> supportedNetworks = {
+				Network::NetID::HSCAN,
+				Network::NetID::HSCAN2,
+				Network::NetID::HSCAN3,
+				Network::NetID::HSCAN4,
+
+				Network::NetID::Ethernet,
+				Network::NetID::Ethernet2,
+
+				Network::NetID::OP_Ethernet1,
+				Network::NetID::OP_Ethernet2,
+				Network::NetID::OP_Ethernet3,
+				Network::NetID::OP_Ethernet4,
+				Network::NetID::OP_Ethernet5,
+				Network::NetID::OP_Ethernet6,
+				Network::NetID::OP_Ethernet7,
+				Network::NetID::OP_Ethernet8,
+				Network::NetID::OP_Ethernet9,
+				Network::NetID::OP_Ethernet10,
+
+				Network::NetID::LIN,
+				Network::NetID::LIN2,
+				Network::NetID::LIN3,
+				Network::NetID::LIN4,
+				Network::NetID::LIN5,
+				Network::NetID::LIN6,
+				Network::NetID::LIN7,
+				Network::NetID::LIN8,
+				Network::NetID::LIN9,
+				Network::NetID::LIN10,
+
+				Network::NetID::I2C,
+				Network::NetID::I2C2,
+
+				Network::NetID::MDIO1,
+				Network::NetID::MDIO2,
+
+				Network::NetID::SPI1,
+				Network::NetID::SPI2,
+				Network::NetID::SPI3,
+				Network::NetID::SPI4,
+				Network::NetID::SPI5,
+				Network::NetID::SPI6,
+				Network::NetID::SPI7,
+				Network::NetID::SPI8,
+			};
+			return supportedNetworks;
+		}
+
+		size_t getEthernetActivationLineCount() const override { return 1; }
+
+		bool getEthPhyRegControlSupported() const override { return true; }
+
+		bool supportsTC10() const override { return true; }
+		bool supportsGPTP() const override { return true; }
+	
+	protected:
+		RADGigastar2(neodevice_t neodevice, const driver_factory_t &makeDriver) : Device(neodevice)
+		{
+			initialize<RADGigastar2Settings>(makeDriver);
+		}
+
+		void setupPacketizer(Packetizer &packetizer) override
+		{
+			Device::setupPacketizer(packetizer);
+			packetizer.disableChecksum = true;
+			packetizer.align16bit = false;
+		}
+
+		void setupDecoder(Decoder &decoder) override
+		{
+			Device::setupDecoder(decoder);
+			decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns
+		}
+
+		void setupEncoder(Encoder &encoder) override
+		{
+			Device::setupEncoder(encoder);
+			encoder.supportCANFD = true;
+			encoder.supportEthPhy = true;
+		}
+
+		void setupSupportedRXNetworks(std::vector<Network> &rxNetworks) override
+		{
+			for (auto &netid : GetSupportedNetworks())
+				rxNetworks.emplace_back(netid);
+		}
+
+		// The supported TX networks are the same as the supported RX networks for this device
+		void setupSupportedTXNetworks(std::vector<Network> &txNetworks) override { setupSupportedRXNetworks(txNetworks); }
+
+		void handleDeviceStatus(const std::shared_ptr<RawMessage> &message) override
+		{
+			if (message->data.size() < sizeof(radgigastar2_status_t))
+				return;
+			std::lock_guard<std::mutex> lk(ioMutex);
+			const radgigastar2_status_t *status = reinterpret_cast<const radgigastar2_status_t *>(message->data.data());
+			ethActivationStatus = status->ethernetActivationLineEnabled;
+		}
+
+		std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override
+		{
+			return 512 * 4;
+		}
+
+		std::optional<MemoryAddress> getCoreminiStartAddressSD() const override
+		{
+			return 0;
+		}
+	};
+
+}
+
+#endif // __cplusplus
+
+#endif
--- a/include/icsneo/device/tree/radgigastar2/radgigastar2settings.h
+++ b/include/icsneo/device/tree/radgigastar2/radgigastar2settings.h
@ -0,0 +1,243 @@
+#ifndef __RADGIGASTAR2SETTINGS_H_
+#define __RADGIGASTAR2SETTINGS_H_
+
+#include <stdint.h>
+#include "icsneo/device/idevicesettings.h"
+
+#ifdef __cplusplus
+
+namespace icsneo
+{
+
+#endif
+
+#pragma pack(push, 2)
+	typedef struct
+	{
+		uint32_t ecu_id;
+		uint16_t perf_en;
+		struct
+		{
+			uint16_t hwComLatencyTestEn : 1;
+			uint16_t disableUsbCheckOnBoot : 1;
+			uint16_t reserved : 14;
+		} flags;
+		uint16_t network_enabled_on_boot;
+		CAN_SETTINGS can1;
+		CANFD_SETTINGS canfd1;
+		CAN_SETTINGS can2;
+		CANFD_SETTINGS canfd2;
+		CAN_SETTINGS can3;
+		CANFD_SETTINGS canfd3;
+		CAN_SETTINGS can4;
+		CANFD_SETTINGS canfd4;
+
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_1;
+		uint16_t iso_parity_1;
+		uint16_t iso_msg_termination_1;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_2;
+		uint16_t iso_parity_2;
+		uint16_t iso_msg_termination_2;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_3;
+		uint16_t iso_parity_3;
+		uint16_t iso_msg_termination_3;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_4;
+		uint16_t iso_parity_4;
+		uint16_t iso_msg_termination_4;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_5;
+		uint16_t iso_parity_5;
+		uint16_t iso_msg_termination_5;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_6;
+		uint16_t iso_parity_6;
+		uint16_t iso_msg_termination_6;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_7;
+		uint16_t iso_parity_7;
+		uint16_t iso_msg_termination_7;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_8;
+		uint16_t iso_parity_8;
+		uint16_t iso_msg_termination_8;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_9;
+		uint16_t iso_parity_9;
+		uint16_t iso_msg_termination_9;
+		ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_10;
+		uint16_t iso_parity_10;
+		uint16_t iso_msg_termination_10;
+		uint64_t network_enables;
+		uint64_t network_enables_2;
+		uint64_t termination_enables;
+		TIMESYNC_ICSHARDWARE_SETTINGS timeSyncSettings;
+		RAD_REPORTING_SETTINGS reporting;
+		int16_t iso15765_separation_time_offset;
+		uint32_t pwr_man_timeout;
+		uint16_t pwr_man_enable;
+		RAD_GPTP_SETTINGS gPTP;
+		STextAPISettings text_api;
+		DISK_SETTINGS disk;
+		LOGGER_SETTINGS logger;
+		LIN_SETTINGS lin1;
+		LIN_SETTINGS lin2;
+		LIN_SETTINGS lin3;
+		LIN_SETTINGS lin4;
+		LIN_SETTINGS lin5;
+		LIN_SETTINGS lin6;
+		LIN_SETTINGS lin7;
+		LIN_SETTINGS lin8;
+		LIN_SETTINGS lin9;
+		LIN_SETTINGS lin10;
+		// TODO more LIN
+		// Ethernet SFP
+		ETHERNET_SETTINGS2 ethernet1;
+		ETHERNET_SETTINGS2 ethernet2;
+		// Ethernet General
+		OP_ETH_GENERAL_SETTINGS opEthGen;
+		// 100/1000T1
+		ETHERNET_SETTINGS2 ethT1;
+		OP_ETH_SETTINGS opEth1;
+		ETHERNET_SETTINGS2 ethT12;
+		OP_ETH_SETTINGS opEth2;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s1;
+		ETHERNET10T1S_SETTINGS t1s1;
+		ETHERNET10T1S_SETTINGS_EXT t1s1Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s2;
+		ETHERNET10T1S_SETTINGS t1s2;
+		ETHERNET10T1S_SETTINGS_EXT t1s2Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s3;
+		ETHERNET10T1S_SETTINGS t1s3;
+		ETHERNET10T1S_SETTINGS_EXT t1s3Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s4;
+		ETHERNET10T1S_SETTINGS t1s4;
+		ETHERNET10T1S_SETTINGS_EXT t1s4Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s5;
+		ETHERNET10T1S_SETTINGS t1s5;
+		ETHERNET10T1S_SETTINGS_EXT t1s5Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s6;
+		ETHERNET10T1S_SETTINGS t1s6;
+		ETHERNET10T1S_SETTINGS_EXT t1s6Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s7;
+		ETHERNET10T1S_SETTINGS t1s7;
+		ETHERNET10T1S_SETTINGS_EXT t1s7Ext;
+		// 10T1S
+		ETHERNET_SETTINGS2 ethT1s8;
+		ETHERNET10T1S_SETTINGS t1s8;
+		ETHERNET10T1S_SETTINGS_EXT t1s8Ext;
+	} radgigastar2_settings_t;
+#pragma pack(pop)
+
+#ifdef __cplusplus
+
+	static_assert(sizeof(radgigastar2_settings_t) == 2024, "RADGigastar2 settings size mismatch");
+
+#include <iostream>
+
+	class RADGigastar2Settings : public IDeviceSettings
+	{
+	public:
+		RADGigastar2Settings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(radgigastar2_settings_t)) {}
+		const CAN_SETTINGS *getCANSettingsFor(Network net) const override
+		{
+			auto cfg = getStructurePointer<radgigastar2_settings_t>();
+			if (cfg == nullptr)
+				return nullptr;
+			switch (net.getNetID())
+			{
+			case Network::NetID::HSCAN:
+				return &(cfg->can1);
+			case Network::NetID::HSCAN2:
+				return &(cfg->can2);
+			case Network::NetID::HSCAN3:
+				return &(cfg->can3);
+			case Network::NetID::HSCAN4:
+				return &(cfg->can4);
+			default:
+				return nullptr;
+			}
+		}
+		const CANFD_SETTINGS *getCANFDSettingsFor(Network net) const override
+		{
+			auto cfg = getStructurePointer<radgigastar2_settings_t>();
+			if (cfg == nullptr)
+				return nullptr;
+			switch (net.getNetID())
+			{
+			case Network::NetID::HSCAN:
+				return &(cfg->canfd1);
+			case Network::NetID::HSCAN2:
+				return &(cfg->canfd2);
+			case Network::NetID::HSCAN3:
+				return &(cfg->canfd3);
+			case Network::NetID::HSCAN4:
+				return &(cfg->canfd4);
+			default:
+				return nullptr;
+			}
+		}
+
+		virtual std::vector<TerminationGroup> getTerminationGroups() const override
+		{
+			return {
+				{Network(Network::NetID::HSCAN)},
+				{Network(Network::NetID::HSCAN2)},
+				{Network(Network::NetID::HSCAN3)},
+				{Network(Network::NetID::HSCAN4)}};
+		}
+
+		const LIN_SETTINGS *getLINSettingsFor(Network net) const override
+		{
+			auto cfg = getStructurePointer<radgigastar2_settings_t>();
+			if (cfg == nullptr)
+				return nullptr;
+			switch (net.getNetID())
+			{
+			case Network::NetID::LIN:
+				return &(cfg->lin1);
+			case Network::NetID::LIN2:
+				return &(cfg->lin2);
+			case Network::NetID::LIN3:
+				return &(cfg->lin3);
+			case Network::NetID::LIN4:
+				return &(cfg->lin4);
+			case Network::NetID::LIN5:
+				return &(cfg->lin5);
+			case Network::NetID::LIN6:
+				return &(cfg->lin6);
+			case Network::NetID::LIN7:
+				return &(cfg->lin7);
+			case Network::NetID::LIN8:
+				return &(cfg->lin8);
+			case Network::NetID::LIN9:
+				return &(cfg->lin9);
+			case Network::NetID::LIN10:
+				return &(cfg->lin10);
+			default:
+				return nullptr;
+			}
+		}
+
+	protected:
+		ICSNEO_UNALIGNED(const uint64_t *)
+		getTerminationEnables() const override
+		{
+			auto cfg = getStructurePointer<radgigastar2_settings_t>();
+			if (cfg == nullptr)
+				return nullptr;
+			return &cfg->termination_enables;
+		}
+	};
+
+	typedef struct
+	{
+		uint8_t unused[3];
+		uint8_t ethernetActivationLineEnabled;
+	} radgigastar2_status_t;
+}
+
+#endif // __cplusplus
+
+#endif
--- a/Show More
+++ b/Show More