Docs: Refactor

- Fixes NeoMemoryDiskDriver::readLogicalDiskAligned() for flash
- Adds FlashMemoryMessage

.gitignore

@@ -14,4 +14,4 @@ third-party/concurrentqueue/tests
 *.orig
 examples/csharp/bin
 examples/csharp/obj
-test/system
+test/system

.gitlab-ci.yml

@@ -5,6 +5,7 @@ stages:
   - build
   - unit_test
   - hardware_test
+  - deploy
 
 #-------------------------------------------------------------------------------
 # Windows
@@ -318,6 +319,7 @@ unit_test linux/fedora/39/amd64/clang:
     - /opt/libvirt-driver/run.sh
   after_script:
     - /opt/libvirt-driver/cleanup.sh
+  allow_failure: true
 
 .fedora38_needs: &fedora38_needs
   needs:
@@ -416,4 +418,99 @@ hardware_test win10-vcan42-EL:
   <<: *win10_needs
   variables:
     GUEST_OS_TAG: win10
-    DEVICE_PORT: USB_C
+    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: tcp://docker:2375/
+    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:
+    - build python/linux/amd64
+    - build python/linux/arm64
+    - build python/macos
+    - build python/windows

.readthedocs.yaml

@@ -0,0 +1,15 @@
+version: 2
+
+build:
+  os: "ubuntu-24.04"
+  tools:
+    python: "3.12"
+  apt_packages:
+    - doxygen
+
+python:
+  install:
+    - requirements: docs/icsneopy/requirements.txt
+
+sphinx:
+  configuration: docs/conf.py

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,6 +240,7 @@ 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
@@ -493,6 +496,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 +524,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)

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

README.md

@@ -1,176 +1,42 @@
 # 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-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.

bindings/CMakeLists.txt

@@ -0,0 +1,3 @@
+if(LIBICSNEO_ENABLE_BINDINGS_PYTHON)
+	add_subdirectory(python)
+endif()

bindings/python/CMakeLists.txt

@@ -0,0 +1,24 @@
+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/ethernetmessage.cpp
+    icsneopy/communication/message/tc10statusmessage.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 .)

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 
+

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 
+

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 
+

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 
+

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 
+

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 
+

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("fcsAvailable", &EthernetMessage::fcsAvailable)
+		.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 
+

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

@@ -0,0 +1,15 @@
+#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<Network::NetID>());
+}
+
+} // namespace icsneo 
+

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

@@ -0,0 +1,51 @@
+#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);
+
+	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
+

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

bindings/python/icsneopy/communication/network.cpp

@@ -0,0 +1,174 @@
+#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);
+	
+    network.def(pybind11::init<Network::NetID>());
+}
+
+} // namespace icsneo 
+

bindings/python/icsneopy/device/device.cpp

@@ -0,0 +1,43 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.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(); })
+		.def("close", &Device::close)
+		.def("is_open", &Device::isOpen)
+		.def("go_online", &Device::goOnline)
+		.def("go_offline", &Device::goOffline)
+		.def("is_online", &Device::isOnline).def("enable_message_polling", &Device::enableMessagePolling)
+		.def("disable_message_polling", &Device::disableMessagePolling)
+		.def("is_message_polling_enabled", &Device::isMessagePollingEnabled)
+		.def("get_messages", [](Device& device) { return device.getMessages(); })
+		.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)
+		.def("remove_message_callback", &Device::removeMessageCallback)
+		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit))
+		.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)
+		.def("set_rtc", &Device::setRTC)
+		.def("describe", &Device::describe)
+		.def("is_online_supported", &Device::isOnlineSupported)
+		.def("supports_tc10", &Device::supportsTC10)
+		.def("request_tc10_wake", &Device::requestTC10Wake)
+		.def("request_tc10_sleep", &Device::requestTC10Sleep)
+		.def("__repr__", &Device::describe);
+}
+
+} // namespace icsneo
+

bindings/python/icsneopy/device/devicetype.cpp

@@ -0,0 +1,75 @@
+#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("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 
+

bindings/python/icsneopy/icsneocpp.cpp

@@ -0,0 +1,45 @@
+#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_ethernetmessage(pybind11::module_&);
+void init_tc10statusmessage(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) {
+	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_ethernetmessage(m);
+	init_tc10statusmessage(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 

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

ci/bootstrap-libusb.sh

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

ci/build-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
+

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

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

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,7 @@
 #include "icsneo/communication/message/diskdatamessage.h"
 #include "icsneo/communication/message/hardwareinfo.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
+#include "icsneo/communication/message/apperrormessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -256,6 +258,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);
@@ -398,6 +412,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]);

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;
-}
+}

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

device/device.cpp

@@ -656,6 +656,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);
@@ -2116,7 +2195,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) {

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
@@ -200,6 +204,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 +340,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
@@ -348,6 +360,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

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

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'),
-]
-
-
-

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'),
-]
-
-
-

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

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

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

docs/icsneoc/index.rst

@@ -0,0 +1,9 @@
+icsneoc
+=======
+
+.. toctree::
+   :maxdepth: 2
+
+   installation
+   examples
+   api

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.

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:

docs/icsneocpp/api.rst

@@ -0,0 +1,8 @@
+=======
+C++ API
+=======
+
+.. doxygennamespace:: icsneo
+   :members:
+   :undoc-members:
+   :content-only:

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.

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
 ~~~~~~~~~~~~~~~~~~~~~~~

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

docs/icsneocpp/index.rst

@@ -0,0 +1,11 @@
+icsneocpp
+=========
+
+.. toctree::
+   :maxdepth: 2
+
+   installation
+   deviceconcepts
+   apiconcepts
+   examples
+   api

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/``

docs/icsneopy/api.rst

@@ -0,0 +1,9 @@
+==========
+Python API
+==========
+
+.. automodule:: icsneopy
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :special-members: __init__

docs/icsneopy/examples.rst

@@ -0,0 +1,52 @@
+===============
+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)

docs/icsneopy/index.rst

@@ -0,0 +1,9 @@
+========
+icsneopy
+========
+
+.. toctree::
+   :maxdepth: 2
+
+   examples
+   api

docs/index.rst

@@ -1,10 +1,10 @@
-Welcome to libicsneo's documentation!
-=======================================
+libicsneo
+=========
 
 .. toctree::
-   :maxdepth: 3
-   :caption: Documentation
+   :maxdepth: 1
+   :caption: API Documentation
 
-   Usage
-   icsneocpp
-   icsneoc
+   icsneocpp/index
+   icsneopy/index
+   icsneoc/index

docs/requirements.txt

@@ -1 +1,4 @@
-breathe==4.12.0
+sphinx
+icsneopy
+breathe
+sphinx_rtd_theme

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

examples/cpp/apperror/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_executable(libicsneocpp-app-error src/AppErrorExample.cpp)
+target_link_libraries(libicsneocpp-app-error icsneocpp)

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;
+}

include/icsneo/api/event.h

@@ -108,6 +108,7 @@ public:
 		LiveDataNotSupported = 0x2052,
 		LINSettingsNotAvailable = 0x2053,
 		ModeNotFound = 0x2054,
+		AppErrorParsingFailed = 0x2055,
 
 		// Transport Events
 		FailedToRead = 0x3000,

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;

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

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

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

include/icsneo/communication/message/message.h

@@ -40,6 +40,7 @@ public:
 		LiveData = 0x800f,
 		HardwareInfo = 0x8010,
 		TC10Status = 0x8011,
+		AppError = 0x8012,
 	};
 
 	Message(Type t) : type(t) {}

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:

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

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"
@@ -163,6 +165,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 +229,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));
 
 
 	/**

include/icsneo/device/devicetype.h

@@ -52,6 +52,8 @@ public:
 		FIRE3_FlexRay = (0x00000025),
 		Connect = (0x00000026),
 		RADComet3 = (0x00000027),
+		RADMoonT1S = (0x00000028),
+		RADGigastar2 = (0x00000029),
 		RED = (0x00000040),
 		ECU = (0x00000080),
 		IEVB = (0x00000100),
@@ -190,8 +192,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:
@@ -247,6 +253,8 @@ private:
 #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 +283,4 @@ private:
 #define ICSNEO_DEVICETYPE_OBD2_SIM ((devicetype_t)0x80000000)
 #endif
 
-#endif
+#endif

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

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

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>
 

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 {

include/icsneo/device/tree/radgigastar/radgigastar.h

@@ -21,7 +21,8 @@ public:
 	size_t getEthernetActivationLineCount() const override { return 1; }
 
 	bool getEthPhyRegControlSupported() const override { return true; }
-
+	bool supportsTC10() const override { return true; }
+	
 protected:
 	RADGigastar(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADGigastarSettings>(makeDriver);

include/icsneo/device/tree/radgigastar2/radgigastar2.h

@@ -0,0 +1,139 @@
+#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; }
+
+	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

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

include/icsneo/device/tree/radmoont1s/radmoont1s.h

@@ -0,0 +1,73 @@
+#ifndef __RADMOONT1S_H_
+#define __RADMOONT1S_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/device.h"
+#include "icsneo/device/tree/radmoont1s/radmoont1ssettings.h"
+
+namespace icsneo {
+
+class RADMoonT1S : public Device {
+public:
+
+	// Serial numbers start with MS
+	// USB PID is 0x1209, standard driver is FTDI3
+	// Ethernet MAC allocation is 0x21, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE(RADMoonT1S, DeviceType::RADMoonT1S, "MS");
+
+	static const std::vector<Network>& GetSupportedNetworks() {
+		static std::vector<Network> supportedNetworks = {
+			Network::NetID::Ethernet,
+
+			Network::NetID::OP_Ethernet1,
+
+			Network::NetID::MDIO1,
+
+			Network::NetID::SPI1,
+		};
+		return supportedNetworks;
+	}
+
+
+	bool getEthPhyRegControlSupported() const override { return true; }
+
+	bool supportsTC10() const override { return true; }
+
+protected:
+	RADMoonT1S(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		initialize<RADMoonT1SSettings>(makeDriver);
+	}
+
+	void setupPacketizer(Packetizer& packetizer) override {
+		Device::setupPacketizer(packetizer);
+		packetizer.disableChecksum = true;
+		packetizer.align16bit = false;
+	}
+
+	void setupEncoder(Encoder& encoder) override {
+		Device::setupEncoder(encoder);
+		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);
+	}
+};
+
+}
+
+#endif // __cplusplus
+
+#endif // __RADMOONT1S_H_

include/icsneo/device/tree/radmoont1s/radmoont1ssettings.h

@@ -0,0 +1,51 @@
+#ifndef __RADMOONT1SSETTINGS_H_
+#define __RADMOONT1SSETTINGS_H_
+
+#include <stdint.h>
+#include "icsneo/device/idevicesettings.h"
+
+#ifdef __cplusplus
+
+namespace icsneo {
+
+#endif
+
+#pragma pack(push, 2)
+typedef struct {
+	uint16_t perf_en;
+	struct
+	{
+		uint16_t hwComLatencyTestEn : 1;
+		uint16_t disableUsbCheckOnBoot : 1;
+		uint16_t reserved : 14;
+	} flags;
+	uint16_t network_enabled_on_boot;
+	uint64_t network_enables;
+	uint64_t network_enables_2;
+	RAD_REPORTING_SETTINGS reporting;
+	uint32_t pwr_man_timeout;
+	uint16_t pwr_man_enable;
+	// Ethernet 10/100/1000
+	ETHERNET_SETTINGS2 ethernet;
+	// Ethernet General
+	OP_ETH_GENERAL_SETTINGS opEthGen;
+	// 10T1S
+	ETHERNET_SETTINGS2 ethT1s;
+	ETHERNET10T1S_SETTINGS t1s;
+} radmoont1s_settings_t;
+#pragma pack(pop)
+
+#ifdef __cplusplus
+
+#include <iostream>
+
+class RADMoonT1SSettings : public IDeviceSettings {
+public:
+	RADMoonT1SSettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(radmoont1s_settings_t)) {}
+};
+
+}
+
+#endif // __cplusplus
+
+#endif // __RADMOONT1SSETTINGS_H_

include/icsneo/platform/ftd3xx.h

@@ -22,8 +22,10 @@ public:
 private:
 	neodevice_t& device;
 	std::optional<void*> handle;
-	void readTask() override;
-	void writeTask() override;
+
+	std::thread readThread, writeThread;
+	void readTask();
+	void writeTask();
 };
 
 }

include/icsneo/platform/posix/cdcacm.h

@@ -47,8 +47,10 @@ private:
 
 	static std::string HandleToTTY(neodevice_handle_t handle);
 
-	void readTask() override;
-	void writeTask() override;
+	std::thread readThread, writeThread;
+	void readTask();
+	void writeTask();
+
 	bool fdIsValid();
 };
 

include/icsneo/platform/posix/devices.h

@@ -16,9 +16,11 @@
 #include "icsneo/device/tree/radcomet/radcomet.h"
 #include "icsneo/device/tree/radcomet/radcomet2.h"
 #include "icsneo/device/tree/radcomet3/radcomet3.h"
+#include "icsneo/device/tree/radmoont1s/radmoont1s.h"
 #include "icsneo/device/tree/radepsilon/radepsilon.h"
 #include "icsneo/device/tree/radgalaxy/radgalaxy.h"
 #include "icsneo/device/tree/radgigastar/radgigastar.h"
+#include "icsneo/device/tree/radgigastar2/radgigastar2.h"
 #include "icsneo/device/tree/radjupiter/radjupiter.h"
 #include "icsneo/device/tree/radmars/radmars.h"
 #include "icsneo/device/tree/radmoon2/radmoon2.h"

include/icsneo/platform/posix/firmio.h

@@ -25,8 +25,11 @@ public:
 	bool isOpen() override;
 	bool close() override;
 private:
-	void readTask() override;
-	void writeTask() override;
+	std::thread readThread, writeThread;
+
+	void readTask();
+	void writeTask();
+
 	bool writeQueueFull() override;
 	bool writeQueueAlmostFull() override;
 	bool writeInternal(const std::vector<uint8_t>& bytes) override;

include/icsneo/platform/posix/ftdi.h

@@ -57,8 +57,11 @@ private:
 	static std::vector<std::string> handles;
 
 	static bool ErrorIsDisconnection(int errorCode);
+	std::thread readThread, writeThread;
+
 	void readTask();
 	void writeTask();
+
 	bool openable; // Set to false in the constructor if the object has not been found in searchResultDevices
 
 	neodevice_t& device;

include/icsneo/platform/posix/pcap.h

@@ -30,8 +30,10 @@ private:
 	uint8_t deviceMAC[6];
 	bool openable = true;
 	EthernetPacketizer ethPacketizer;
-	void readTask() override;
-	void writeTask() override;
+
+	std::thread readThread, writeThread;
+	void readTask();
+	void writeTask();
 
 	class NetworkInterface {
 	public:

include/icsneo/platform/tcp.h

@@ -47,8 +47,10 @@ private:
 	uint32_t dstIP;
 	uint16_t dstPort;
 	std::unique_ptr<Socket> socket;
-	void readTask() override;
-	void writeTask() override;
+
+	std::thread readThread, writeThread;
+	void readTask();
+	void writeTask();
 };
 
 }

include/icsneo/platform/windows/devices.h

@@ -16,9 +16,11 @@
 #include "icsneo/device/tree/radcomet/radcomet.h"
 #include "icsneo/device/tree/radcomet/radcomet2.h"
 #include "icsneo/device/tree/radcomet3/radcomet3.h"
+#include "icsneo/device/tree/radmoont1s/radmoont1s.h"
 #include "icsneo/device/tree/radepsilon/radepsilon.h"
 #include "icsneo/device/tree/radgalaxy/radgalaxy.h"
 #include "icsneo/device/tree/radgigastar/radgigastar.h"
+#include "icsneo/device/tree/radgigastar2/radgigastar2.h"
 #include "icsneo/device/tree/radjupiter/radjupiter.h"
 #include "icsneo/device/tree/radmars/radmars.h"
 #include "icsneo/device/tree/radmoon2/radmoon2.h"

include/icsneo/platform/windows/pcap.h

@@ -32,6 +32,7 @@ private:
 	bool openable = true;
 	EthernetPacketizer ethPacketizer;
 	
+	std::thread readThread, writeThread;
 	std::thread transmitThread;
 	pcap_send_queue* transmitQueue = nullptr;
 	std::condition_variable transmitQueueCV;

include/icsneo/platform/windows/vcp.h

@@ -37,6 +37,7 @@ private:
 	std::shared_ptr<Detail> detail;
 
 	std::vector<std::shared_ptr<std::thread>> threads;
+	std::thread readThread, writeThread;
 	void readTask();
 	void writeTask();
 };

platform/ftd3xx.cpp

@@ -64,7 +64,7 @@ bool FTD3XX::open() {
 	}
 	handle.emplace(tmpHandle);
 
-	closing = false;
+	setIsClosing(false);
 	readThread = std::thread(&FTD3XX::readTask, this);
 	writeThread = std::thread(&FTD3XX::writeTask, this);
 
@@ -81,23 +81,21 @@ bool FTD3XX::close() {
 		return false;
 	}
 
-	closing = true;
-	disconnected = false;
+	setIsClosing(true);
+	setIsDisconnected(false);
 
 	if(readThread.joinable())
 		readThread.join();
 	if(writeThread.joinable())
 		writeThread.join();
 
-	WriteOperation flushop;
-	readBuffer.pop(readBuffer.size());
-	while(writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
 
 	if(const auto ret = FT_Close(*handle); ret != FT_OK) {
 		addEvent(ret, APIEvent::Severity::EventWarning);
 	}
 
-	closing = false;
+	setIsClosing(false);
 
 	return true;
 }
@@ -110,7 +108,7 @@ void FTD3XX::readTask() {
 
 	FT_SetStreamPipe(*handle, false, false, READ_PIPE_ID, bufferSize);
 	FT_SetPipeTimeout(*handle, READ_PIPE_ID, 1);
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		ULONG received = 0;
 		OVERLAPPED overlap = {};
 		FT_InitializeOverlapped(*handle, &overlap);
@@ -119,13 +117,13 @@ void FTD3XX::readTask() {
 		#else
 			FT_ReadPipeAsync(*handle, 0, buffer, bufferSize, &received, &overlap);
 		#endif
-		while(!closing) {
+		while(!isClosing()) {
 			const auto ret = FT_GetOverlappedResult(*handle, &overlap, &received, true);
 			if(ret == FT_IO_PENDING)
 				continue;
 			if(ret != FT_OK) {
 				if(ret == FT_IO_ERROR) {
-					disconnected = true;
+					setIsDisconnected(true);
 					report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 				} else {
 					addEvent(ret, APIEvent::Severity::Error);
@@ -146,7 +144,7 @@ void FTD3XX::writeTask() {
 
 	FT_SetPipeTimeout(*handle, WRITE_PIPE_ID, 100);
 	WriteOperation writeOp;
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		if(!writeQueue.wait_dequeue_timed(writeOp, std::chrono::milliseconds(100)))
 			continue;
 
@@ -160,13 +158,13 @@ void FTD3XX::writeTask() {
 		#else
 			FT_WritePipeAsync(*handle, 0, writeOp.bytes.data(), size, &sent, &overlap);
 		#endif
-		while(!closing) {
+		while(!isClosing()) {
 			const auto ret = FT_GetOverlappedResult(*handle, &overlap, &sent, true);
 			if(ret == FT_IO_PENDING)
 				continue;
 			if(ret != FT_OK) {
 				if(ret == FT_IO_ERROR) {
-					disconnected = true;
+					setIsDisconnected(true);
 					report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 				} else {
 					addEvent(ret, APIEvent::Severity::Error);

platform/posix/cdcacm.cpp

@@ -117,7 +117,7 @@ bool CDCACM::close() {
 		return false;
 	}
 
-	closing = true;
+	setIsClosing(true);
 
 	if(readThread.joinable())
 		readThread.join();
@@ -125,8 +125,8 @@ bool CDCACM::close() {
 	if(writeThread.joinable())
 		writeThread.join();
 
-	closing = false;
-	disconnected = false;
+	setIsClosing(false);
+	setIsDisconnected(false);
 
 	if(modeChanging) {
 		// We're expecting this inode to go away after we close the device
@@ -140,9 +140,7 @@ bool CDCACM::close() {
 	int ret = ::close(fd);
 	fd = -1;
 
-	WriteOperation flushop;
-	readBuffer.clear();
-	while (writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
 
 	if(modeChanging) {
 		modeChanging = false;
@@ -173,7 +171,7 @@ void CDCACM::readTask() {
 	constexpr size_t READ_BUFFER_SIZE = 2048;
 	uint8_t readbuf[READ_BUFFER_SIZE];
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		fd_set rfds = {0};
 		struct timeval tv = {0};
 		FD_SET(fd, &rfds);
@@ -199,8 +197,8 @@ void CDCACM::readTask() {
 					// Requesting thread is responsible for calling close. This allows for more flexibility
 				});
 				break;
-			} else if(!closing && !fdIsValid() && !isDisconnected()) {
-				disconnected = true;
+			} else if(!isClosing() && !fdIsValid() && !isDisconnected()) {
+				setIsDisconnected(true);
 				report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 			}
 		}
@@ -210,7 +208,7 @@ void CDCACM::readTask() {
 void CDCACM::writeTask() {
 	WriteOperation writeOp;
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		if(!writeQueue.wait_dequeue_timed(writeOp, std::chrono::milliseconds(100)))
 			continue;
 
@@ -233,7 +231,7 @@ void CDCACM::writeTask() {
 				} else if (actualWritten < 0) {
 					if(!fdIsValid()) {
 						if(!isDisconnected()) {
-							disconnected = true;
+							setIsDisconnected(true);
 							report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 						}
 					} else

platform/posix/firmio.cpp

@@ -166,13 +166,13 @@ bool FirmIO::close() {
 		return false;
 	}
 
-	closing = true;
+	setIsClosing(true);
 
 	if(readThread.joinable())
 		readThread.join();
 
-	closing = false;
-	disconnected = false;
+	setIsClosing(false);
+	setIsDisconnected(false);
 
 	int ret = 0;
 	if(vbase != nullptr) {
@@ -202,7 +202,7 @@ void FirmIO::readTask() {
 		std::cerr << "FirmIO::readTask setpriority failed : " << strerror(errno)  << std::endl;
 	}
 
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		fd_set rfds = {0};
 		struct timeval tv = {0};
 		FD_SET(fd, &rfds);
@@ -244,7 +244,7 @@ void FirmIO::readTask() {
 				uint8_t* addr = reinterpret_cast<uint8_t*>(msg.payload.data.addr - PHY_ADDR_BASE + vbase);
 				while (!pushRx(addr, msg.payload.data.len)) {
 					std::this_thread::sleep_for(std::chrono::milliseconds(1)); // back-off so reading thread can empty the buffer
-					if (closing || isDisconnected()) {
+					if (isClosing() || isDisconnected()) {
 						break;
 					}
 				}

platform/posix/ftdi.cpp

@@ -81,7 +81,7 @@ bool FTDI::open() {
 	ftdi.flush();
 
 	// Create threads
-	closing = false;
+	setIsClosing(false);
 	readThread = std::thread(&FTDI::readTask, this);
 	writeThread = std::thread(&FTDI::writeTask, this);
 
@@ -94,7 +94,7 @@ bool FTDI::close() {
 		return false;
 	}
 		
-	closing = true;
+	setIsClosing(true);
 	
 	if(readThread.joinable())
 		readThread.join();
@@ -109,12 +109,10 @@ bool FTDI::close() {
 			report(APIEvent::Type::DriverFailedToClose, APIEvent::Severity::Error);
 	}
 	
-	WriteOperation flushop;
-	readBuffer.clear();
-	while(writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
 
-	closing = false;
-	disconnected = false;
+	setIsClosing(false);
+	setIsDisconnected(false);
 	return ret;
 }
 
@@ -202,12 +200,12 @@ void FTDI::readTask() {
 	constexpr size_t READ_BUFFER_SIZE = 8;
 	uint8_t readbuf[READ_BUFFER_SIZE];
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		auto readBytes = ftdi.read(readbuf, READ_BUFFER_SIZE);
 		if(readBytes < 0) {
 			if(ErrorIsDisconnection(readBytes)) {
 				if(!isDisconnected()) {
-					disconnected = true;
+					setIsDisconnected(true);
 					report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 				}
 			} else
@@ -220,7 +218,7 @@ void FTDI::readTask() {
 void FTDI::writeTask() {
 	WriteOperation writeOp;
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		if(!writeQueue.wait_dequeue_timed(writeOp, std::chrono::milliseconds(100)))
 			continue;
 
@@ -230,7 +228,7 @@ void FTDI::writeTask() {
 			if(writeBytes < 0) {
 				if(ErrorIsDisconnection(writeBytes)) {
 					if(!isDisconnected()) {
-						disconnected = true;
+						setIsDisconnected(true);
 						report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 					}
 					break;

platform/posix/pcap.cpp

@@ -258,28 +258,26 @@ bool PCAP::close() {
 	if(!isOpen())
 		return false;
 
-	closing = true; // Signal the threads that we are closing
+	setIsClosing(true); // Signal the threads that we are closing
 	pcap_breakloop(iface.fp);
 #ifndef __linux__
 	pthread_cancel(readThread.native_handle());
 #endif
 	readThread.join();
 	writeThread.join();
-	closing = false;
+	setIsClosing(false);
 
 	pcap_close(iface.fp);
 	iface.fp = nullptr;
 
-	WriteOperation flushop;
-	readBuffer.clear();
-	while(writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
 
 	return true;
 }
 
 void PCAP::readTask() {
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while (!closing) {
+	while (!isClosing()) {
 		pcap_dispatch(iface.fp, -1, [](uint8_t* obj, const struct pcap_pkthdr* header, const uint8_t* data) {
 			PCAP* driver = reinterpret_cast<PCAP*>(obj);
 			if(driver->ethPacketizer.inputUp({data, data + header->caplen})) {
@@ -294,7 +292,7 @@ void PCAP::writeTask() {
 	WriteOperation writeOp;
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
 
-	while(!closing) {
+	while(!isClosing()) {
 		if(!writeQueue.wait_dequeue_timed(writeOp, std::chrono::milliseconds(100)))
 			continue;
 

platform/tcp.cpp

@@ -511,20 +511,18 @@ bool TCP::close() {
 		return false;
 	}
 
-	closing = true;
-	disconnected = false;
+	setIsClosing(true);
+	setIsDisconnected(false);
 
 	if(readThread.joinable())
 		readThread.join();
 	if(writeThread.joinable())
 		writeThread.join();
 
-	WriteOperation flushop;
-	readBuffer.pop(readBuffer.size());
-	while(writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
 
 	socket.reset();
-	closing = false;
+	setIsClosing(false);
 
 	return true;
 }
@@ -534,7 +532,7 @@ void TCP::readTask() {
 
 	constexpr size_t READ_BUFFER_SIZE = 2048;
 	uint8_t readbuf[READ_BUFFER_SIZE];
-	while(!closing) {
+	while(!isClosing()) {
 		if(const auto received = ::recv(*socket, (char*)readbuf, READ_BUFFER_SIZE, 0); received > 0) {
 			pushRx(readbuf, received);
 		} else {
@@ -547,11 +545,11 @@ void TCP::writeTask() {
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
 
 	WriteOperation writeOp;
-	while(!closing) {
+	while(!isClosing()) {
 		if(!writeQueue.wait_dequeue_timed(writeOp, std::chrono::milliseconds(100)))
 			continue;
 
-		while(!closing) {
+		while(!isClosing()) {
 			if(::send(*socket, (char*)writeOp.bytes.data(), WIN_INT(writeOp.bytes.size()), 0) > 0)
 				break;
 			socket->poll(POLLOUT, 100);

platform/windows/pcap.cpp

@@ -246,18 +246,17 @@ bool PCAP::close() {
 		return false;
 	}
 
-	closing = true; // Signal the threads that we are closing
+	setIsClosing(true); // Signal the threads that we are closing
 	readThread.join();
 	writeThread.join();
 	transmitThread.join();
-	closing = false;
+	setIsClosing(false);
 
 	pcap.close(iface.fp);
 	iface.fp = nullptr;
 
-	WriteOperation flushop;
-	readBuffer.clear();
-	while(writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
+
 	transmitQueue = nullptr;
 
 	return true;
@@ -267,7 +266,7 @@ void PCAP::readTask() {
 	struct pcap_pkthdr* header;
 	const uint8_t* data;
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing) {
+	while(!isClosing()) {
 		auto readBytes = pcap.next_ex(iface.fp, &header, &data);
 		if(readBytes < 0) {
 			report(APIEvent::Type::FailedToRead, APIEvent::Severity::Error);
@@ -291,7 +290,7 @@ void PCAP::writeTask() {
 	pcap_send_queue* queue2 = pcap.sendqueue_alloc(128000);
 	pcap_send_queue* queue = queue1;
 
-	while(!closing) {
+	while(!isClosing()) {
 		// Potentially, we added frames to a second queue faster than the other thread was able to hand the first
 		// off to the kernel. In that case, wait for a minimal amount of time before checking whether we can
 		// transmit it again.
@@ -342,9 +341,9 @@ void PCAP::writeTask() {
 }
 
 void PCAP::transmitTask() {
-	while(!closing) {
+	while(!isClosing()) {
 		std::unique_lock<std::mutex> lk(transmitQueueMutex);
-		if(transmitQueueCV.wait_for(lk, std::chrono::milliseconds(100), [this] { return !!transmitQueue; }) && !closing && transmitQueue) {
+		if(transmitQueueCV.wait_for(lk, std::chrono::milliseconds(100), [this] { return !!transmitQueue; }) && !isClosing() && transmitQueue) {
 			pcap_send_queue* current = transmitQueue;
 			lk.unlock();
 			pcap.sendqueue_transmit(iface.fp, current, 0);

platform/windows/vcp.cpp

@@ -326,12 +326,12 @@ bool VCP::close() {
 		return false;
 	}
 		
-	closing = true; // Signal the threads that we are closing
+	setIsClosing(true); // Signal the threads that we are closing
 	for(auto& t : threads)
 		t->join(); // Wait for the threads to close
 	readThread.join();
 	writeThread.join();
-	closing = false;
+	setIsClosing(false);
 
 	if(!CloseHandle(detail->handle)) {
 		report(APIEvent::Type::DriverFailedToClose, APIEvent::Severity::Error);
@@ -357,9 +357,7 @@ bool VCP::close() {
 		detail->overlappedWait.hEvent = INVALID_HANDLE_VALUE;
 	}
 
-	WriteOperation flushop;
-	readBuffer.clear();
-	while(writeQueue.try_dequeue(flushop)) {}
+	clearBuffers();
 
 	if(!ret)
 		report(APIEvent::Type::DriverFailedToClose, APIEvent::Severity::Error);
@@ -379,7 +377,7 @@ void VCP::readTask() {
 	IOTaskState state = LAUNCH;
 	DWORD bytesRead = 0;
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		switch(state) {
 			case LAUNCH: {
 				COMSTAT comStatus;
@@ -401,7 +399,7 @@ void VCP::readTask() {
 				else if(lastError != ERROR_SUCCESS) {
 					if(lastError == ERROR_ACCESS_DENIED) {
 						if(!isDisconnected()) {
-							disconnected = true;
+							setIsDisconnected(true);
 							report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 						}
 					} else
@@ -432,7 +430,7 @@ void VCP::writeTask() {
 	VCP::WriteOperation writeOp;
 	DWORD bytesWritten = 0;
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-	while(!closing && !isDisconnected()) {
+	while(!isClosing() && !isDisconnected()) {
 		switch(state) {
 			case LAUNCH: {
 				if(!writeQueue.wait_dequeue_timed(writeOp, std::chrono::milliseconds(100)))
@@ -448,7 +446,7 @@ void VCP::writeTask() {
 				}
 				else if(winerr == ERROR_ACCESS_DENIED) {
 					if(!isDisconnected()) {
-						disconnected = true;
+						setIsDisconnected(true);
 						report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 					}
 				} else

pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["scikit-build-core", "pybind11", "setuptools>=64", "setuptools-scm>=8"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "icsneopy"
+dynamic = ["version"]
+requires-python = ">=3.9"
+readme = "README.md"
+authors = [{name = "Intrepid Control Systems, Inc."}]
+maintainers = [
+    {name = "Kyle Schwarz", email="kschwarz@intrepidcs.com"},
+]
+license = {file = "LICENSE"}
+classifiers = [
+    'Development Status :: 5 - Production/Stable',
+    'Intended Audience :: Developers',
+    'Programming Language :: C',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3 :: Only',
+    'Programming Language :: Python :: Implementation :: CPython',
+    'Operating System :: Microsoft :: Windows',
+    'Operating System :: POSIX',
+    'Operating System :: Unix',
+    'Operating System :: MacOS',
+]
+
+[project.urls]
+homepage = "https://github.com/intrepidcs/libicsneo"
+documentation = "https://libicsneo.readthedocs.io"
+source = "https://github.com/intrepidcs/libicsneo"
+tracker = "https://github.com/intrepidcs/libicsneo/issues"
+
+[tool.scikit-build]
+metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
+
+[tool.setuptools_scm]
+version_scheme = "no-guess-dev"
+local_scheme = "no-local-version"
+
+[tool.scikit-build.cmake.define]
+LIBICSNEO_ENABLE_BINDINGS_PYTHON = true
+LIBICSNEO_ENABLE_TCP = true

test/unit/apperrordecodertest.cpp

@@ -0,0 +1,101 @@
+#include "icsneo/icsneocpp.h"
+#include "icsneo/communication/encoder.h"
+#include "icsneo/communication/message/apperrormessage.h"
+#include "icsneo/communication/packetizer.h"
+#include "icsneo/device/tree/neovired2/neovired2.h"
+#include "icsneo/api/eventmanager.h"
+#include "gtest/gtest.h"
+#include <vector>
+#include <iostream>
+
+using namespace icsneo;
+
+class REDAppErrorDecoderTest : public ::testing::Test {
+protected:
+	void SetUp() override {
+		report = [](APIEvent::Type, APIEvent::Severity) {
+			// Unless caught by the test, the packetizer should not throw errors
+			EXPECT_TRUE(false);
+		};
+
+		packetizer.emplace([this](APIEvent::Type t, APIEvent::Severity s) { report(t, s); });
+		packetEncoder.emplace([this](APIEvent::Type t, APIEvent::Severity s) { report(t, s); });
+		packetDecoder.emplace([this](APIEvent::Type t, APIEvent::Severity s) { report(t, s); });
+	}
+
+	device_eventhandler_t report;
+	std::optional<Encoder> packetEncoder;
+	std::optional<Packetizer> packetizer;
+	std::optional<Decoder> packetDecoder;
+	
+	RingBuffer ringBuffer = RingBuffer(128);
+
+	std::vector<uint8_t> testErrorData =
+	{0xaa, 0x0c,
+	 0x12, 0x00, //size
+	 0x34, 0x00, //netID
+	 0x0b, 0x00, //error_type
+	 0x01, 0x00, //network_id
+	 0x33, 0x44, 0x55, 0x66, //uiTime10us
+	 0x77, 0x88, 0x99, 0xAA, //uiTime10usMSB
+	};
+};
+
+TEST_F(REDAppErrorDecoderTest, PacketDecoderTest) {
+	std::shared_ptr<icsneo::Message> decodeMsg;
+
+	auto msg1 = std::make_shared<icsneo::AppErrorMessage>();
+	msg1->errorType = static_cast<uint16_t>(AppErrorType::AppErrorNetworkNotEnabled);
+	msg1->errorNetID = Network::NetID::HSCAN;
+	msg1->timestamp10us = 0x66554433;
+	msg1->timestamp10usMSB = 0xAA998877;
+	msg1->network = icsneo::Network::NetID::RED_App_Error;
+
+	ringBuffer.clear();
+	ringBuffer.write(testErrorData);
+
+	EXPECT_TRUE(packetizer->input(ringBuffer));
+	auto packets = packetizer->output();
+
+	EXPECT_TRUE(packetDecoder->decode(decodeMsg, packets.back()));
+	EXPECT_NE(decodeMsg, nullptr);
+	auto testMessage = std::dynamic_pointer_cast<icsneo::AppErrorMessage>(decodeMsg);
+	EXPECT_EQ(msg1->network, testMessage->network);
+	EXPECT_EQ(msg1->errorType, testMessage->errorType);
+	EXPECT_EQ(msg1->errorNetID, testMessage->errorNetID);
+	EXPECT_EQ(msg1->timestamp10us, testMessage->timestamp10us);
+	EXPECT_EQ(msg1->timestamp10usMSB, testMessage->timestamp10usMSB);
+	packets.pop_back();
+}
+
+TEST_F(REDAppErrorDecoderTest, GetErrorStringTest) {
+	std::shared_ptr<icsneo::Message> decodeMsg;
+
+	ringBuffer.clear();
+	ringBuffer.write(testErrorData);
+
+	EXPECT_TRUE(packetizer->input(ringBuffer));
+	auto packets = packetizer->output();
+
+	EXPECT_TRUE(packetDecoder->decode(decodeMsg, packets.back()));
+	EXPECT_NE(decodeMsg, nullptr);
+	auto testMessage = std::dynamic_pointer_cast<icsneo::AppErrorMessage>(decodeMsg);
+	EXPECT_EQ("HSCAN: Network not enabled", testMessage->getAppErrorString());
+	packets.pop_back();
+}
+
+TEST_F(REDAppErrorDecoderTest, GetTypeTest) {
+	std::shared_ptr<icsneo::Message> decodeMsg;
+
+	ringBuffer.clear();
+	ringBuffer.write(testErrorData);
+
+	EXPECT_TRUE(packetizer->input(ringBuffer));
+	auto packets = packetizer->output();
+
+	EXPECT_TRUE(packetDecoder->decode(decodeMsg, packets.back()));
+	EXPECT_NE(decodeMsg, nullptr);
+	auto testMessage = std::dynamic_pointer_cast<icsneo::AppErrorMessage>(decodeMsg);
+	EXPECT_EQ(AppErrorType::AppErrorNetworkNotEnabled, testMessage->getAppErrorType());
+	packets.pop_back();
+}