Merge 0c9f1c5f3e into d42c51d772

On macOS 12 and later, Apple replaced IOUSBDevice with IOUSBHostDevice
in the USB host stack. When walking the IORegistry parent chain to find
the USB device providing a serial port, the existing code only checked
IOObjectConformsTo(parent, kIOUSBDeviceClassName). On macOS 12+, this
check fails because the USB device node conforms to IOUSBHostDevice
instead.

Fix by also checking IOObjectConformsTo(parent, "IOUSBHostDevice"),
so CDCACM device discovery works on both old and new macOS.

Verified on macOS 26 (Tahoe, arm64) with a ValueCAN 4-2 (V2D805).

.gitlab-ci.yml

@@ -1,6 +1,3 @@
-default:
-  interruptible: true
-
 variables:
   DEBIAN_FRONTEND: noninteractive
   LIBICSNEO_ICSPB_REPO: https://gitlab-ci-token:${CI_JOB_TOKEN}@${LIBICSNEO_ICSPB_GIT}
@@ -38,6 +35,30 @@ unit_test windows/x64:
     - libicsneo-win-x64
   timeout: 5m
 
+build windows/x86:
+  stage: build
+  script:
+    - cmd /C ci\build-windows32.bat
+  artifacts:
+    when: always
+    paths:
+      - build
+    expire_in: 3 days
+  tags:
+    - libicsneo-win-x64
+
+unit_test windows/x86:
+  stage: unit_test
+  script:
+    - build\libicsneo-unit-tests.exe
+  dependencies:
+    - build windows/x86
+  needs:
+    - build windows/x86
+  tags:
+    - libicsneo-win-x64
+  timeout: 5m
+
 #-------------------------------------------------------------------------------
 # Ubuntu
 #-------------------------------------------------------------------------------
@@ -338,7 +359,6 @@ build python/windows:
 
 deploy python/pypi:
   stage: deploy
-  interruptible: false
   variables:
     TWINE_USERNAME: __token__
     TWINE_PASSWORD: $PYPI_TOKEN
@@ -363,7 +383,6 @@ deploy python/pypi:
 
 push github:
   stage: deploy
-  interruptible: false
   tags:
     - linux-build
   image: alpine:latest

CMakeLists.txt

@@ -82,7 +82,7 @@ if(MSVC)
 	add_definitions(-D_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING)
 	add_definitions(-D_ITERATOR_DEBUG_LEVEL=0)
 else() #if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-	set(LIBICSNEO_COMPILER_WARNINGS -Wall -Wno-unknown-pragmas)
+	set(LIBICSNEO_COMPILER_WARNINGS -Wall -Wno-switch -Wno-unknown-pragmas)
 endif()
 
 find_package(Threads REQUIRED)
@@ -234,14 +234,7 @@ set(SRC_FILES
 	communication/message/ethernetstatusmessage.cpp
 	communication/message/networkmutexmessage.cpp
 	communication/message/clientidmessage.cpp
-	communication/message/mfgconfigmessage.cpp
 	communication/message/transmitmessage.cpp
-
-
-	communication/message/spiportkeymessage.cpp
-	communication/message/genericapidatamessage.cpp
-	communication/message/genericapistatusmessage.cpp
-	communication/message/iso15765message.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp
@@ -352,7 +345,6 @@ add_library(icsneocpp
 	api/icsneocpp/icsneocpp.cpp
 	api/icsneocpp/event.cpp
 	api/icsneocpp/eventmanager.cpp
-	api/icsneocpp/heartbeat.cpp
 	api/icsneocpp/version.cpp
 	${SRC_FILES}
 )

README.md

@@ -45,7 +45,6 @@ Instructions for installing each API can be found in its respective documentatio
 - RAD-Pluto
 - RAD-Star 2
 - RAD-SuperMoon
-- RAD-wBMS
 - ValueCAN 3
 - ValueCAN 4
 

api/icsneoc2/icsneoc2.cpp

@@ -5,7 +5,6 @@
 #include "icsneo/device/devicefinder.h"
 #include "icsneo/icsneocpp.h"
 #include "icsneo/communication/io.h"
-#include "icsneo/communication/network.h"
 
 #include <string>
 #include <vector>
@@ -13,7 +12,6 @@
 #include <map>
 #include <algorithm>
 #include <optional>
-#include <chrono>
 #include <sstream>
 #include <fstream>
 #include <cstring>
@@ -72,7 +70,6 @@ icsneoc2_error_t icsneoc2_error_code_get(icsneoc2_error_t error_code, char* valu
 		"Close failed",                     // icsneoc2_error_close_failed
 		"Reconnect failed",                 // icsneoc2_error_reconnect_failed
 		"Invalid data",                     // icsneoc2_error_invalid_data
-		"Force disk config update failed",  // icsneoc2_error_force_disk_config_update_failed
 	};
 	static_assert(std::size(error_strings) == icsneoc2_error_maxsize,
 		"error_strings is out of sync with _icsneoc2_error_t enum - update both together");
@@ -273,9 +270,7 @@ static icsneoc2_error_t open_device_with_options(std::shared_ptr<Device> dev, ic
 	if(!dev) {
 		return icsneoc2_error_invalid_device;
 	}
-	MessageFilter filter;
-	filter.includeInternalInAny = true;
-	if(!dev->enableMessagePolling(std::make_optional(filter))) {
+	if(!dev->enableMessagePolling(std::make_optional<MessageFilter>())) {
 		return icsneoc2_error_enable_message_polling_failed;
 	}
 	if(!dev->isOpen() && !dev->open()) {
@@ -443,16 +438,6 @@ icsneoc2_error_t icsneoc2_device_serial_get(const icsneoc2_device_t* device, cha
 	return safe_str_copy(value, value_length, dev->getSerial()) ? icsneoc2_error_success : icsneoc2_error_string_copy_failed;
 }
 
-icsneoc2_error_t icsneoc2_device_product_name_get(const icsneoc2_device_t* device, char* value, size_t* value_length) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	auto dev = device->device;
-	// Copy the string into value
-	return safe_str_copy(value, value_length, dev->getProductName()) ? icsneoc2_error_success : icsneoc2_error_string_copy_failed;
-}
-
 icsneoc2_error_t icsneoc2_device_pcb_serial_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length) {
 	auto res = icsneoc2_device_is_valid(device);
 	if(res != icsneoc2_error_success) {
@@ -466,13 +451,11 @@ icsneoc2_error_t icsneoc2_device_pcb_serial_get(const icsneoc2_device_t* device,
 		return icsneoc2_error_invalid_type;
 	}
 	const auto& data = *pcbSerial;
-	if(!value) {
-		*value_length = data.size();
-		return icsneoc2_error_success;
+	if(value) {
+		size_t copyLen = std::min(*value_length, data.size());
+		std::copy(data.begin(), data.begin() + copyLen, value);
 	}
-	size_t copyLen = std::min(*value_length, data.size());
-	std::copy(data.begin(), data.begin() + copyLen, value);
-	*value_length = copyLen;
+	*value_length = data.size();
 	return icsneoc2_error_success;
 }
 
@@ -506,32 +489,26 @@ icsneoc2_error_t icsneoc2_device_mac_addresses_enumerate(const icsneoc2_device_t
 		}
 		tail = node;
 	}
-	*mac_entries = head;
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_mac_network_id_get(const icsneoc2_mac_addr_entry_t* mac_address, icsneoc2_netid_t* network_id) {
+icsneoc2_error_t icsneoc2_mac_network_id_get(const icsneoc2_mac_addr_entry_t* mac_address, _icsneoc2_netid_t* network_id) {
 	if(!mac_address || !network_id) {
 		return icsneoc2_error_invalid_parameters;
 	}
-	const auto netid = static_cast<Network::NetID>(mac_address->network_id);
-	*network_id = Network::GetCoreMiniNetworkFromNetID(netid).has_value()
-		? mac_address->network_id
-		: static_cast<icsneoc2_netid_t>(icsneoc2_netid_invalid);
+	*network_id = static_cast<_icsneoc2_netid_t>(mac_address->network_id);
 	return icsneoc2_error_success;
 }
 
 icsneoc2_error_t icsneoc2_mac_address_get(const icsneoc2_mac_addr_entry_t* mac_address, uint8_t* value, size_t* value_length) {
-	if(!mac_address || !value_length) {
+	if(!mac_address || !value || !value_length) {
 		return icsneoc2_error_invalid_parameters;
 	}
-	if(!value) {
-		*value_length = static_cast<size_t>(ICSNEO_MAC_ADDRESS_LEN);
-		return icsneoc2_error_success;
+	if(value) {
+		size_t copyLen = std::min(*value_length, static_cast<size_t>(ICSNEO_MAC_ADDRESS_LEN));
+		std::copy(mac_address->address, mac_address->address + copyLen, value);
 	}
-	size_t copyLen = std::min(*value_length, static_cast<size_t>(ICSNEO_MAC_ADDRESS_LEN));
-	std::copy(mac_address->address, mac_address->address + copyLen, value);
-	*value_length = copyLen;
+	*value_length = static_cast<size_t>(ICSNEO_MAC_ADDRESS_LEN);
 	return icsneoc2_error_success;
 }
 
@@ -810,67 +787,6 @@ icsneoc2_error_t icsneoc2_device_tc10_status_get(const icsneoc2_device_t* device
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_device_supports_gptp(const icsneoc2_device_t* device, bool* supported) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!supported) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*supported = device->device->supportsGPTP();
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_device_gptp_status_get(const icsneoc2_device_t* device, uint32_t timeout_ms, icsneoc2_gptp_status_t* status) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!status) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto cpp_status = device->device->getGPTPStatus(std::chrono::milliseconds(timeout_ms));
-	if(!cpp_status.has_value()) {
-		return icsneoc2_error_get_settings_failure;
-	}
-	status->current_time_seconds     = cpp_status->currentTime.seconds;
-	status->current_time_nanoseconds = cpp_status->currentTime.nanoseconds;
-	status->ms_offset_ns             = cpp_status->msOffsetNs;
-	status->is_sync                  = cpp_status->isSync;
-	status->link_status              = cpp_status->linkStatus;
-	status->link_delay_ns            = cpp_status->linkDelayNS;
-	status->selected_role            = cpp_status->selectedRole;
-	status->as_capable               = cpp_status->asCapable;
-	status->is_syntonized            = cpp_status->isSyntonized;
-	status->short_format             = cpp_status->shortFormat;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_device_supports_reboot(const icsneoc2_device_t* device, bool* supported) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!supported) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*supported = device->device->supportsReboot();
-
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_device_reboot(const icsneoc2_device_t* device, bool safe) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!device->device->reboot(safe)) {
-		return icsneoc2_error_transmit_message_failed;
-	}
-	return icsneoc2_error_success;
-}
-
 icsneoc2_error_t icsneoc2_device_digital_io_get(const icsneoc2_device_t* device, icsneoc2_io_type_t type, uint32_t number, bool* value) {
 	auto res = icsneoc2_device_is_valid(device);
 	if(res != icsneoc2_error_success) {
@@ -1107,21 +1023,6 @@ icsneoc2_error_t icsneoc2_device_format_disk(const icsneoc2_device_t* device, ic
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_device_force_disk_config_update(const icsneoc2_device_t* device, icsneoc2_disk_details_t* disk_details) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!disk_details || !disk_details->details) {
-		return icsneoc2_error_invalid_parameters;
-	}
-
-	if(!device->device->forceDiskConfigUpdate(*disk_details->details)) {
-		return icsneoc2_error_force_disk_config_update_failed;
-	}
-	return icsneoc2_error_success;
-}
-
 static icsneoc2_error_t get_supported_networks(const icsneoc2_device_t* device, const std::vector<Network>& nets, icsneoc2_netid_t* networks, size_t* count) {
 	auto res = icsneoc2_device_is_valid(device);
 	if(res != icsneoc2_error_success) {

api/icsneoc2/icsneoc2_internal.h

@@ -48,11 +48,6 @@ typedef struct icsneoc2_chip_versions_t {
 	icsneoc2_chip_versions_t* next;
 } icsneoc2_chip_versions_t;
 
-typedef struct icsneoc2_termination_group_t {
-	std::vector<icsneoc2_netid_t> netids;
-	icsneoc2_termination_group_t* next;
-} icsneoc2_termination_group_t;
-
 typedef struct icsneoc2_mac_addr_entry_t {
 	uint16_t network_id;
 	uint8_t address[ICSNEO_MAC_ADDRESS_LEN];

api/icsneoc2/icsneoc2messages.cpp

@@ -7,10 +7,8 @@
 #include "icsneo/communication/message/message.h"
 #include "icsneo/communication/message/canmessage.h"
 #include "icsneo/communication/message/canerrormessage.h"
-#include "icsneo/communication/message/apperrormessage.h"
 #include "icsneo/communication/message/linmessage.h"
 #include "icsneo/communication/message/ethernetmessage.h"
-#include "icsneo/communication/message/ethernetstatusmessage.h"
 #include "icsneo/communication/packet/canpacket.h"
 
 icsneoc2_error_t icsneoc2_message_is_valid(icsneoc2_message_t* message, bool* is_valid) {
@@ -318,44 +316,6 @@ icsneoc2_error_t icsneoc2_message_can_error_props_get(
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_message_is_app_error(icsneoc2_message_t* message, bool* is_app_error) {
-	if(!message || !is_app_error) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_app_error = std::dynamic_pointer_cast<AppErrorMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_app_error_props_get(icsneoc2_message_t* message,
-    icsneoc2_app_error_type_t* error_type, icsneoc2_netid_t* error_netid) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto app_err = std::dynamic_pointer_cast<AppErrorMessage>(message->message);
-	if(!app_err) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(error_type) {
-		*error_type = static_cast<icsneoc2_app_error_type_t>(app_err->getAppErrorType());
-	}
-	if(error_netid) {
-		*error_netid = static_cast<icsneoc2_netid_t>(app_err->errorNetID);
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_app_error_string_get(icsneoc2_message_t* message,
-    char* value, size_t* value_length) {
-	if(!message || !value_length) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto app_err = std::dynamic_pointer_cast<AppErrorMessage>(message->message);
-	if(!app_err) {
-		return icsneoc2_error_invalid_type;
-	}
-	return safe_str_copy(value, value_length, app_err->getAppErrorString()) ? icsneoc2_error_success : icsneoc2_error_string_copy_failed;
-}
-
 icsneoc2_error_t icsneoc2_message_is_lin(icsneoc2_message_t* message, bool* is_lin) {
 	if(!message || !is_lin) {
 		return icsneoc2_error_invalid_parameters;
@@ -471,7 +431,6 @@ icsneoc2_error_t icsneoc2_message_lin_status_flags_get(const icsneoc2_message_t*
 	if(lin_msg->statusFlags.HasUpdatedResponderOnce) *status_flags |= ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE;
 	if(lin_msg->statusFlags.BusRecovered) *status_flags |= ICSNEOC2_LIN_STATUS_BUS_RECOVERED;
 	if(lin_msg->statusFlags.BreakOnly) *status_flags |= ICSNEOC2_LIN_STATUS_BREAK_ONLY;
-	if(lin_msg->statusFlags.WakeupRequest) *status_flags |= ICSNEOC2_LIN_STATUS_WAKEUP_REQUEST;
 	return icsneoc2_error_success;
 }
 
@@ -672,40 +631,9 @@ icsneoc2_error_t icsneoc2_message_eth_t1s_props_get(icsneoc2_message_t* message,
 }
 
 icsneoc2_error_t icsneoc2_message_is_ethernet(icsneoc2_message_t* message, bool* is_ethernet) {
-	if(!message || !is_ethernet) {
+	if(!message) {
 		return icsneoc2_error_invalid_parameters;
 	}
 	*is_ethernet = std::dynamic_pointer_cast<EthernetMessage>(message->message) != nullptr;
 	return icsneoc2_error_success;
 }
-
-icsneoc2_error_t icsneoc2_message_is_ethernet_status(icsneoc2_message_t* message, bool* is_ethernet_status) {
-	if(!message || !is_ethernet_status) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	*is_ethernet_status = std::dynamic_pointer_cast<EthernetStatusMessage>(message->message) != nullptr;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_message_eth_status_props_get(icsneoc2_message_t* message, bool* link_state, bool* duplex, icsneoc2_link_speed_t* link_speed, icsneoc2_link_mode_t* link_mode) {
-	if(!message) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	auto msg = std::dynamic_pointer_cast<EthernetStatusMessage>(message->message);
-	if(!msg) {
-		return icsneoc2_error_invalid_type;
-	}
-	if(link_state) {
-		*link_state = msg->state;
-	}
-	if(duplex) {
-		*duplex = msg->duplex;
-	}
-	if(link_speed) {
-		*link_speed = static_cast<icsneoc2_link_speed_t>(msg->speed);
-	}
-	if(link_mode) {
-		*link_mode = static_cast<icsneoc2_link_mode_t>(msg->mode);
-	}
-	return icsneoc2_error_success;
-}

api/icsneoc2/icsneoc2settings.cpp

@@ -179,82 +179,6 @@ icsneoc2_error_t icsneoc2_settings_termination_set(icsneoc2_device_t* device, ic
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_settings_termination_groups_enumerate(icsneoc2_device_t* device, icsneoc2_termination_group_t** groups, size_t* count) {
-	// Make sure the device is valid
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!groups) {
-		return icsneoc2_error_invalid_parameters;
-	}
-
-	auto termination_groups = device->device->settings->getTerminationGroups();
-
-	icsneoc2_termination_group_t* head = nullptr;
-	icsneoc2_termination_group_t* tail = nullptr;
-	for(const auto& group : termination_groups) {
-		auto* node = new (std::nothrow) icsneoc2_termination_group_t;
-		if(!node) {
-			icsneoc2_settings_termination_groups_free(head);
-			return icsneoc2_error_out_of_memory;
-		}
-		node->netids.reserve(group.size());
-		for(const auto& network : group) {
-			node->netids.push_back(static_cast<icsneoc2_netid_t>(network.getNetID()));
-		}
-		node->next = nullptr;
-		if(!head) {
-			head = node;
-		} else {
-			tail->next = node;
-		}
-		tail = node;
-	}
-
-	*groups = head;
-	if(count) {
-		*count = termination_groups.size();
-	}
-	return icsneoc2_error_success;
-}
-
-icsneoc2_termination_group_t* icsneoc2_termination_group_next(const icsneoc2_termination_group_t* group) {
-	if(!group) {
-		return nullptr;
-	}
-	return group->next;
-}
-
-icsneoc2_error_t icsneoc2_termination_group_networks_get(const icsneoc2_termination_group_t* group, icsneoc2_netid_t* networks, size_t* count) {
-	if(!group || !count) {
-		return icsneoc2_error_invalid_parameters;
-	}
-	if(!networks) {
-		*count = group->netids.size();
-		return icsneoc2_error_success;
-	}
-	size_t to_copy = std::min<size_t>(*count, group->netids.size());
-	for(size_t i = 0; i < to_copy; i++) {
-		networks[i] = group->netids[i];
-	}
-	*count = to_copy;
-	return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_termination_groups_free(icsneoc2_termination_group_t* groups) {
-	if(!groups) {
-		return icsneoc2_error_invalid_parameters;
-	}
-
-	while(groups) {
-		auto* next = groups->next;
-		delete groups;
-		groups = next;
-	}
-	return icsneoc2_error_success;
-}
-
 icsneoc2_error_t icsneoc2_settings_commander_resistor_enabled(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* enabled) {
     // Make sure the device is valid
     auto res = icsneoc2_device_is_valid(device);
@@ -943,120 +867,6 @@ icsneoc2_error_t icsneoc2_settings_misc_io_analog_output_set(icsneoc2_device_t*
     return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_settings_linux_boot_enabled_get(icsneoc2_device_t* device, bool* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getLinuxBootEnabled(); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_linux_boot_enabled_set(icsneoc2_device_t* device, bool value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setLinuxBootEnabled(value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_external_wifi_antenna_enabled_get(icsneoc2_device_t* device, bool* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getExternalWifiAntennaEnabled(); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_external_wifi_antenna_enabled_set(icsneoc2_device_t* device, bool value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setExternalWifiAntennaEnabled(value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_perf_test_enabled_get(icsneoc2_device_t* device, bool* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->isPerfTestEnabled(); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    } else {
-        *value = false;
-        return icsneoc2_error_get_settings_failure;
-    }
-}
-
-icsneoc2_error_t icsneoc2_settings_perf_test_enabled_set(icsneoc2_device_t* device, bool value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setPerfTestEnable(value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_linux_configuration_port_get(icsneoc2_device_t* device, icsneoc2_linux_configuration_port_t* value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getLinuxConfigurationPort(); result.has_value()) {
-        *value = static_cast<icsneoc2_linux_configuration_port_t>(result.value());
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_linux_configuration_port_set(icsneoc2_device_t* device, icsneoc2_linux_configuration_port_t value) {
-    // Make sure the device is valid
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setLinuxConfigurationPort(static_cast<LinuxConfigurationPort>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
 icsneoc2_error_t icsneoc2_settings_disabled_get(icsneoc2_device_t* device, bool* value) {
     if(!value) {
         return icsneoc2_error_invalid_parameters;
@@ -1082,113 +892,3 @@ icsneoc2_error_t icsneoc2_settings_readonly_get(icsneoc2_device_t* device, bool*
     *value = device->device->settings->readonly;
     return icsneoc2_error_success;
 }
-
-icsneoc2_error_t icsneoc2_settings_gptp_profile_get(icsneoc2_device_t* device, icsneoc2_gptp_profile_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getGPTPProfile(); result.has_value()) {
-        *value = static_cast<icsneoc2_gptp_profile_t>(result.value());
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_profile_set(icsneoc2_device_t* device, icsneoc2_gptp_profile_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(value >= icsneoc2_gptp_profile_maxsize) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(!device->device->settings->setGPTPProfile(static_cast<RADGPTPProfile>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_role_get(icsneoc2_device_t* device, icsneoc2_gptp_role_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getGPTPRole(); result.has_value()) {
-        *value = static_cast<icsneoc2_gptp_role_t>(result.value());
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_role_set(icsneoc2_device_t* device, icsneoc2_gptp_role_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(value >= icsneoc2_gptp_role_maxsize) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(!device->device->settings->setGPTPRole(static_cast<RADGPTPRole>(value))) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_enabled_port_get(icsneoc2_device_t* device, uint8_t* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->getGPTPEnabledPort(); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_enabled_port_set(icsneoc2_device_t* device, uint8_t value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setGPTPEnabledPort(value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_clock_syntonization_enabled_get(icsneoc2_device_t* device, bool* value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!value) {
-        return icsneoc2_error_invalid_parameters;
-    }
-    if(auto result = device->device->settings->isGPTPClockSyntonizationEnabled(); result.has_value()) {
-        *value = result.value();
-        return icsneoc2_error_success;
-    }
-    return icsneoc2_error_get_settings_failure;
-}
-
-icsneoc2_error_t icsneoc2_settings_gptp_clock_syntonization_enabled_set(icsneoc2_device_t* device, bool value) {
-    auto res = icsneoc2_device_is_valid(device);
-    if(res != icsneoc2_error_success) {
-        return res;
-    }
-    if(!device->device->settings->setGPTPClockSyntonizationEnabled(value)) {
-        return icsneoc2_error_set_settings_failure;
-    }
-    return icsneoc2_error_success;
-}

api/icsneocpp/event.cpp

@@ -4,10 +4,10 @@
 
 using namespace icsneo;
 
-APIEvent::APIEvent(Type type, APIEvent::Severity severity, std::weak_ptr<Device> device) : eventStruct({}), device(device) {
-	auto shared = device.lock();
-	if(shared) {
-		serial = shared->getSerial();
+APIEvent::APIEvent(Type type, APIEvent::Severity severity, const Device* device) : eventStruct({}) {
+	this->device = device;
+	if(device) {
+		serial = device->getSerial();
 		eventStruct.serial[serial.copy(eventStruct.serial, sizeof(eventStruct.serial))] = '\0';
 	}
 
@@ -27,10 +27,9 @@ void APIEvent::downgradeFromError() noexcept {
 }
 
 bool APIEvent::isForDevice(std::string filterSerial) const noexcept {
-	auto shared = device.lock();
-	if(!shared || filterSerial.length() == 0)
+	if(!device || filterSerial.length() == 0)
 		return false;
-	return shared->getSerial() == filterSerial;
+	return device->getSerial() == filterSerial;
 }
 
 // API Errors
@@ -462,17 +461,14 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return TOO_MANY_EVENTS;
 		case Type::Unknown:
 			return UNKNOWN;
-		case Type::Any:
-			break;
 	}
 	return INVALID;
 }
 
 std::string APIEvent::describe() const noexcept {
 	std::stringstream ss;
-	auto shared = device.lock();
-	if(shared)
-		ss << *shared; // Makes use of device.describe()
+	if(device)
+		ss << *device; // Makes use of device.describe()
 	else
 		ss << "API";
 

api/icsneocpp/heartbeat.cpp

@@ -1,60 +0,0 @@
-#include "icsneo/api/heartbeat.h"
-#include "icsneo/api/lifetime.h"
-#include "icsneo/device/device.h"
-
-using namespace icsneo;
-
-Heartbeat::Heartbeat(Device& device) :
-	device(device), mode(device.isOnline() ? Mode::Passive : Mode::Active), thread(&Heartbeat::run, this) {
-}
-
-Heartbeat::~Heartbeat() {
-	{
-		std::lock_guard lk(mutex);
-		stop = true;
-	}
-	cv.notify_one();
-	thread.join();
-}
-
-void Heartbeat::run() {
-	EventManager::GetInstance().downgradeErrorsOnCurrentThread();
-
-	auto filter = std::make_shared<MessageFilter>();
-	filter->includeInternalInAny = true;
-	bool status = false;
-	auto cbHandle = device.com->addMessageCallback(std::make_shared<MessageCallback>(filter, [&](std::shared_ptr<Message> msg) {
-		// TODO: remove DeviceStatus after 2027-08-17, as ResetStatus should be widely supported
-		const bool isHeartbeat =
-			(msg->type == Message::Type::ResetStatus) ||
-			(msg->type == Message::Type::RawMessage && std::static_pointer_cast<RawMessage>(msg)->network == Network::NetID::DeviceStatus);
-		if(!isHeartbeat)
-			return;
-		{
-			std::lock_guard lk(mutex);
-			status = true;
-		}
-		cv.notify_one();
-	}));
-	Lifetime cbLifetime([&] {
-		device.com->removeMessageCallback(cbHandle);
-	});
-	while(true) {
-		std::unique_lock lk(mutex);
-		if(mode == Mode::Active) {
-			if(cv.wait_for(lk, std::chrono::milliseconds(100), [&] { return stop; })) {
-				break;
-			}
-			device.com->sendCommand(Command::RequestStatusUpdate);
-		}
-		if(!cv.wait_for(lk, std::chrono::seconds(2), [&] { return status || stop; })) {
-			// we disconnect instead of close because it indicates to the user that a cleanup is still required (our thread join)
-			device.report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
-			device.com->driver->setIsDisconnected(true);
-			break;
-		}
-		if(stop)
-			break;
-		status = false;
-	}
-}

api/icsneolegacy/dllhelper/icsneo40DLLAPI.h

@@ -5,13 +5,6 @@
 #include <windows.h>
 #include "icsneo/icsnVC40.h"
 
-// Vehicle Spy 3.26.3.9 removed these legacy settings structure definitions from
-// icsnVC40.h. The corresponding functions only ever treat them as opaque
-// buffers, so forward declarations keep the existing API/ABI intact.
-typedef struct _SFireSettings SFireSettings;
-typedef struct _SVCAN3Settings SVCAN3Settings;
-typedef struct _SVCANRFSettings SVCANRFSettings;
-
 
 
 bool LoadDLLAPI(HINSTANCE &hAPIDLL);

api/icsneolegacy/icsneolegacy.cpp

@@ -545,13 +545,15 @@ int LegacyDLLExport icsneoGetTimeStampForMsg(void* hObject, icsSpyMessage* pMsg,
 void LegacyDLLExport icsneoGetISO15765Status(void* hObject, int lNetwork, int lClearTxStatus, int lClearRxStatus,
 	int* lTxStatus, int* lRxStatus)
 {
-	// Not supported
+	// TODO Implement
+	return;
 }
 
 void LegacyDLLExport icsneoSetISO15765RxParameters(void* hObject, int lNetwork, int lEnable, spyFilterLong* pFF_CFMsgFilter,
 	icsSpyMessage* pTxMsg, int lCFTimeOutMs, int lFlowCBlockSize, int lUsesExtendedAddressing, int lUseHardwareIfPresent)
 {
-	// Not supported
+	// TODO Implement
+	return;
 }
 
 int LegacyDLLExport icsneoGetRTC(void* hObject, icsSpyTime* time)
@@ -833,25 +835,26 @@ int LegacyDLLExport icsneoGetErrorInfo(int lErrorNumber, char* szErrorDescriptio
 //ISO15765-2 Functions
 int LegacyDLLExport icsneoISO15765_EnableNetworks(void* hObject, unsigned long ulNetworks)
 {
-	// Not supported
+	// TODO Implement
 	return false;
 }
 
 int LegacyDLLExport icsneoISO15765_DisableNetworks(void* hObject)
 {
-	// Not supported
+	// TODO Implement
 	return false;
 }
 
-int LegacyDLLExport icsneoISO15765_TransmitMessage(void* hObject, unsigned long ulNetworkID, stCM_ISO157652_TxMessage* pMsg, unsigned long ulBlockingTimeout)
+int LegacyDLLExport icsneoISO15765_TransmitMessage(void* hObject, unsigned long ulNetworkID, stCM_ISO157652_TxMessage* pMsg,
+	unsigned long ulBlockingTimeout)
 {
-	// Not supported
+	// TODO Implement
 	return false;
 }
 
 int LegacyDLLExport icsneoISO15765_ReceiveMessage(void* hObject, int ulNetworkID, stCM_ISO157652_RxMessage* pMsg)
 {
-	// Not supported
+	// TODO Implement
 	return false;
 }
 
@@ -1032,10 +1035,10 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_ION:
 		*pDeviceSettingsType = DeviceFire2SettingsType; //defaults to FIRE2 vnets with libicsneo - no firevnets!
 		break;
-	case NEODEVICE_VCAN3_DEPRECATED:
-		*pDeviceSettingsType = DeviceVCAN3SettingsTypeDeprecated;
+	case NEODEVICE_VCAN3:
+		*pDeviceSettingsType = DeviceVCAN3SettingsType;
 		break;
-	case NEODEVICE_FIRE_DEPRECATED:
+	case NEODEVICE_FIRE:
 		*pDeviceSettingsType = DeviceFireSettingsType;
 		break;
 	case NEODEVICE_FIRE2:
@@ -1058,17 +1061,17 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_VIVIDCAN:
 		*pDeviceSettingsType = DeviceVividCANSettingsType;
 		break;
-	case NEODEVICE_ECU_AVB_DEPRECATED:
-		*pDeviceSettingsType = DeviceECU_AVBSettingsTypeDeprecated;
+	case NEODEVICE_ECU_AVB:
+		*pDeviceSettingsType = DeviceECU_AVBSettingsType;
 		break;
-	case NEODEVICE_RADSUPERMOON_DEPRECATED:
-		*pDeviceSettingsType = DeviceRADSuperMoonSettingsTypeDeprecated;
+	case NEODEVICE_RADSUPERMOON:
+		*pDeviceSettingsType = DeviceRADSuperMoonSettingsType;
 		break;
 	case NEODEVICE_RADMOON2:
 		*pDeviceSettingsType = DeviceRADMoon2SettingsType;
 		break;
-	case NEODEVICE_RADGIGALOG_DEPRECATED:
-		*pDeviceSettingsType = DeviceRADGigalogSettingsTypeDeprecated;
+	case NEODEVICE_RADGIGALOG:
+		*pDeviceSettingsType = DeviceRADGigalogSettingsType;
 		break;
 	case NEODEVICE_RADMOON3:
 		*pDeviceSettingsType = DeviceRADMoon3SettingsType;
@@ -1085,8 +1088,6 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_FIRE3_FLEXRAY:
 		*pDeviceSettingsType = DeviceFire3FlexraySettingsType;
 		break;
-	case NEODEVICE_RAD_BMS:
-		*pDeviceSettingsType = DeviceRADBMSSettingsType;
 	default:
 		return 0;
 	}
@@ -1282,11 +1283,10 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		return false;
 
 	neodevice_t* device = reinterpret_cast<neodevice_t*>(hObject);
-    const auto& cmd = static_cast<icsneo::J2534Command>(*CmdBuf);
 
-	switch (cmd)
+	switch (*CmdBuf)
 	{
-	case icsneo::J2534Command::SetNetworkBaudRate:
+	case J2534NVCMD_SetNetworkBaudRate:
 
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1296,7 +1296,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 			iRetVal = 0;
 		break;
 
-	case icsneo::J2534Command::GetNetworkBaudRate:
+	case J2534NVCMD_GetNetworkBaudRate:
 	{
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1309,7 +1309,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		*pTmp = static_cast<uint64_t>(ret);
 		break;
 	}
-	case icsneo::J2534Command::SetCANFDRate:
+	case J2534NVCMD_SetCANFDRate:
 
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1320,7 +1320,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 			iRetVal = 0;
 		break;
 
-	case icsneo::J2534Command::GetCANFDRate:
+	case J2534NVCMD_GetCANFDRate:
 
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1330,7 +1330,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		*pTmp = icsneo_getFDBaudrate(device, NetworkID);
 		break;
 
-	case icsneo::J2534Command::GetCANFDTermination:
+	case J2534NVCMD_GetCANFDTermination:
 
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1366,7 +1366,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		}
 		break;
 
-	case icsneo::J2534Command::SetCANFDTermination:
+	case J2534NVCMD_SetCANFDTermination:
 
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1420,9 +1420,11 @@ int LegacyDLLExport icsneoEnableBusVoltageMonitor(void* hObject, unsigned int en
 	return false;
 }
 
-int LegacyDLLExport icsneoISO15765_TransmitMessageEx(void* hObject, unsigned long ulNetworkID, ISO15765_2015_TxMessage* pMsg, unsigned long ulBlockingTimeout)
+int LegacyDLLExport icsneoISO15765_TransmitMessageEx(void* hObject,
+	unsigned long ulNetworkID,
+	ISO15765_2015_TxMessage* pMsg,
+	unsigned long ulBlockingTimeout)
 {
-	// Not supported
 	return false;
 }
 

bindings/python/CMakeLists.txt

@@ -32,7 +32,6 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/mdiomessage.cpp
     icsneopy/communication/message/gptpstatusmessage.cpp
     icsneopy/communication/message/allmacaddressesmessage.cpp
-    icsneopy/communication/message/apperrormessage.cpp
     icsneopy/communication/message/ethernetstatusmessage.cpp
     icsneopy/communication/message/spimessage.cpp
     icsneopy/communication/message/scriptstatusmessage.cpp
@@ -40,9 +39,6 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/livedatamessage.cpp
     icsneopy/communication/message/callback/messagecallback.cpp
     icsneopy/communication/message/filter/messagefilter.cpp
-    icsneopy/communication/message/filter/main51messagefilter.cpp
-    icsneopy/communication/message/main51message.cpp
-    icsneopy/communication/command.cpp
     icsneopy/core/macseccfg.cpp
     icsneopy/flexray/flexray.cpp
     icsneopy/disk/diskdriver.cpp
@@ -60,14 +56,7 @@ install(TARGETS icsneopy LIBRARY DESTINATION icsneopy)
 
 find_program(STUBGEN_EXE stubgen)
 if(STUBGEN_EXE)
-    # Multi-config generators put the extension in Release/ or Debug/. Import
-    # that freshly built module, not a globally installed older icsneopy.
-    add_custom_command(TARGET icsneopy POST_BUILD
-        COMMAND "${CMAKE_COMMAND}" -E rm -f "${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi"
-        COMMAND "${STUBGEN_EXE}" -v -p icsneopy -o "${CMAKE_CURRENT_BINARY_DIR}"
-        WORKING_DIRECTORY "$<TARGET_FILE_DIR:icsneopy>"
-        VERBATIM
-    )
+    add_custom_command(TARGET icsneopy POST_BUILD COMMAND stubgen -v -p icsneopy -o .)
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi py.typed DESTINATION icsneopy)
 endif()
 

bindings/python/icsneopy/communication/command.cpp

@@ -1,40 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/native_enum.h>
-
-#include "icsneo/communication/command.h"
-
-namespace icsneo {
-
-void init_command(pybind11::module_& m) {
-	pybind11::native_enum<Command>(m, "Command", "enum.IntEnum")
-		.value("Main51RxBufferOverflow", Command::Main51RxBufferOverflow)
-		.value("Main51StartCmd", Command::Main51StartCmd)
-		.value("Main51TxFifoOverflow", Command::Main51TxFifoOverflow)
-		.value("Main51BulkInNoData", Command::Main51BulkInNoData)
-		.value("Main51SetModeComplete", Command::Main51SetModeComplete)
-		.value("Main51ReadEeprom", Command::Main51ReadEeprom)
-		.value("Main51CmdDone", Command::Main51CmdDone)
-		.value("Main51ErrStatus", Command::Main51ErrStatus)
-		.value("Main51ReadSectorBuff", Command::Main51ReadSectorBuff)
-		.value("Main51WriteSectorBuff", Command::Main51WriteSectorBuff)
-		.value("Main51MmcProcessDone", Command::Main51MmcProcessDone)
-		.value("Main51ReInitDone", Command::Main51ReInitDone)
-		.value("EnableNetworkCommunication", Command::EnableNetworkCommunication)
-		.value("EnableNetworkCommunicationEx", Command::EnableNetworkCommunicationEx)
-		.value("KeepAlive", Command::KeepAlive)
-		.value("RequestSerialNumber", Command::RequestSerialNumber)
-		.value("GetMainVersion", Command::GetMainVersion)
-		.value("SetSettings", Command::SetSettings)
-		.value("SaveSettings", Command::SaveSettings)
-		.value("SetDefaultSettings", Command::SetDefaultSettings)
-		.value("ReadSettings", Command::ReadSettings)
-		.value("ScriptStatus", Command::ScriptStatus)
-		.value("WiVICommand", Command::WiVICommand)
-		.value("Extended", Command::Extended)
-		.value("ExtendedData", Command::ExtendedData)
-		.value("FlexRayControl", Command::FlexRayControl)
-		.value("CoreMiniPreload", Command::CoreMiniPreload)
-		.finalize();
-}
-
-} // namespace icsneo

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

@@ -1,71 +0,0 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/native_enum.h>
-
-#include "icsneo/communication/message/apperrormessage.h"
-
-namespace icsneo {
-
-void init_errortypes(pybind11::module_& m) {
-	pybind11::native_enum<AppErrorType>(m, "AppErrorType", "enum.IntEnum")
-		.value("RxMessagesFull", AppErrorType::AppErrorRxMessagesFull)
-		.value("TxMessagesFull", AppErrorType::AppErrorTxMessagesFull)
-		.value("TxReportMessagesFull", AppErrorType::AppErrorTxReportMessagesFull)
-		.value("BadCommWithDspIC", AppErrorType::AppErrorBadCommWithDspIC)
-		.value("DriverOverflow", AppErrorType::AppErrorDriverOverflow)
-		.value("PCBuffOverflow", AppErrorType::AppErrorPCBuffOverflow)
-		.value("PCChksumError", AppErrorType::AppErrorPCChksumError)
-		.value("PCMissedByte", AppErrorType::AppErrorPCMissedByte)
-		.value("PCOverrunError", AppErrorType::AppErrorPCOverrunError)
-		.value("SettingFailure", AppErrorType::AppErrorSettingFailure)
-		.value("TooManySelectedNetworks", AppErrorType::AppErrorTooManySelectedNetworks)
-		.value("NetworkNotEnabled", AppErrorType::AppErrorNetworkNotEnabled)
-		.value("RtcNotCorrect", AppErrorType::AppErrorRtcNotCorrect)
-		.value("LoadedDefaultSettings", AppErrorType::AppErrorLoadedDefaultSettings)
-		.value("FeatureNotUnlocked", AppErrorType::AppErrorFeatureNotUnlocked)
-		.value("FeatureRtcCmdDropped", AppErrorType::AppErrorFeatureRtcCmdDropped)
-		.value("TxMessagesFlushed", AppErrorType::AppErrorTxMessagesFlushed)
-		.value("TxMessagesHalfFull", AppErrorType::AppErrorTxMessagesHalfFull)
-		.value("NetworkNotValid", AppErrorType::AppErrorNetworkNotValid)
-		.value("TxInterfaceNotImplemented", AppErrorType::AppErrorTxInterfaceNotImplemented)
-		.value("TxMessagesCommEnableIsOff", AppErrorType::AppErrorTxMessagesCommEnableIsOff)
-		.value("RxFilterMatchCountExceeded", AppErrorType::AppErrorRxFilterMatchCountExceeded)
-		.value("EthPreemptionNotEnabled", AppErrorType::AppErrorEthPreemptionNotEnabled)
-		.value("TxNotSupportedInMode", AppErrorType::AppErrorTxNotSupportedInMode)
-		.value("JumboFramesNotSupported", AppErrorType::AppErrorJumboFramesNotSupported)
-		.value("EthernetIpFragment", AppErrorType::AppErrorEthernetIpFragment)
-		.value("TxMessagesUnderrun", AppErrorType::AppErrorTxMessagesUnderrun)
-		.value("DeviceFanFailure", AppErrorType::AppErrorDeviceFanFailure)
-		.value("DeviceOvertemperature", AppErrorType::AppErrorDeviceOvertemperature)
-		.value("TxMessageIndexOutOfRange", AppErrorType::AppErrorTxMessageIndexOutOfRange)
-		.value("UndersizedFrameDropped", AppErrorType::AppErrorUndersizedFrameDropped)
-		.value("OversizedFrameDropped", AppErrorType::AppErrorOversizedFrameDropped)
-		.value("WatchdogEvent", AppErrorType::AppErrorWatchdogEvent)
-		.value("SystemClockFailure", AppErrorType::AppErrorSystemClockFailure)
-		.value("SystemClockRecovered", AppErrorType::AppErrorSystemClockRecovered)
-		.value("SystemPeripheralReset", AppErrorType::AppErrorSystemPeripheralReset)
-		.value("SystemCommunicationFailure", AppErrorType::AppErrorSystemCommunicationFailure)
-		.value("TxMessagesUnsupportedSourceOrPacketId", AppErrorType::AppErrorTxMessagesUnsupportedSourceOrPacketId)
-		.value("WbmsManagerConnectFailed", AppErrorType::AppErrorWbmsManagerConnectFailed)
-		.value("WbmsManagerConnectBadState", AppErrorType::AppErrorWbmsManagerConnectBadState)
-		.value("WbmsManagerConnectTimeout", AppErrorType::AppErrorWbmsManagerConnectTimeout)
-		.value("FailedToInitializeLoggerDisk", AppErrorType::AppErrorFailedToInitializeLoggerDisk)
-		.value("InvalidSetting", AppErrorType::AppErrorInvalidSetting)
-		.value("SystemFailureRequestedReset", AppErrorType::AppErrorSystemFailureRequestedReset)
-		.value("PortKeyMistmatch", AppErrorType::AppErrorPortKeyMistmatch)
-		.value("BusFailure", AppErrorType::AppErrorBusFailure)
-		.value("TapOverflow", AppErrorType::AppErrorTapOverflow)
-		.value("EthTxNoLink", AppErrorType::AppErrorEthTxNoLink)
-		.value("ErrorBufferOverflow", AppErrorType::AppErrorErrorBufferOverflow)
-		.value("NoError", AppErrorType::AppNoError)
-		.finalize();
-}
-
-void init_apperrormessage(pybind11::module_& m) {
-	init_errortypes(m);
-	pybind11::classh<AppErrorMessage, Message>(m, "AppErrorMessage")
-		.def("get_app_error_type", &AppErrorMessage::getAppErrorType)
-		.def("get_app_error_string", &AppErrorMessage::getAppErrorString);
-}
-
-} // namespace icsneo 

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

@@ -7,7 +7,7 @@
 namespace icsneo {
 
 void init_ethernetstatusmessage(pybind11::module_& m) {
-	pybind11::classh<EthernetStatusMessage, RawMessage> ethernetStatusMessage(m, "EthernetStatusMessage");
+	pybind11::classh<EthernetStatusMessage, Message> ethernetStatusMessage(m, "EthernetStatusMessage");
 
 	pybind11::enum_<EthernetStatusMessage::LinkSpeed>(ethernetStatusMessage, "LinkSpeed")
 		.value("LinkSpeedAuto", EthernetStatusMessage::LinkSpeed::LinkSpeedAuto)

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

@@ -1,13 +0,0 @@
-#include <pybind11/pybind11.h>
-
-#include "icsneo/communication/message/filter/main51messagefilter.h"
-
-namespace icsneo {
-
-void init_main51messagefilter(pybind11::module_& m) {
-	pybind11::classh<Main51MessageFilter, MessageFilter>(m, "Main51MessageFilter")
-		.def(pybind11::init<>())
-		.def(pybind11::init<Command>());
-}
-
-} // namespace icsneo

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

@@ -28,8 +28,7 @@ void init_linmessage(pybind11::module_& m) {
 		.def_readwrite("UpdateResponderOnce", &LINStatusFlags::UpdateResponderOnce)
 		.def_readwrite("HasUpdatedResponderOnce", &LINStatusFlags::HasUpdatedResponderOnce)
 		.def_readwrite("BusRecovered", &LINStatusFlags::BusRecovered)
-		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly)
-		.def_readwrite("WakeupRequest", &LINStatusFlags::WakeupRequest);
+		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly);
 
 	pybind11::classh<LINMessage, Frame> linMessage(m, "LINMessage");
 
@@ -40,8 +39,7 @@ void init_linmessage(pybind11::module_& m) {
 		.value("LIN_BREAK_ONLY", LINMessage::Type::LIN_BREAK_ONLY)
 		.value("LIN_SYNC_ONLY", LINMessage::Type::LIN_SYNC_ONLY)
 		.value("LIN_UPDATE_RESPONDER", LINMessage::Type::LIN_UPDATE_RESPONDER)
-		.value("LIN_ERROR", LINMessage::Type::LIN_ERROR)
-		.value("LIN_WAKEUP_REQUEST", LINMessage::Type::LIN_WAKEUP_REQUEST);
+		.value("LIN_ERROR", LINMessage::Type::LIN_ERROR);
 
 	linMessage
 		.def(pybind11::init<>())

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

@@ -1,13 +0,0 @@
-#include <pybind11/pybind11.h>
-
-#include "icsneo/communication/message/main51message.h"
-
-namespace icsneo {
-
-void init_main51message(pybind11::module_& m) {
-	pybind11::classh<Main51Message, RawMessage>(m, "Main51Message")
-		.def(pybind11::init<>())
-		.def_readonly("command", &Main51Message::command);
-}
-
-} // namespace icsneo

bindings/python/icsneopy/device/device.cpp

@@ -52,11 +52,9 @@ void init_device(pybind11::module_& m) {
 		.def("set_digital_io", pybind11::overload_cast<IO, size_t, bool>(&Device::setDigitalIO), pybind11::arg("type"), pybind11::arg("number"), pybind11::arg("value"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("set_polling_message_limit", &Device::setPollingMessageLimit)
 		.def("set_rtc", &Device::setRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("reboot", &Device::reboot, pybind11::arg("safe") = false, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("start_script", &Device::startScript, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("stop_script", &Device::stopScript, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("supports_tc10", &Device::supportsTC10)
-		.def("supports_reboot", &Device::supportsReboot)
 		.def("supports_live_data", &Device::supportsLiveData)
 		.def("subscribe_live_data", &Device::subscribeLiveData, pybind11::arg("message"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("unsubscribe_live_data", &Device::unsubscribeLiveData, pybind11::arg("handle"), pybind11::call_guard<pybind11::gil_scoped_release>())

bindings/python/icsneopy/device/devicetype.cpp

@@ -36,7 +36,6 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADEpsilon", DeviceType::Enum::RADEpsilon)
 		.value("RADEpsilonXL", DeviceType::Enum::RADEpsilonXL)
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
-		.value("RADwBMS", DeviceType::Enum::RADwBMS)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
 		.value("RADGemini", DeviceType::Enum::RADGemini)
 		.value("RADComet2", DeviceType::Enum::RADComet2)

bindings/python/icsneopy/device/idevicesettings.cpp

@@ -40,16 +40,6 @@ void init_idevicesettings(pybind11::module_& m) {
         .value("Normal", LINMode::NORMAL_MODE)
         .value("Fast", LINMode::FAST_MODE);
 
-    pybind11::enum_<RADGPTPProfile>(settings, "GPTPProfile")
-        .value("Standard", RADGPTPProfile::RAD_GPTP_PROFILE_STANDARD)
-        .value("Automotive", RADGPTPProfile::RAD_GPTP_PROFILE_AUTOMOTIVE);
-
-    pybind11::enum_<RADGPTPRole>(settings, "GPTPRole")
-        .value("Disabled", RADGPTPRole::RAD_GPTP_ROLE_DISABLED)
-        .value("Passive", RADGPTPRole::RAD_GPTP_ROLE_PASSIVE)
-        .value("Master", RADGPTPRole::RAD_GPTP_ROLE_MASTER)
-        .value("Slave", RADGPTPRole::RAD_GPTP_ROLE_SLAVE);
-
     pybind11::enum_<MiscIOAnalogVoltage>(settings, "MiscIOAnalogVoltage")
         .value("V0", MiscIOAnalogVoltage::V0)
         .value("V1", MiscIOAnalogVoltage::V1)
@@ -58,10 +48,6 @@ void init_idevicesettings(pybind11::module_& m) {
         .value("V4", MiscIOAnalogVoltage::V4)
         .value("V5", MiscIOAnalogVoltage::V5);
 
-    pybind11::enum_<LinuxConfigurationPort>(settings, "LinuxConfigurationPort")
-        .value("USB", LinuxConfigurationPort::USB)
-        .value("ETH01", LinuxConfigurationPort::ETH01);
-
     pybind11::classh<IDeviceSettings>(m, "IDeviceSettings")
         .def("apply", &IDeviceSettings::apply, pybind11::arg("temporary") = 0, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("apply_defaults", &IDeviceSettings::applyDefaults, pybind11::arg("temporary") = 0, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -133,28 +119,7 @@ void init_idevicesettings(pybind11::module_& m) {
         
         .def("set_misc_io_analog_output_enabled", &IDeviceSettings::setMiscIOAnalogOutputEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("set_misc_io_analog_output", &IDeviceSettings::setMiscIOAnalogOutput, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // Performance blast
-        .def("is_perf_test_enabled", &IDeviceSettings::isPerfTestEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_perf_test_enable", &IDeviceSettings::setPerfTestEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
-        // gPTP methods
-        .def("get_gptp_profile", &IDeviceSettings::getGPTPProfile, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_gptp_profile", &IDeviceSettings::setGPTPProfile, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_gptp_role", &IDeviceSettings::getGPTPRole, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_gptp_role", &IDeviceSettings::setGPTPRole, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_gptp_enabled_port", &IDeviceSettings::getGPTPEnabledPort, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_gptp_enabled_port", &IDeviceSettings::setGPTPEnabledPort, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("is_gptp_clock_syntonization_enabled", &IDeviceSettings::isGPTPClockSyntonizationEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_gptp_clock_syntonization_enabled", &IDeviceSettings::setGPTPClockSyntonizationEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-
-        // Linux operating-system settings (Fire3 family devices)
-        .def("get_linux_boot_enabled", &IDeviceSettings::getLinuxBootEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_linux_boot_enabled", &IDeviceSettings::setLinuxBootEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_external_wifi_antenna_enabled", &IDeviceSettings::getExternalWifiAntennaEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_external_wifi_antenna_enabled", &IDeviceSettings::setExternalWifiAntennaEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("get_linux_configuration_port", &IDeviceSettings::getLinuxConfigurationPort, pybind11::call_guard<pybind11::gil_scoped_release>())
-        .def("set_linux_configuration_port", &IDeviceSettings::setLinuxConfigurationPort, pybind11::call_guard<pybind11::gil_scoped_release>())
-
+        
         // Status properties
         .def_readonly("disabled", &IDeviceSettings::disabled)
         .def_readonly("readonly", &IDeviceSettings::readonly);

bindings/python/icsneopy/icsneocpp.cpp

@@ -20,7 +20,6 @@ void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
 void init_gptpstatusmessage(pybind11::module_&);
 void init_allmacaddressesmessage(pybind11::module_&);
-void init_apperrormessage(pybind11::module_&);
 void init_mdiomessage(pybind11::module_&);
 void init_spimessage(pybind11::module_&);
 void init_ethernetstatusmessage(pybind11::module_&);
@@ -32,10 +31,7 @@ void init_deviceextension(pybind11::module_&);
 void init_chipid(pybind11::module_&);
 void init_versionreport(pybind11::module_&);
 void init_device(pybind11::module_&);
-void init_command(pybind11::module_&);
-void init_main51message(pybind11::module_&);
 void init_messagefilter(pybind11::module_&);
-void init_main51messagefilter(pybind11::module_&);
 void init_messagecallback(pybind11::module_&);
 void init_version(pybind11::module_&);
 void init_flexray(pybind11::module_& m);
@@ -65,17 +61,13 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_tc10statusmessage(m);
 	init_gptpstatusmessage(m);
 	init_allmacaddressesmessage(m);
-	init_apperrormessage(m);
 	init_mdiomessage(m);
 	init_ethernetstatusmessage(m);
 	init_macsecconfig(m);
 	init_scriptstatusmessage(m);
 	init_spimessage(m);
 	init_livedatamessage(m);
-	init_command(m);
-	init_main51message(m);
 	init_messagefilter(m);
-	init_main51messagefilter(m);
 	init_messagecallback(m);
 	init_diskdriver(m);
 	init_diskdetails(m);

ci/build-posix.sh

@@ -1,6 +1,7 @@
 #!/bin/sh
 
-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON \
+	-DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
 
 cmake --build build || exit 1
 

ci/build-windows.bat

@@ -3,6 +3,7 @@
 
 mkdir build >nul 2>&1
 
-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON-DLIBICSNEO_ENABLE_TCP=ON || exit /b 1
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_UNIT_TESTS=ON ^
+    -DLIBICSNEO_ENABLE_TCP=ON || exit /b 1
 
 cmake --build build || exit /b 1

communication/decoder.cpp

@@ -26,10 +26,6 @@
 #include "icsneo/communication/message/ethernetstatusmessage.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
 #include "icsneo/communication/message/clientidmessage.h"
-#include "icsneo/communication/message/mfgconfigmessage.h"
-#include "icsneo/communication/message/spiportkeymessage.h"
-#include "icsneo/communication/message/genericapidatamessage.h"
-#include "icsneo/communication/message/genericapistatusmessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -44,7 +40,6 @@
 #include "icsneo/communication/packet/i2cpacket.h"
 #include "icsneo/communication/packet/scriptstatuspacket.h"
 #include "icsneo/communication/packet/linpacket.h"
-#include "icsneo/communication/message/iso15765message.h"
 #include "icsneo/communication/packet/componentversionpacket.h"
 #include "icsneo/communication/packet/supportedfeaturespacket.h"
 #include "icsneo/communication/packet/mdiopacket.h"
@@ -346,15 +341,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::LiveData:
 							result = HardwareLiveDataPacket::DecodeToMessage(packet->data, report);
 							return true;
-						case ExtendedCommand::ExecuteSPIPortKeyOperation:
-							result = SPIPortKeyMessage::DecodeToMessage(packet->data);
-							return true;
-						case ExtendedCommand::ReadGenericAPIData:
-							result = GenericAPIDataMessage::DecodeToMessage(packet->data);
-							return true;
-						case ExtendedCommand::ReadGenericAPIStatus:
-							result = GenericAPIStatusMessage::DecodeToMessage(packet->data);
-							return true;
 						case ExtendedCommand::GetTC10Status:
 							result = TC10StatusMessage::DecodeToMessage(packet->data);
 							return true;
@@ -373,9 +359,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 							);
 							protoapi::Id protoId = protoapi::getProtoId(responseBody.data(), responseBody.size());
 							switch(protoId) {
-								case protoapi::Id::MfgConfig:
-									result = MfgConfigMessage::DecodeToMessage(responseBody);
-									return true;
 								case protoapi::Id::NetworkMutex:
 									result = NetworkMutexMessage::DecodeToMessage(responseBody);
 									return true;
@@ -480,14 +463,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 							return true;
 						}
-						case Command::J2534Command: {
-							result = J2534CommandMessage::decodeToMessage(packet->data);
-							if(!result) {
-								report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
-								return false;
-							}
-							return true;
-						}
 						default:
 							auto msg = std::make_shared<Main51Message>();
 							msg->command = Command(packet->data[0]);
@@ -588,9 +563,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			}
 			break;
 		}
-		default:
-			report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
-			return false;
 	}
 
 	// For the moment other types of messages will automatically be decoded as raw messages

communication/encoder.cpp

@@ -234,9 +234,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			result = packetizer.packetWrap(result, false);
 			return true;
 		}
-		default:
-			report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-			return false; // The message was not a properly formed Message
+		break;
 	}
 
 	// Early returns may mean we don't reach this far, check the type you're concerned with

communication/message/a2bmessage.cpp

@@ -163,8 +163,6 @@ void A2BMessage::setChannelSample(Direction dir, uint8_t channel, size_t frame,
 		case PCMType::L24:
 			sampleToSet = sampleToSet << 8;
 			break;
-		case PCMType::L32:
-			break;
 	}
 
 	if(channelSize16) {

communication/message/ethernetstatusmessage.cpp

@@ -37,7 +37,7 @@ struct Packet {
 };
 #pragma pack(pop)
 
-std::shared_ptr<RawMessage> EthernetStatusMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+std::shared_ptr<Message> EthernetStatusMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
 	if(bytestream.size() < sizeof(Packet)) {
 		return nullptr;
 	}
@@ -76,5 +76,5 @@ std::shared_ptr<RawMessage> EthernetStatusMessage::DecodeToMessage(const std::ve
 			break;
 		default: return nullptr;
 	}
-	return std::make_shared<EthernetStatusMessage>(packet->network, packet->state != 0, speed, packet->duplex != 0, mode);
-}
+	return std::make_shared<EthernetStatusMessage>(packet->network, packet->state, speed, packet->duplex, mode);
+}

communication/message/ethphymessage.cpp

@@ -35,7 +35,7 @@ bool EthPhyMessage::appendPhyMessage(bool writeEnable, bool clause45, uint8_t ph
 
 bool EthPhyMessage::appendPhyMessage(std::shared_ptr<PhyMessage> message)
 {
-	if(message)
+	if(message != nullptr)
 	{
 		messages.push_back(message);
 		return true;

communication/message/genericapidatamessage.cpp

@@ -1,28 +0,0 @@
-#include "icsneo/communication/message/genericapidatamessage.h"
-#include "icsneo/communication/message/extendedresponsemessage.h"
-#include "icsneo/communication/command.h"
-
-using namespace icsneo;
-
-std::shared_ptr<GenericAPIDataMessage> GenericAPIDataMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	if(bytestream.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
-		return nullptr;
-
-	const auto* hdr = reinterpret_cast<const ExtendedResponseMessage::ResponseHeader*>(bytestream.data());
-
-	if(hdr->command != ExtendedCommand::ReadGenericAPIData)
-		return nullptr;
-
-	const size_t required = sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(GenericAPIDataHeader);
-	if(bytestream.size() < required)
-		return nullptr;
-
-	auto msg = std::make_shared<GenericAPIDataMessage>();
-
-	const auto* packet = reinterpret_cast<const GenericAPIDataPacket*>(bytestream.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
-
-	msg->functionId = packet->header.functionId;
-	msg->buffer.resize(packet->header.bufferLength);
-	std::copy(packet->buffer, packet->buffer + packet->header.bufferLength, msg->buffer.data());
-	return msg;
-}

communication/message/genericapistatusmessage.cpp

@@ -1,29 +0,0 @@
-#include "icsneo/communication/message/genericapistatusmessage.h"
-#include "icsneo/communication/message/extendedresponsemessage.h"
-#include "icsneo/communication/command.h"
-
-using namespace icsneo;
-
-std::shared_ptr<GenericAPIStatusMessage> GenericAPIStatusMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	if(bytestream.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
-		return nullptr;
-
-	const auto* hdr = reinterpret_cast<const ExtendedResponseMessage::ResponseHeader*>(bytestream.data());
-
-	if(hdr->command != ExtendedCommand::ReadGenericAPIStatus)
-		return nullptr;
-
-	const size_t required = sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(GenericAPIStatusResponsePacket);
-	if(bytestream.size() < required)
-		return nullptr;
-
-	auto msg = std::make_shared<GenericAPIStatusMessage>();
-
-	const auto* packet = reinterpret_cast<const GenericAPIStatusResponsePacket*>(bytestream.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
-
-	msg->functionId = packet->functionId;
-	msg->finishedProcessing = static_cast<bool>(packet->finishedProcessing);
-	msg->functionError = packet->functionError;
-	msg->callbackError = packet->callbackError;
-	return msg;
-}

communication/message/iso15765message.cpp

@@ -1,337 +0,0 @@
-#include "icsneo/communication/message/iso15765message.h"
-
-#include <cstring>
-
-using namespace icsneo;
-
-std::shared_ptr<J2534CommandMessage> J2534CommandMessage::decodeToMessage(const std::vector<uint8_t>& data) {
-	if(data.size() < 2)
-		return nullptr;
-
-	auto msg = std::make_shared<J2534CommandMessage>((J2534Command)data[1]);
-	if(data.size() > 2)
-        msg->setArgumentData(std::vector<uint8_t>(data.begin() + 2, data.end()));
-
-	return msg;
-}
-
-uint16_t J2534CommandMessage::read16LE(size_t o) const {
-	return (uint16_t)((uint16_t)argumentData[o] | ((uint16_t)argumentData[o + 1] << 8));
-}
-
-void J2534CommandMessage::write16LE(size_t o, uint16_t v) {
-	argumentData[o] = (uint8_t)(v & 0xFF);
-	argumentData[o + 1] = (uint8_t)((v >> 8) & 0xFF);
-}
-
-uint16_t J2534CommandMessage::read16BE(size_t o) const {
-	return (uint16_t)(((uint16_t)argumentData[o] << 8) | argumentData[o + 1]);
-}
-
-void J2534CommandMessage::write16BE(size_t o, uint16_t v) {
-	argumentData[o] = (uint8_t)((v >> 8) & 0xFF);
-	argumentData[o + 1] = (uint8_t)(v & 0xFF);
-}
-
-void J2534CommandMessage::writeBits16LE(size_t o, unsigned bitPos, unsigned bitCount, uint32_t value) {
-	const uint16_t mask = (uint16_t)(((1u << bitCount) - 1u) << bitPos);
-	uint16_t word = read16LE(o);
-	word = (uint16_t)((word & ~mask) | (((value << bitPos) & mask)));
-	write16LE(o, word);
-}
-
-uint32_t J2534CommandMessage::read32LE(size_t o) const {
-	return  (uint32_t)argumentData[o]
-		| ((uint32_t)argumentData[o + 1] << 8)
-		| ((uint32_t)argumentData[o + 2] << 16)
-		| ((uint32_t)argumentData[o + 3] << 24);
-}
-
-void J2534CommandMessage::write32LE(size_t o, uint32_t v) {
-	argumentData[o] = (uint8_t)(v & 0xFF);
-	argumentData[o + 1] = (uint8_t)((v >> 8) & 0xFF);
-	argumentData[o + 2] = (uint8_t)((v >> 16) & 0xFF);
-	argumentData[o + 3] = (uint8_t)((v >> 24) & 0xFF);
-}
-
-uint32_t J2534CommandMessage::read32BE(size_t o) const {
-	return ((uint32_t)argumentData[o] << 24) | ((uint32_t)argumentData[o + 1] << 16)
-		| ((uint32_t)argumentData[o + 2] << 8) | (uint32_t)argumentData[o + 3];
-}
-
-void J2534CommandMessage::write32BE(size_t o, uint32_t v) {
-	argumentData[o] = (uint8_t)((v >> 24) & 0xFF);
-	argumentData[o + 1] = (uint8_t)((v >> 16) & 0xFF);
-	argumentData[o + 2] = (uint8_t)((v >> 8) & 0xFF);
-	argumentData[o + 3] = (uint8_t)(v & 0xFF);
-}
-
-J2534_RxCanFilter J2534SetupCanRxFilteringMessage::getRxCanFilter() const {
-	constexpr size_t filterSize = sizeof(J2534_RxCanFilter::fb);
-	J2534_RxCanFilter filter = {};
-	if(argumentData.size() >= (10 + filterSize))
-	{
-		filter.idx = (argumentData[2] << 8) | argumentData[3];
-		filter.enabled = (argumentData[4] << 8) | argumentData[5];
-		filter.filterCount = (argumentData[6] << 8) | argumentData[7];
-		filter.fb = *((MessageFilterBytes*)(argumentData.data() + 8));
-		filter.networkId = (argumentData[8 + filterSize] << 8) | argumentData[9 + filterSize];
-	}
-	return filter;
-}
-
-void J2534SetupCanRxFilteringMessage::setRxCanFilter(const J2534_RxCanFilter& filter) {
-	argumentData.resize(10 + sizeof(filter.fb));
-	argumentData[2] = (filter.idx >> 8) & 0xFF;
-	argumentData[3] = filter.idx & 0xFF;
-	argumentData[4] = (filter.enabled >> 8) & 0xFF;
-	argumentData[5] = filter.enabled & 0xFF;
-	argumentData[6] = (filter.filterCount >> 8) & 0xFF;
-	argumentData[7] = filter.filterCount & 0xFF;
-    *((MessageFilterBytes*)(argumentData.data() + 8)) = filter.fb;
-	argumentData[8 + sizeof(filter.fb)] = (filter.networkId >> 8) & 0xFF;
-	argumentData[9 + sizeof(filter.fb)] = filter.networkId & 0xFF;
-}
-
-
-J2534SetupIso15765FlowControlMessage::J2534SetupIso15765FlowControlMessage()
-	: J2534CommandMessage(J2534Command::SetupIso15765RxFilter) {
-	argumentData.resize(MessageSize);
-	// Bytes [0..1] were populated by the base constructor. Everything else starts at zero
-	// (matches the previous behavior which zeroed the flt region and left the rest of the
-	// caller-supplied struct as-is; typical callers value-initialized their struct too).
-	for(size_t i = 2; i < MessageSize; ++i)
-		argumentData[i] = 0;
-}
-
-void J2534SetupIso15765FlowControlMessage::rebuildFilterBytes(void) {
-	// Zero the 28-byte flt region.
-	for(size_t i = 0; i < FltSize; ++i)
-		argumentData[FltOffset + i] = 0;
-
-	const uint32_t id      = read32LE(IdOffset);
-	const uint32_t idMask  = read32LE(IdMaskOffset);
-	const bool is29Bit     = getFlagBit(FlagId29BitEnable);
-	const bool extAddr     = getFlagBit(FlagExtAddressEnable);
-	const uint8_t extAddrByte = argumentData[ExtAddrOffset];
-
-	// CoreMiniMessageFilterBytes has an interleaved layout:
-	//   uiFilterMask0 at flt+0,  uiFilterID0 at flt+2
-	//   uiFilterMask1 at flt+4,  uiFilterID1 at flt+6
-	//   uiFilterMask2 at flt+8,  uiFilterID2 at flt+10
-	//   datalink.uiFilterMask3 at flt+12, datalink.uiFilterID3 at flt+14
-	//
-	// CoreMiniMsgBitsCAN bit layout within each 16-bit unit:
-	//   unit0: IDE(bit0), SRR(bit1), SID(bits2-12), NETWORKINDEX(bits13-15)
-	//   unit1: EID(bits0-11), TXMSG(bit12), ...
-	//   unit2: DLC(bits0-3), ..., RTR(bit9), EID2(bits10-15)
-	const size_t MaskUnit0  = FltOffset + 0;
-	const size_t MaskUnit1  = FltOffset + 4;
-	const size_t MaskUnit2  = FltOffset + 8;
-	const size_t ValueUnit0 = FltOffset + 2;
-	const size_t ValueUnit1 = FltOffset + 6;
-	const size_t ValueUnit2 = FltOffset + 10;
-
-	// filter arbid: pMask->IDE = 1
-	writeBits16LE(MaskUnit0, /*bit*/0, /*width*/1, 1);
-
-	if(is29Bit) {
-		// pValue->IDE = 1; pValue->SID = (id >> 18) & 0x7FF
-		writeBits16LE(ValueUnit0, 0, 1, 1);
-		writeBits16LE(ValueUnit0, 2, 11, (id >> 18) & 0x7FF);
-		// pValue->EID = (id >> 6) & 0xFFF
-		writeBits16LE(ValueUnit1, 0, 12, (id >> 6) & 0xFFF);
-		// pValue->EID2 = id & 0x3F
-		writeBits16LE(ValueUnit2, 10, 6, id & 0x3F);
-		// pMask->SID = (id_mask >> 18) & 0x7FF
-		writeBits16LE(MaskUnit0, 2, 11, (idMask >> 18) & 0x7FF);
-		// pMask->EID = (id_mask >> 6) & 0xFFF  (overlaps pValue->{IDE,SID} storage)
-		writeBits16LE(MaskUnit1, 0, 12, (idMask >> 6) & 0xFFF);
-		// pMask->EID2 = id_mask & 0x3F         (overlaps pValue->EID storage)
-		writeBits16LE(MaskUnit2, 10, 6, idMask & 0x3F);
-	} else {
-		// pValue->IDE = 0 (already zero); pValue->SID = id
-		writeBits16LE(ValueUnit0, 2, 11, id & 0x7FF);
-		// pMask->SID = id_mask
-		writeBits16LE(MaskUnit0, 2, 11, idMask & 0x7FF);
-	}
-
-	// Extended-address filter: writes into the datalink.uiFilterID3 / uiFilterMask3 bytes.
-	//   uiFilterMask3 = flt[12..13] = wire[37..38]
-	//   uiFilterID3   = flt[14..15] = wire[39..40]
-	if(extAddr) {
-		const size_t kValueBytes = FltOffset + 14; // uiFilterID3
-		const size_t kMaskBytes  = FltOffset + 12; // uiFilterMask3
-		argumentData[kValueBytes + 0] = extAddrByte;
-		argumentData[kMaskBytes  + 0] = 0xFF;
-		argumentData[kValueBytes + 1] = 0;
-		argumentData[kMaskBytes  + 1] = 0;
-	}
-}
-
-uint16_t J2534SetupIso15765FlowControlMessage::getIdx(void) const { return read16LE(IdxOffset); }
-void J2534SetupIso15765FlowControlMessage::setIdx(uint16_t idx) { write16LE(IdxOffset, idx); }
-
-uint16_t J2534SetupIso15765FlowControlMessage::getCoreMiniId(void) const { return read16LE(CoreMiniOffset); }
-void J2534SetupIso15765FlowControlMessage::setCoreMiniId(uint16_t coreMiniId) { write16LE(CoreMiniOffset, coreMiniId); }
-
-uint8_t J2534SetupIso15765FlowControlMessage::getPadding(void) const { return argumentData[PaddingOffset]; }
-void J2534SetupIso15765FlowControlMessage::setPadding(uint8_t padding) { argumentData[PaddingOffset] = padding; }
-
-uint32_t J2534SetupIso15765FlowControlMessage::getId(void) const { return read32LE(IdOffset); }
-void J2534SetupIso15765FlowControlMessage::setId(uint32_t id) { write32LE(IdOffset, id); rebuildFilterBytes(); }
-
-uint32_t J2534SetupIso15765FlowControlMessage::getIdMask(void) const { return read32LE(IdMaskOffset); }
-void J2534SetupIso15765FlowControlMessage::setIdMask(uint32_t idMask) { write32LE(IdMaskOffset, idMask); rebuildFilterBytes(); }
-
-uint32_t J2534SetupIso15765FlowControlMessage::getFcId(void) const { return read32LE(FcIdOffset); }
-void J2534SetupIso15765FlowControlMessage::setFcId(uint32_t fcId) { write32LE(FcIdOffset, fcId); }
-
-uint8_t J2534SetupIso15765FlowControlMessage::getFlowControlExtendedAddress(void) const { return argumentData[FcExtAddrOffset]; }
-void J2534SetupIso15765FlowControlMessage::setFlowControlExtendedAddress(uint8_t addr) { argumentData[FcExtAddrOffset] = addr; }
-
-uint8_t J2534SetupIso15765FlowControlMessage::getExtendedAddress(void) const { return argumentData[ExtAddrOffset]; }
-void J2534SetupIso15765FlowControlMessage::setExtendedAddress(uint8_t addr) { argumentData[ExtAddrOffset] = addr; rebuildFilterBytes(); }
-
-uint8_t J2534SetupIso15765FlowControlMessage::getBlockSize(void) const { return argumentData[BlockSizeOffset]; }
-void J2534SetupIso15765FlowControlMessage::setBlockSize(uint8_t blockSize) { argumentData[BlockSizeOffset] = blockSize; }
-
-uint8_t J2534SetupIso15765FlowControlMessage::getStMin(void) const { return argumentData[StMinOffset]; }
-void J2534SetupIso15765FlowControlMessage::setStMin(uint8_t stMin) { argumentData[StMinOffset] = stMin; }
-
-uint16_t J2534SetupIso15765FlowControlMessage::getCfTimeout(void) const { return read16LE(CfTimeoutOffset); }
-void J2534SetupIso15765FlowControlMessage::setCfTimeout(uint16_t cfTimeout) { write16LE(CfTimeoutOffset, cfTimeout); }
-
-uint32_t J2534SetupIso15765FlowControlMessage::getFlags(void) const { return read32LE(FlagsOffset); }
-void J2534SetupIso15765FlowControlMessage::setFlags(uint32_t flags) { write32LE(FlagsOffset, flags); rebuildFilterBytes(); }
-
-bool J2534SetupIso15765FlowControlMessage::getEnable(void) const { return getFlagBit(FlagEnable); }
-void J2534SetupIso15765FlowControlMessage::setEnable(bool enable) { setFlagBit(FlagEnable, enable); }
-
-bool J2534SetupIso15765FlowControlMessage::getIs29BitEnabled(void) const { return getFlagBit(FlagId29BitEnable); }
-void J2534SetupIso15765FlowControlMessage::setIs29BitEnabled(bool enable) { setFlagBit(FlagId29BitEnable, enable); rebuildFilterBytes(); }
-
-bool J2534SetupIso15765FlowControlMessage::getIsFc29BitEnabled(void) const { return getFlagBit(FlagFcId29BitEnable); }
-void J2534SetupIso15765FlowControlMessage::setIsFc29BitEnabled(bool enable) { setFlagBit(FlagFcId29BitEnable, enable); }
-
-bool J2534SetupIso15765FlowControlMessage::getExtAddressEnabled(void) const { return getFlagBit(FlagExtAddressEnable); }
-void J2534SetupIso15765FlowControlMessage::setExtAddressEnabled(bool enable) { setFlagBit(FlagExtAddressEnable, enable); rebuildFilterBytes(); }
-
-bool J2534SetupIso15765FlowControlMessage::getFcExtAddressEnabled(void) const { return getFlagBit(FlagFcExtAddressEnable); }
-void J2534SetupIso15765FlowControlMessage::setFcExtAddressEnabled(bool enable) { setFlagBit(FlagFcExtAddressEnable, enable); }
-
-bool J2534SetupIso15765FlowControlMessage::getFlowControlTransmissionEnabled(void) const { return getFlagBit(FlagEnableFlowControlTransmit); }
-void J2534SetupIso15765FlowControlMessage::setFlowControlTransmissionEnabled(bool enable) { setFlagBit(FlagEnableFlowControlTransmit, enable); }
-
-bool J2534SetupIso15765FlowControlMessage::getPaddingEnabled(void) const { return getFlagBit(FlagPaddingEnable); }
-void J2534SetupIso15765FlowControlMessage::setPaddingEnabled(bool enable) { setFlagBit(FlagPaddingEnable, enable); }
-
-bool J2534SetupIso15765FlowControlMessage::getIsCanFd(void) const { return getFlagBit(FlagIsCanFd); }
-void J2534SetupIso15765FlowControlMessage::setIsCanFd(bool enable) { setFlagBit(FlagIsCanFd, enable); }
-
-bool J2534SetupIso15765FlowControlMessage::getIsBrsEnabled(void) const { return getFlagBit(FlagIsBrsEnabled); }
-void J2534SetupIso15765FlowControlMessage::setIsBrsEnabled(bool enable) { setFlagBit(FlagIsBrsEnabled, enable); }
-
-void J2534SetupIso15765FlowControlMessage::setFlagBit(uint32_t mask, bool enable) {
-	uint32_t f = read32LE(FlagsOffset);
-	if(enable) f |= mask;
-	else        f &= ~mask;
-	write32LE(FlagsOffset, f);
-}
-
-bool J2534SetupIso15765FlowControlMessage::getFlagBit(uint32_t mask) const {
-	return (read32LE(FlagsOffset) & mask) != 0;
-}
-
-uint16_t Iso15765TxSetupMessage::getIdx(void) const { return read16LE(SetupIdxOffset); }
-void Iso15765TxSetupMessage::setIdx(uint16_t idx) { write16LE(SetupIdxOffset, idx); }
-
-uint16_t Iso15765TxSetupMessage::getCoreMiniId(void) const { return read16LE(SetupCoreMiniOffset); }
-void Iso15765TxSetupMessage::setCoreMiniId(uint16_t coreMiniId) { write16LE(SetupCoreMiniOffset, coreMiniId); }
-
-uint32_t Iso15765TxSetupMessage::getMessageLength(void) const { return read32LE(SetupMsgLenOffset); }
-void Iso15765TxSetupMessage::setMessageLength(uint32_t messageLength) { write32LE(SetupMsgLenOffset, messageLength); }
-
-uint8_t Iso15765TxSetupMessage::getPadding(void) const { return argumentData[SetupPaddingOffset]; }
-void Iso15765TxSetupMessage::setPadding(uint8_t padding) { argumentData[SetupPaddingOffset] = padding; }
-
-uint8_t Iso15765TxSetupMessage::getTxDl(void) const { return argumentData[SetupTxDlOffset]; }
-void Iso15765TxSetupMessage::setTxDl(uint8_t txDl) { argumentData[SetupTxDlOffset] = txDl; }
-
-uint32_t Iso15765TxSetupMessage::getId(void) const { return read32LE(SetupIdOffset); }
-void Iso15765TxSetupMessage::setId(uint32_t id) { write32LE(SetupIdOffset, id); }
-
-uint32_t Iso15765TxSetupMessage::getFcId(void) const { return read32LE(SetupFcIdOffset); }
-void Iso15765TxSetupMessage::setFcId(uint32_t fcId) { write32LE(SetupFcIdOffset, fcId); }
-
-uint32_t Iso15765TxSetupMessage::getFcIdMask(void) const { return read32LE(SetupFcIdMaskOffset); }
-void Iso15765TxSetupMessage::setFcIdMask(uint32_t fcIdMask) { write32LE(SetupFcIdMaskOffset, fcIdMask); }
-
-uint8_t Iso15765TxSetupMessage::getFlowControlExtendedAddress(void) const { return argumentData[SetupFcExtAddrOffset]; }
-void Iso15765TxSetupMessage::setFlowControlExtendedAddress(uint8_t addr) { argumentData[SetupFcExtAddrOffset] = addr; }
-
-uint8_t Iso15765TxSetupMessage::getExtendedAddress(void) const { return argumentData[SetupExtAddrOffset]; }
-void Iso15765TxSetupMessage::setExtendedAddress(uint8_t addr) { argumentData[SetupExtAddrOffset] = addr; }
-
-uint16_t Iso15765TxSetupMessage::getFsTimeout(void) const { return read16LE(SetupFsTimeoutOffset); }
-void Iso15765TxSetupMessage::setFsTimeout(uint16_t timeout) { write16LE(SetupFsTimeoutOffset, timeout); }
-
-uint16_t Iso15765TxSetupMessage::getFsWait(void) const { return read16LE(SetupFsWaitOffset); }
-void Iso15765TxSetupMessage::setFsWait(uint16_t wait) { write16LE(SetupFsWaitOffset, wait); }
-
-uint32_t Iso15765TxSetupMessage::getFlags(void) const { return read32LE(SetupFlagsOffset); }
-void Iso15765TxSetupMessage::setFlags(uint32_t flags) { write32LE(SetupFlagsOffset, flags); }
-
-uint8_t Iso15765TxSetupMessage::getStMin(void) const { return argumentData[SetupStMinOffset]; }
-void Iso15765TxSetupMessage::setStMin(uint8_t stMin) { argumentData[SetupStMinOffset] = stMin; }
-
-uint8_t Iso15765TxSetupMessage::getBlockSize(void) const { return argumentData[SetupBlockSizeOffset]; }
-void Iso15765TxSetupMessage::setBlockSize(uint8_t blockSize) { argumentData[SetupBlockSizeOffset] = blockSize; }
-
-bool Iso15765TxSetupMessage::getIs29BitEnabled(void) const { return getFlagBit(FlagId29BitEnable); }
-void Iso15765TxSetupMessage::setIs29BitEnabled(bool enable) { setFlagBit(FlagId29BitEnable, enable); }
-bool Iso15765TxSetupMessage::getIsFc29BitEnabled(void) const { return getFlagBit(FlagFcId29BitEnable); }
-void Iso15765TxSetupMessage::setIsFc29BitEnabled(bool enable) { setFlagBit(FlagFcId29BitEnable, enable); }
-bool Iso15765TxSetupMessage::getExtAddressEnabled(void) const { return getFlagBit(FlagExtAddressEnable); }
-void Iso15765TxSetupMessage::setExtAddressEnabled(bool enable) { setFlagBit(FlagExtAddressEnable, enable); }
-bool Iso15765TxSetupMessage::getFcExtAddressEnabled(void) const { return getFlagBit(FlagFcExtAddressEnable); }
-void Iso15765TxSetupMessage::setFcExtAddressEnabled(bool enable) { setFlagBit(FlagFcExtAddressEnable, enable); }
-bool Iso15765TxSetupMessage::getOverrideStMin(void) const { return getFlagBit(FlagOverrideStMin); }
-void Iso15765TxSetupMessage::setOverrideStMin(bool enable) { setFlagBit(FlagOverrideStMin, enable); }
-bool Iso15765TxSetupMessage::getOverrideBlockSize(void) const { return getFlagBit(FlagOverrideBlockSize); }
-void Iso15765TxSetupMessage::setOverrideBlockSize(bool enable) { setFlagBit(FlagOverrideBlockSize, enable); }
-bool Iso15765TxSetupMessage::getPaddingEnabled(void) const { return getFlagBit(FlagPaddingEnable); }
-void Iso15765TxSetupMessage::setPaddingEnabled(bool enable) { setFlagBit(FlagPaddingEnable, enable); }
-bool Iso15765TxSetupMessage::getIsCanFd(void) const { return getFlagBit(FlagIsCanFd); }
-void Iso15765TxSetupMessage::setIsCanFd(bool enable) { setFlagBit(FlagIsCanFd, enable); }
-bool Iso15765TxSetupMessage::getIsBrsEnabled(void) const { return getFlagBit(FlagIsBrsEnabled); }
-void Iso15765TxSetupMessage::setIsBrsEnabled(bool enable) { setFlagBit(FlagIsBrsEnabled, enable); }
-
-bool Iso15765TxSetupMessage::getFlagBit(uint32_t mask) const {
-	return (getFlags() & mask) != 0;
-}
-
-void Iso15765TxSetupMessage::setFlagBit(uint32_t mask, bool enable) {
-	uint32_t f = getFlags();
-	if(enable) f |= mask;
-	else        f &= ~mask;
-	setFlags(f);
-}
-
-uint16_t Iso15765TxDataMessage::getIdx(void) const { return read16LE(DataIdxOffset); }
-void Iso15765TxDataMessage::setIdx(uint16_t idx) { write16LE(DataIdxOffset, idx); }
-
-uint32_t Iso15765TxDataMessage::getOffset(void) const { return read32LE(DataOffsetOffset); }
-void Iso15765TxDataMessage::setOffset(uint32_t offset) { write32LE(DataOffsetOffset, offset); }
-
-uint16_t Iso15765TxDataMessage::getLen(void) const { return read16LE(DataLenOffset); }
-
-const uint8_t* Iso15765TxDataMessage::getData(void) const { return argumentData.data() + DataPayloadOffset; }
-
-void Iso15765TxDataMessage::setData(const uint8_t* sourceData, uint16_t len) {
-    len = std::min(len, (uint16_t)MaxDataLength);
-	argumentData.resize(DataPayloadOffset + len);
-	write16LE(DataLenOffset, len);
-	if(len > 0 && sourceData != nullptr)
-		std::copy(sourceData, sourceData + len, argumentData.begin() + DataPayloadOffset);
-}

communication/message/mfgconfigmessage.cpp

@@ -1,77 +0,0 @@
-#include "icsneo/communication/message/mfgconfigmessage.h"
-#include "icsneo/communication/icspb.h"
-
-#include <algorithm>
-
-using namespace icsneo;
-
-static MfgConfigMessage::VersionNumber versionFromProto(const settings::common::v1::VersionNumber& version) {
-	MfgConfigMessage::VersionNumber decoded;
-	decoded.major = version.major();
-	decoded.minor = version.minor();
-	if(version.has_release())
-		decoded.release = version.release();
-	if(version.has_build())
-		decoded.build = version.build();
-	return decoded;
-}
-
-std::shared_ptr<MfgConfigMessage> MfgConfigMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	MfgConfigMessage decoded;
-	settings::manufacturing::v1::MfgConfig msg;
-
-	if(!protoapi::processResponse(bytestream.data(), bytestream.size(), msg)) {
-		return nullptr;
-	}
-
-	if(msg.has_serial_number()) {
-		decoded.serialNumber = msg.serial_number();
-	}
-	if(msg.has_manufacture_date()) {
-		const auto& date = msg.manufacture_date();
-		decoded.manufactureDate = MfgDate{date.manufacture_day(), date.manufacture_month(), date.manufacture_year()};
-	}
-	if(msg.has_hardware_rev()) {
-		decoded.hardwareRev = versionFromProto(msg.hardware_rev());
-	}
-	if(msg.has_product_id()) {
-		decoded.productId = static_cast<uint8_t>(msg.product_id());
-	}
-	if(msg.has_bootloader_rev()) {
-		decoded.bootloaderRev = versionFromProto(msg.bootloader_rev());
-	}
-	if(msg.has_usb_descriptor()) {
-		decoded.usbDescriptor = msg.usb_descriptor();
-	}
-	for(const auto& mac : msg.mac_addresses()) {
-		const auto& bytes = mac.mac_addr();
-		if(bytes.size() < MACAddressLength)
-			continue;
-		MACAddress address{};
-		std::copy_n(bytes.begin(), MACAddressLength, address.begin());
-		decoded.macAddresses.push_back(address);
-	}
-	if(msg.has_pcb_serial()) {
-		decoded.pcbSerial = msg.pcb_serial().pcb_serial();
-	}
-	if(msg.has_chip_id()) {
-		decoded.chipId = static_cast<ChipID>(msg.chip_id());
-	}
-	if(msg.has_imei()) {
-		decoded.imei = msg.imei();
-	}
-	if(msg.has_parent_product_id()) {
-		decoded.parentProductId = static_cast<uint8_t>(msg.parent_product_id());
-	}
-	if(msg.has_software_version_lock()) {
-		decoded.softwareVersionLock = versionFromProto(msg.software_version_lock());
-	}
-
-	return std::make_shared<MfgConfigMessage>(decoded);
-}
-
-std::vector<uint8_t> MfgConfigMessage::EncodeArgumentsForGet() {
-	settings::manufacturing::v1::MfgConfig msg;
-	msg.Clear();
-	return protoapi::getPayload(protoapi::Command::GET, msg);
-}

communication/message/spiportkeymessage.cpp

@@ -1,27 +0,0 @@
-#include "icsneo/communication/message/spiportkeymessage.h"
-#include "icsneo/communication/message/extendedresponsemessage.h"
-#include "icsneo/communication/command.h"
-#include "icsneo/communication/network.h"
-
-using namespace icsneo;
-
-std::shared_ptr<SPIPortKeyMessage> SPIPortKeyMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
-	if(bytestream.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
-		return nullptr;
-
-	const auto* hdr = reinterpret_cast<const ExtendedResponseMessage::ResponseHeader*>(bytestream.data());
-
-	if(hdr->command != ExtendedCommand::ExecuteSPIPortKeyOperation)
-		return nullptr;
-
-	const size_t required = sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(SPIPortKeyPacket);
-	if(bytestream.size() < required)
-		return nullptr;
-
-	auto msg = std::make_shared<SPIPortKeyMessage>();
-
-	const auto* packet = reinterpret_cast<const SPIPortKeyPacket*>(bytestream.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
-	msg->isKeyLoaded = packet->isKeyLoaded;
-
-	return msg;
-}

communication/message/transmitmessage.cpp

@@ -137,7 +137,6 @@ static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> frame, c
 			linpacket->CoreMiniBitsLIN.TXResponder = 1;
 			break;
 		case LINMessage::Type::LIN_BREAK_ONLY:
-			linpacket->CoreMiniBitsLIN.TXCommander = 1;
 			linpacket->CoreMiniBitsLIN.BreakOnly = 1;
 			break;
 		default:

communication/multichannelcommunication.cpp

@@ -142,8 +142,6 @@ void MultiChannelCommunication::hidReadTask() {
 							dispatchMessage(msg);
 							break;
 						}
-						default:
-							break;
 					}
 
 					if(currentQueue == nullptr) {

communication/packet/linpacket.cpp

@@ -72,30 +72,18 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 		static_cast<bool>(packet->CoreMiniBitsLIN.UpdateResponderOnce),
 		static_cast<bool>(packet->CoreMiniBitsLIN.HasUpdatedResponderOnce),
 		static_cast<bool>(packet->CoreMiniBitsLIN.BusRecovered),
-		static_cast<bool>(packet->CoreMiniBitsLIN.BreakOnly),
-		static_cast<bool>(packet->CoreMiniBitsLIN.WakeupRequest)
+		static_cast<bool>(packet->CoreMiniBitsLIN.BreakOnly)
 	};
-	// Wake type only for a wake-only pulse. A UART/LIN break or a complete
-	// frame may also carry WakeupRequest; those keep their existing type.
-	const bool wakeupPulse = msg->statusFlags.WakeupRequest &&
-		packet->CoreMiniBitsLIN.len == 0 &&
-		packet->CoreMiniBitsLIN.ID == 0 &&
-		!msg->statusFlags.BreakOnly &&
-		!msg->errFlags.ErrRxBreakOnly &&
-		!msg->errFlags.ErrRxBreakSyncOnly;
-	if(wakeupPulse)
-		msg->linMsgType = LINMessage::Type::LIN_WAKEUP_REQUEST;
-	else if(msg->statusFlags.TxCommander || msg->statusFlags.TxResponder)
+	if(msg->statusFlags.TxCommander || msg->statusFlags.TxResponder)
 		msg->linMsgType = LINMessage::Type::LIN_COMMANDER_MSG;
 	else if(msg->statusFlags.BreakOnly)
 		msg->linMsgType = LINMessage::Type::LIN_BREAK_ONLY;
-	if( !wakeupPulse &&
-		(msg->errFlags.ErrRxBreakOnly     || msg->errFlags.ErrRxBreakSyncOnly ||
+	if( msg->errFlags.ErrRxBreakOnly     || msg->errFlags.ErrRxBreakSyncOnly ||
 		msg->errFlags.ErrTxRxMismatch    || msg->errFlags.ErrRxBreakNotZero  ||
 		msg->errFlags.ErrRxBreakTooShort || msg->errFlags.ErrRxSyncNot55     ||
 		msg->errFlags.ErrRxDataLenOver8  || msg->errFlags.ErrFrameSync       ||
 		msg->errFlags.ErrFrameMessageID  || msg->errFlags.ErrChecksumMatch   ||
-		msg->errFlags.ErrFrameResponderData) )
+		msg->errFlags.ErrFrameResponderData )
 		{ msg->linMsgType = LINMessage::Type::LIN_ERROR; }
 
 	msg->timestamp = packet->timestamp;
@@ -115,7 +103,7 @@ bool HardwareLINPacket::EncodeFromMessage(LINMessage& message, std::vector<uint8
 		}
 		case LINMessage::Type::LIN_BREAK_ONLY:
 		{
-			size |= 0x80u | 0x20u;
+			size |= 0x20u;
 			break;
 		}
 		case LINMessage::Type::NOT_SET:

communication/packetizer.cpp

@@ -80,7 +80,7 @@ bool Packetizer::input(RingBuffer& bytes) {
 				* end of the payload. The short packet length, for reference, only encompasses the length of the actual
 				* payload, and not the header or checksum.
 				*/
-				if(packetLength < 6 || packetLength > std::numeric_limits<uint16_t>::max()) {
+				if(packetLength < 6 || packetLength > 4000) {
 					bytes.pop_front();
 					EventManager::GetInstance().add(APIEvent::Type::FailedToRead, APIEvent::Severity::Error);
 					state = ReadState::SearchForHeader;

device/device.cpp

@@ -8,7 +8,6 @@
 #include "icsneo/disk/fat.h"
 #include "icsneo/communication/message/filter/extendedresponsefilter.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
-#include "icsneo/communication/message/mfgconfigmessage.h"
 #include "icsneo/communication/message/transmitmessage.h"
 
 #ifdef _MSC_VER
@@ -93,6 +92,10 @@ Device::~Device() {
 		disableMessagePolling();
 	if(isOpen())
 		close();
+	if(heartbeatThread.joinable()) {
+		stopHeartbeatThread = true;		
+		heartbeatThread.join();
+	}
 }
 
 uint16_t Device::getTimestampResolution() const {
@@ -239,12 +242,12 @@ std::vector<VersionReport> Device::getChipVersions(bool refreshComponents) {
 					auto& version = chipVersions.back();
 
 					auto disectedVersion = disectVersion(component.dotVersion);
-					version.id		  = chipInfo.id;
-					version.name		= chipInfo.name;
-					version.major	   = disectedVersion[0];
-					version.minor	   = disectedVersion[1];
+					version.id          = chipInfo.id;
+					version.name        = chipInfo.name;
+					version.major       = disectedVersion[0];
+					version.minor       = disectedVersion[1];
 					version.maintenance = disectedVersion[2];
-					version.build	   = disectedVersion[3];
+					version.build       = disectedVersion[3];
 				}
 			}
 		}
@@ -264,12 +267,12 @@ std::vector<VersionReport> Device::getChipVersions(bool refreshComponents) {
 			chipVersions.emplace_back();
 			auto& version = chipVersions.back();
 
-			version.id		  = chipInfo.id;
-			version.name		= chipInfo.name;
-			version.major	   = appVer->major;
-			version.minor	   = appVer->minor;
+			version.id          = chipInfo.id;
+			version.name        = chipInfo.name;
+			version.major       = appVer->major;
+			version.minor       = appVer->minor;
 			version.maintenance = 0;
-			version.build	   = 0;
+			version.build       = 0;
 		}			
 	}
 	return chipVersions;
@@ -285,8 +288,6 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 		return false;
 	}
 
-	startHeartbeat();
-
 	APIEvent::Type attemptErr = attemptToBeginCommunication();
 	if(attemptErr != APIEvent::Type::NoErrorFound) {
 		// We could not communicate with the device, let's see if an extension can
@@ -333,6 +334,79 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 			EventManager::GetInstance().cancelErrorDowngradingOnCurrentThread();
 	}
 
+	MessageFilter filter;
+	filter.includeInternalInAny = true;
+	internalHandlerCallbackID = com->addMessageCallback(std::make_shared<MessageCallback>(filter, [this](std::shared_ptr<Message> message) {
+		handleInternalMessage(message);
+	}));
+
+	// Clear the previous heartbeat thread, in case open() was called on this instance more than once
+	if(heartbeatThread.joinable())
+		heartbeatThread.join();
+
+	stopHeartbeatThread = false;
+
+	heartbeatThread = std::thread([this]() {
+		EventManager::GetInstance().downgradeErrorsOnCurrentThread();
+
+		MessageFilter filter;
+		filter.includeInternalInAny = true;
+
+		std::condition_variable heartbeatCV;
+		std::mutex receivedMessageMutex;
+		bool receivedMessage = false;
+		auto messageReceivedCallbackID = com->addMessageCallback(std::make_shared<MessageCallback>(filter, [&](std::shared_ptr<Message>) {
+			{
+				std::scoped_lock<std::mutex> lk(receivedMessageMutex);
+				receivedMessage = true;
+			}
+			heartbeatCV.notify_all();
+		}));
+
+		// Give the device time to get situated
+		auto i = 150;
+		while(!stopHeartbeatThread && i != 0) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(50));
+			i--;
+		}
+
+		while(!stopHeartbeatThread) {
+			std::unique_lock<std::mutex> recvLk(receivedMessageMutex);
+			// Wait for 110ms for a possible heartbeat
+			if(heartbeatCV.wait_for(recvLk, std::chrono::milliseconds(110), [&]() { return receivedMessage; })) {
+				receivedMessage = false;
+			} else if(!stopHeartbeatThread) { // Add this condition here in case the thread was stopped while waiting for the last message
+
+				// Some communication, such as the bootloader and extractor interfaces, must
+				// redirect the input stream from the device as it will no longer be in the
+				// packet format we expect here. As a result, status updates will not reach
+				// us here and suppressDisconnects() must be used. We don't want to request
+				// a status and then redirect the stream, as we'll then be polluting an
+				// otherwise quiet stream. This lock makes sure suppressDisconnects() will
+				// block until we've either gotten our status update or disconnected from
+				// the device.
+				std::unique_lock<std::mutex> lk(heartbeatMutex);
+				if(heartbeatSuppressed()) continue;
+
+				// No heartbeat received, request a status
+				com->sendCommand(Command::RequestStatusUpdate);
+
+				// Check if we got a message, and if not, if settings are being applied
+				if(heartbeatCV.wait_for(recvLk, std::chrono::milliseconds(3500), [&](){ return receivedMessage; })) {
+					receivedMessage = false;
+				} else {
+					if(!stopHeartbeatThread) {
+						close();
+						report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
+					}
+					break;
+				}
+			}
+		}
+
+		com->removeMessageCallback(messageReceivedCallbackID);
+	});
+
 	if(supportsLiveData())
 		clearAllLiveData();
 
@@ -429,7 +503,7 @@ bool Device::close() {
 		return false;
 	}
 
-	stopHeartbeat();
+	stopHeartbeatThread = true;
 
 	if (isMessagePollingEnabled()) {
 		disableMessagePolling();
@@ -460,15 +534,31 @@ bool Device::goOnline() {
 	if(!enableNetworkCommunication(true, onlineTimeoutMs))
 		return false;
 
+	auto startTime = std::chrono::system_clock::now();
+
 	ledState = LEDState::Online;
 
 	updateLEDState();
 
-	// (re)start the keeponline
-	keeponline = std::make_unique<Periodic>([this] {
-		static std::vector<uint8_t> timeoutBytes = std::vector<uint8_t>((uint8_t*)&onlineTimeoutMs, (uint8_t*)&onlineTimeoutMs + sizeof(onlineTimeoutMs));
-		return com->sendCommand(Command::KeepAlive, timeoutBytes);
-	}, std::chrono::milliseconds(onlineTimeoutMs / 4));
+	std::shared_ptr<MessageFilter> filter = std::make_shared<MessageFilter>(Network::NetID::Reset_Status);
+	filter->includeInternalInAny = true;
+
+	// Wait until communication is enabled or 5 seconds, whichever comes first
+	while((std::chrono::system_clock::now() - startTime) < std::chrono::seconds(5)) {
+		if(latestResetStatus && latestResetStatus->comEnabled)
+			break;
+
+		bool failOut = false;
+		com->waitForMessageSync([this, &failOut]() {
+			if(!com->sendCommand(Command::RequestStatusUpdate)) {
+				failOut = true;
+				return false;
+			}
+			return true;
+		}, filter, std::chrono::milliseconds(100));
+		if(failOut)
+			return false;
+	}
 
 	if(supportsNetworkMutex) {
 		assignedClientId = com->getClientIDSync();
@@ -485,26 +575,25 @@ bool Device::goOnline() {
 						case NetworkMutexEvent::Acquired:
 							lockedNetworks.emplace(*netMutexMsg->networks.begin());
 							break;
-						case NetworkMutexEvent::Expired:
-						case NetworkMutexEvent::Preempted:
 						case NetworkMutexEvent::Released: {
 							auto it = lockedNetworks.find(*netMutexMsg->networks.begin());
 							if (it != lockedNetworks.end())
 								lockedNetworks.erase(it);
 							break;
 						}
-						case NetworkMutexEvent::Queued:
-							break;
 					}
 				}
 			});
 		}
 	}
 
-	online = true;
+	// (re)start the keeponline
+	keeponline = std::make_unique<Periodic>([this] {
+		static std::vector<uint8_t> timeoutBytes = std::vector<uint8_t>((uint8_t*)&onlineTimeoutMs, (uint8_t*)&onlineTimeoutMs + sizeof(onlineTimeoutMs));
+		return com->sendCommand(Command::KeepAlive, timeoutBytes);
+	}, std::chrono::milliseconds(onlineTimeoutMs / 4));
 
-	// restart the heartbeat in online mode
-	restartHeartbeat();
+	online = true;
 
 	forEachExtension([](const std::shared_ptr<DeviceExtension>& ext) { ext->onGoOnline(); return true; });
 
@@ -512,19 +601,15 @@ bool Device::goOnline() {
 }
 
 bool Device::goOffline() {
-	online = false;
-
 	keeponline.reset();
 
-	// restart the heartbeat in offline mode
-	restartHeartbeat();
-
 	if(networkMutexCallbackHandle)
 		removeMessageCallback(*networkMutexCallbackHandle);
 
 	forEachExtension([](const std::shared_ptr<DeviceExtension>& ext) { ext->onGoOffline(); return true; });
 
 	if(isDisconnected()) {
+		online = false;
 		return true;
 	}
 
@@ -540,6 +625,8 @@ bool Device::goOffline() {
 
 	updateLEDState();
 
+	online = false;
+
 	return true;
 }
 
@@ -650,17 +737,15 @@ bool Device::uploadCoremini(std::istream& stream, Disk::MemoryType memType) {
 		return false;
 	}
 
-	if (memType == Disk::MemoryType::SD) {
-		auto connected = isLogicalDiskConnected();
-		
-		if(!connected) {
-			return false; // Already added an API error
-		}
-		
-		if(!(*connected)) {
-			report(APIEvent::Type::DiskNotConnected, APIEvent::Severity::Error);
-			return false;
-		}
+	auto connected = isLogicalDiskConnected();
+	
+	if(!connected) {
+		return false; // Already added an API error
+	}
+	
+	if(!(*connected)) {
+		report(APIEvent::Type::DiskNotConnected, APIEvent::Severity::Error);
+		return false;
 	}
 
 	if(!stopScript()) {
@@ -671,6 +756,7 @@ bool Device::uploadCoremini(std::istream& stream, Disk::MemoryType memType) {
 		return false;
 	}
 
+
 	if(!eraseScriptMemory(memType, static_cast<uint64_t>(bin.size()))) {
 		return false;
 	}
@@ -760,12 +846,10 @@ std::optional<CoreminiHeader> Device::readCoreminiHeader(Disk::MemoryType memTyp
 		return std::nullopt;
 	}
 
-	if (memType == Disk::MemoryType::SD) {
-		auto connected = isLogicalDiskConnected();
-
-		if(!connected) {
-			return std::nullopt; // Already added an API error
-		}
+	auto connected = isLogicalDiskConnected();
+	
+	if(!connected) {
+		return std::nullopt; // Already added an API error
 	}
 
 	#pragma pack(push, 2)
@@ -924,36 +1008,6 @@ std::shared_ptr<HardwareInfo> Device::getHardwareInfo(std::chrono::milliseconds
 	return hardwareInfo;
 }
 
-std::shared_ptr<MfgConfigMessage> Device::getMfgConfig() {
-	if(!isOpen()) {
-		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	std::vector<uint8_t> payload = MfgConfigMessage::EncodeArgumentsForGet();
-
-	auto response = com->waitForMessageSync(
-		[this, payload]() {
-			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
-		},
-		std::make_shared<MessageFilter>(Message::Type::MfgConfig),
-		std::chrono::milliseconds(250)
-	);
-
-	if(!response) {
-		report(APIEvent::Type::Timeout, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	auto mfgConfig = std::dynamic_pointer_cast<MfgConfigMessage>(response);
-	if(!mfgConfig) {
-		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
-		return nullptr;
-	}
-
-	return mfgConfig;
-}
-
 
 std::optional<uint64_t> Device::readLogicalDisk(uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, Disk::MemoryType memType) {
 	if(!into || timeout <= std::chrono::milliseconds(0)) {
@@ -1931,9 +1985,11 @@ void Device::stopScriptStatusThreadIfNecessary(std::unique_lock<std::mutex> lk)
 }
 
 Lifetime Device::suppressDisconnects() {
-	stopHeartbeat();
+	std::lock_guard<std::mutex> lk(heartbeatMutex);
+	heartbeatSuppressedByUser++;
 	return Lifetime([this] { 
-		startHeartbeat();
+		std::lock_guard<std::mutex> lk2(heartbeatMutex);
+		heartbeatSuppressedByUser--;
 	});
 }
 
@@ -2069,18 +2125,6 @@ std::optional<EthPhyMessage> Device::sendEthPhyMsg(const EthPhyMessage& message,
 	return std::make_optional<EthPhyMessage>(*retMsg);
 }
 
-bool Device::sendSPIPortKeyOperation(uint8_t portIndex, SPIPortKeyMessage::Operation op, std::array<uint8_t, 16> key) {
-	std::vector<uint8_t> args(sizeof(SPIPortKeyMessage::SPIPortKeyPacket));
-	auto& params = *reinterpret_cast<SPIPortKeyMessage::SPIPortKeyPacket*>(args.data());
-	params.op = op;
-	params.portIndex = portIndex;
-	std::copy(key.begin(), key.end(), params.key);
-	if(!com->sendCommand(ExtendedCommand::ExecuteSPIPortKeyOperation, args)) {
-		return false;
-	}
-	return true;
-}
-
 std::optional<bool> Device::SetRootDirectoryEntryFlags(uint8_t mask, uint8_t values, uint32_t collectionEntryByteAddress)
 {
 	if(!supportsWiVI())
@@ -3250,12 +3294,11 @@ bool Device::findVSAOffsetFromTimepoint(ICSClock::time_point point, uint64_t& vs
 		std::shared_ptr<VSA> midRecord;
 		auto midRecordStatus = parser.getRecordFromBytes(buffer.data(), Disk::SectorSize, midRecord);
 		switch(midRecordStatus) {
-			case VSAParser::RecordParseStatus::NotARecordStart: {
+			case VSAParser::RecordParseStatus::NotARecordStart:
 				// This part of the buffer does not contain records
 				rightIndex = midIndex - 1;
 				continue;
-			}
-			case VSAParser::RecordParseStatus::ConsecutiveExtended: {
+			case VSAParser::RecordParseStatus::ConsecutiveExtended:
 				// We dropped in the middle of an extended message record
 				auto extendedRecord = std::dynamic_pointer_cast<VSAExtendedMessage>(midRecord); 
 				uint64_t pos = readPos;
@@ -3270,9 +3313,6 @@ bool Device::findVSAOffsetFromTimepoint(ICSClock::time_point point, uint64_t& vs
 				midIndex = (pos - firstOffset) / Disk::SectorSize;
 				midRecord = extendedRecord;
 				break;
-			}
-			default:
-				break;
 		}
 		if(midIndex <= leftIndex) {
 			// Extended records cause problems with binary search
@@ -3695,15 +3735,6 @@ bool Device::requestTC10Sleep(Network::NetID network) {
 	return typed->response == ExtendedResponse::OK;
 }
 
-bool Device::reboot(bool safe) {
-	if(!supportsReboot()) {
-		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
-		return false;
-	}
-	// The device reboots in response to this command, so no reply is expected.
-	return com->sendCommand(ExtendedCommand::Reboot, { uint8_t(safe ? 1 : 0) });
-}
-
 std::optional<TC10StatusMessage> Device::getTC10Status(Network::NetID network) {
 	if(!supportsTC10()) {
 		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
@@ -4113,270 +4144,3 @@ bool Device::unlockAllNetworks()
 
 	return true;
 }
-
-void Device::startHeartbeat() {
-	if(!heartbeat)
-		heartbeat = std::make_unique<Heartbeat>(*this);
-}
-
-void Device::stopHeartbeat() {
-	heartbeat.reset();
-}
-
-void Device::restartHeartbeat() {
-	stopHeartbeat();
-	startHeartbeat();
-}
-
-bool Device::iso15765Enable(const Network& network) {
-	return J2534_EnableIso15765(network, true);
-}
-
-bool Device::iso15765DisableAll(void) {
-	bool ok = true;
-	for(const auto& slot : iso15765FirmwareEnabled)
-	{
-        if (slot.second)
-        {
-            if (!J2534_EnableIso15765(slot.first, false))
-                ok = false;
-        }
-	}
-	return ok;
-}
-
-bool Device::iso15765TransmitMessage(const Network& network, const Iso15765MessageArgs& msg, const std::chrono::milliseconds& timeout) {
-	if (!isOnline())
-		return false;
-
-	if(iso15765FirmwareEnabled.find(network) == iso15765FirmwareEnabled.end() || !iso15765FirmwareEnabled[network])
-		return false;
-
-	bool result;
-	Iso15765TxSetupMessage setupMsg;
-
-	//Set the network ID to use
-	if(const auto& coreMiniId = network.getCoreMini())
-		setupMsg.setCoreMiniId((uint16_t)*coreMiniId);
-
-	const uint8_t txIndex = msg.getTxIndex();
-	setupMsg.setIdx(txIndex);
-
-	setupMsg.setId(msg.getArbId().Id);
-	setupMsg.setFcId(msg.getFlowControlArbId().Id);
-	setupMsg.setFcIdMask(msg.getFlowControlArbIdMask());
-
-	setupMsg.setFsTimeout(msg.getFsTimeout());
-	setupMsg.setFsWait(msg.getFsWaitTimeout());
-
-	const uint32_t messageLength = (uint32_t)msg.getData().size();
-	setupMsg.setMessageLength(messageLength);
-	setupMsg.setIs29BitEnabled(msg.getArbId().Is29Bit);
-	setupMsg.setIsFc29BitEnabled(msg.getFlowControlArbId().Is29Bit);
-	if(const auto& extAddress = msg.getExtendedAddress())
-	{
-		setupMsg.setExtAddressEnabled(true);
-		setupMsg.setExtendedAddress(*extAddress);
-	}
-	if(const auto& extFcAddress = msg.getFlowControlExtendedAddress())
-	{
-		setupMsg.setFcExtAddressEnabled(true);
-		setupMsg.setFlowControlExtendedAddress(*extFcAddress);
-	}
-	if(const auto& stMin = msg.getStMin())
-	{
-		setupMsg.setOverrideStMin(true);
-		setupMsg.setStMin(*stMin);
-	}
-	if(const auto& blockSize = msg.getBlockSize())
-	{
-		setupMsg.setOverrideBlockSize(true);
-		setupMsg.setBlockSize(*blockSize);
-	}
-	if(const auto& padding = msg.getPaddingValue())
-	{
-		setupMsg.setPaddingEnabled(true);
-		setupMsg.setPadding(*padding);
-	}
-	setupMsg.setIsBrsEnabled(msg.getIsBrsEnabled());
-	setupMsg.setIsCanFd(msg.getIsCanFd());
-	setupMsg.setTxDl(msg.getTxDl());
-
-	{
-		uint32_t octetsToSend = messageLength;
-		const uint8_t* payload = msg.getData().data();
-		uint32_t offset = 0;
-
-		result = J2534_Transaction(network, std::move(setupMsg), timeout);
-		while(result && octetsToSend)
-		{
-			const uint16_t chunkSize = (uint16_t)std::min((uint32_t)Iso15765TxDataMessage::MaxDataLength, octetsToSend);
-
-			Iso15765TxDataMessage dataMsg;
-			dataMsg.setIdx(txIndex);
-			dataMsg.setOffset(offset);
-			dataMsg.setData(&payload[offset], chunkSize);
-
-			result = J2534_Transaction(network, std::move(dataMsg), timeout);
-
-			offset += chunkSize;
-			octetsToSend -= chunkSize;
-		}
-	}
-
-	return result;
-}
-
-bool Device::iso15765SetupRxFlowControl(const Network& network, const Iso15765MessageArgs& msg) {
-	if (!isOnline())
-		return false;
-
-	if(iso15765FirmwareEnabled.find(network) == iso15765FirmwareEnabled.end() || !iso15765FirmwareEnabled[network])
-		return false;
-
-	J2534SetupIso15765FlowControlMessage rxFlowControl;
-
-	rxFlowControl.setIsBrsEnabled(msg.getIsBrsEnabled());
-	rxFlowControl.setIsCanFd(msg.getIsCanFd());
-	rxFlowControl.setIdx(msg.getTxIndex());
-	if(const auto& coreMiniId = network.getCoreMini())
-		rxFlowControl.setCoreMiniId((uint16_t)*coreMiniId);
-	rxFlowControl.setEnable(true);
-	if(const auto& blockSize = msg.getBlockSize())
-	{
-		rxFlowControl.setBlockSize(*blockSize);
-	}
-	rxFlowControl.setCfTimeout(msg.getCfTimeout());
-	rxFlowControl.setFlowControlTransmissionEnabled(msg.getIsFlowControlEnabled());
-	if(const auto& extAddress = msg.getExtendedAddress())
-	{
-		rxFlowControl.setExtendedAddress(*extAddress);
-		rxFlowControl.setExtAddressEnabled(true);
-	}
-	if(const auto& fcExtAddress = msg.getFlowControlExtendedAddress())
-	{
-		rxFlowControl.setFlowControlExtendedAddress(*fcExtAddress);
-		rxFlowControl.setFcExtAddressEnabled(true);
-	}
-	rxFlowControl.setFcId(msg.getFlowControlArbId().Id);
-	rxFlowControl.setIsFc29BitEnabled(msg.getFlowControlArbId().Is29Bit);
-	rxFlowControl.setIs29BitEnabled(msg.getArbId().Is29Bit);
-	rxFlowControl.setId(msg.getArbId().Id);
-	rxFlowControl.setIdMask(msg.getFlowControlArbIdMask());
-	if(const auto& padding = msg.getPaddingValue())
-	{
-		rxFlowControl.setPadding(*padding);
-		rxFlowControl.setPaddingEnabled(true);
-	}
-	if(const auto& stMin = msg.getStMin())
-	{
-		rxFlowControl.setStMin(*stMin);
-	}
-
-	return J2534_Transaction(network, std::move(rxFlowControl), std::chrono::milliseconds(0));
-}
-
-bool Device::J2534_Transaction(const Network& network, J2534CommandMessage&& msg, const std::chrono::milliseconds& timeout) {
-	msg.network = network;
-	if (timeout.count())
-	{
-		static std::shared_ptr<MessageFilter> filter = std::make_shared<Main51MessageFilter>(Command::J2534Command);
-		const auto& response = com->waitForMessageSync([&](void)
-			{
-				return com->sendCommand(msg.command, msg.getArgumentData());
-			}, filter, timeout);
-
-		if (!response)
-		{
-			report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
-			return false;
-		}
-
-		auto responseMsg = std::dynamic_pointer_cast<Main51Message>(response);
-		if (!responseMsg || responseMsg->command != Command::J2534Command)
-		{
-			report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
-			return false;
-		}
-	}
-	else
-	{
-		return com->sendCommand(msg.command, msg.getArgumentData());
-	}
-
-	// NOTE: responseMsg->data.front()
-
-	return true;
-}
-
-
-bool Device::J2534_ClearRxFilters(const Network& network)
-{
-	return J2534_Transaction(network, J2534CommandMessage(J2534CommandMessage::J2534Command::SetupClearCanRxFilters, { (uint8_t)0 /* is this necessary? */}), std::chrono::milliseconds(0));
-}
-
-bool Device::J2534_SetupCanRxFilter(const Network& network, const J2534_RxCanFilter& rxCanFilter)
-{
-	return J2534_Transaction(network, J2534SetupCanRxFilteringMessage(rxCanFilter), std::chrono::milliseconds(0));
-}
-
-bool Device::J2534_EnableFiltering(const Network& network, const bool enable)
-{
-	return J2534_Transaction(network, J2534EnableFilteringMessage(enable), std::chrono::milliseconds(0));
-}
-
-
-
-bool Device::J2534_EnableIso15765(const Network& network, const bool enable)
-{
-	if (iso15765FirmwareEnabled[network] == enable)
-		return true;
-
-	if (!J2534_Transaction(network, J2534EnableMessage(enable), std::chrono::milliseconds(0)))
-		return false;
-
-	iso15765FirmwareEnabled[network] = enable;
-
-	if (enable)
-	{
-		// Turn OFF filtering of CAN messages in the firmware
-		return J2534_EnableFirmwareUsbPassFilters(network, false);
-	}
-	return true;
-}
-
-bool Device::J2534_ClearRxFilter(const Network& network, unsigned int iIndex)
-{
-	if (const auto& slot = iso15765FirmwareEnabled.find(network); slot != iso15765FirmwareEnabled.end() && slot->second)
-	{
-		J2534_RxCanFilter rxFilter;
-		memset(&rxFilter, 0, sizeof(rxFilter));
-		rxFilter.idx = (uint16_t)iIndex;
-		return J2534_SetupCanRxFilter(network, rxFilter);
-	}
-	return false;
-}
-
-bool Device::J2534_EnableFirmwareUsbPassFilters(const Network& network, const bool enable)
-{
-	const auto& slot = iso15765FirmwareEnabled.find(network);
-	if (slot == iso15765FirmwareEnabled.end())
-		return false;
-	//check for disconnect here!
-	if (!slot->second)
-	{
-		// Tried to shut-off Rx table message filtering but FW ISO15765 was not enabled
-		return true; //just ignore it, no filtering can occur anyway
-	}
-
-	if (enable) //turning ON filtering in the Firmware based on the rx table
-	{
-		//Rx table message filtering is on by default in the firmware when m_bISO15765_FW_Enabled is true
-		//need to check here to see if we set index 0 to a PASS all filter (i.e. turned off USB filtering)
-		if (!J2534_ClearRxFilters(network))
-			return false;
-	}
-
-	// New "filtering enable" mechanism - old firmware ignores this frame
-	return J2534_EnableFiltering(network, enable);
-}

device/devicefinder.cpp

@@ -241,10 +241,6 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADSupermoon>(dev, newFoundDevices);
 		#endif
 
-		#ifdef __RADWBMS_H_
-		makeIfSerialMatches<RADwBMS>(dev, newFoundDevices);
-		#endif
-
 		#ifdef __VALUECAN3_H_
 		makeIfSerialRangeMatches<ValueCAN3>(dev, newFoundDevices);
 		#endif
@@ -408,10 +404,6 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADSupermoon::DEVICE_TYPE,
 		#endif
 
-		#ifdef __RADWBMS_H_
-		RADwBMS::DEVICE_TYPE,
-		#endif
-
 		#ifdef __VALUECAN3_H_
 		ValueCAN3::DEVICE_TYPE,
 		#endif

device/idevicesettings.cpp

@@ -1,16 +1,9 @@
-#include "icsneo/device/device.h"
 #include "icsneo/device/idevicesettings.h"
 #include "icsneo/communication/message/filter/main51messagefilter.h"
 #include <cstring>
 
 using namespace icsneo;
 
-IDeviceSettings::IDeviceSettings(Device* device, size_t size)
-	: device(device), report(device->report), structSize(size) {}
-
-IDeviceSettings::IDeviceSettings(warn_t createInoperableSettings, Device* device)
-	: disabled(true), readonly(true), report(device->report), structSize(0) { (void)createInoperableSettings; }
-
 std::optional<uint16_t> IDeviceSettings::CalculateGSChecksum(const std::vector<uint8_t>& settings) {
 	const uint16_t* p = reinterpret_cast<const uint16_t*>(settings.data());
 	size_t words = settings.size();
@@ -173,7 +166,7 @@ bool IDeviceSettings::refresh() {
 	}
 
 	std::vector<uint8_t> rxSettings;
-	bool ret = device->com->getSettingsSync(rxSettings);
+	bool ret = com->getSettingsSync(rxSettings);
 	if(!ret) {
 		report(APIEvent::Type::SettingsReadError, APIEvent::Severity::Error);
 		return false;
@@ -238,10 +231,10 @@ bool IDeviceSettings::apply(bool temporary) {
 	memcpy(bytestream.data() + 7, getMutableRawStructurePointer(), settings.size());
 
 	// Pause I/O with the device while the settings are applied
-	device->stopHeartbeat();
+	applyingSettings = true;
 
-	std::shared_ptr<Main51Message> msg = std::dynamic_pointer_cast<Main51Message>(device->com->waitForMessageSync([this, &bytestream]() {
-		return device->com->sendCommand(Command::SetSettings, bytestream);
+	std::shared_ptr<Main51Message> msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this, &bytestream]() {
+		return com->sendCommand(Command::SetSettings, bytestream);
 	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(5000)));
 
 	if(!msg || msg->data[0] != 1) { // We did not receive a response
@@ -266,8 +259,8 @@ bool IDeviceSettings::apply(bool temporary) {
 	bytestream[6] = (uint8_t)(*gsChecksum >> 8);
 	memcpy(bytestream.data() + 7, getMutableRawStructurePointer(), settings.size());
 
-	msg = std::dynamic_pointer_cast<Main51Message>(device->com->waitForMessageSync([this, &bytestream]() {
-		return device->com->sendCommand(Command::SetSettings, bytestream);
+	msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this, &bytestream]() {
+		return com->sendCommand(Command::SetSettings, bytestream);
 	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(5000)));
 	if(!msg || msg->data[0] != 1) {
 		// Attempt to get the settings from the device so we're up to date if possible
@@ -279,12 +272,12 @@ bool IDeviceSettings::apply(bool temporary) {
 	}
 
 	if(!temporary) {
-		msg = std::dynamic_pointer_cast<Main51Message>(device->com->waitForMessageSync([this]() {
-			return device->com->sendCommand(Command::SaveSettings);
+		msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this]() {
+			return com->sendCommand(Command::SaveSettings);
 		}, std::make_shared<Main51MessageFilter>(Command::SaveSettings), std::chrono::milliseconds(5000)));
 	}
 
-	device->startHeartbeat();
+	applyingSettings = false;
 
 	refresh(); // Refresh our buffer with what the device has, whether we were successful or not
 
@@ -306,10 +299,10 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
 		return false;
 	}
 
-	device->stopHeartbeat();
+	applyingSettings = true;
 
-	std::shared_ptr<Main51Message> msg = std::dynamic_pointer_cast<Main51Message>(device->com->waitForMessageSync([this]() {
-		return device->com->sendCommand(Command::SetDefaultSettings);
+	std::shared_ptr<Main51Message> msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this]() {
+		return com->sendCommand(Command::SetDefaultSettings);
 	}, std::make_shared<Main51MessageFilter>(Command::SetDefaultSettings), std::chrono::milliseconds(5000)));
 	if(!msg || msg->data[0] != 1) {
 		// Attempt to get the settings from the device so we're up to date if possible
@@ -343,8 +336,8 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
 	bytestream[6] = (uint8_t)(*gsChecksum >> 8);
 	memcpy(bytestream.data() + 7, getMutableRawStructurePointer(), settings.size());
 
-	msg = std::dynamic_pointer_cast<Main51Message>(device->com->waitForMessageSync([this, &bytestream]() {
-		return device->com->sendCommand(Command::SetSettings, bytestream);
+	msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this, &bytestream]() {
+		return com->sendCommand(Command::SetSettings, bytestream);
 	}, std::make_shared<Main51MessageFilter>(Command::SetSettings), std::chrono::milliseconds(5000)));
 	if(!msg || msg->data[0] != 1) {
 		// Attempt to get the settings from the device so we're up to date if possible
@@ -356,12 +349,12 @@ bool IDeviceSettings::applyDefaults(bool temporary) {
 	}
 
 	if(!temporary) {
-		msg = std::dynamic_pointer_cast<Main51Message>(device->com->waitForMessageSync([this]() {
-			return device->com->sendCommand(Command::SaveSettings);
+		msg = std::dynamic_pointer_cast<Main51Message>(com->waitForMessageSync([this]() {
+			return com->sendCommand(Command::SaveSettings);
 		}, std::make_shared<Main51MessageFilter>(Command::SaveSettings), std::chrono::milliseconds(5000)));
 	}
 
-	device->startHeartbeat();
+	applyingSettings = false;
 
 	refresh(); // Refresh our buffer with what the device has, whether we were successful or not
 
@@ -966,150 +959,4 @@ bool IDeviceSettings::setMiscIOAnalogOutput(uint8_t pin, MiscIOAnalogVoltage vol
 	(void)voltage;
 	report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::Error);
 	return false;
-}
-std::optional<RADGPTPProfile> IDeviceSettings::getGPTPProfile() const {
-	const auto* gptp = getGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	return static_cast<RADGPTPProfile>(gptp->profile);
-}
-
-bool IDeviceSettings::setGPTPProfile(RADGPTPProfile profile) {
-	auto* gptp = getMutableGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-	gptp->profile = static_cast<uint8_t>(profile);
-	return true;
-}
-
-std::optional<RADGPTPRole> IDeviceSettings::getGPTPRole() const {
-	const auto* gptp = getGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	return static_cast<RADGPTPRole>(gptp->gptpPortRole);
-}
-
-bool IDeviceSettings::setGPTPRole(RADGPTPRole role) {
-	auto* gptp = getMutableGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-	gptp->gptpPortRole = static_cast<uint8_t>(role);
-	return true;
-}
-
-std::optional<uint8_t> IDeviceSettings::getGPTPEnabledPort() const {
-	const auto* gptp = getGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	return gptp->gptpEnabledPort;
-}
-
-bool IDeviceSettings::setGPTPEnabledPort(uint8_t port) {
-	auto* gptp = getMutableGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-	gptp->gptpEnabledPort = port;
-	return true;
-}
-
-std::optional<bool> IDeviceSettings::isGPTPClockSyntonizationEnabled() const {
-	const auto* gptp = getGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	return gptp->enableClockSyntonization != 0;
-}
-
-bool IDeviceSettings::setGPTPClockSyntonizationEnabled(bool enable) {
-	auto* gptp = getMutableGPTPSettings();
-	if(!gptp) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return false;
-	}
-	gptp->enableClockSyntonization = enable ? 1 : 0;
-	return true;
-}
-
-std::optional<bool> IDeviceSettings::getLinuxBootEnabled() {
-	const auto* os = getLinuxSettings();
-	if(os == nullptr) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	return os->allowBoot != 0;
-}
-
-bool IDeviceSettings::setLinuxBootEnabled(bool enabled) {
-	auto os = getMutableLinuxSettings();
-	if(!os) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::Error);
-		return false;
-	}
-	(*os)->allowBoot = enabled ? 1 : 0;
-	return true;
-}
-
-std::optional<bool> IDeviceSettings::getExternalWifiAntennaEnabled() {
-	const auto* os = getLinuxSettings();
-	if(os == nullptr) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	return os->useExternalWifiAntenna != 0;
-}
-
-bool IDeviceSettings::setExternalWifiAntennaEnabled(bool enabled) {
-	auto os = getMutableLinuxSettings();
-	if(!os) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::Error);
-		return false;
-	}
-	(*os)->useExternalWifiAntenna = enabled ? 1 : 0;
-	return true;
-}
-
-std::optional<LinuxConfigurationPort> IDeviceSettings::getLinuxConfigurationPort() {
-	const auto* os = getLinuxSettings();
-	if(os == nullptr) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-	switch(static_cast<LinuxConfigurationPort>(os->ethConfigurationPort)) {
-		case LinuxConfigurationPort::ETH01:
-			return LinuxConfigurationPort::ETH01;
-		case LinuxConfigurationPort::USB:
-		default: // Any other value means the configuration interface is over USB
-			return LinuxConfigurationPort::USB;
-	}
-}
-
-bool IDeviceSettings::setLinuxConfigurationPort(LinuxConfigurationPort port) {
-	switch(port) {
-		case LinuxConfigurationPort::USB:
-		case LinuxConfigurationPort::ETH01:
-			break;
-		default:
-			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
-			return false;
-	}
-	auto os = getMutableLinuxSettings();
-	if(!os) {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::Error);
-		return false;
-	}
-	(*os)->ethConfigurationPort = static_cast<uint8_t>(port);
-	return true;
-}
+}

docs/icsneoc2/examples.rst

@@ -74,14 +74,6 @@ Ethernet Receive
 .. literalinclude:: ../../examples/c2/ethernet_receive/src/main.c
    :language: c
 
-Ethernet Status
-===============
-
-:download:`Download example <../../examples/c2/ethernet_status/src/main.c>`
-
-.. literalinclude:: ../../examples/c2/ethernet_status/src/main.c
-   :language: c
-
 T1S Loopback
 ============
 
@@ -98,27 +90,3 @@ TC10
 .. literalinclude:: ../../examples/c2/tc10/src/main.c
    :language: c
 
-gPTP
-====
-
-:download:`Download example <../../examples/c2/gptp/src/main.c>`
-
-.. literalinclude:: ../../examples/c2/gptp/src/main.c
-   :language: c
-
-PerfTest
-========
-
-:download:`Download example <../../examples/c2/perf_test/src/main.c>`
-
-.. literalinclude:: ../../examples/c2/perf_test/src/main.c
-   :language: c
-
-Termination Groups
-==================
-
-:download:`Download example <../../examples/c2/termination/src/main.c>`
-
-.. literalinclude:: ../../examples/c2/termination/src/main.c
-   :language: c
-

examples/CMakeLists.txt

@@ -8,16 +8,12 @@ option(LIBICSNEO_BUILD_C2_DISKFORMAT_EXAMPLE "Build the C2 disk format example."
 option(LIBICSNEO_BUILD_C2_RECONNECT_EXAMPLE "Build the C2 reconnect example." ON)
 option(LIBICSNEO_BUILD_C2_DEVICE_INFO_EXAMPLE "Build the C2 device info example." ON)
 option(LIBICSNEO_BUILD_C2_CHIP_VERSIONS_EXAMPLE "Build the C2 chip versions example." ON)
-option(LIBICSNEO_BUILD_C2_TERMINATION_EXAMPLE "Build the C2 termination groups example." ON)
 option(LIBICSNEO_BUILD_C2_LIN_EXAMPLE "Build the C2 LIN example." ON)
 option(LIBICSNEO_BUILD_C2_LIN_TRANSMIT_EXAMPLE "Build the C2 LIN transmit example." ON)
 option(LIBICSNEO_BUILD_C2_ETHERNET_TRANSMIT_EXAMPLE "Build the C2 ethernet transmit example." ON)
 option(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE "Build the C2 ethernet receive example." ON)
-option(LIBICSNEO_BUILD_C2_ETHERNET_STATUS_EXAMPLE "Build the C2 ethernet status example." ON)
 option(LIBICSNEO_BUILD_C2_T1S_LOOPBACK_EXAMPLE "Build the C2 RAD-Comet3 T1S loopback example." ON)
 option(LIBICSNEO_BUILD_C2_TC10_EXAMPLE "Build the C2 TC10 example." ON)
-option(LIBICSNEO_BUILD_C2_GPTP_EXAMPLE "Build the C2 gPTP settings example." ON)
-option(LIBICSNEO_BUILD_C2_PERF_TEST_EXAMPLE "Build the C2 PerfTest setting example." ON)
 option(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE "Build the simple C++ example." ON)
 option(LIBICSNEO_BUILD_CPP_DEVICE_INFO_EXAMPLE "Build the C++ device info example." ON)
 option(LIBICSNEO_BUILD_CPP_INTERACTIVE_EXAMPLE "Build the command-line interactive C++ example." ON)
@@ -35,8 +31,6 @@ option(LIBICSNEO_BUILD_CPP_MUTEX_EXAMPLE "Build the NetworkMutex example." ON)
 option(LIBICSNEO_BUILD_CPP_ANALOG_OUT_EXAMPLE "Build the analog output example." ON)
 option(LIBICSNEO_BUILD_CPP_DISKFORMAT_EXAMPLE "Build the disk format example." ON)
 option(LIBICSNEO_BUILD_CPP_T1S_EXAMPLE "Build the T1S example." ON)
-option(LIBICSNEO_BUILD_CPP_GPTP_EXAMPLE "Build the C++ gPTP settings example." ON)
-option(LIBICSNEO_BUILD_CPP_ISO15765_LOOPBACK_EXAMPLE "Build the C++ ISO15765 two-device CAN1 loopback example." ON)
 
 add_compile_options(${LIBICSNEO_COMPILER_WARNINGS})
 
@@ -80,10 +74,6 @@ if(LIBICSNEO_BUILD_C2_CHIP_VERSIONS_EXAMPLE)
 	add_subdirectory(c2/chip_versions)
 endif()
 
-if(LIBICSNEO_BUILD_C2_TERMINATION_EXAMPLE)
-	add_subdirectory(c2/termination)
-endif()
-
 if(LIBICSNEO_BUILD_C2_LIN_EXAMPLE)
 	add_subdirectory(c2/lin)
 endif()
@@ -100,10 +90,6 @@ if(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE)
 	add_subdirectory(c2/ethernet_receive)
 endif()
 
-if(LIBICSNEO_BUILD_C2_ETHERNET_STATUS_EXAMPLE)
-	add_subdirectory(c2/ethernet_status)
-endif()
-
 if(LIBICSNEO_BUILD_C2_T1S_LOOPBACK_EXAMPLE)
 	add_subdirectory(c2/t1s_loopback)
 endif()
@@ -112,14 +98,6 @@ if(LIBICSNEO_BUILD_C2_TC10_EXAMPLE)
 	add_subdirectory(c2/tc10)
 endif()
 
-if(LIBICSNEO_BUILD_C2_GPTP_EXAMPLE)
-	add_subdirectory(c2/gptp)
-endif()
-
-if(LIBICSNEO_BUILD_C2_PERF_TEST_EXAMPLE)
-	add_subdirectory(c2/perf_test)
-endif()
-
 if(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE)
 	add_subdirectory(cpp/simple)
 endif()
@@ -187,11 +165,3 @@ endif()
 if(LIBICSNEO_BUILD_CPP_T1S_EXAMPLE)
 	add_subdirectory(cpp/t1s)
 endif()
-
-if(LIBICSNEO_BUILD_CPP_GPTP_EXAMPLE)
-	add_subdirectory(cpp/gptp)
-endif()
-
-if(LIBICSNEO_BUILD_CPP_ISO15765_LOOPBACK_EXAMPLE)
-	add_subdirectory(cpp/iso15765_loopback)
-endif()

examples/c/legacy/lin/main.c

@@ -58,7 +58,7 @@ int main() {
 		msg1.Protocol = SPY_PROTOCOL_LIN;
 		msg1.StatusBitField = 0;
 		msg1.StatusBitField2 = 0;
-		lNetworkID = NETID_LIN2;
+		lNetworkID = NETID_LIN_02;
 		msg1.Header[0] = 0x11; //protected ID
 		msg1.Header[1] = 0xaa;
 		msg1.Header[2] = 0xbb;
@@ -80,7 +80,7 @@ int main() {
 		icsSpyMessageJ1850 msg2 = {0};
 		msg2.Protocol = SPY_PROTOCOL_LIN;
 		msg2.StatusBitField = SPY_STATUS_INIT_MESSAGE;
-		lNetworkID = NETID_LIN;
+		lNetworkID = NETID_LIN_01;
 		msg2.Header[0] = 0x11; //protected ID
 		msg2.NumberBytesData = 0;
 		msg2.NumberBytesHeader = 1;
@@ -96,7 +96,7 @@ int main() {
 		msg3.Protocol = SPY_PROTOCOL_LIN;
 		msg3.StatusBitField = SPY_STATUS_INIT_MESSAGE;
 		msg3.StatusBitField2 = 0;
-		lNetworkID = NETID_LIN;
+		lNetworkID = NETID_LIN_01;
 		msg3.Header[0] = 0xe2; //protected ID
 		msg3.Header[1] = 0x44;
 		msg3.Header[2] = 0x33;
@@ -131,10 +131,10 @@ int main() {
 					const icsSpyMessageJ1850* linMsg = (icsSpyMessageJ1850*)&rxMsg[idx];
 					size_t frameLen = (linMsg->NumberBytesHeader + linMsg->NumberBytesData);
 					size_t dataLen = (frameLen > 2) ? (frameLen - 2) : 0;
-					if(linMsg->NetworkID == NETID_LIN) {
+					if(linMsg->NetworkID == NETID_LIN_01) {
 						printf("LIN 1 | ID: 0x%02x [%zu] ", linMsg->Header[0], dataLen);
 					}
-					else if (linMsg->NetworkID == NETID_LIN2) {
+					else if (linMsg->NetworkID == NETID_LIN_02) {
 						printf("LIN 2 | ID: 0x%02x [%zu] ", linMsg->Header[0], dataLen);
 					}
 

examples/c2/device_info/src/main.c

@@ -112,7 +112,7 @@ int main() {
 		}
 		printf("MACs:       %u entr%s\n", mac_count, mac_count == 1 ? "y" : "ies");
 		for(icsneoc2_mac_addr_entry_t* cur = macs; cur; cur = icsneoc2_mac_addresses_next(cur)) {
-			icsneoc2_netid_t network_id;
+			_icsneoc2_netid_t network_id;
 			icsneoc2_mac_network_id_get(cur, &network_id);
 			printf("  Network %-5u  ", (unsigned)network_id);
 			uint8_t address[6];

examples/c2/diskformat/src/main.c

@@ -109,85 +109,6 @@ int main() {
 		}
 	}
 
-	/* Choose operation */
-	printf("\n\tChoose operation:\n");
-	printf("\t  [f] Format the disk(s)\n");
-	printf("\t  [u] Update the disk configuration without formatting\n");
-	printf("\t  [q] Quit\n");
-	printf("\tSelection [f/u/q]: ");
-	char choice[8] = {0};
-	if(scanf("%7s", choice) != 1) {
-		choice[0] = 'q';
-	}
-
-	if(choice[0] == 'u' || choice[0] == 'U') {
-		/* Force a disk config update (e.g. changing the disk layout) without formatting.
-		 * Unlike a format, this preserves the existing data on the disk(s). */
-		printf("\n\tChoose disk layout:\n");
-		printf("\t  [s] Spanned\n");
-		printf("\t  [r] RAID0\n");
-		printf("\tSelection [s/r] (current: %s): ", layout == icsneoc2_disk_layout_raid0 ? "RAID0" : "Spanned");
-		char layout_choice[8] = {0};
-		if(scanf("%7s", layout_choice) != 1) {
-			layout_choice[0] = '\0';
-		}
-		if(layout_choice[0] == 'r' || layout_choice[0] == 'R') {
-			icsneoc2_disk_details_layout_set(details, icsneoc2_disk_layout_raid0);
-		} else if(layout_choice[0] == 's' || layout_choice[0] == 'S') {
-			icsneoc2_disk_details_layout_set(details, icsneoc2_disk_layout_spanned);
-		} else {
-			printf("\tKeeping current layout.\n");
-		}
-
-		/* Enable/disable individual disks in the configuration. A disk's enabled
-		 * state is carried by the FORMATTED flag; only present disks can be enabled. */
-		for(size_t i = 0; i < detail_count; i++) {
-			icsneoc2_disk_format_flags_t flags = 0;
-			icsneoc2_disk_details_flags_get(details, i, &flags);
-			if(!(flags & ICSNEOC2_DISK_FORMAT_FLAGS_PRESENT)) {
-				continue; /* Can't enable a disk that isn't present */
-			}
-			printf("\tEnable disk [%zu]? [y/N] (currently %s): ", i,
-				(flags & ICSNEOC2_DISK_FORMAT_FLAGS_FORMATTED) ? "enabled" : "disabled");
-			char disk_choice[8] = {0};
-			if(scanf("%7s", disk_choice) != 1) {
-				disk_choice[0] = '\0';
-			}
-			if(disk_choice[0] == 'y' || disk_choice[0] == 'Y') {
-				flags |= ICSNEOC2_DISK_FORMAT_FLAGS_FORMATTED;
-			} else {
-				flags &= ~(icsneoc2_disk_format_flags_t)ICSNEOC2_DISK_FORMAT_FLAGS_FORMATTED;
-			}
-			icsneoc2_disk_details_flags_set(details, i, flags);
-		}
-
-		icsneoc2_disk_layout_t new_layout = 0;
-		icsneoc2_disk_details_layout_get(details, &new_layout);
-		printf("\n\tForcing disk config update on %s to %s layout (no data will be erased)...\n",
-			description, new_layout == icsneoc2_disk_layout_raid0 ? "RAID0" : "Spanned");
-		res = icsneoc2_device_force_disk_config_update(device, details);
-		if(res != icsneoc2_error_success) {
-			print_error_code("\tForce disk config update failed", res);
-			icsneoc2_disk_details_free(details);
-			icsneoc2_device_close(device);
-			icsneoc2_device_free(device);
-			return -1;
-		}
-		printf("\tDisk config update complete!\n");
-		icsneoc2_disk_details_free(details);
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-		return 0;
-	}
-
-	if(choice[0] != 'f' && choice[0] != 'F') {
-		printf("\tAborted.\n");
-		icsneoc2_disk_details_free(details);
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-		return 0;
-	}
-
 	/* Build format config: mark present disks for formatting */
 	bool any_present = false;
 	for(size_t i = 0; i < detail_count; i++) {

examples/c2/ethernet_status/CMakeLists.txt

@@ -1,6 +0,0 @@
-add_executable(libicsneoc2-ethernet-status-example src/main.c)
-target_link_libraries(libicsneoc2-ethernet-status-example icsneoc2-static)
-
-if(WIN32)
-	target_compile_definitions(libicsneoc2-ethernet-status-example PRIVATE _CRT_SECURE_NO_WARNINGS)
-endif()

examples/c2/ethernet_status/src/main.c

@@ -1,228 +0,0 @@
-#include <icsneo/icsneoc2.h>
-#include <icsneo/icsneoc2messages.h>
-
-#include <stdio.h>
-#include <time.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <unistd.h>
-#endif
-
-void sleep_ms(uint32_t ms) {
-#ifdef _WIN32
-	Sleep(ms);
-#else
-	usleep(ms * 1000);
-#endif
-}
-
-int print_error_code(const char* message, icsneoc2_error_t error) {
-	char error_str[64] = {0};
-	size_t error_str_len = sizeof(error_str);
-	icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
-	if(res != icsneoc2_error_success) {
-		printf("%s: Failed to get string for error code %u with error code %u\n", message, error, res);
-		return (int)res;
-	}
-	printf("%s: \"%s\" (%u)\n", message, error_str, error);
-	return (int)error;
-}
-
-void print_events(void) {
-	icsneoc2_event_t* events[256] = {0};
-	size_t events_count = 256;
-	for(size_t i = 0; i < events_count; ++i) {
-		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
-		if(res != icsneoc2_error_success) {
-			(void)print_error_code("\tFailed to get events", res);
-			return;
-		}
-		if(events[i] == NULL) {
-			events_count = i;
-			break;
-		}
-	}
-
-	for(size_t i = 0; i < events_count; i++) {
-		char description[255] = {0};
-		size_t description_length = sizeof(description);
-		icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
-		if(res != icsneoc2_error_success) {
-			(void)print_error_code("\tFailed to get event description", res);
-			continue;
-		}
-		printf("\tEvent %zu: %s\n", i, description);
-	}
-
-	for(size_t i = 0; i < events_count; i++) {
-		icsneoc2_event_free(events[i]);
-	}
-	if(events_count > 0) {
-		printf("\tReceived %zu events\n", events_count);
-	}
-}
-
-const char* link_speed_name(icsneoc2_link_speed_t speed) {
-	switch(speed) {
-	case icsneoc2_link_speed_auto:
-		return "Auto";
-	case icsneoc2_link_speed_10mbps:
-		return "10 Mbps";
-	case icsneoc2_link_speed_100mbps:
-		return "100 Mbps";
-	case icsneoc2_link_speed_1000mbps:
-		return "1000 Mbps";
-	case icsneoc2_link_speed_2500mbps:
-		return "2500 Mbps";
-	case icsneoc2_link_speed_5000mbps:
-		return "5000 Mbps";
-	case icsneoc2_link_speed_10000mbps:
-		return "10000 Mbps";
-	default:
-		return "Unknown";
-	}
-}
-
-const char* link_mode_name(icsneoc2_link_mode_t mode) {
-	switch(mode) {
-	case icsneoc2_link_mode_auto:
-		return "Auto";
-	case icsneoc2_link_mode_master:
-		return "Master";
-	case icsneoc2_link_mode_slave:
-		return "Slave";
-	case icsneoc2_link_mode_invalid:
-		return "Invalid";
-	case icsneoc2_link_mode_none:
-		return "None";
-	default:
-		return "Unknown";
-	}
-}
-
-int print_ethernet_status_message(icsneoc2_message_t* message, size_t index) {
-	icsneoc2_netid_t netid = 0;
-	char netid_name[128] = {0};
-	size_t netid_name_length = sizeof(netid_name);
-	bool link_state = false;
-	bool duplex = false;
-	icsneoc2_link_speed_t link_speed = icsneoc2_link_speed_auto;
-	icsneoc2_link_mode_t link_mode = icsneoc2_link_mode_auto;
-
-	icsneoc2_error_t res = icsneoc2_message_netid_get(message, &netid);
-	if(res != icsneoc2_error_success) {
-		return print_error_code("\tFailed to get Ethernet status netid", res);
-	}
-
-	res = icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
-	if(res != icsneoc2_error_success) {
-		return print_error_code("\tFailed to get Ethernet status netid name", res);
-	}
-
-	res = icsneoc2_message_eth_status_props_get(message, &link_state, &duplex, &link_speed, &link_mode);
-	if(res != icsneoc2_error_success) {
-		return print_error_code("\tFailed to get Ethernet status properties", res);
-	}
-
-	printf("\t%zu) Ethernet status on %s (0x%x)\n", index, netid_name, netid);
-	printf("\t   Link: %s\n", link_state ? "Up" : "Down");
-	printf("\t   Duplex: %s\n", duplex ? "Full" : "Half");
-	printf("\t   Speed: %s (%u)\n", link_speed_name(link_speed), link_speed);
-	printf("\t   Mode: %s (%u)\n", link_mode_name(link_mode), link_mode);
-
-	return icsneoc2_error_success;
-}
-
-int main(void) {
-	printf("Opening first available device offline...\n");
-	icsneoc2_device_t* device = NULL;
-	icsneoc2_open_options_t options = icsneoc2_open_options_default & ~ICSNEOC2_OPEN_OPTIONS_GO_ONLINE;
-	icsneoc2_error_t res = icsneoc2_device_open_first(0, options, &device);
-	if(res != icsneoc2_error_success) {
-		return print_error_code("Failed to open first device", res);
-	}
-
-	char description[255] = {0};
-	size_t description_length = sizeof(description);
-	res = icsneoc2_device_description_get(device, description, &description_length);
-	if(res != icsneoc2_error_success) {
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-		return print_error_code("Failed to get device description", res);
-	}
-	printf("Opened device: %s\n", description);
-
-	printf("Going online to trigger Ethernet status broadcast...\n");
-	res = icsneoc2_device_go_online(device, true);
-	if(res != icsneoc2_error_success) {
-		print_events();
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-		return print_error_code("Failed to go online", res);
-	}
-
-	const int listen_seconds = 6;
-	time_t start_time = time(NULL);
-	size_t status_count = 0;
-	size_t total_count = 0;
-	printf("Listening for Ethernet status messages for %d seconds...\n", listen_seconds);
-
-	while(time(NULL) - start_time < listen_seconds) {
-		icsneoc2_message_t* message = NULL;
-		res = icsneoc2_device_message_get(device, &message, 100);
-		if(res != icsneoc2_error_success) {
-			print_events();
-			icsneoc2_device_close(device);
-			icsneoc2_device_free(device);
-			return print_error_code("Failed to get message", res);
-		}
-		if(message == NULL) {
-			sleep_ms(10);
-			continue;
-		}
-
-		total_count++;
-		bool is_ethernet_status = false;
-		res = icsneoc2_message_is_ethernet_status(message, &is_ethernet_status);
-		if(res != icsneoc2_error_success) {
-			icsneoc2_message_free(message);
-			print_events();
-			icsneoc2_device_close(device);
-			icsneoc2_device_free(device);
-			return print_error_code("Failed to check for Ethernet status message", res);
-		}
-
-		if(is_ethernet_status) {
-			res = print_ethernet_status_message(message, status_count);
-			if(res != icsneoc2_error_success) {
-				icsneoc2_message_free(message);
-				print_events();
-				icsneoc2_device_close(device);
-				icsneoc2_device_free(device);
-				return (int)res;
-			}
-			status_count++;
-		}
-
-		icsneoc2_message_free(message);
-	}
-
-	printf("Received %zu Ethernet status messages out of %zu total messages.\n", status_count, total_count);
-	if(status_count == 0) {
-		printf("No Ethernet status messages were seen. These messages are broadcast when the device goes online and may depend on device Ethernet support.\n");
-	}
-
-	print_events();
-
-	printf("Closing device...\n");
-	res = icsneoc2_device_close(device);
-	if(res != icsneoc2_error_success) {
-		icsneoc2_device_free(device);
-		return print_error_code("Failed to close device", res);
-	}
-
-	icsneoc2_device_free(device);
-	return 0;
-}

examples/c2/gptp/CMakeLists.txt

@@ -1,6 +0,0 @@
-add_executable(libicsneoc2-gptp-example src/main.c)
-target_link_libraries(libicsneoc2-gptp-example icsneoc2-static)
-
-if(WIN32)
-	target_compile_definitions(libicsneoc2-gptp-example PRIVATE _CRT_SECURE_NO_WARNINGS)
-endif()

examples/c2/gptp/src/main.c

@@ -1,330 +0,0 @@
-/*
- * gPTP settings configurator example.
- *
- * Lists connected devices and their gPTP support, then lets the user
- * configure the gPTP profile, role, port, and clock syntonization on any
- * device that supports it. If --serial is omitted, the first available
- * gPTP-capable device is used.
- */
-
-#include <icsneo/icsneoc2.h>
-#include <icsneo/icsneoc2settings.h>
-#include <icsneo/icsneoc2messages.h>
-
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-typedef struct {
-	const char* serial;
-	bool list;
-} args_t;
-
-/* Maps an icsneoc2_netid_t to its gPTP port index (0 = not a gPTP port). */
-static uint8_t netid_to_gptp_port(icsneoc2_netid_t netid) {
-	switch(netid) {
-		case icsneoc2_netid_ae_01: return 1;
-		case icsneoc2_netid_ae_02: return 2;
-		case icsneoc2_netid_ae_03: return 3;
-		case icsneoc2_netid_ae_04: return 4;
-		case icsneoc2_netid_ae_05: return 5;
-		case icsneoc2_netid_ae_06: return 6;
-		case icsneoc2_netid_ae_07: return 7;
-		case icsneoc2_netid_ae_08: return 8;
-		case icsneoc2_netid_ae_09: return 9;
-		case icsneoc2_netid_ae_10: return 10;
-		case icsneoc2_netid_ae_11: return 11;
-		case icsneoc2_netid_ae_12: return 12;
-		case icsneoc2_netid_ethernet_01: return 13;
-		case icsneoc2_netid_ethernet_02: return 14;
-		case icsneoc2_netid_ethernet_03: return 15;
-		case icsneoc2_netid_ae_13: return 16;
-		case icsneoc2_netid_ae_14: return 17;
-		case icsneoc2_netid_ae_15: return 18;
-		case icsneoc2_netid_ae_16: return 19;
-		default: return 0;
-	}
-}
-
-static const char* gptp_profile_str(icsneoc2_gptp_profile_t p) {
-	switch(p) {
-		case icsneoc2_gptp_profile_standard:   return "Standard";
-		case icsneoc2_gptp_profile_automotive: return "Automotive";
-		default:                               return "Unknown";
-	}
-}
-
-static const char* gptp_role_str(icsneoc2_gptp_role_t r) {
-	switch(r) {
-		case icsneoc2_gptp_role_disabled: return "Disabled";
-		case icsneoc2_gptp_role_passive:  return "Passive";
-		case icsneoc2_gptp_role_master:   return "Master";
-		case icsneoc2_gptp_role_slave:    return "Slave";
-		default:                          return "Unknown";
-	}
-}
-
-static int print_error_code(const char* message, icsneoc2_error_t error) {
-	char error_str[64] = {0};
-	size_t error_str_len = sizeof(error_str);
-	icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
-	if(res != icsneoc2_error_success) {
-		fprintf(stderr, "%s: failed to get string for error code %u\n", message, error);
-		return (int)res;
-	}
-	fprintf(stderr, "%s: \"%s\" (%u)\n", message, error_str, error);
-	return (int)error;
-}
-
-static void print_usage(const char* prog) {
-	printf("Usage:\n");
-	printf("  %s --list\n", prog);
-	printf("  %s [--serial SERIAL]\n", prog);
-	printf("\n");
-	printf("  --list            List connected devices and their gPTP support.\n");
-	printf("  --serial SERIAL   Serial number of the device to configure.\n");
-	printf("  -h, --help        Show this message.\n");
-}
-
-static int parse_args(int argc, char** argv, args_t* out) {
-	memset(out, 0, sizeof(*out));
-	for(int i = 1; i < argc; ++i) {
-		const char* a = argv[i];
-		if(strcmp(a, "-h") == 0 || strcmp(a, "--help") == 0) {
-			print_usage(argv[0]);
-			exit(0);
-		} else if(strcmp(a, "--list") == 0) {
-			out->list = true;
-		} else if(strcmp(a, "--serial") == 0) {
-			if(i + 1 >= argc) {
-				fprintf(stderr, "error: --serial requires a value\n");
-				return 1;
-			}
-			out->serial = argv[++i];
-		} else {
-			fprintf(stderr, "error: unknown argument '%s'\n", a);
-			print_usage(argv[0]);
-			return 1;
-		}
-	}
-	return 0;
-}
-
-static icsneoc2_device_info_t* find_device(icsneoc2_device_info_t* list, const char* serial) {
-	for(icsneoc2_device_info_t* cur = list; cur != NULL; cur = icsneoc2_device_info_next(cur)) {
-		if(serial == NULL)
-			return cur;
-		char dev_serial[64] = {0};
-		size_t dev_serial_len = sizeof(dev_serial);
-		if(icsneoc2_device_info_serial_get(cur, dev_serial, &dev_serial_len) != icsneoc2_error_success)
-			continue;
-		if(strcmp(dev_serial, serial) == 0)
-			return cur;
-	}
-	return NULL;
-}
-
-/*
- * Print a list of available Ethernet/AE networks with their gPTP port indices.
- * Returns the number of ports printed.
- */
-static size_t print_gptp_ports(icsneoc2_device_t* device) {
-	icsneoc2_netid_t nets[128] = {0};
-	size_t count = sizeof(nets) / sizeof(nets[0]);
-	if(icsneoc2_device_supported_tx_networks_get(device, nets, &count) != icsneoc2_error_success)
-		return 0;
-
-	size_t printed = 0;
-	for(size_t i = 0; i < count; ++i) {
-		uint8_t port = netid_to_gptp_port(nets[i]);
-		if(port == 0)
-			continue;
-		char name[64] = {0};
-		size_t name_len = sizeof(name);
-		icsneoc2_netid_name_get(nets[i], name, &name_len);
-		printf("    [%u] %s\n", (unsigned)port, name);
-		++printed;
-	}
-	return printed;
-}
-
-static int list_devices(icsneoc2_device_info_t* list) {
-	size_t index = 0;
-	for(icsneoc2_device_info_t* cur = list; cur != NULL; cur = icsneoc2_device_info_next(cur)) {
-		char serial[64] = {0};
-		size_t serial_len = sizeof(serial);
-		char description[256] = {0};
-		size_t description_len = sizeof(description);
-		icsneoc2_device_info_serial_get(cur, serial, &serial_len);
-		icsneoc2_device_info_description_get(cur, description, &description_len);
-		printf("[%zu] %s (%s)\n", index++, description, serial);
-
-		icsneoc2_device_t* device = NULL;
-		if(icsneoc2_device_create(cur, &device) != icsneoc2_error_success)
-			continue;
-
-		icsneoc2_open_options_t opts = icsneoc2_open_options_default;
-		opts &= ~ICSNEOC2_OPEN_OPTIONS_SYNC_RTC;
-		opts &= ~ICSNEOC2_OPEN_OPTIONS_GO_ONLINE;
-		if(icsneoc2_device_open(device, opts) != icsneoc2_error_success) {
-			icsneoc2_device_free(device);
-			continue;
-		}
-
-		bool supported = false;
-		icsneoc2_device_supports_gptp(device, &supported);
-		printf("    gPTP supported: %s\n", supported ? "yes" : "no");
-		if(supported) {
-			printf("    gPTP ports:\n");
-			print_gptp_ports(device);
-		}
-
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-	}
-	return 0;
-}
-
-static void print_current_settings(icsneoc2_device_t* device) {
-	icsneoc2_gptp_profile_t profile = icsneoc2_gptp_profile_standard;
-	icsneoc2_gptp_role_t role = icsneoc2_gptp_role_disabled;
-	uint8_t port = 0;
-	bool clock_syntonization = false;
-
-	printf("\nCurrent gPTP settings:\n");
-	if(icsneoc2_settings_gptp_profile_get(device, &profile) == icsneoc2_error_success)
-		printf("  Profile:             %s\n", gptp_profile_str(profile));
-	if(icsneoc2_settings_gptp_role_get(device, &role) == icsneoc2_error_success)
-		printf("  Role:                %s\n", gptp_role_str(role));
-	if(icsneoc2_settings_gptp_enabled_port_get(device, &port) == icsneoc2_error_success)
-		printf("  Enabled port:        %u%s\n", (unsigned)port, port == 0 ? " (disabled)" : "");
-	if(icsneoc2_settings_gptp_clock_syntonization_enabled_get(device, &clock_syntonization) == icsneoc2_error_success)
-		printf("  Clock syntonization: %s\n", clock_syntonization ? "enabled" : "disabled");
-}
-
-static long prompt_long(const char* prompt, long default_val, long min, long max) {
-	char buf[32] = {0};
-	printf("%s [%ld]: ", prompt, default_val);
-	fflush(stdout);
-	if(fgets(buf, sizeof(buf), stdin) == NULL || buf[0] == '\n')
-		return default_val;
-	char* end = NULL;
-	long val = strtol(buf, &end, 10);
-	if(end == buf || val < min || val > max) {
-		printf("Invalid input, using %ld.\n", default_val);
-		return default_val;
-	}
-	return val;
-}
-
-static int configure_device(icsneoc2_device_t* device) {
-	icsneoc2_error_t res;
-
-	res = icsneoc2_settings_refresh(device);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to refresh settings", res);
-
-	print_current_settings(device);
-
-	printf("\nAvailable gPTP ports (0 = disabled):\n");
-	printf("    [0] Disabled\n");
-	print_gptp_ports(device);
-
-	printf("\nConfigure gPTP:\n");
-
-	long profile = prompt_long("  Profile (0=Standard, 1=Automotive)", 1, 0, 1);
-	res = icsneoc2_settings_gptp_profile_set(device, (icsneoc2_gptp_profile_t)profile);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to set profile", res);
-
-	long role = prompt_long("  Role (0=Disabled, 1=Passive, 2=Master, 3=Slave)", 3, 0, 3);
-	res = icsneoc2_settings_gptp_role_set(device, (icsneoc2_gptp_role_t)role);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to set role", res);
-
-	long port = prompt_long("  Enabled port index", 0, 0, 19);
-	res = icsneoc2_settings_gptp_enabled_port_set(device, (uint8_t)port);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to set enabled port", res);
-
-	long syntonization = prompt_long("  Clock syntonization (0=disabled, 1=enabled)", 0, 0, 1);
-	res = icsneoc2_settings_gptp_clock_syntonization_enabled_set(device, syntonization != 0);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to set clock syntonization", res);
-
-	printf("\nNote: icsneoc2_settings_apply() persists settings on the device.\n");
-	res = icsneoc2_settings_apply(device);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to apply settings", res);
-
-	printf("\nUpdated gPTP settings:\n");
-	print_current_settings(device);
-	return 0;
-}
-
-int main(int argc, char** argv) {
-	args_t args;
-	if(parse_args(argc, argv, &args) != 0)
-		return 1;
-
-	icsneoc2_device_info_t* found_devices = NULL;
-	icsneoc2_error_t res = icsneoc2_device_enumerate(0, &found_devices);
-	if(res != icsneoc2_error_success)
-		return print_error_code("Failed to enumerate devices", res);
-	if(found_devices == NULL) {
-		fprintf(stderr, "error: no devices found\n");
-		return 1;
-	}
-
-	if(args.list) {
-		int rc = list_devices(found_devices);
-		icsneoc2_enumeration_free(found_devices);
-		return rc;
-	}
-
-	icsneoc2_device_info_t* info = find_device(found_devices, args.serial);
-	if(info == NULL) {
-		fprintf(stderr, "error: unable to find device %s\n", args.serial ? args.serial : "(any)");
-		icsneoc2_enumeration_free(found_devices);
-		return 1;
-	}
-
-	char description[256] = {0};
-	size_t description_len = sizeof(description);
-	icsneoc2_device_info_description_get(info, description, &description_len);
-
-	icsneoc2_device_t* device = NULL;
-	res = icsneoc2_device_create(info, &device);
-	if(res != icsneoc2_error_success) {
-		icsneoc2_enumeration_free(found_devices);
-		return print_error_code("Failed to create device", res);
-	}
-
-	printf("Opening %s\n", description);
-	res = icsneoc2_device_open(device, icsneoc2_open_options_default);
-	if(res != icsneoc2_error_success) {
-		icsneoc2_device_free(device);
-		icsneoc2_enumeration_free(found_devices);
-		return print_error_code("Failed to open device", res);
-	}
-
-	bool supported = false;
-	icsneoc2_device_supports_gptp(device, &supported);
-	if(!supported) {
-		fprintf(stderr, "error: device does not support gPTP (%s)\n", description);
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-		icsneoc2_enumeration_free(found_devices);
-		return 1;
-	}
-
-	int rc = configure_device(device);
-
-	printf("Closing %s\n", description);
-	icsneoc2_device_close(device);
-	icsneoc2_device_free(device);
-	icsneoc2_enumeration_free(found_devices);
-	return rc;
-}

examples/c2/perf_test/CMakeLists.txt

@@ -1,6 +0,0 @@
-add_executable(libicsneoc2-perf_test-example src/main.c)
-target_link_libraries(libicsneoc2-perf_test-example icsneoc2-static)
-
-if(WIN32)
-	target_compile_definitions(libicsneoc2-perf_test-example PRIVATE _CRT_SECURE_NO_WARNINGS)
-endif()

examples/c2/perf_test/src/main.c

@@ -1,137 +0,0 @@
-/*
- * PerfTest setting example.
- *
- * Opens the first available device, enables the device-global PerfTest mode
- * via icsneoc2_settings_perf_test_enabled_set(), reads messages for a few
- * seconds while PerfTest is active, then disables PerfTest again. Each step
- * reads the value back with icsneoc2_settings_perf_test_enabled_get() to
- * confirm the change took effect.
- */
-
-#include <icsneo/icsneoc2.h>
-#include <icsneo/icsneoc2settings.h>
-#include <icsneo/icsneoc2messages.h>
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <time.h>
-
-static int print_error_code(const char* message, icsneoc2_error_t error) {
-	char error_str[64] = {0};
-	size_t error_str_len = sizeof(error_str);
-	icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
-	if(res != icsneoc2_error_success) {
-		fprintf(stderr, "%s: failed to get string for error code %u\n", message, error);
-		return (int)res;
-	}
-	fprintf(stderr, "%s: \"%s\" (%u)\n", message, error_str, error);
-	return (int)error;
-}
-
-/* Sets PerfTest, applies it to the device, then reads it back to confirm. */
-static icsneoc2_error_t set_and_verify_perf_test(icsneoc2_device_t* device, bool enable) {
-	icsneoc2_error_t res = icsneoc2_settings_perf_test_enabled_set(device, enable);
-	if(res != icsneoc2_error_success)
-		return res;
-
-	res = icsneoc2_settings_apply(device);
-	if(res != icsneoc2_error_success)
-		return res;
-
-	/* Re-read settings from the device so the read-back reflects what was
-	 * actually persisted, not just the local settings buffer. */
-	res = icsneoc2_settings_refresh(device);
-	if(res != icsneoc2_error_success)
-		return res;
-
-	bool value = !enable;
-	res = icsneoc2_settings_perf_test_enabled_get(device, &value);
-	if(res != icsneoc2_error_success)
-		return res;
-
-	printf("\tPerfTest now reads back as: %s\n", value ? "enabled" : "disabled");
-	if(value != enable) {
-		fprintf(stderr, "\tERROR: expected PerfTest %s but device reports %s\n",
-			enable ? "enabled" : "disabled", value ? "enabled" : "disabled");
-		return icsneoc2_error_get_settings_failure;
-	}
-	return icsneoc2_error_success;
-}
-
-/* Continuously drains and counts messages for the given wall-clock duration. */
-static icsneoc2_error_t read_messages_for(icsneoc2_device_t* device, unsigned seconds) {
-	size_t total = 0;
-	printf("\tReading messages for %u seconds...\n", seconds);
-	time_t start = time(NULL);
-	while((time_t)(time(NULL) - start) < (time_t)seconds) {
-		/* Short timeout so an idle bus still lets us re-check the clock,
-		 * while a flooding bus is drained as fast as messages arrive. */
-		icsneoc2_message_t* message = NULL;
-		icsneoc2_error_t res = icsneoc2_device_message_get(device, &message, 50);
-		if(res != icsneoc2_error_success)
-			return res;
-		if(message == NULL)
-			continue;
-		++total;
-		icsneoc2_message_free(message);
-	}
-	printf("\tReceived %zu messages in %u seconds.\n", total, seconds);
-	return icsneoc2_error_success;
-}
-
-int main(void) {
-	printf("Opening first available device...\n");
-	icsneoc2_device_t* device = NULL;
-	icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
-	if(res != icsneoc2_error_success)
-		return print_error_code("\tFailed to open first device", res);
-
-	char description[255] = {0};
-	size_t description_length = sizeof(description);
-	res = icsneoc2_device_description_get(device, description, &description_length);
-	if(res != icsneoc2_error_success) {
-		icsneoc2_device_free(device);
-		return print_error_code("\tFailed to get device description", res);
-	}
-	printf("\tOpened device: %s\n", description);
-
-	/* Pull the current settings down from the device before reading/modifying them. */
-	res = icsneoc2_settings_refresh(device);
-	if(res != icsneoc2_error_success)
-		goto cleanup;
-
-	bool initial = false;
-	res = icsneoc2_settings_perf_test_enabled_get(device, &initial);
-	if(res != icsneoc2_error_success) {
-		print_error_code("\tFailed to read initial PerfTest state (device may not support it)", res);
-		goto cleanup;
-	}
-	printf("\tInitial PerfTest state: %s\n", initial ? "enabled" : "disabled");
-
-	printf("Enabling PerfTest...\n");
-	res = set_and_verify_perf_test(device, true);
-	if(res != icsneoc2_error_success) {
-		print_error_code("\tFailed to enable PerfTest", res);
-		goto cleanup;
-	}
-
-	res = read_messages_for(device, 3);
-	if(res != icsneoc2_error_success) {
-		print_error_code("\tFailed while reading messages", res);
-		goto cleanup;
-	}
-
-	printf("Disabling PerfTest...\n");
-	res = set_and_verify_perf_test(device, false);
-	if(res != icsneoc2_error_success) {
-		print_error_code("\tFailed to disable PerfTest", res);
-		goto cleanup;
-	}
-
-	printf("PerfTest enable/read/disable cycle completed successfully.\n");
-
-cleanup:
-	icsneoc2_device_close(device);
-	icsneoc2_device_free(device);
-	return (int)res;
-}

examples/c2/read_messages/src/main.c

@@ -176,7 +176,6 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 	// Print the type and bus type of each message
 	size_t tx_count = 0;
 	size_t can_error_count = 0;
-	size_t internal_count = 0;
 	icsneoc2_error_t res = icsneoc2_error_success;
 	for(size_t i = 0; i < messages_count; i++) {
 		icsneoc2_message_t* message = messages[i];
@@ -217,21 +216,13 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 			continue;
 		}
 
-		// This example only cares about bus traffic, so skip internal
-		// device/status messages.
-		icsneoc2_network_type_t internal_check = icsneoc2_network_type_invalid;
-		res = icsneoc2_message_network_type_get(message, &internal_check);
-		if(res == icsneoc2_error_success && internal_check == icsneoc2_network_type_internal) {
-			internal_count++;
-			continue;
-		}
-
 		bool is_frame = false;
 		res = icsneoc2_message_is_frame(message, &is_frame);
 		if(res != icsneoc2_error_success) {
 			return print_error_code("\tFailed to check if message is a frame", res);
 		}
 		if(!is_frame) {
+			printf("Ignoring non-frame message at index %zu\n", i);
 			continue;
 		}
 		icsneoc2_network_type_t network_type;
@@ -305,7 +296,7 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 			printf(" ]\n");
 		}
 	}
-	printf("\tReceived %zu messages total, %zu were TX messages, %zu were CAN errors, %zu internal (skipped)\n", messages_count, tx_count, can_error_count, internal_count);
+	printf("\tReceived %zu messages total, %zu were TX messages, %zu were CAN errors\n", messages_count, tx_count, can_error_count);
 
 	return icsneoc2_error_success;
 }

examples/c2/simple/src/main.c

@@ -359,8 +359,6 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 	// Print the type and bus type of each message
 	size_t tx_count = 0;
 	size_t can_error_count = 0;
-	size_t app_error_count = 0;
-	size_t internal_count = 0;
 	for(size_t i = 0; i < messages_count; i++) {
 		icsneoc2_message_t* message = messages[i];
 
@@ -394,42 +392,13 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 			continue;
 		}
 
-		// Check for application error messages
-		bool is_app_error = false;
-		res = icsneoc2_message_is_app_error(message, &is_app_error);
-		if(res != icsneoc2_error_success) {
-			return print_error_code("\tFailed to check if message is an app error", res);
-		}
-		if(is_app_error) {
-			icsneoc2_app_error_type_t error_type = icsneoc2_app_error_type_no_error;
-			icsneoc2_netid_t error_netid = 0;
-			char description[256] = {0};
-			size_t description_length = sizeof(description);
-			res = icsneoc2_message_app_error_props_get(message, &error_type, &error_netid);
-			res += icsneoc2_message_app_error_string_get(message, description, &description_length);
-			if(res != icsneoc2_error_success) {
-				return print_error_code("\tFailed to get app error properties", res);
-			}
-			printf("\t%zd) App Error (type %u) on netid 0x%x: %s\n", i, error_type, error_netid, description);
-			app_error_count++;
-			continue;
-		}
-
-		// This example only cares about bus traffic, so skip internal
-		// device/status messages.
-		icsneoc2_network_type_t internal_check = icsneoc2_network_type_invalid;
-		res = icsneoc2_message_network_type_get(message, &internal_check);
-		if(res == icsneoc2_error_success && internal_check == icsneoc2_network_type_internal) {
-			internal_count++;
-			continue;
-		}
-
 		bool is_frame = false;
 		res = icsneoc2_message_is_frame(message, &is_frame);
 		if(res != icsneoc2_error_success) {
 			return print_error_code("\tFailed to check if message is a frame", res);
 		}
 		if(!is_frame) {
+			printf("Ignoring non-frame message at index %zu\n", i);
 			continue;
 		}
 		icsneoc2_network_type_t network_type;
@@ -503,7 +472,7 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 			printf(" ]\n");
 		}
 	}
-	printf("\tReceived %zu messages total, %zu were TX messages, %zu were CAN errors, %zu were app errors, %zu internal (skipped)\n", messages_count, tx_count, can_error_count, app_error_count, internal_count);
+	printf("\tReceived %zu messages total, %zu were TX messages, %zu were CAN errors\n", messages_count, tx_count, can_error_count);
 
 	return icsneoc2_error_success;
 }

examples/c2/termination/CMakeLists.txt

@@ -1,6 +0,0 @@
-add_executable(libicsneoc2-termination-example src/main.c)
-target_link_libraries(libicsneoc2-termination-example icsneoc2-static)
-
-if(WIN32)
-	target_compile_definitions(libicsneoc2-termination-example PRIVATE _CRT_SECURE_NO_WARNINGS)
-endif()

examples/c2/termination/src/main.c

@@ -1,91 +0,0 @@
-#include <icsneo/icsneoc2.h>
-#include <icsneo/icsneoc2messages.h>
-#include <icsneo/icsneoc2settings.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-
-int print_error_code(const char* message, icsneoc2_error_t error) {
-	char error_str[64];
-	size_t error_str_len = sizeof(error_str);
-	icsneoc2_error_t res = icsneoc2_error_code_get(error, error_str, &error_str_len);
-	if(res != icsneoc2_error_success) {
-		printf("%s: Failed to get string for error code %u with error code %u\n", message, error, res);
-		return (int)res;
-	}
-	printf("%s: \"%s\" (%u)\n", message, error_str, error);
-	return (int)error;
-}
-
-int main() {
-	icsneoc2_error_t res;
-
-	icsneoc2_device_t* device = NULL;
-	res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
-	if(res != icsneoc2_error_success) {
-		return print_error_code("Failed to open first device", res);
-	}
-
-	char description[128] = {0};
-	size_t description_length = sizeof(description);
-	icsneoc2_device_description_get(device, description, &description_length);
-	printf("Opened device: %s\n\n", description);
-
-	size_t count = 0;
-	icsneoc2_termination_group_t* groups = NULL;
-	res = icsneoc2_settings_termination_groups_enumerate(device, &groups, &count);
-	if(res != icsneoc2_error_success) {
-		print_error_code("Failed to enumerate termination groups", res);
-		icsneoc2_device_close(device);
-		icsneoc2_device_free(device);
-		return 1;
-	}
-
-	if(count == 0) {
-		printf("This device does not support software switchable termination.\n");
-	} else {
-		printf("Found %zu termination group(s) (only one network per group may be terminated at a time):\n", count);
-	}
-
-	size_t group_index = 0;
-	for(icsneoc2_termination_group_t* group = groups; group; group = icsneoc2_termination_group_next(group), group_index++) {
-		// First call with a NULL buffer to learn how many networks are in this group.
-		size_t network_count = 0;
-		icsneoc2_termination_group_networks_get(group, NULL, &network_count);
-
-		icsneoc2_netid_t* netids = (icsneoc2_netid_t*)malloc(network_count * sizeof(icsneoc2_netid_t));
-		if(!netids) {
-			print_error_code("Out of memory", icsneoc2_error_out_of_memory);
-			break;
-		}
-
-		// Second call to fill the buffer.
-		res = icsneoc2_termination_group_networks_get(group, netids, &network_count);
-		if(res != icsneoc2_error_success) {
-			print_error_code("Failed to get termination group networks", res);
-			free(netids);
-			continue;
-		}
-
-		printf("  Group %zu:", group_index);
-		for(size_t i = 0; i < network_count; i++) {
-			char name[64] = {0};
-			size_t name_length = sizeof(name);
-			if(icsneoc2_netid_name_get(netids[i], name, &name_length) == icsneoc2_error_success) {
-				printf(" %s", name);
-			} else {
-				printf(" %u", netids[i]);
-			}
-			if(i + 1 < network_count) {
-				printf(",");
-			}
-		}
-		printf("\n");
-		free(netids);
-	}
-
-	icsneoc2_settings_termination_groups_free(groups);
-	icsneoc2_device_close(device);
-	icsneoc2_device_free(device);
-	return 0;
-}

examples/cpp/gptp/CMakeLists.txt

@@ -1,2 +0,0 @@
-add_executable(libicsneocpp-gptp-settings src/GPTPSettingsExample.cpp)
-target_link_libraries(libicsneocpp-gptp-settings icsneocpp)

examples/cpp/gptp/src/GPTPSettingsExample.cpp

@@ -1,179 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <vector>
-#include <optional>
-#include <string>
-#include <limits>
-
-#include "icsneo/icsneocpp.h"
-
-/* Maps a Network::NetID to its gPTP port index (0 = not a gPTP port). */
-static uint8_t netidToGPTPPort(icsneo::Network::NetID netid) {
-	using N = icsneo::Network::NetID;
-	switch(netid) {
-		case N::AE_01:       return 1;
-		case N::AE_02:       return 2;
-		case N::AE_03:       return 3;
-		case N::AE_04:       return 4;
-		case N::AE_05:       return 5;
-		case N::AE_06:       return 6;
-		case N::AE_07:       return 7;
-		case N::AE_08:       return 8;
-		case N::AE_09:       return 9;
-		case N::AE_10:       return 10;
-		case N::AE_11:       return 11;
-		case N::AE_12:       return 12;
-		case N::ETHERNET_01: return 13;
-		case N::ETHERNET_02: return 14;
-		case N::ETHERNET_03: return 15;
-		case N::AE_13:       return 16;
-		case N::AE_14:       return 17;
-		case N::AE_15:       return 18;
-		case N::AE_16:       return 19;
-		default:             return 0;
-	}
-}
-
-static std::string gptpProfileStr(RADGPTPProfile p) {
-	switch(p) {
-		case RAD_GPTP_PROFILE_STANDARD:   return "Standard";
-		case RAD_GPTP_PROFILE_AUTOMOTIVE: return "Automotive";
-		default:                          return "Unknown";
-	}
-}
-
-static std::string gptpRoleStr(RADGPTPRole r) {
-	switch(r) {
-		case RAD_GPTP_ROLE_DISABLED: return "Disabled";
-		case RAD_GPTP_ROLE_PASSIVE:  return "Passive";
-		case RAD_GPTP_ROLE_MASTER:   return "Master";
-		case RAD_GPTP_ROLE_SLAVE:    return "Slave";
-		default:                     return "Unknown";
-	}
-}
-
-template<typename T>
-static std::string optStr(const std::optional<T>& opt) {
-	if(!opt.has_value()) return "N/A";
-	if constexpr(std::is_same_v<T, bool>)
-		return opt.value() ? "enabled" : "disabled";
-	else
-		return std::to_string(static_cast<int>(opt.value()));
-}
-
-static long promptLong(const std::string& prompt, long defaultVal, long min, long max) {
-	std::cout << prompt << " [" << defaultVal << "]: " << std::flush;
-	std::string input;
-	std::getline(std::cin, input);
-	if(input.empty())
-		return defaultVal;
-	try {
-		long val = std::stol(input);
-		if(val >= min && val <= max)
-			return val;
-	} catch(...) {}
-	std::cout << "Invalid input, using " << defaultVal << ".\n";
-	return defaultVal;
-}
-
-static void printGPTPPorts(const std::shared_ptr<icsneo::Device>& device) {
-	for(const auto& net : device->getSupportedTXNetworks()) {
-		uint8_t port = netidToGPTPPort(net.getNetID());
-		if(port == 0) continue;
-		std::cout << "    [" << (int)port << "] " << net << "\n";
-	}
-}
-
-static void printCurrentSettings(const std::shared_ptr<icsneo::Device>& device) {
-	std::cout << "\nCurrent gPTP settings:\n";
-	auto profile = device->settings->getGPTPProfile();
-	auto role    = device->settings->getGPTPRole();
-	auto port    = device->settings->getGPTPEnabledPort();
-	auto synton  = device->settings->isGPTPClockSyntonizationEnabled();
-
-	if(profile.has_value())
-		std::cout << "  Profile:             " << gptpProfileStr(profile.value()) << "\n";
-	if(role.has_value())
-		std::cout << "  Role:                " << gptpRoleStr(role.value()) << "\n";
-	if(port.has_value())
-		std::cout << "  Enabled port:        " << (int)port.value() << (port.value() == 0 ? " (disabled)" : "") << "\n";
-	if(synton.has_value())
-		std::cout << "  Clock syntonization: " << optStr(synton) << "\n";
-}
-
-int main() {
-	std::cout << "Finding devices... " << std::flush;
-	auto devices = icsneo::FindAllDevices();
-	std::cout << devices.size() << " found\n";
-
-	if(devices.empty()) {
-		auto err = icsneo::GetLastError();
-		if(err.getType() != icsneo::APIEvent::Type::NoErrorFound)
-			std::cout << err << "\n";
-		return 1;
-	}
-
-	std::vector<std::shared_ptr<icsneo::Device>> gptp_devices;
-	for(auto& d : devices) {
-		if(d->supportsGPTP())
-			gptp_devices.push_back(d);
-	}
-
-	if(gptp_devices.empty()) {
-		std::cout << "No gPTP-capable devices found.\n";
-		return 1;
-	}
-
-	std::cout << "\nAvailable gPTP-capable devices:\n";
-	for(size_t i = 0; i < gptp_devices.size(); ++i)
-		std::cout << "  [" << (i + 1) << "] " << gptp_devices[i]->describe() << "\n";
-
-	long choice = promptLong("Select device", 1, 1, (long)gptp_devices.size());
-	auto device = gptp_devices[choice - 1];
-
-	std::cout << "\nOpening " << device->describe() << "... " << std::flush;
-	if(!device->open()) {
-		std::cout << "failed\n" << icsneo::GetLastError() << "\n";
-		return 1;
-	}
-	std::cout << "OK\n";
-
-	if(!device->settings->refresh()) {
-		std::cout << "Failed to refresh settings\n";
-		device->close();
-		return 1;
-	}
-
-	printCurrentSettings(device);
-
-	std::cout << "\nAvailable gPTP ports (0 = disabled):\n";
-	std::cout << "    [0] Disabled\n";
-	printGPTPPorts(device);
-
-	std::cout << "\nConfigure gPTP:\n";
-
-	long profile = promptLong("  Profile (0=Standard, 1=Automotive)", 1, 0, 1);
-	device->settings->setGPTPProfile(static_cast<RADGPTPProfile>(profile));
-
-	long role = promptLong("  Role (0=Disabled, 1=Passive, 2=Master, 3=Slave)", 3, 0, 3);
-	device->settings->setGPTPRole(static_cast<RADGPTPRole>(role));
-
-	long port = promptLong("  Enabled port index", 0, 0, 19);
-	device->settings->setGPTPEnabledPort(static_cast<uint8_t>(port));
-
-	long syntonization = promptLong("  Clock syntonization (0=disabled, 1=enabled)", 0, 0, 1);
-	device->settings->setGPTPClockSyntonizationEnabled(syntonization != 0);
-
-	long permanent = promptLong("\nSave to EEPROM? (0=temporary, 1=permanent)", 0, 0, 1);
-	if(!device->settings->apply(permanent == 0)) {
-		std::cout << "Failed to apply settings\n" << icsneo::GetLastError() << "\n";
-		device->close();
-		return 1;
-	}
-
-	printCurrentSettings(device);
-
-	std::cout << "\nClosing " << device->describe() << "\n";
-	device->close();
-	return 0;
-}

examples/cpp/iso15765_loopback/CMakeLists.txt

@@ -1,2 +0,0 @@
-add_executable(libicsneocpp-iso15765-loopback src/ISO15765Loopback.cpp)
-target_link_libraries(libicsneocpp-iso15765-loopback icsneocpp)

examples/cpp/iso15765_loopback/src/ISO15765Loopback.cpp

@@ -1,450 +0,0 @@
-#include <cctype>
-#include <chrono>
-#include <cstdint>
-#include <iomanip>
-#include <iostream>
-#include <mutex>
-#include <optional>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include "icsneo/icsneocpp.h"
-
-namespace {
-
-using namespace std::chrono_literals;
-
-enum class Mode {
-	None,
-	Raw,
-	SingleFrame,
-	Both,
-};
-
-struct Options {
-	Mode mode = Mode::None;
-	std::string testerSerial;
-	std::string ecuSerial;
-	int64_t baud = 500000;
-	bool keepBaud = false;
-	uint32_t txId = 0x7E0;
-	uint32_t fcId = 0x7E8;
-	std::optional<size_t> payloadBytes;
-	int listenMs = 2000;
-	uint8_t padding = 0x00;
-	uint16_t fsTimeoutMs = 75;
-	uint16_t fsWaitMs = 150;
-	uint16_t cfTimeoutMs = 150;
-};
-
-std::mutex gLogMutex;
-
-void logLine(const std::string& line) {
-	std::lock_guard<std::mutex> lk(gLogMutex);
-	std::cout << line << std::endl;
-}
-
-bool iequals(const std::string& a, const std::string& b) {
-	if(a.size() != b.size())
-		return false;
-	for(size_t i = 0; i < a.size(); i++) {
-		if(std::tolower(static_cast<unsigned char>(a[i])) != std::tolower(static_cast<unsigned char>(b[i])))
-			return false;
-	}
-	return true;
-}
-
-std::string hexBytes(const std::vector<uint8_t>& data) {
-	std::ostringstream oss;
-	oss << std::hex << std::setfill('0');
-	for(size_t i = 0; i < data.size(); i++) {
-		if(i)
-			oss << ' ';
-		oss << std::setw(2) << static_cast<unsigned>(data[i]);
-	}
-	return oss.str();
-}
-
-std::string pciDescribe(const std::vector<uint8_t>& data) {
-	if(data.empty())
-		return {};
-	const uint8_t pciType = static_cast<uint8_t>(data[0] >> 4);
-	const uint8_t pciLow = static_cast<uint8_t>(data[0] & 0x0F);
-	std::ostringstream oss;
-	switch(pciType) {
-		case 0x0:
-			if(pciLow > 7 || data.size() < static_cast<size_t>(1 + pciLow))
-				return {};
-			oss << "SF len=" << static_cast<unsigned>(pciLow);
-			break;
-		case 0x1: {
-			if(data.size() < 8)
-				return {};
-			const uint16_t len = static_cast<uint16_t>((pciLow << 8) | data[1]);
-			if(len < 8)
-				return {};
-			oss << "FF len=" << len;
-			break;
-		}
-		case 0x2:
-			if(data.size() < 2)
-				return {};
-			oss << "CF SN=" << static_cast<unsigned>(pciLow);
-			break;
-		case 0x3: {
-			if(data.size() < 3 || pciLow > 2)
-				return {};
-			static const char* fsName[] = { "CTS", "WAIT", "OVFLW" };
-			oss << "FC FS=" << fsName[pciLow];
-			oss << " BS=" << static_cast<unsigned>(data[1]);
-			oss << " STmin=0x" << std::hex << std::setw(2) << std::setfill('0')
-				<< static_cast<unsigned>(data[2]);
-			break;
-		}
-		default:
-			return {};
-	}
-	return oss.str();
-}
-
-void printUsage(const char* argv0) {
-	std::cerr
-		<< "Usage: " << argv0 << " --raw|--sf|--both [options]\n\n"
-		<< "Two Intrepid devices with CAN1 wired together (CANH/CANL, terminated).\n"
-		<< "Prints CAN1 frames with ISO-TP PCI decode (SF/FF/CF/FC).\n\n"
-		<< "Modes:\n"
-		<< "  --raw   Raw CAN ping-pong (cable check)\n"
-		<< "  --sf    Firmware ISO-TP single-frame TX from tester\n"
-		<< "  --both  Firmware ISO-TP TX on tester, firmware flow-control on ECU\n\n"
-		<< "Devices:\n"
-		<< "  --tester SERIAL   Tester (sender) serial\n"
-		<< "  --ecu SERIAL      ECU / peer serial\n"
-		<< "                    Optional if exactly two devices are found.\n\n"
-		<< "Optional:\n"
-		<< "  --baud N          CAN1 baud (default 500000, applied temporarily)\n"
-		<< "  --keep-baud       Do not change device baud\n"
-		<< "  --tx-id HEX       Tester ISO-TP CAN ID (default 0x7E0)\n"
-		<< "  --fc-id HEX       Flow-control CAN ID (default 0x7E8)\n"
-		<< "  --bytes N         ISO-TP payload size (sf default 5, both default 20)\n"
-		<< "  --listen-ms N     Time to listen after the action (default 2000)\n";
-}
-
-uint32_t parseU32(const std::string& s) {
-	return static_cast<uint32_t>(std::stoul(s, nullptr, 0));
-}
-
-bool parseArgs(int argc, char** argv, Options& opt) {
-	for(int i = 1; i < argc; i++) {
-		const std::string a = argv[i];
-		auto need = [&](const char* name) -> std::string {
-			if(i + 1 >= argc)
-				throw std::runtime_error(std::string("missing value for ") + name);
-			return argv[++i];
-		};
-		if(a == "--raw")
-			opt.mode = Mode::Raw;
-		else if(a == "--sf")
-			opt.mode = Mode::SingleFrame;
-		else if(a == "--both")
-			opt.mode = Mode::Both;
-		else if(a == "--tester")
-			opt.testerSerial = need("--tester");
-		else if(a == "--ecu")
-			opt.ecuSerial = need("--ecu");
-		else if(a == "--baud")
-			opt.baud = static_cast<int64_t>(std::stoll(need("--baud")));
-		else if(a == "--keep-baud")
-			opt.keepBaud = true;
-		else if(a == "--tx-id")
-			opt.txId = parseU32(need("--tx-id"));
-		else if(a == "--fc-id")
-			opt.fcId = parseU32(need("--fc-id"));
-		else if(a == "--bytes")
-			opt.payloadBytes = static_cast<size_t>(std::stoul(need("--bytes")));
-		else if(a == "--listen-ms")
-			opt.listenMs = std::stoi(need("--listen-ms"));
-		else if(a == "-h" || a == "--help") {
-			printUsage(argv[0]);
-			return false;
-		} else {
-			std::cerr << "Unknown argument: " << a << "\n";
-			printUsage(argv[0]);
-			return false;
-		}
-	}
-	if(opt.mode == Mode::None) {
-		printUsage(argv[0]);
-		return false;
-	}
-	return true;
-}
-
-size_t defaultPayloadSize(Mode mode) {
-	return mode == Mode::SingleFrame ? 5 : 20;
-}
-
-std::vector<uint8_t> makePayload(size_t n) {
-	std::vector<uint8_t> data(n);
-	for(size_t i = 0; i < n; i++)
-		data[i] = static_cast<uint8_t>(i & 0xFF);
-	return data;
-}
-
-bool isExtended(uint32_t id) {
-	return id > 0x7FFu;
-}
-
-void printApiResult(const char* what, bool ok) {
-	std::ostringstream oss;
-	oss << "  " << what << ": " << (ok ? "OK" : "FAIL");
-	if(!ok) {
-		const auto err = icsneo::GetLastError();
-		if(err.getType() != icsneo::APIEvent::Type::NoErrorFound)
-			oss << " [" << err << "]";
-	}
-	logLine(oss.str());
-}
-
-bool transmitCan(icsneo::Device& device, uint32_t arbId, std::vector<uint8_t> data) {
-	auto frame = std::make_shared<icsneo::CANMessage>();
-	frame->network = icsneo::Network::NetID::DWCAN_01;
-	frame->arbid = arbId;
-	frame->data = std::move(data);
-	frame->isExtended = isExtended(arbId);
-	frame->isCANFD = false;
-	const bool ok = device.transmit(frame);
-	if(!ok)
-		printApiResult("transmit CAN", ok);
-	return ok;
-}
-
-void fillIso15765(icsneo::Iso15765MessageArgs& msg, const Options& opt, const std::vector<uint8_t>& payload, bool rx) {
-	msg.setTxIndex(0);
-	msg.setArbId(icsneo::Iso15765MessageArgs::ArbId(opt.txId, isExtended(opt.txId)));
-	msg.setFlowControlArbId(icsneo::Iso15765MessageArgs::ArbId(opt.fcId, isExtended(opt.fcId)));
-	msg.setFlowControlArbIdMask(isExtended(opt.txId) ? 0x1FFFFFFFu : 0x7FFu);
-	msg.setIsCanFd(false);
-	msg.setIsBrsEnabled(false);
-	msg.setTxDl(8);
-	msg.setPaddingValue(opt.padding);
-	msg.setFsTimeout(opt.fsTimeoutMs);
-	msg.setFsWaitTimeout(opt.fsWaitMs);
-	msg.setCfTimeout(opt.cfTimeoutMs);
-	msg.setIsFlowControlEnabled(rx);
-	if(!payload.empty()) {
-		auto copy = payload;
-		msg.setData(std::move(copy));
-	}
-}
-
-struct Sniffer {
-	const char* tag = "";
-	std::optional<uint64_t> t0;
-	std::mutex t0Mutex;
-
-	void onCan(const std::shared_ptr<icsneo::CANMessage>& can) {
-		{
-			std::lock_guard<std::mutex> lk(t0Mutex);
-			if(!t0)
-				t0 = can->timestamp;
-		}
-
-		double relMs = 0.0;
-		{
-			std::lock_guard<std::mutex> lk(t0Mutex);
-			if(t0 && can->timestamp >= *t0)
-				relMs = static_cast<double>(can->timestamp - *t0) / 1e6;
-		}
-
-		std::ostringstream oss;
-		oss << "  [" << tag << (can->transmitted ? " TX" : " RX") << "] "
-			<< std::fixed << std::setprecision(3) << relMs << " ms  "
-			<< can->network << "  0x" << std::hex << std::uppercase
-			<< std::setw(isExtended(can->arbid) ? 8 : 3) << std::setfill('0') << can->arbid
-			<< std::dec << " [" << can->data.size() << "]  " << hexBytes(can->data);
-		const auto pci = pciDescribe(can->data);
-		if(!pci.empty())
-			oss << "  " << pci;
-		logLine(oss.str());
-	}
-};
-
-void addCanSniffer(icsneo::Device& device, Sniffer& sniffer) {
-	auto filter = std::make_shared<icsneo::MessageFilter>(icsneo::Network::NetID::DWCAN_01);
-	device.addMessageCallback(std::make_shared<icsneo::MessageCallback>(filter, [&sniffer](std::shared_ptr<icsneo::Message> message) {
-		if(message->type != icsneo::Message::Type::Frame)
-			return;
-		auto frame = std::static_pointer_cast<icsneo::Frame>(message);
-		if(frame->network.getType() != icsneo::Network::Type::CAN)
-			return;
-		sniffer.onCan(std::static_pointer_cast<icsneo::CANMessage>(message));
-	}));
-}
-
-bool openAndOnline(std::shared_ptr<icsneo::Device>& device, const Options& opt) {
-	logLine(std::string("Opening ") + device->describe() + " ...");
-	if(!device->open()) {
-		printApiResult("open", false);
-		return false;
-	}
-	if(!opt.keepBaud && device->settings) {
-		if(!device->settings->setBaudrateFor(icsneo::Network::NetID::DWCAN_01, opt.baud))
-			printApiResult("setBaudrateFor", false);
-		else if(!device->settings->apply(true))
-			printApiResult("settings->apply(temporary)", false);
-	}
-	if(!device->goOnline()) {
-		printApiResult("goOnline", false);
-		device->close();
-		return false;
-	}
-	return true;
-}
-
-void closeDevice(const std::shared_ptr<icsneo::Device>& device) {
-	if(!device)
-		return;
-	device->iso15765DisableAll();
-	if(device->isOnline())
-		device->goOffline();
-	if(device->isOpen())
-		device->close();
-}
-
-bool enableIso(icsneo::Device& device, const char* who) {
-	const bool ok = device.iso15765Enable(icsneo::Network(icsneo::Network::NetID::DWCAN_01));
-	printApiResult((std::string(who) + " ISO15765_Enable").c_str(), ok);
-	return ok;
-}
-
-bool receiveIso(icsneo::Device& device, const Options& opt) {
-	icsneo::Iso15765MessageArgs msg;
-	fillIso15765(msg, opt, {}, true);
-	const bool ok = device.iso15765SetupRxFlowControl(icsneo::Network(icsneo::Network::NetID::DWCAN_01), msg);
-	printApiResult("ECU ISO15765_ReceiveMessage", ok);
-	return ok;
-}
-
-bool transmitIso(icsneo::Device& device, const Options& opt, const std::vector<uint8_t>& payload) {
-	icsneo::Iso15765MessageArgs msg;
-	fillIso15765(msg, opt, payload, false);
-	const bool ok = device.iso15765TransmitMessage(
-		icsneo::Network(icsneo::Network::NetID::DWCAN_01), msg, std::chrono::milliseconds(0));
-	printApiResult("tester ISO15765_TransmitMessage", ok);
-	return ok;
-}
-
-std::shared_ptr<icsneo::Device> findBySerial(const std::vector<std::shared_ptr<icsneo::Device>>& devices, const std::string& serial) {
-	for(const auto& d : devices) {
-		if(iequals(d->getSerial(), serial))
-			return d;
-	}
-	return nullptr;
-}
-
-} // namespace
-
-int main(int argc, char** argv) {
-	Options opt;
-	try {
-		if(!parseArgs(argc, argv, opt))
-			return 1;
-	} catch(const std::exception& ex) {
-		std::cerr << ex.what() << std::endl;
-		return 1;
-	}
-
-	std::cout << "libicsneo " << icsneo::GetVersion() << std::endl;
-
-	auto devices = icsneo::FindAllDevices();
-	std::cout << "Found " << devices.size() << " device(s)\n";
-	for(const auto& d : devices)
-		std::cout << "  " << d->describe() << " serial=" << d->getSerial() << "\n";
-
-	if(devices.size() < 2) {
-		std::cerr << "Need two devices connected.\n";
-		return 1;
-	}
-
-	std::shared_ptr<icsneo::Device> tester;
-	std::shared_ptr<icsneo::Device> ecu;
-	if(opt.testerSerial.empty() && opt.ecuSerial.empty()) {
-		if(devices.size() != 2) {
-			std::cerr << "More than two devices found; pass --tester and --ecu serials.\n";
-			return 1;
-		}
-		tester = devices[0];
-		ecu = devices[1];
-		std::cout << "No serials given; using first as tester, second as ECU.\n";
-	} else {
-		if(opt.testerSerial.empty() || opt.ecuSerial.empty()) {
-			std::cerr << "Pass both --tester and --ecu, or neither.\n";
-			return 1;
-		}
-		tester = findBySerial(devices, opt.testerSerial);
-		ecu = findBySerial(devices, opt.ecuSerial);
-		if(!tester || !ecu) {
-			std::cerr << "Could not match tester/ECU serials.\n";
-			return 1;
-		}
-	}
-
-	const size_t payloadSize = opt.payloadBytes.value_or(defaultPayloadSize(opt.mode));
-	const auto payload = makePayload(payloadSize);
-
-	std::cout << "Tester: " << tester->describe() << "\n"
-			  << "ECU:    " << ecu->describe() << "\n";
-	if(opt.mode != Mode::Raw) {
-		std::ostringstream hdr;
-		hdr << "CAN1 TX 0x" << std::hex << std::uppercase << opt.txId
-			<< "  FC 0x" << opt.fcId << std::dec
-			<< "  payload " << payloadSize << " bytes";
-		std::cout << hdr.str() << "\n";
-	}
-	std::cout << std::endl;
-
-	if(!openAndOnline(tester, opt) || !openAndOnline(ecu, opt))
-		return 1;
-
-	Sniffer testerSniff;
-	testerSniff.tag = "TESTER";
-	Sniffer ecuSniff;
-	ecuSniff.tag = "ECU   ";
-	addCanSniffer(*tester, testerSniff);
-	addCanSniffer(*ecu, ecuSniff);
-
-	switch(opt.mode) {
-		case Mode::Raw:
-			logLine("Mode --raw: tester 0x123, then ECU 0x456");
-			transmitCan(*tester, 0x123, { 0x11, 0x22, 0x33, 0x44 });
-			std::this_thread::sleep_for(200ms);
-			transmitCan(*ecu, 0x456, { 0x55, 0x66, 0x77, 0x88 });
-			break;
-		case Mode::SingleFrame:
-			logLine("Mode --sf: firmware ISO-TP single frame from tester");
-			if(payload.size() > 7)
-				logLine("  warning: payload > 7 bytes will be a First Frame (no flow control in this mode)");
-			enableIso(*tester, "tester");
-			transmitIso(*tester, opt, payload);
-			break;
-		case Mode::Both:
-			logLine("Mode --both: firmware TX on tester, firmware flow-control on ECU");
-			enableIso(*tester, "tester");
-			enableIso(*ecu, "ECU");
-			receiveIso(*ecu, opt);
-			std::this_thread::sleep_for(100ms);
-			transmitIso(*tester, opt, payload);
-			break;
-		case Mode::None:
-			break;
-	}
-
-	std::this_thread::sleep_for(std::chrono::milliseconds(opt.listenMs));
-
-	closeDevice(tester);
-	closeDevice(ecu);
-	return 0;
-}

examples/python/apperror/apperror.py

@@ -1,51 +0,0 @@
-import icsneopy
-import time
-
-#
-# App errors are responses from the device indicating internal runtime errors
-# NOTE: To trigger the app error in this example, disable the DW CAN 01 network on the device
-# (e.g. with ICS Device Manager)
-#
-def apperror():
-	devices = icsneopy.find_all_devices()
-
-	if len(devices) == 0:
-		print("no devices found")
-		return False
-
-	device = devices[0]
-	print(f"selected {device}")
-
-	def on_apperror(message):
-		if message.get_app_error_type() != icsneopy.AppErrorType.NetworkNotEnabled:
-			print("unexpected app error type")
-			return
-		print(message.get_app_error_string())
-
-	filter = icsneopy.MessageFilter(icsneopy.Message.Type.AppError)
-	callback = icsneopy.MessageCallback(on_apperror, filter)
-	device.add_message_callback(callback)
-
-	if not device.open():
-		print("unable to open device")
-		return False
-
-	if not device.go_online():
-		print("unable to go online")
-		return False
-
-	frame = icsneopy.CANMessage()
-	frame.network = icsneopy.Network(icsneopy.Network.NetID.DWCAN_01)
-	frame.arbid = 0x22
-	frame.data = (0xAA, 0xBB, 0xCC)
-
-	if not device.transmit(frame):
-		print("failed to transmit frame")
-		return False
-
-	time.sleep(2) # wait for error to come back
-
-	return True
-
-if __name__ == "__main__":
-	apperror()

examples/python/gptp/gptp_settings.py

@@ -1,151 +0,0 @@
-import icsneopy
-
-GPTP_PORT_MAP = {
-	icsneopy.Network.NetID.AE_01:       (1,  "AE 01"),
-	icsneopy.Network.NetID.AE_02:       (2,  "AE 02"),
-	icsneopy.Network.NetID.AE_03:       (3,  "AE 03"),
-	icsneopy.Network.NetID.AE_04:       (4,  "AE 04"),
-	icsneopy.Network.NetID.AE_05:       (5,  "AE 05"),
-	icsneopy.Network.NetID.AE_06:       (6,  "AE 06"),
-	icsneopy.Network.NetID.AE_07:       (7,  "AE 07"),
-	icsneopy.Network.NetID.AE_08:       (8,  "AE 08"),
-	icsneopy.Network.NetID.AE_09:       (9,  "AE 09"),
-	icsneopy.Network.NetID.AE_10:       (10, "AE 10"),
-	icsneopy.Network.NetID.AE_11:       (11, "AE 11"),
-	icsneopy.Network.NetID.AE_12:       (12, "AE 12"),
-	icsneopy.Network.NetID.ETHERNET_01: (13, "Ethernet 01"),
-	icsneopy.Network.NetID.ETHERNET_02: (14, "Ethernet 02"),
-	icsneopy.Network.NetID.ETHERNET_03: (15, "Ethernet 03"),
-	icsneopy.Network.NetID.AE_13:       (16, "AE 13"),
-	icsneopy.Network.NetID.AE_14:       (17, "AE 14"),
-	icsneopy.Network.NetID.AE_15:       (18, "AE 15"),
-	icsneopy.Network.NetID.AE_16:       (19, "AE 16"),
-}
-
-PROFILE_NAMES = {
-	icsneopy.Settings.GTPPProfile.Standard:   "Standard",
-	icsneopy.Settings.GTPPProfile.Automotive: "Automotive",
-}
-
-ROLE_NAMES = {
-	icsneopy.Settings.GTPPRole.Disabled: "Disabled",
-	icsneopy.Settings.GTPPRole.Passive:  "Passive",
-	icsneopy.Settings.GTPPRole.Master:   "Master",
-	icsneopy.Settings.GTPPRole.Slave:    "Slave",
-}
-
-
-def prompt_int(prompt, default, lo, hi):
-	try:
-		raw = input(f"{prompt} [{default}]: ").strip()
-		if not raw:
-			return default
-		val = int(raw)
-		if lo <= val <= hi:
-			return val
-	except (ValueError, EOFError):
-		pass
-	print(f"Invalid input, using {default}.")
-	return default
-
-
-def gptp_ports(device):
-	ports = []
-	for net in device.get_supported_tx_networks():
-		entry = GPTP_PORT_MAP.get(net.get_net_id())
-		if entry:
-			ports.append(entry)
-	return sorted(ports)
-
-
-def print_settings(device):
-	s = device.settings
-	profile  = s.get_gptp_profile()
-	role     = s.get_gptp_role()
-	port     = s.get_gptp_enabled_port()
-	synton   = s.is_gptp_clock_syntonization_enabled()
-
-	print("\nCurrent gPTP settings:")
-	if profile is not None:
-		print(f"  Profile:             {PROFILE_NAMES.get(profile, profile)}")
-	if role is not None:
-		print(f"  Role:                {ROLE_NAMES.get(role, role)}")
-	if port is not None:
-		suffix = " (disabled)" if port == 0 else ""
-		print(f"  Enabled port:        {port}{suffix}")
-	if synton is not None:
-		print(f"  Clock syntonization: {'enabled' if synton else 'disabled'}")
-
-
-def configure(device):
-	if not device.settings.refresh():
-		print("error: failed to refresh settings")
-		return False
-
-	print_settings(device)
-
-	ports = gptp_ports(device)
-	print("\nAvailable gPTP ports (0 = disabled):")
-	print("    [0] Disabled")
-	for idx, name in ports:
-		print(f"    [{idx}] {name}")
-
-	print("\nConfigure gPTP:")
-	profile   = prompt_int("  Profile (0=Standard, 1=Automotive)", 1, 0, 1)
-	role      = prompt_int("  Role (0=Disabled, 1=Passive, 2=Master, 3=Slave)", 3, 0, 3)
-	port      = prompt_int("  Enabled port index", 0, 0, 19)
-	synton    = prompt_int("  Clock syntonization (0=disabled, 1=enabled)", 0, 0, 1)
-	permanent = prompt_int("\nSave to EEPROM? (0=temporary, 1=permanent)", 0, 0, 1)
-
-	s = device.settings
-	profile_enum = list(PROFILE_NAMES.keys())[profile]
-	role_enum    = list(ROLE_NAMES.keys())[role]
-
-	s.set_gptp_profile(profile_enum)
-	s.set_gptp_role(role_enum)
-	s.set_gptp_enabled_port(port)
-	s.set_gptp_clock_syntonization_enabled(bool(synton))
-
-	if not s.apply(not permanent):
-		print("error: failed to apply settings")
-		return False
-
-	print_settings(device)
-	return True
-
-
-def main():
-	devices = icsneopy.find_all_devices()
-	if not devices:
-		print("error: no devices found")
-		return 1
-
-	gptp_devices = [d for d in devices if d.settings.get_gptp_profile() is not None]
-	if not gptp_devices:
-		print("error: no gPTP-capable devices found")
-		return 1
-
-	print("Available gPTP-capable devices:")
-	for i, d in enumerate(gptp_devices, 1):
-		print(f"  [{i}] {d}")
-
-	choice = prompt_int("Select device", 1, 1, len(gptp_devices))
-	device = gptp_devices[choice - 1]
-
-	print(f"\nOpening {device}... ", end="", flush=True)
-	if not device.open():
-		print("failed")
-		return 1
-	print("OK")
-
-	try:
-		ok = configure(device)
-	finally:
-		print(f"\nClosing {device}")
-		device.close()
-
-	return 0 if ok else 1
-
-
-if __name__ == "__main__":
-	raise SystemExit(main())

examples/python/main51/main51_filter.py

@@ -1,45 +0,0 @@
-import icsneopy
-import time
-
-#
-# Main51 messages are device-originated notifications from the firmware's Main51 processor.
-# This example filters for RX buffer overflow and TX FIFO overflow events.
-#
-def main51_filter():
-	devices = icsneopy.find_all_devices()
-
-	if len(devices) == 0:
-		print("no devices found")
-		return False
-
-	device = devices[0]
-	print(f"selected {device}")
-
-	def on_main51(message):
-		if not isinstance(message, icsneopy.Main51Message):
-			return
-		if message.command == icsneopy.Command.Main51RxBufferOverflow:
-			print("RX buffer overflow")
-		elif message.command == icsneopy.Command.Main51TxFifoOverflow:
-			print("TX FIFO overflow")
-		else:
-			print(f"Main51 command: {message.command}")
-
-	filter = icsneopy.Main51MessageFilter()
-	callback = icsneopy.MessageCallback(on_main51, filter)
-	device.add_message_callback(callback)
-
-	if not device.open():
-		print("unable to open device")
-		return False
-
-	if not device.go_online():
-		print("unable to go online")
-		return False
-
-	time.sleep(5)
-
-	return True
-
-if __name__ == "__main__":
-	main51_filter()

include/icsneo/J2534.h

@@ -1,133 +1,33 @@
 #ifndef _J2534_H
 #define _J2534_H
 
-#include <cstdint>
-
-namespace icsneo {
-
 //J2534 Commands
 #define J1534_NUM_PERIOD_TX_MSGS 128
 #define J1534_NUM_PERIOD_RX_MSGS 128
-
-enum class J2534Command : uint8_t {
-    SetISJ2534 = 0,
-    SetISO5Baud = 1,
-    SetISOFastInit = 2,
-    SetISOCheckSum = 3,
-    SetISO9141Parms = 4,
-    GetISO9141Parms = 5,
-    ISO9141APIChkSum = 6,
-    SetNetworkBaudRate = 7,
-    GetNetworkBaudRate = 8,
-    EnableTransmitEvent = 9,
-    SetTransmitEvent = 10,
-    BlueEnableStopFilters = 11,
-    Blue15765HWSupport = 12,
-    GetTXBufferInfo = 13,
-    GetEncryptionKey = 14,
-    SetMiscIOForVBATT = 15,
-    EnableISO_KW_Network = 16,
-    SetJ1708CheckSum = 17,
-    GetTimestamp = 18,
-    GetCANFDRate = 19,
-    SetCANFDRate = 20,
-    GetCANFDTermination = 21,
-    SetCANFDTermination = 22,
-    GetCANFDFormat = 23,
-    SetCANFDFormat = 24
-};
-
-#pragma pack(push)
-#pragma pack(1)
-
-/**
- * SubFrame Commands
- */
-enum class J2534SubCommand : uint8_t {
-    Enable = 0,
-    SetupIso15765RxFilter = 1,
-    SetupIso15765TxMessageProperties = 2,
-    SetupIso15765TxMessageDataBytes = 3,
-    SetupCanRxFilter = 4,
-    SetupClearCanRxFilters = 5,
-    EnableFiltering = 6
-};
-
-typedef struct
-{
-	uint16_t uiFilterMask0;
-	uint16_t uiFilterID0;
-	uint16_t uiFilterMask1;
-	uint16_t uiFilterID1;
-	uint16_t uiFilterMask2;
-	uint16_t uiFilterID2;
-	union {
-		/** Mask and value words if rx filter is datalink filter*/
-		struct
-		{
-			uint16_t uiFilterMask3;
-			uint16_t uiFilterID3;
-			uint16_t uiFilterMask4;
-			uint16_t uiFilterID4;
-			uint16_t uiFilterMask5;
-			uint16_t uiFilterID5;
-			uint16_t uiFilterMask6;
-			uint16_t uiFilterID6;
-		} datalink;
-		/** Mask and value bytes if rx filter is datalink filter*/
-		struct
-		{
-			uint8_t uiFilterMask_DB0;
-			uint8_t uiFilterMask_DB1;
-			uint8_t uiFilterID_DB0;
-			uint8_t uiFilterID_DB1;
-			uint8_t uiFilterMask_DB2;
-			uint8_t uiFilterMask_DB3;
-			uint8_t uiFilterID_DB2;
-			uint8_t uiFilterID_DB3;
-			uint8_t uiFilterMask_DB4;
-			uint8_t uiFilterMask_DB5;
-			uint8_t uiFilterID_DB4;
-			uint8_t uiFilterID_DB5;
-			uint8_t uiFilterMask_DB6;
-			uint8_t uiFilterMask_DB7;
-			uint8_t uiFilterID_DB6;
-			uint8_t uiFilterID_DB7;
-		} datalinkBytes;
-		/** Mask and value bytes if rx filter is Iso15765-2*/
-		struct
-		{
-			uint8_t uiFilterMask_DB0;
-			uint8_t uiFilterID_DB0;
-			uint8_t uiFilterMask_DB1;
-			uint8_t uiFilterID_DB1;
-			uint8_t uiFilterMask_DB2;
-			uint8_t uiFilterID_DB2;
-			uint8_t uiFilterMask_DB3;
-			uint8_t uiFilterID_DB3;
-			uint8_t uiFilterMask_DB4;
-			uint8_t uiFilterID_DB4;
-			uint8_t uiFilterMask_DB5;
-			uint8_t uiFilterID_DB5;
-			uint8_t uiFilterMask_DB6;
-			uint8_t uiFilterID_DB6;
-			uint8_t uiFilterMask_DB7;
-			uint8_t uiFilterID_DB7;
-		} iso15Bytes;
-	} args;
-} MessageFilterBytes;
-
-typedef struct
-{
-	uint16_t idx;
-	uint16_t enabled;
-	uint16_t filterCount;
-	MessageFilterBytes fb;
-	uint16_t networkId;
-} J2534_RxCanFilter;
-
-#pragma pack(pop)
-
-} // namespace icsneo
+#define J2534NVCMD_SetISJ2534 0
+#define J2534NVCMD_SetISO5Baud 1
+#define J2534NVCMD_SetISOFastInit 2
+#define J2534NVCMD_SetISOCheckSum 3
+#define J2534NVCMD_SetISO9141Parms 4
+#define J2534NVCMD_GetISO9141Parms 5
+#define J2534NVCMD_ISO9141APIChkSum 6
+#define J2534NVCMD_SetNetworkBaudRate 7
+#define J2534NVCMD_GetNetworkBaudRate 8
+#define J2534NVCMD_EnableTransmitEvent 9
+#define J2534NVCMD_SetTransmitEvent 10
+#define J2534NVCMD_BlueEnableStopFilters 11
+#define J2534NVCMD_Blue15765HWSupport 12
+#define J2534NVCMD_GetTXBufferInfo 13
+#define J2534NVCMD_GetEncryptionKey 14
+#define J2534NVCMD_SetMiscIOForVBATT 15
+#define J2534NVCMD_EnableISO_KW_Network 16
+#define J2534NVCMD_SetJ1708CheckSum 17
+#define J2534NVCMD_GetTimestamp 18
+#define J2534NVCMD_GetCANFDRate 19
+#define J2534NVCMD_SetCANFDRate 20
+#define J2534NVCMD_GetCANFDTermination 21
+#define J2534NVCMD_SetCANFDTermination 22
+#define J2534NVCMD_GetCANFDFormat 23
+#define J2534NVCMD_SetCANFDFormat 24
 
 #endif

include/icsneo/api/event.h

@@ -19,7 +19,6 @@ typedef struct {
 #include <chrono>
 #include <string>
 #include <ostream>
-#include <memory>
 
 namespace icsneo {
 
@@ -186,25 +185,19 @@ public:
 		Error = 0x30
 	};
 
-	APIEvent() : eventStruct({}), serial(), timepoint() {}
-	APIEvent(APIEvent::Type event, APIEvent::Severity severity, std::weak_ptr<Device> device = {});
+	APIEvent() : eventStruct({}), serial(), timepoint(), device(nullptr) {}
+	APIEvent(APIEvent::Type event, APIEvent::Severity severity, const Device* device = nullptr);
 
 	const neoevent_t* getNeoEvent() const noexcept { return &eventStruct; }
 	Type getType() const noexcept { return Type(eventStruct.eventNumber); }
 	Severity getSeverity() const noexcept { return Severity(eventStruct.severity); }
 	std::string getDescription() const noexcept { return std::string(eventStruct.description); }
-	const Device* getDevice() const noexcept { // Will return nullptr if this is an API-wide event
-		auto shared = device.lock();
-		return (shared) ? shared.get() : nullptr;
-	} 
+	const Device* getDevice() const noexcept { return device; } // Will return nullptr if this is an API-wide event
 	EventTimePoint getTimestamp() const noexcept { return timepoint; }
 
 	void downgradeFromError() noexcept;
 
-	bool isForDevice(const Device* forDevice) const noexcept {
-		auto shared = device.lock();
-		return shared && (shared.get() == forDevice);
-	}
+	bool isForDevice(const Device* forDevice) const noexcept { return forDevice == device; }
 	bool isForDevice(std::string serial) const noexcept;
 
 	// As opposed to getDescription, this will also add text such as "neoVI FIRE 2 CY2468 Error: " to fully describe the problem
@@ -220,7 +213,7 @@ private:
 	neoevent_t eventStruct;
 	std::string serial;
 	EventTimePoint timepoint;
-	std::weak_ptr<Device> device;
+	const Device* device;
 
 	void init(APIEvent::Type event, APIEvent::Severity);
 };

include/icsneo/api/eventmanager.h

@@ -56,7 +56,7 @@ public:
 	APIEvent getLastError();
 
 	void add(APIEvent event);
-	void add(APIEvent::Type type, APIEvent::Severity severity, std::weak_ptr<Device> forDevice = {}) {
+	void add(APIEvent::Type type, APIEvent::Severity severity, const Device* forDevice = nullptr) {
 		add(APIEvent(type, severity, forDevice));
 	}
 

include/icsneo/api/heartbeat.h

@@ -1,38 +0,0 @@
-#ifndef __HEARTBEAT_H__
-#define __HEARTBEAT_H__
-
-#ifdef __cplusplus
-
-#include <thread>
-#include <condition_variable>
-#include <mutex>
-
-namespace icsneo {
-
-class Device;
-
-class Heartbeat {
-public:
-    Heartbeat(Device& device);
-    ~Heartbeat();
-
-private:
-    enum class Mode {
-        Passive, // ResetStatus messages arrive without requesting
-        Active, // RequestStatusUpdate needs to be sent
-    };
-    Device& device;
-    const Mode mode;
-    bool stop = false;
-    std::mutex mutex;
-    std::condition_variable cv;
-    std::thread thread;
-
-    void run();
-};
-
-} // icsneo
-
-#endif // __cplusplus
-
-#endif // __HEARTBEAT_H__

include/icsneo/cicsSpyStatusBits.h

@@ -1,249 +0,0 @@
-// --------------------------------------------------------------------------
-// COPYRIGHT INTREPID CONTROL SYSTEMS, INC. (c) 1994-20xx
-// Confidential and proprietary. This document and its contents are the 
-// property of Intrepid Control Systems, Inc. It is not to be copied, 
-// distributed, or otherwise disclosed or used without the prior written 
-// consent of Intrepid Control Systems Inc.
-// All rights reserved.
-// --------------------------------------------------------------------------
-
-// SPY Status Bit Definitions
-// Generated automatically - DO NOT MODIFY
-// Modify cicsSpyStatusBits_config.yml and run cicsSpyStatusBits_gen.py
-// Generated on: 2025-07-14 14:31:40
-
-
-#ifndef CICSSPYSTATUSBITS_H_
-#define CICSSPYSTATUSBITS_H_ 1
-
-// WARNING: The following bit conflicts were detected:
-// spystatus value 0x10000000: // VSI value 'SPY_STATUS_VSI_IFR_CRC_BIT' conflicts with common value 'SPY_STATUS_PDU'
-// spystatus value 0x10000000: // A2B value 'SPY_STATUS_A2B_CONTROL' conflicts with common value 'SPY_STATUS_PDU'
-// spystatus value 0x08: // A2B value 'SPY_STATUS_A2B_SCF_VALID_WAITING' conflicts with common value 'SPY_STATUS_REMOTE_FRAME'
-// spystatus value 0x40000000: // A2B value 'SPY_STATUS_A2B_UPSTREAM' conflicts with common value 'SPY_STATUS_HIGH_SPEED'
-// spystatus value 0x10000000: // FLEXRAY value 'SPY_STATUS_FLEXRAY_PDU' conflicts with common value 'SPY_STATUS_PDU'
-// spystatus value 0x40000000: // FLEXRAY value 'SPY_STATUS_FLEXRAY_PDU_UPDATE_BIT_SET' conflicts with common value 'SPY_STATUS_HIGH_SPEED'
-// spystatus value 0x08: // FLEXRAY value 'SPY_STATUS_FLEXRAY_PDU_NO_UPDATE_BIT' conflicts with common value 'SPY_STATUS_REMOTE_FRAME'
-
-
-// Glyph definitions
-// '|' - byte divider
-// '.' - nibble divider
-// '-' - unused bit
-// 'o' - common bit
-// 'x' - protocol specific bit
-// '!' - conflict bit
-
-// SPYSTATUS bit definitions
-// SPYSTATUS - Common bits
-// |oo-o.oooo|oooo.oooo|oooo.oo-o|oo-o.oooo| 
-#define SPY_STATUS_GLOBAL_ERR                    0x01         // Global error flag 
-#define SPY_STATUS_TX_MSG                        0x02         // Transmitted message 
-#define SPY_STATUS_XTD_FRAME                     0x04         // Extended frame 
-#define SPY_STATUS_REMOTE_FRAME                  0x08         // Remote frame 
-#define SPY_STATUS_CRC_ERROR                     0x10         // CRC error 
-#define SPY_STATUS_INCOMPLETE_FRAME              0x40         // Incomplete frame 
-#define SPY_STATUS_LOST_ARBITRATION              0x80         // Lost arbitration 
-#define SPY_STATUS_UNDEFINED_ERROR               0x0100       // Undefined error 
-#define SPY_STATUS_BUS_RECOVERED                 0x0400       // Bus recovered 
-#define SPY_STATUS_BUS_SHORTED_PLUS              0x0800       // Bus shorted to plus 
-#define SPY_STATUS_BUS_SHORTED_GND               0x1000       // Bus shorted to ground 
-#define SPY_STATUS_CHECKSUM_ERROR                0x2000       // Checksum error 
-#define SPY_STATUS_BAD_MESSAGE_BIT_TIME_ERROR    0x4000       // Bad message bit time error 
-#define SPY_STATUS_TX_NOMATCH                    0x8000       // TX no match 
-#define SPY_STATUS_COMM_IN_OVERFLOW              0x010000     // Communication input overflow 
-#define SPY_STATUS_EXPECTED_LEN_MISMATCH         0x020000     // Expected length mismatch 
-#define SPY_STATUS_MSG_NO_MATCH                  0x040000     // Message no match 
-#define SPY_STATUS_BREAK                         0x080000     // Break detected 
-#define SPY_STATUS_AVSI_REC_OVERFLOW             0x100000     // AVSI record overflow 
-#define SPY_STATUS_TEST_TRIGGER                  0x200000     // Test trigger 
-#define SPY_STATUS_AUDIO_COMMENT                 0x400000     // Audio comment 
-#define SPY_STATUS_GPS_DATA                      0x800000     // GPS data 
-#define SPY_STATUS_ANALOG_DIGITAL_INPUT          0x01000000   // Analog digital input 
-#define SPY_STATUS_TEXT_COMMENT                  0x02000000   // Text comment 
-#define SPY_STATUS_NETWORK_MESSAGE_TYPE          0x04000000   // Network message type 
-#define SPY_STATUS_VSI_TX_UNDERRUN               0x08000000   // VSI TX underrun 
-#define SPY_STATUS_PDU                           0x10000000   // PDU message 
-#define SPY_STATUS_HIGH_SPEED                    0x40000000   // High speed 
-#define SPY_STATUS_EXTENDED                      0x80000000   // Extended - if this bit is set than decode StatusBitField3 in AckBytes 
-
-// SPYSTATUS - A2B protocol bits
-// |o!x!.oooo|oooo.oooo|oooo.oo-o|oo-o.!ooo| 
-#define SPY_STATUS_A2B_SCF_VALID_WAITING         0x08         // A2B SCF valid waiting 
-#define SPY_STATUS_A2B_CONTROL                   0x10000000   // A2B control message 
-#define SPY_STATUS_A2B_MONITOR                   0x20000000   // A2B monitor message 
-#define SPY_STATUS_A2B_UPSTREAM                  0x40000000   // A2B upstream message 
-
-// SPYSTATUS - CAN protocol bits
-// |ooxo.oooo|oooo.oooo|oooo.ooxo|ooxo.oooo| 
-#define SPY_STATUS_CAN_ERROR_PASSIVE             0x20         // CAN error passive state 
-#define SPY_STATUS_CAN_BUS_OFF                   0x0200       // CAN bus off state 
-#define SPY_STATUS_CANFD                         0x20000000   // CAN FD frame 
-
-// SPYSTATUS - ETHERNET protocol bits
-// |oo-o.oooo|oooo.oooo|oooo.oo-o|ooxo.oooo| 
-#define SPY_STATUS_HEADERCRC_ERROR               0x20         // Header CRC error 
-
-// SPYSTATUS - FLEXRAY protocol bits
-// |o!-!.oooo|oooo.oooo|oooo.oo-o|oo-o.!ooo| 
-#define SPY_STATUS_FLEXRAY_PDU_NO_UPDATE_BIT     0x08         // FlexRay PDU no update bit 
-#define SPY_STATUS_FLEXRAY_PDU                   0x10000000   // FlexRay PDU (alias for SPY_STATUS_PDU) 
-#define SPY_STATUS_FLEXRAY_PDU_UPDATE_BIT_SET    0x40000000   // FlexRay PDU update bit set 
-
-// SPYSTATUS - LIN protocol bits
-// |ooxo.oooo|oooo.oooo|oooo.oo-o|oo-o.oooo| 
-#define SPY_STATUS_LIN_MASTER                    0x20000000   // LIN master message 
-
-// SPYSTATUS - VSI protocol bits
-// |oox!.oooo|oooo.oooo|oooo.oo-o|oo-o.oooo| 
-#define SPY_STATUS_VSI_IFR_CRC_BIT               0x10000000   // VSI IFR CRC bit 
-#define SPY_STATUS_INIT_MESSAGE                  0x20000000   // Initialization message 
-
-
-// SPYSTATUS2 bit definitions
-// SPYSTATUS2 - Common bits
-// |----.----|---o.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_HAS_VALUE                    0x01
-#define SPY_STATUS2_VALUE_IS_BOOLEAN             0x02
-#define SPY_STATUS2_HIGH_VOLTAGE                 0x04
-#define SPY_STATUS2_LONG_MESSAGE                 0x08
-#define SPY_STATUS2_GLOBAL_CHANGE                0x010000
-#define SPY_STATUS2_ERROR_FRAME                  0x020000
-#define SPY_STATUS2_END_OF_LONG_MESSAGE          0x100000
-
-// SPYSTATUS2 - CAN protocol bits
-// |----.----|-xxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_CAN_ISO15765_LOGICAL_FRAME   0x200000
-#define SPY_STATUS2_CAN_HAVE_LINK_DATA           0x400000
-
-// SPYSTATUS2 - ETHERNET protocol bits
-// |xxxx.xxxx|xxxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_ETHERNET_CRC_ERROR           0x200000
-#define SPY_STATUS2_ETHERNET_FRAME_TOO_SHORT     0x400000
-#define SPY_STATUS2_ETHERNET_FCS_AVAILABLE       0x800000     // This frame contains FCS (4 bytes) obtained from ICS Ethernet hardware (ex. RAD-STAR) 
-#define SPY_STATUS2_ETHERNET_NO_PADDING          0x01000000
-#define SPY_STATUS2_ETHERNET_PREEMPTION_ENABLED  0x02000000
-#define SPY_STATUS2_ETHERNET_UPDATE_CHECKSUMS    0x04000000
-#define SPY_STATUS2_ETHERNET_MANUALFCS_ENABLED   0x08000000
-#define SPY_STATUS2_ETHERNET_FCS_VERIFIED        0x10000000
-#define SPY_STATUS2_ETHERNET_T1S_SYMBOL          0x20000000
-#define SPY_STATUS2_ETHERNET_T1S_BURST           0x40000000
-#define SPY_STATUS2_ETHERNET_T1S_ETHERNET        0x80000000
-
-// SPYSTATUS2 - FLEXRAY protocol bits
-// |----.-xxx|xxxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_FLEXRAY_TX_AB                0x200000
-#define SPY_STATUS2_FLEXRAY_TX_AB_NO_A           0x400000
-#define SPY_STATUS2_FLEXRAY_TX_AB_NO_B           0x800000
-#define SPY_STATUS2_FLEXRAY_TX_AB_NO_MATCH       0x01000000
-#define SPY_STATUS2_FLEXRAY_NO_CRC               0x02000000
-#define SPY_STATUS2_FLEXRAY_NO_HEADERCRC         0x04000000   //     
-
-// SPYSTATUS2 - I2C protocol bits
-// |----.----|xxxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_I2C_ERR_TIMEOUT              0x200000
-#define SPY_STATUS2_I2C_ERR_NACK                 0x400000
-#define SPY_STATUS2_I2C_DIR_READ                 0x800000
-
-// SPYSTATUS2 - ISO protocol bits
-// |-xxx.x---|---o.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_ISO_FRAME_ERROR              0x08000000   // ISO frame error 
-#define SPY_STATUS2_ISO_OVERFLOW_ERROR           0x10000000   // ISO overflow error 
-#define SPY_STATUS2_ISO_PARITY_ERROR             0x20000000   // ISO parity error 
-#define SPY_STATUS2_ISO_RX_TIMEOUT_ERROR         0x40000000   // ISO specific timeout error 
-
-// SPYSTATUS2 - LIN protocol bits
-// |xxxx.xxxx|xxxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_LIN_ERR_RX_BREAK_NOT_0       0x200000     // LIN RX break not 0 error 
-#define SPY_STATUS2_LIN_ERR_RX_BREAK_TOO_SHORT   0x400000     // LIN RX break too short error 
-#define SPY_STATUS2_LIN_ERR_RX_SYNC_NOT_55       0x800000     // LIN RX sync not 0x55 error 
-#define SPY_STATUS2_LIN_ERR_RX_DATA_GREATER_8    0x01000000   // LIN RX data greater than 8 bytes error 
-#define SPY_STATUS2_LIN_ERR_TX_RX_MISMATCH       0x02000000   // LIN TX/RX mismatch error 
-#define SPY_STATUS2_LIN_ERR_MSG_ID_PARITY        0x04000000   // LIN message ID parity error 
-#define SPY_STATUS2_LIN_SYNC_FRAME_ERROR         0x08000000   // LIN sync frame error 
-#define SPY_STATUS2_LIN_ID_FRAME_ERROR           0x10000000   // LIN ID frame error 
-#define SPY_STATUS2_LIN_SLAVE_BYTE_ERROR         0x20000000   // LIN slave byte error 
-#define SPY_STATUS2_LIN_RX_TIMEOUT_ERROR         0x40000000   // RX timeout error 
-#define SPY_STATUS2_LIN_NO_SLAVE_DATA            0x80000000   // LIN no slave data 
-
-// SPYSTATUS2 - MDIO protocol bits
-// |-xxx.xxxx|xxxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_MDIO_ERR_TIMEOUT             0x200000
-#define SPY_STATUS2_MDIO_JOB_CANCELLED           0x400000
-#define SPY_STATUS2_MDIO_INVALID_BUS             0x800000
-#define SPY_STATUS2_MDIO_INVALID_PHYADDR         0x01000000
-#define SPY_STATUS2_MDIO_INVALID_REGADDR         0x02000000
-#define SPY_STATUS2_MDIO_UNSUPPORTED_CLAUSE      0x04000000
-#define SPY_STATUS2_MDIO_UNSUPPORTED_OPCODE      0x08000000
-#define SPY_STATUS2_MDIO_OVERFLOW                0x10000000
-#define SPY_STATUS2_MDIO_CLAUSE45                0x20000000
-#define SPY_STATUS2_MDIO_READ                    0x40000000
-
-// SPYSTATUS2 - MOST protocol bits
-// |xxxx.xxxx|xxxo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_MOST_PACKET_DATA             0x200000
-#define SPY_STATUS2_MOST_STATUS                  0x400000     // reflects changes in light/lock/MPR/SBC/etc... 
-#define SPY_STATUS2_MOST_LOW_LEVEL               0x800000     // MOST low level message, allocs, deallocs, remote requests...*/ 
-#define SPY_STATUS2_MOST_CONTROL_DATA            0x01000000
-#define SPY_STATUS2_MOST_MHP_USER_DATA           0x02000000   // MOST HIGH User Data Frame 
-#define SPY_STATUS2_MOST_MHP_CONTROL_DATA        0x04000000   // MOST HIGH Control Data 
-#define SPY_STATUS2_MOST_I2S_DUMP                0x08000000
-#define SPY_STATUS2_MOST_TOO_SHORT               0x10000000
-#define SPY_STATUS2_MOST_MOST50                  0x20000000   // absence of MOST50 and MOST150 implies it's MOST25 
-#define SPY_STATUS2_MOST_MOST150                 0x40000000
-#define SPY_STATUS2_MOST_CHANGED_PAR             0x80000000   // first byte in ack reflects what changed. 
-
-// SPYSTATUS2 - WBMS protocol bits
-// |----.----|--xo.--oo|----.----|----.oooo| 
-#define SPY_STATUS2_WBMS_API_IS_CALLBACK         0x200000
-
-
-// SPYSTATUS3 bit definitions
-// SPYSTATUS3 - CAN protocol bits
-// |----.----|-xxx.xxxx|-xxx.xxxx|----.-xxx| 
-#define SPY_STATUS3_CAN_ERR_PASSIVE              0x01         // CAN error passive state: typically when error counter is > 127 
-#define SPY_STATUS3_CAN_BUS_OFF                  0x02         // CAN bus off state 
-#define SPY_STATUS3_CAN_ERR_WARNING              0x04         // CAN error warning: typically when error counter is > 96 
-#define SPY_STATUS3_CAN_DATAERR_STUFF_ERROR      0x0100       // CAN stuff error during the data payload phase 
-#define SPY_STATUS3_CAN_DATAERR_FORM_ERROR       0x0200       // CAN form error during the data payload phase 
-#define SPY_STATUS3_CAN_DATAERR_ACK_ERROR        0x0400       // CAN ack error during the data payload phase 
-#define SPY_STATUS3_CAN_DATAERR_BIT1_ERROR       0x0800       // CAN bit1 error during the data payload phase 
-#define SPY_STATUS3_CAN_DATAERR_BIT0_ERROR       0x1000       // CAN bit0 error during the data payload phase 
-#define SPY_STATUS3_CAN_DATAERR_CRC_ERROR        0x2000       // CAN CRC error during the data payload phase 
-#define SPY_STATUS3_CAN_DATAERR_NOCHANGE         0x4000       // CAN data error occurred before and no change yet 
-#define SPY_STATUS3_CAN_GENERR_STUFF_ERROR       0x010000     // CAN stuff error at the general frame level 
-#define SPY_STATUS3_CAN_GENERR_FORM_ERROR        0x020000     // CAN form error at the general frame level 
-#define SPY_STATUS3_CAN_GENERR_ACK_ERROR         0x040000     // CAN ack error at the general frame level 
-#define SPY_STATUS3_CAN_GENERR_BIT1_ERROR        0x080000     // CAN bit1 error at the general frame level 
-#define SPY_STATUS3_CAN_GENERR_BIT0_ERROR        0x100000     // CAN bit0 error at the general frame level 
-#define SPY_STATUS3_CAN_GENERR_CRC_ERROR         0x200000     // CAN CRC error at the general frame level 
-#define SPY_STATUS3_CAN_GENERR_NOCHANGE          0x400000     // CAN frame Error occurred before and no change yet 
-
-// SPYSTATUS3 - CANFD protocol bits
-// |----.----|----.----|----.----|---x.xxxx| 
-#define SPY_STATUS3_CANFD_ESI                    0x01         // CAN FD Error State Indicator (ESI) reflects the error state of the transmitting node 
-#define SPY_STATUS3_CANFD_IDE                    0x02         // CAN FD Identifier Extension (IDE) indicates if standard or extended IDs are in use 
-#define SPY_STATUS3_CANFD_RTR                    0x04
-#define SPY_STATUS3_CANFD_FDF                    0x08         // CAN FD Format (FDF) flag -- distinguishes classic CAN from CANFD 
-#define SPY_STATUS3_CANFD_BRS                    0x10         // CANFD Baud Rate Select (BRS) flag, indicates if the data portion transmits at a higher bitrate 
-
-// SPYSTATUS3 - ETHERNET protocol bits
-// |----.----|----.----|----.----|----.--xx| 
-#define SPY_STATUS3_ETHERNET_TX_COLLISION        0x01
-#define SPY_STATUS3_ETHERNET_T1S_WAKE            0x02
-
-// SPYSTATUS3 - LIN protocol bits
-// |----.----|----.----|----.----|----.-xxx| 
-#define SPY_STATUS3_LIN_JUST_BREAK_SYNC          0x01
-#define SPY_STATUS3_LIN_SLAVE_DATA_TOO_SHORT     0x02
-#define SPY_STATUS3_LIN_ONLY_UPDATE_SLAVE_TABLE_ONCE 0x04
-
-
-// SPYSTATUS4 bit definitions
-// SPYSTATUS4 - ETHERNET protocol bits
-// |----.----|----.----|----.----|----.--xx| 
-#define SPY_STATUS4_ETH_CRC_ERROR                0x01         // Ethernet CRC error 
-#define SPY_STATUS4_ETH_FRAME_TOO_LONG           0x02         // Ethernet frame too long 
-
-
-#endif // CICSSPYSTATUSBITS_H_ 

include/icsneo/communication/command.h

@@ -6,22 +6,6 @@
 namespace icsneo {
 
 enum class Command : uint8_t {
-	// Device-originated Main51 event/error notifications (device -> host)
-	Main51RxBufferOverflow = 0x01,
-	Main51StartCmd = 0x02,
-	Main51TxFifoOverflow = 0x03,
-	Main51BulkInNoData = 0x04,
-	Main51SetModeComplete = 0x05,
-	Main51ReadEeprom = 0x06,
-	// 0x07, 0x08, 0x09 reserved for host->device commands below
-	Main51CmdDone = 0x0A,
-	Main51ErrStatus = 0x0B,
-	Main51ReadSectorBuff = 0x0C,
-	Main51WriteSectorBuff = 0x0D,
-	Main51MmcProcessDone = 0x0E,
-	Main51ReInitDone = 0x0F,
-
-	// Host-originated commands (host -> device)
 	EnableNetworkCommunication = 0x07,
 	EnableNetworkCommunicationEx = 0x08,
 	KeepAlive = 0x09,
@@ -43,7 +27,6 @@ enum class Command : uint8_t {
 	GetLogicalDiskInfo = 0xBB, // Previously known as RED_CMD_GET_SDCARD_INFO
 	RequestStatusUpdate = 0xBC,
 	ReadSettings = 0xC7, // Previously known as 3G_READ_SETTINGS_EX
-	J2534Command = 0xD7, // Previously known as RED_CMD_J2534_EXTENSION
 	SetVBattMonitor = 0xDB, // Previously known as RED_CMD_CM_VBATT_MONITOR
 	RequestBitSmash = 0xDC, // Previously known as RED_CMD_CM_BITSMASH
 	WiVICommand = 0xDD, // Previously known as RED_CMD_WIVI_COMM
@@ -74,14 +57,10 @@ enum class ExtendedCommand : uint16_t {
 	GetComponentVersions = 0x001A,
 	SoftwareUpdate = 0x001B,
 	Reboot = 0x001C,
-	ReadGenericAPIStatus = 0x001D,
 	SetRootFSEntryFlags = 0x0027,
 	TransmitCoreminiMessage = 0x0028,
-	ReadGenericAPIData = 0x002E,
-	WriteGenericAPICommand = 0x002F,
 	GenericBinaryInfo = 0x0030,
 	LiveData = 0x0035,
-	ExecuteSPIPortKeyOperation = 0x003C,
 	RequestTC10Wake = 0x003D,
 	RequestTC10Sleep = 0x003E,
 	GetTC10Status = 0x003F,

include/icsneo/communication/communication.h

@@ -14,7 +14,6 @@
 #include "icsneo/communication/message/extendedresponsemessage.h"
 #include "icsneo/device/deviceversion.h"
 #include "icsneo/api/eventmanager.h"
-#include "icsneo/api/heartbeat.h"
 #include "icsneo/communication/packetizer.h"
 #include "icsneo/communication/encoder.h"
 #include "icsneo/communication/decoder.h"

include/icsneo/communication/driver.h

@@ -31,7 +31,6 @@ public:
 	virtual driver_finder_t getFinder() = 0;
 
 	inline bool isDisconnected() const { return disconnected; };
-	inline void setIsDisconnected(bool isDisconnected) { disconnected = isDisconnected; }
 	inline bool isClosing() const { return closing; }
 
 	bool waitForRx(size_t limit, std::chrono::milliseconds timeout);
@@ -63,6 +62,7 @@ protected:
 	};
 
 	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; }

include/icsneo/communication/icspb.h

@@ -9,7 +9,6 @@
 #include <common/v1/proto_header.pb.h>
 #include <commands/generic/v1/client_id.pb.h>
 #include <commands/network/v1/mutex.pb.h>
-#include <settings/manufacturing/v1/mfg_config.pb.h>
 #ifdef _WIN32
 #pragma warning(pop)
 #endif
@@ -37,11 +36,6 @@ struct IDLookup {
 	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_UNSPECIFIED;
 };
 
-template <>
-struct IDLookup<settings::manufacturing::v1::MfgConfig> {
-	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_MFG_CONFIG;
-};
-
 template <>
 struct IDLookup<commands::network::v1::NetworkMutex> {
 	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_NETWORK_MUTEX;

include/icsneo/communication/message/apperrormessage.h

@@ -4,7 +4,6 @@
 #ifdef __cplusplus
 
 #include "icsneo/communication/message/message.h"
-#include "icsneo/icsneoc2types.h"
 #include <unordered_set>
 #include <memory>
 #include "icsneo/api/eventmanager.h"
@@ -12,57 +11,57 @@
 
 namespace icsneo {
 
-enum class AppErrorType : icsneoc2_app_error_type_t {
-	AppErrorRxMessagesFull = icsneoc2_app_error_type_rx_messages_full,
-	AppErrorTxMessagesFull = icsneoc2_app_error_type_tx_messages_full,
-	AppErrorTxReportMessagesFull = icsneoc2_app_error_type_tx_report_messages_full,
-	AppErrorBadCommWithDspIC = icsneoc2_app_error_type_bad_comm_with_dsp_ic,
-	AppErrorDriverOverflow = icsneoc2_app_error_type_driver_overflow,
-	AppErrorPCBuffOverflow = icsneoc2_app_error_type_pc_buff_overflow,
-	AppErrorPCChksumError = icsneoc2_app_error_type_pc_chksum_error,
-	AppErrorPCMissedByte = icsneoc2_app_error_type_pc_missed_byte,
-	AppErrorPCOverrunError = icsneoc2_app_error_type_pc_overrun_error,
-	AppErrorSettingFailure = icsneoc2_app_error_type_setting_failure,
-	AppErrorTooManySelectedNetworks = icsneoc2_app_error_type_too_many_selected_networks,
-	AppErrorNetworkNotEnabled = icsneoc2_app_error_type_network_not_enabled,
-	AppErrorRtcNotCorrect = icsneoc2_app_error_type_rtc_not_correct,
-	AppErrorLoadedDefaultSettings = icsneoc2_app_error_type_loaded_default_settings,
-	AppErrorFeatureNotUnlocked = icsneoc2_app_error_type_feature_not_unlocked,
-	AppErrorFeatureRtcCmdDropped = icsneoc2_app_error_type_feature_rtc_cmd_dropped,
-	AppErrorTxMessagesFlushed = icsneoc2_app_error_type_tx_messages_flushed,
-	AppErrorTxMessagesHalfFull = icsneoc2_app_error_type_tx_messages_half_full,
-	AppErrorNetworkNotValid = icsneoc2_app_error_type_network_not_valid,
-	AppErrorTxInterfaceNotImplemented = icsneoc2_app_error_type_tx_interface_not_implemented,
-	AppErrorTxMessagesCommEnableIsOff = icsneoc2_app_error_type_tx_messages_comm_enable_is_off,
-	AppErrorRxFilterMatchCountExceeded = icsneoc2_app_error_type_rx_filter_match_count_exceeded,
-	AppErrorEthPreemptionNotEnabled = icsneoc2_app_error_type_eth_preemption_not_enabled,
-	AppErrorTxNotSupportedInMode = icsneoc2_app_error_type_tx_not_supported_in_mode,
-	AppErrorJumboFramesNotSupported = icsneoc2_app_error_type_jumbo_frames_not_supported,
-	AppErrorEthernetIpFragment = icsneoc2_app_error_type_ethernet_ip_fragment,
-	AppErrorTxMessagesUnderrun = icsneoc2_app_error_type_tx_messages_underrun,
-	AppErrorDeviceFanFailure = icsneoc2_app_error_type_device_fan_failure,
-	AppErrorDeviceOvertemperature = icsneoc2_app_error_type_device_overtemperature,
-	AppErrorTxMessageIndexOutOfRange = icsneoc2_app_error_type_tx_message_index_out_of_range,
-	AppErrorUndersizedFrameDropped = icsneoc2_app_error_type_undersized_frame_dropped,
-	AppErrorOversizedFrameDropped = icsneoc2_app_error_type_oversized_frame_dropped,
-	AppErrorWatchdogEvent = icsneoc2_app_error_type_watchdog_event,
-	AppErrorSystemClockFailure = icsneoc2_app_error_type_system_clock_failure,
-	AppErrorSystemClockRecovered = icsneoc2_app_error_type_system_clock_recovered,
-	AppErrorSystemPeripheralReset = icsneoc2_app_error_type_system_peripheral_reset,
-	AppErrorSystemCommunicationFailure = icsneoc2_app_error_type_system_communication_failure,
-	AppErrorTxMessagesUnsupportedSourceOrPacketId = icsneoc2_app_error_type_tx_messages_unsupported_source_or_packet_id,
-	AppErrorWbmsManagerConnectFailed = icsneoc2_app_error_type_wbms_manager_connect_failed,
-	AppErrorWbmsManagerConnectBadState = icsneoc2_app_error_type_wbms_manager_connect_bad_state,
-	AppErrorWbmsManagerConnectTimeout = icsneoc2_app_error_type_wbms_manager_connect_timeout,
-	AppErrorFailedToInitializeLoggerDisk = icsneoc2_app_error_type_failed_to_initialize_logger_disk,
-	AppErrorInvalidSetting = icsneoc2_app_error_type_invalid_setting,
-	AppErrorSystemFailureRequestedReset = icsneoc2_app_error_type_system_failure_requested_reset,
-	AppErrorPortKeyMistmatch = icsneoc2_app_error_type_port_key_mistmatch,
-	AppErrorBusFailure = icsneoc2_app_error_type_bus_failure,
-	AppErrorTapOverflow = icsneoc2_app_error_type_tap_overflow,
-	AppErrorEthTxNoLink = icsneoc2_app_error_type_eth_tx_no_link,
-	AppErrorErrorBufferOverflow = icsneoc2_app_error_type_error_buffer_overflow,
-	AppNoError = icsneoc2_app_error_type_no_error
+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 {

include/icsneo/communication/message/ethernetstatusmessage.h

@@ -4,41 +4,37 @@
 #ifdef __cplusplus
 
 #include "icsneo/communication/message/message.h"
-#include "icsneo/icsneoc2types.h"
 
 #include <memory>
 
 namespace icsneo {
 
-class EthernetStatusMessage : public RawMessage {
+class EthernetStatusMessage : public Message {
 public:
-	enum class LinkSpeed: icsneoc2_link_speed_t {
-		LinkSpeedAuto = icsneoc2_link_speed_auto,
-		LinkSpeed10 = icsneoc2_link_speed_10mbps,
-		LinkSpeed100 = icsneoc2_link_speed_100mbps,
-		LinkSpeed1000 = icsneoc2_link_speed_1000mbps,
-		LinkSpeed2500 = icsneoc2_link_speed_2500mbps,
-		LinkSpeed5000 = icsneoc2_link_speed_5000mbps,
-		LinkSpeed10000 = icsneoc2_link_speed_10000mbps,
+	enum class LinkSpeed {
+		LinkSpeedAuto,
+		LinkSpeed10,
+		LinkSpeed100,
+		LinkSpeed1000,
+		LinkSpeed2500,
+		LinkSpeed5000,
+		LinkSpeed10000,
 	};
-	enum class LinkMode: icsneoc2_link_mode_t {
-		LinkModeAuto = icsneoc2_link_mode_auto,
-		LinkModeMaster = icsneoc2_link_mode_master,
-		LinkModeSlave = icsneoc2_link_mode_slave,
-		LinkModeInvalid = icsneoc2_link_mode_invalid,
-		LinkModeNone = icsneoc2_link_mode_none,
+	enum class LinkMode {
+		LinkModeAuto,
+		LinkModeMaster,
+		LinkModeSlave,
+		LinkModeInvalid,
+		LinkModeNone,
 	};
-
-	EthernetStatusMessage(Network net, bool state, LinkSpeed speed, bool duplex, LinkMode mode) : RawMessage(Type::EthernetStatus, net),
-		state(state), speed(speed), duplex(duplex), mode(mode) {}
-	// Link State: False = Link Down, True = Link Up
+	EthernetStatusMessage(Network net, bool state, LinkSpeed speed, bool duplex, LinkMode mode) : Message(Type::EthernetStatus),
+		network(net), state(state), speed(speed), duplex(duplex), mode(mode) {}
+	Network network;
 	bool state;
 	LinkSpeed speed;
-	// Duplex: False = Half, True = Full
 	bool duplex;
 	LinkMode mode;
-	
-	static std::shared_ptr<RawMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+	static std::shared_ptr<Message> DecodeToMessage(const std::vector<uint8_t>& bytestream);
 };
 
 }; // namespace icsneo

include/icsneo/communication/message/ethphymessage.h

@@ -6,6 +6,7 @@
 #include "icsneo/communication/packet/ethphyregpacket.h"
 #include "icsneo/communication/message/message.h"
 #include "icsneo/communication/packet.h"
+#include "icsneo/api/eventmanager.h"
 #include <vector>
 #include <memory>
 

include/icsneo/communication/message/genericapidatamessage.h

@@ -1,44 +0,0 @@
-#ifndef __GENERICAPIDATAMESSAGE_H_
-#define __GENERICAPIDATAMESSAGE_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/communication/message/message.h"
-
-#include <vector>
-#include <memory>
-
-namespace icsneo {
-
-class GenericAPIDataMessage : public Message {
-public:
-	static constexpr size_t GENERIC_API_BUFFER_SIZE = 513;
-
-#pragma pack(push, 1)
-	struct GenericAPIDataHeader {
-		uint16_t bufferLength;
-		uint8_t apiIndex;
-		uint8_t instance;
-		uint8_t functionId;
-	};
-
-	struct GenericAPIDataPacket
-	{
-		GenericAPIDataHeader header;
-		uint8_t buffer[GENERIC_API_BUFFER_SIZE];
-	};
-#pragma pack(pop)
-
-	static std::shared_ptr<GenericAPIDataMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
-
-	GenericAPIDataMessage() : Message(Type::GenericAPIData) {}
-
-	uint8_t functionId;
-	std::vector<uint8_t> buffer;
-};
-
-} // namespace icsneo
-
-#endif // __cplusplus
-
-#endif // __GENERICAPIDATAMESSAGE_H_

include/icsneo/communication/message/genericapistatusmessage.h

@@ -1,40 +0,0 @@
-#ifndef __GENERICAPISTATUSMESSAGE_H_
-#define __GENERICAPISTATUSMESSAGE_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/communication/message/message.h"
-
-#include <memory>
-
-namespace icsneo {
-
-class GenericAPIStatusMessage : public Message {
-public:
-#pragma pack(push, 2)
-	struct GenericAPIStatusResponsePacket
-	{
-		uint8_t apiIndex;
-		uint8_t instance;
-		uint8_t functionId;
-		uint8_t functionError;
-		uint8_t callbackError;
-		uint8_t finishedProcessing;
-	};
-#pragma pack(pop)
-
-	static std::shared_ptr<GenericAPIStatusMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
-
-	GenericAPIStatusMessage() : Message(Type::GenericAPIStatus) {}
-
-	uint8_t functionId;
-	bool finishedProcessing;
-	uint8_t functionError;
-	uint8_t callbackError;
-};
-
-} // namespace icsneo
-
-#endif // __cplusplus
-
-#endif // __GENERICAPISTATUSMESSAGE_H_

include/icsneo/communication/message/iso15765message.h

@@ -1,443 +0,0 @@
-#ifndef __ISO_15765MESSAGE_H_
-#define __ISO_15765MESSAGE_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/communication/message/main51message.h"
-#include "icsneo/communication/command.h"
-#include "icsneo/J2534.h"
-
-#include <memory>
-#include <optional>
-#include <vector>
-
-namespace icsneo {
-
-class J2534CommandMessage : public Main51Message
-{
-public:
-	enum class J2534Command : uint8_t
-	{
-		Enable = 0,	//RED_CMD_J2534_EXTENSION_ENABLE,
-		SetupIso15765RxFilter = 1, //RED_CMD_J2534_EXTENSION_SETUP_ISO15_RX_FILTER,
-		SetupIso15765TxMessageProperties = 2, //RED_CMD_J2534_EXTENSION_SETUP_ISO15_TX_MESSAGE_PROPERTIES,
-		SetupIso15765TxMessageDataBytes = 3, //RED_CMD_J2534_EXTENSION_SETUP_ISO15_TX_MESSAGE_DATABYTES,
-		SetupCanRxFilter = 4, //RED_CMD_J2534_EXTENSION_SETUP_CAN_RX_FILTER,
-		SetupClearCanRxFilters = 5, //RED_CMD_J2534_EXTENSION_SETUP_CLEAR_CAN_RX_FILTERS,
-		EnableFiltering = 6, //RED_CMD_J2534_EXTENSION_ENABLE_FILTERING,
-	};
-
-	J2534CommandMessage(const J2534Command j2534Command, const std::vector<uint8_t>& arguments = {})
-		: Main51Message() {
-		command = Command::J2534Command;
-		argumentData.push_back((uint8_t)j2534Command);
-		argumentData.push_back(0);
-		setArgumentData(arguments);
-	}
-	virtual ~J2534CommandMessage(void) = default;
-
-    J2534Command getJ2534Command(void) const { return (J2534Command)argumentData[0]; }
-    void setJ2534Command(const J2534Command& j2534Command) { argumentData[0] = (uint8_t)j2534Command; }
-
-    const std::vector<uint8_t>& getArgumentData(void) const { return argumentData; }
-    void setArgumentData(const std::vector<uint8_t>& arguments) { argumentData.insert(argumentData.end(), arguments.begin(), arguments.end()); }
-
-	static std::shared_ptr<J2534CommandMessage> decodeToMessage(const std::vector<uint8_t>& data);
-
-protected:
-    std::vector<uint8_t> argumentData;
-
-	uint16_t read16LE(size_t o) const;
-	void write16LE(size_t o, uint16_t v);
-	uint16_t read16BE(size_t o) const;
-	void write16BE(size_t o, uint16_t v);
-	void writeBits16LE(size_t o, unsigned bitPos, unsigned bitCount, uint32_t value);
-	uint32_t read32LE(size_t o) const;
-	void write32LE(size_t o, uint32_t v);
-	uint32_t read32BE(size_t o) const;
-	void write32BE(size_t o, uint32_t v);
-};
-
-class J2534EnableMessage : public J2534CommandMessage {
-public:
-	J2534EnableMessage(const bool enable)
-		: J2534CommandMessage(J2534Command::Enable, { (uint8_t)enable }) {
-	}
-	bool getEnable(void) const { return (bool)argumentData[2]; }
-    void setEnable(bool enable) { argumentData[2] = (uint8_t)enable; }
-};
-
-class J2534EnableFilteringMessage : public J2534CommandMessage {
-public:
-	J2534EnableFilteringMessage(const bool enable)
-		: J2534CommandMessage(J2534Command::EnableFiltering, { (uint8_t)enable }) {
-	}
-	bool getEnable(void) const { return (bool)argumentData[2]; }
-	void setEnable(bool enable) { argumentData[2] = (uint8_t)enable; }
-};
-
-class J2534SetupCanRxFilteringMessage : public J2534CommandMessage {
-public:
-	J2534SetupCanRxFilteringMessage(const J2534_RxCanFilter& filter)
-		: J2534CommandMessage(J2534Command::SetupCanRxFilter) {
-        setRxCanFilter(filter);
-	}
-
-	J2534_RxCanFilter getRxCanFilter(void) const;
-
-	void setRxCanFilter(const J2534_RxCanFilter& filter);
-};
-
-class J2534SetupIso15765FlowControlMessage : public J2534CommandMessage
-{
-public:
-	J2534SetupIso15765FlowControlMessage();
-
-	uint16_t getIdx(void) const;
-	void setIdx(uint16_t idx);
-	uint16_t getCoreMiniId(void) const;
-	void setCoreMiniId(uint16_t coreMiniId);
-	uint8_t getPadding(void) const;
-	void setPadding(uint8_t padding);
-	uint32_t getId(void) const;
-	void setId(uint32_t id);
-	uint32_t getIdMask(void) const;
-	void setIdMask(uint32_t idMask);
-	uint32_t getFcId(void) const;
-	void setFcId(uint32_t fcId);
-	uint8_t getFlowControlExtendedAddress(void) const;
-	void setFlowControlExtendedAddress(uint8_t addr);
-	uint8_t getExtendedAddress(void) const;
-	void setExtendedAddress(uint8_t addr);
-	uint8_t getBlockSize(void) const;
-	void setBlockSize(uint8_t blockSize);
-	uint8_t getStMin(void) const;
-	void setStMin(uint8_t stMin);
-	uint16_t getCfTimeout(void) const;
-	void setCfTimeout(uint16_t cfTimeout);
-	uint32_t getFlags(void) const;
-	void setFlags(uint32_t flags);
-
-	bool getEnable(void) const;
-	void setEnable(bool enable);
-	bool getIs29BitEnabled(void) const;
-	void setIs29BitEnabled(bool enable);
-	bool getIsFc29BitEnabled(void) const;
-	void setIsFc29BitEnabled(bool enable);
-	bool getExtAddressEnabled(void) const;
-	void setExtAddressEnabled(bool enable);
-	bool getFcExtAddressEnabled(void) const;
-	void setFcExtAddressEnabled(bool enable);
-	bool getFlowControlTransmissionEnabled(void) const;
-	void setFlowControlTransmissionEnabled(bool enable);
-	bool getPaddingEnabled(void) const;
-	void setPaddingEnabled(bool enable);
-	bool getIsCanFd(void) const;
-	void setIsCanFd(bool enable);
-	bool getIsBrsEnabled(void) const;
-	void setIsBrsEnabled(bool enable);
-
-private:
-	// The legacy wire format was the raw memory of the (now-removed) J2534_RxFlowControlRequest
-	// struct copied into mArgumentData starting at offset 1 (overwriting the header pad byte).
-	// The struct was compiled with `#pragma pack(2)` on MSVC little-endian. All multi-byte
-	// scalars are therefore stored little-endian; the "flt" region reproduces the exact
-	// byte pattern produced by the old MessageBitsCAN bitfield writes.
-	//
-	// Byte layout (mArgumentData indices):
-	//   [0]      J2534 command header byte (set by base class)
-	//   [1]	  padding
-	//   [2..3]   idx (u16 LE)
-	//   [4..5]   iCoreMiniID (u16 LE)
-	//   [6]      padding (u8)
-	//   [7]      structure pad byte (unused)
-	//   [8..11]  id (u32 LE)
-	//   [12..15] id_mask (u32 LE)
-	//   [16..19] fc_id (u32 LE)
-	//   [20]     flowControlExtendedAddress (u8)
-	//   [21]     extendedAddress (u8)
-	//   [22]     blockSize (u8)
-	//   [23]     stMin (u8)
-	//   [24..25] cf_timeout (u16 LE)
-	//   [26..53] MessageFilterBytes flt (28 bytes) -- see RebuildFilterBytes for details
-	//   [54..57] flags (u32 LE) -- see kFcFlag* below
-	//
-	// Total wire size: 58 bytes.
-	static const size_t MessageSize = 58;
-	static const size_t IdxOffset = 2;
-	static const size_t CoreMiniOffset = 4;
-	static const size_t PaddingOffset = 6;
-	static const size_t IdOffset = 8;
-	static const size_t IdMaskOffset = 12;
-	static const size_t FcIdOffset = 16;
-	static const size_t FcExtAddrOffset = 20;
-	static const size_t ExtAddrOffset = 21;
-	static const size_t BlockSizeOffset = 22;
-	static const size_t StMinOffset = 23;
-	static const size_t CfTimeoutOffset = 24;
-	static const size_t FltOffset = 26; // 28 bytes
-	static const size_t FltSize = 28;
-	static const size_t FlagsOffset = 54;
-
-	// Bit positions inside the u32 LE flags word (matches the legacy bitfield layout).
-	static const uint32_t FlagEnable = 1u << 0;
-	static const uint32_t FlagId29BitEnable = 1u << 1;
-	static const uint32_t FlagFcId29BitEnable = 1u << 2;
-	static const uint32_t FlagExtAddressEnable = 1u << 3;
-	static const uint32_t FlagFcExtAddressEnable = 1u << 4;
-	static const uint32_t FlagEnableFlowControlTransmit = 1u << 5;
-	static const uint32_t FlagPaddingEnable = 1u << 6;
-	static const uint32_t FlagIsCanFd = 1u << 7;
-	static const uint32_t FlagIsBrsEnabled = 1u << 8;
-
-	// Rebuilds the filter bytes region of mArgumentData based on the current id / id_mask /
-	// id_29_bit_enable / ext_address_enable / extendedAddress state. Preserves the legacy
-	// (pre-existing) wire format bit-for-bit.
-	void rebuildFilterBytes(void);
-
-	void setFlagBit(uint32_t mask, bool enable);
-
-	bool getFlagBit(uint32_t mask) const;
-};
-
-class Iso15765TxSetupMessage : public J2534CommandMessage {
-public:
-	Iso15765TxSetupMessage()
-		: J2534CommandMessage(J2534Command::SetupIso15765TxMessageProperties) {
-		argumentData.resize(36);
-	}
-
-	uint16_t getIdx(void) const;
-	void setIdx(uint16_t idx);
-	uint16_t getCoreMiniId(void) const;
-	void setCoreMiniId(uint16_t coreMiniId);
-	uint32_t getMessageLength(void) const;
-	void setMessageLength(uint32_t messageLength);
-	uint8_t getPadding(void) const;
-	void setPadding(uint8_t padding);
-	uint8_t getTxDl(void) const;
-	void setTxDl(uint8_t txDl);
-	uint32_t getId(void) const;
-	void setId(uint32_t id);
-	uint32_t getFcId(void) const;
-	void setFcId(uint32_t fcId);
-	uint32_t getFcIdMask(void) const;
-	void setFcIdMask(uint32_t fcIdMask);
-	uint8_t getFlowControlExtendedAddress(void) const;
-	void setFlowControlExtendedAddress(uint8_t addr);
-	uint8_t getExtendedAddress(void) const;
-	void setExtendedAddress(uint8_t addr);
-	uint16_t getFsTimeout(void) const;
-	void setFsTimeout(uint16_t timeout);
-	uint16_t getFsWait(void) const;
-	void setFsWait(uint16_t wait);
-	uint32_t getFlags(void) const;
-	void setFlags(uint32_t flags);
-	uint8_t getStMin(void) const;
-	void setStMin(uint8_t stMin);
-	uint8_t getBlockSize(void) const;
-	void setBlockSize(uint8_t blockSize);
-
-	bool getIs29BitEnabled(void) const;
-	void setIs29BitEnabled(bool enable);
-	bool getIsFc29BitEnabled(void) const;
-	void setIsFc29BitEnabled(bool enable);
-	bool getExtAddressEnabled(void) const;
-	void setExtAddressEnabled(bool enable);
-	bool getFcExtAddressEnabled(void) const;
-	void setFcExtAddressEnabled(bool enable);
-	bool getOverrideStMin(void) const;
-	void setOverrideStMin(bool enable);
-	bool getOverrideBlockSize(void) const;
-	void setOverrideBlockSize(bool enable);
-	bool getPaddingEnabled(void) const;
-	void setPaddingEnabled(bool enable);
-	bool getIsCanFd(void) const;
-	void setIsCanFd(bool enable);
-	bool getIsBrsEnabled(void) const;
-	void setIsBrsEnabled(bool enable);
-
-private:
-	// Matches J2534_Iso15TxRequest (#pragma pack(2), little-endian) copied after the
-	// 2-byte J2534 command header, as sent by vspy3 J2534_Transaction.
-	//   [0..1]   J2534 command header (managed by base class)
-	//   [2..3]   idx           (u16 LE)
-	//   [4..5]   iCoreMiniID   (u16 LE)
-	//   [6..9]   messageLength (u32 LE)
-	//   [10]     padding
-	//   [11]     tx_dl
-	//   [12..15] id            (u32 LE)
-	//   [16..19] fc_id         (u32 LE)
-	//   [20..23] fc_id_mask    (u32 LE)
-	//   [24]     flowControlExtendedAddress
-	//   [25]     extendedAddress
-	//   [26..27] fs_timeout    (u16 LE)
-	//   [28..29] fs_wait       (u16 LE)
-	//   [30..33] flags         (u32 LE)
-	//   [34]     stMin
-	//   [35]     blockSize
-
-	static const size_t SetupIdxOffset = 2;
-	static const size_t SetupCoreMiniOffset = 4;
-	static const size_t SetupMsgLenOffset = 6;
-	static const size_t SetupPaddingOffset = 10;
-	static const size_t SetupTxDlOffset = 11;
-	static const size_t SetupIdOffset = 12;
-	static const size_t SetupFcIdOffset = 16;
-	static const size_t SetupFcIdMaskOffset = 20;
-	static const size_t SetupFcExtAddrOffset = 24;
-	static const size_t SetupExtAddrOffset = 25;
-	static const size_t SetupFsTimeoutOffset = 26;
-	static const size_t SetupFsWaitOffset = 28;
-	static const size_t SetupFlagsOffset = 30;
-	static const size_t SetupStMinOffset = 34;
-	static const size_t SetupBlockSizeOffset = 35;
-
-	// Flag bit positions within the 32-bit flags word.
-	static const uint32_t FlagId29BitEnable = 1u << 0;
-	static const uint32_t FlagFcId29BitEnable = 1u << 1;
-	static const uint32_t FlagExtAddressEnable = 1u << 2;
-	static const uint32_t FlagFcExtAddressEnable = 1u << 3;
-	static const uint32_t FlagOverrideStMin = 1u << 4;
-	static const uint32_t FlagOverrideBlockSize = 1u << 5;
-	static const uint32_t FlagPaddingEnable = 1u << 6;
-	static const uint32_t FlagIsCanFd = 1u << 7;
-	static const uint32_t FlagIsBrsEnabled = 1u << 8;
-
-	bool getFlagBit(uint32_t mask) const;
-	void setFlagBit(uint32_t mask, bool enable);
-};
-
-class Iso15765TxDataMessage : public J2534CommandMessage {
-public:
-	static constexpr uint16_t MaxDataLength = 500;
-
-	Iso15765TxDataMessage()
-		: J2534CommandMessage(J2534Command::SetupIso15765TxMessageDataBytes) {
-		argumentData.resize(10);
-	}
-
-	uint16_t getIdx(void) const;
-	void setIdx(uint16_t idx);
-	uint32_t getOffset(void) const;
-	void setOffset(uint32_t offset);
-	uint16_t getLen(void) const;
-	const uint8_t* getData(void) const;
-	void setData(const uint8_t* sourceData, uint16_t len);
-
-private:
-	// Matches J2534_Iso15TxDataRequest (#pragma pack(2), little-endian) after the
-	// 2-byte J2534 command header.
-	//   [0..1]  J2534 command header (managed by base class)
-	//   [2..3]  idx    (u16 LE)
-	//   [4..7]  offset (u32 LE)
-	//   [8..9]  len    (u16 LE)
-	//   [10..]  data
-	static const size_t DataIdxOffset = 2;
-	static const size_t DataOffsetOffset = 4;
-	static const size_t DataLenOffset = 8;
-	static const size_t DataPayloadOffset = 10;
-};
-
-class Iso15765MessageArgs {
-public:
-	struct ArbId {
-		bool Is29Bit;
-		uint32_t Id;
-
-        ArbId(uint32_t id = 0, bool is29Bit = false)
-            : Is29Bit(is29Bit)
-            , Id(id) {
-        }
-	};
-
-	Iso15765MessageArgs(void)
-		: networkId(0)
-        , txIndex(0)
-        , arbId({ false, 0 })
-        , flowControlArbId({ false, 0 })
-        , flowControlArbIdMask(0)
-        , isCanFd(false)
-        , isBrsEnabled(false)
-        , tx_DL(8)
-        , fs_Timeout(0)
-        , fs_WaitTimeout(0)
-        , cf_Timeout(0)
-        , isFlowControlEnabled(false) {
-	}
-
-	uint16_t getNetworkId(void) const { return networkId; }
-	void setNetworkId(uint16_t netId) { networkId = netId; }
-	uint8_t getTxIndex(void) const { return txIndex; }
-	void setTxIndex(uint8_t idx) { txIndex = idx; }
-
-	const ArbId& getArbId(void) const { return arbId; }
-	void setArbId(const ArbId& id) { arbId = id; }
-	const ArbId& getFlowControlArbId(void) const { return flowControlArbId; }
-	void setFlowControlArbId(const ArbId& id) { flowControlArbId = id; }
-	uint32_t getFlowControlArbIdMask(void) const { return flowControlArbIdMask; }
-	void setFlowControlArbIdMask(uint32_t mask) { flowControlArbIdMask = mask; }
-	bool getIsCanFd(void) const { return isCanFd; }
-	void setIsCanFd(bool value) { isCanFd = value; }
-	bool getIsBrsEnabled(void) const { return isBrsEnabled; }
-	void setIsBrsEnabled(bool value) { isBrsEnabled = value; }
-
-	uint8_t getTxDl(void) const { return tx_DL; }
-	void setTxDl(uint8_t txDl) { tx_DL = txDl; }
-	std::optional<uint8_t> getStMin(void) const { return stMin; }
-	void setStMin(std::optional<uint8_t> v) { stMin = v; }
-	std::optional<uint8_t> getBlockSize(void) const { return blockSize; }
-	void setBlockSize(std::optional<uint8_t> b) { blockSize = b; }
-	std::optional<uint8_t> getFlowControlExtendedAddress(void) const { return flowControlExtendedAddress; }
-	void setFlowControlExtendedAddress(std::optional<uint8_t> fcExtAddr) { flowControlExtendedAddress = fcExtAddr; }
-	std::optional<uint8_t> getExtendedAddress(void) const { return extendedAddress; }
-	void setExtendedAddress(std::optional<uint8_t> extAddr) { extendedAddress = extAddr; }
-	std::optional<uint8_t> getPaddingValue(void) const { return paddingValue; }
-	void setPaddingValue(std::optional<uint8_t> v) { paddingValue = v; }
-
-	uint16_t getFsTimeout(void) const { return fs_Timeout; }
-	void setFsTimeout(uint16_t timeout) { fs_Timeout = timeout; }
-	uint16_t getFsWaitTimeout(void) const { return fs_WaitTimeout; }
-	void setFsWaitTimeout(uint16_t timeout) { fs_WaitTimeout = timeout; }
-	uint16_t getCfTimeout(void) const { return cf_Timeout; }
-	void setCfTimeout(uint16_t timeout) { cf_Timeout = timeout; }
-
-	const std::vector<uint8_t>& getData(void) const { return data; }
-	void setData(std::vector<uint8_t>&& d) { data = std::move(d); }
-
-	bool getIsFlowControlEnabled(void) const { return isFlowControlEnabled; }
-	void setIsFlowControlEnabled(bool enabled) { isFlowControlEnabled = enabled; }
-
-protected:
-
-	uint16_t networkId;	// The netid of the message (determines which network to transmit on)
-	uint8_t txIndex;		// identifier for this transmit message
-
-	ArbId arbId;					// arbId of transmitted frames (CAN id to transmit to)
-	ArbId flowControlArbId;		// flow control arb id filter value (response id from receiver)
-	uint32_t flowControlArbIdMask; // The flow control arb id filter mask (response id from receiver)
-	bool isCanFd;
-	bool isBrsEnabled;
-
-	uint8_t tx_DL;										// Maximum CAN(FD) protocol length for transmitted frames (Valid values are 8, 12, 16, 20, 24, 32, 48, 64)
-	std::optional<uint8_t> stMin;						// Overrides the stMin that the receiver reports (Set to J2534's STMIN_TX if <= 0xFF)
-	std::optional<uint8_t> blockSize;					// Overrides the block size that the receiver reports (Set to J2534's BS_TX if <= 0xFF)
-	std::optional<uint8_t> flowControlExtendedAddress; // Expected Extended Address byte of response from receiver
-	std::optional<uint8_t> extendedAddress;			// Extended Address byte of transmitter
-	std::optional<uint8_t> paddingValue;				// The padding byte to use to fill the unused portion of transmitted CAN frames (single frame, first frame, consecutive frame)
-
-	uint16_t fs_Timeout;		// max timeout (ms) for waiting on flow control response (Set this to N_BS_MAX's value if J2534)
-	uint16_t fs_WaitTimeout;	// max timeout (ms) for waiting on flow control response after receiving flow control with flow status set to WAIT (Set this to N_BS_MAX's value if J2534)
-	uint16_t cf_Timeout;		// max timeout (ms) for waiting on consecutive frame (Set this to N_CR_MAX's value in J2534)
-
-	std::vector<uint8_t> data;
-
-	bool isFlowControlEnabled;	// Enables Flow Control frame transmission (Rx message; from neoVI to ECU)
-};
-
-
-}
-
-#endif // __cplusplus
-
-#endif

include/icsneo/communication/message/linmessage.h

@@ -34,7 +34,6 @@ struct LINStatusFlags {
 	bool HasUpdatedResponderOnce = false;
 	bool BusRecovered = false;
 	bool BreakOnly = false;
-	bool WakeupRequest = false;
 };
 
 class LINMessage : public Frame {
@@ -46,8 +45,7 @@ public:
 		LIN_BREAK_ONLY = icsneoc2_lin_msg_type_break_only,
 		LIN_SYNC_ONLY = icsneoc2_lin_msg_type_sync_only,
 		LIN_UPDATE_RESPONDER = icsneoc2_lin_msg_type_update_responder,
-		LIN_ERROR = icsneoc2_lin_msg_type_error,
-		LIN_WAKEUP_REQUEST = icsneoc2_lin_msg_type_wakeup_request
+		LIN_ERROR = icsneoc2_lin_msg_type_error
 	};
 
 	static void calcChecksum(LINMessage& message);

include/icsneo/communication/message/message.h

@@ -48,10 +48,6 @@ public:
 		NetworkMutex = 0x8016,
 		ClientId = 0x8017,
 		AllMACAddresses = 0x8018,
-		SPIPortKeyOperation = 0x8019,
-		GenericAPIData = 0x8020,
-		GenericAPIStatus = 0x8021,
-		MfgConfig = 0x8022,
 	};
 
 	Message(Type t) : type(t) {}

include/icsneo/communication/message/mfgconfigmessage.h

@@ -1,56 +0,0 @@
-#ifndef __MFGCONFIGMESSAGE_H_
-#define __MFGCONFIGMESSAGE_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/communication/message/message.h"
-#include "icsneo/communication/message/allmacaddressesmessage.h"
-#include "icsneo/device/chipid.h"
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace icsneo {
-
-class MfgConfigMessage : public Message {
-public:
-	struct MfgDate {
-		uint32_t day = 0;
-		uint32_t month = 0;
-		uint32_t year = 0;
-	};
-
-	struct VersionNumber {
-		uint32_t major = 0;
-		uint32_t minor = 0;
-		std::optional<uint32_t> release;
-		std::optional<uint32_t> build;
-	};
-
-	MfgConfigMessage() : Message(Message::Type::MfgConfig) {}
-
-	static std::shared_ptr<MfgConfigMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
-	static std::vector<uint8_t> EncodeArgumentsForGet();
-
-	std::optional<uint64_t> serialNumber;
-	std::optional<MfgDate> manufactureDate;
-	std::optional<VersionNumber> hardwareRev;
-	std::optional<uint8_t> productId;
-	std::optional<VersionNumber> bootloaderRev;
-	std::optional<std::string> usbDescriptor;
-	std::vector<MACAddress> macAddresses;
-	std::optional<std::string> pcbSerial;
-	std::optional<ChipID> chipId;
-	std::optional<uint64_t> imei;
-	std::optional<uint8_t> parentProductId;
-	std::optional<VersionNumber> softwareVersionLock;
-};
-
-} // namespace icsneo
-
-#endif // __cplusplus
-
-#endif // __MFGCONFIGMESSAGE_H_

include/icsneo/communication/message/spiportkeymessage.h

@@ -1,43 +0,0 @@
-#ifndef __SPIPORTKEYMESSAGE_H_
-#define __SPIPORTKEYMESSAGE_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/communication/message/message.h"
-
-#include <array>
-#include <memory>
-
-namespace icsneo {
-
-class SPIPortKeyMessage : public Message {
-public:
-	enum class Operation : uint8_t {
-		WriteKey = 0,
-		IsKeySet = 1,
-		ClearKey = 2
-	};
-
-#pragma pack(push, 2)
-	struct SPIPortKeyPacket
-	{
-		Operation op;
-		uint8_t portIndex;
-		bool isKeyLoaded;
-		uint8_t rsvd;
-		uint8_t key[16];
-	};
-#pragma pack(pop)
-
-	static std::shared_ptr<SPIPortKeyMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
-
-	SPIPortKeyMessage() : Message(Type::SPIPortKeyOperation) {}
-
-	bool isKeyLoaded;
-};
-
-} // namespace icsneo
-
-#endif // __cplusplus
-
-#endif // __SPIPORTKEYMESSAGE_H_

include/icsneo/communication/packet/linpacket.h

@@ -47,8 +47,7 @@ struct HardwareLINPacket {
 		uint16_t ResponderByteFerr : 1; //Framing error in one of our responder bytes.
 		uint16_t TxAborted : 1;//!< This transmit was aborted.
 		uint16_t BreakOnly : 1;
-		uint16_t WakeupRequest : 1; //!< LIN wakeup pulse.
-		uint16_t : 1;
+		uint16_t : 2;
 	} CoreMiniBitsLIN;
 
 	uint8_t data[8];

include/icsneo/device/chipid.h

@@ -126,7 +126,6 @@ enum class ChipID : icsneoc2_chip_id_t {
 	RADA2B_REVB_ZCHIP = icsneoc2_chip_id_rada2b_revb_zchip,
 	RADGigastar_FFG_ZYNQ = icsneoc2_chip_id_radgigastar_ffg_zynq,
 	VEM_02_FR_FCHIP = icsneoc2_chip_id_vem_02_fr_fchip,
-	RADBMS_WIL = icsneoc2_chip_id_radbms_wil,
 	Connect_ZCHIP = icsneoc2_chip_id_connect_zchip,
 	SFPModule_88q2221_MCHIP = icsneoc2_chip_id_sfpmodule_88q2221_mchip,
 	RADGALAXY2_SYSMON_CHIP = icsneoc2_chip_id_radgalaxy2_sysmon_chip,

include/icsneo/device/device.h

@@ -46,9 +46,6 @@
 #include "icsneo/communication/message/extendeddatamessage.h"
 #include "icsneo/communication/message/livedatamessage.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
-#include "icsneo/communication/message/spiportkeymessage.h"
-#include "icsneo/communication/message/genericapidatamessage.h"
-#include "icsneo/communication/message/genericapistatusmessage.h"
 #include "icsneo/core/macseccfg.h"
 #include "icsneo/communication/packet/genericbinarystatuspacket.h"
 #include "icsneo/communication/packet/livedatapacket.h"
@@ -63,9 +60,6 @@
 #include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
 #include "icsneo/communication/message/allmacaddressesmessage.h"
-#include "icsneo/communication/message/mfgconfigmessage.h"
-#include "icsneo/communication/message/iso15765message.h"
-#include "icsneo/J2534.h"
 
 #define ICSNEO_FINDABLE_DEVICE_BASE(className, type) \
 	static constexpr DeviceType::Enum DEVICE_TYPE = type; \
@@ -93,7 +87,7 @@ class DeviceExtension;
 
 typedef uint64_t MemoryAddress;
 
-class Device : public std::enable_shared_from_this<Device> {
+class Device {
 public:
 	virtual ~Device();
 
@@ -139,7 +133,6 @@ public:
 		RADA2B = 40,
 		SFPModule_88q2112 = 41,
 		RADGalaxy2 = 47,
-		RADwBMS = 48,
 		RADMoon3 = 49,
 		RADComet2 = 50,
 		Connect = 51,
@@ -238,18 +231,9 @@ public:
 	enum class OpenStatusType {
 		QuestionContinueSkipCancel,
 		QuestionContinueCancel,
-		Progress,
-		Failed
+		Progress
 	};
 
-	/**
-	 * @brief Alias of callback function for progress of a bootloader pipeline task
-	 * 
-	 * The progress value passed into the callback function indicates the following:
-	 * 1) If the value is std::nullopt, this implies the status message is for an asynchronous task or a task in which the current progress is unknown.
-	 * 2) If the value is between 0 and 1 (i.e., 0 <= progress <= 1), this implies the actual progress of the current task as a percentage.
-	 * 3) Values not between 0 and 1 (i.e., progress < 0 or progress > 1) are undefined.
-	 */
 	using OpenStatusHandler = std::function<Device::OpenDirective(OpenStatusType type, const std::string& status, std::optional<double> progress)>;
 
 	bool open(OpenFlags flags = {}, OpenStatusHandler handler =
@@ -348,7 +332,6 @@ public:
 	virtual Network getNetworkByNumber(Network::Type, size_t) const;
 
 	std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
-	std::shared_ptr<MfgConfigMessage> getMfgConfig();
 
 
 	/**
@@ -733,8 +716,6 @@ public:
 
 	std::optional<EthPhyMessage> sendEthPhyMsg(const EthPhyMessage& message, std::chrono::milliseconds timeout = std::chrono::milliseconds(50));
 
-	
-	bool sendSPIPortKeyOperation(uint8_t portIndex, SPIPortKeyMessage::Operation op, std::array<uint8_t, 16> key = {});
 
 	/**
 	 * Set the flags of the root directory entry specified at given address
@@ -749,7 +730,6 @@ public:
 	 */
 	std::optional<bool> SetRootDirectoryEntryFlags(uint8_t mask, uint8_t values, uint32_t collectionEntryByteAddress);
 
-	device_eventhandler_t report;
 	std::shared_ptr<Communication> com;
 	std::shared_ptr<IDeviceSettings> settings;
 
@@ -882,17 +862,10 @@ public:
 
 	virtual bool supportsGPTP() const { return false; }
 
-	virtual bool supportsReboot() const { return false; }
-
 	bool requestTC10Wake(Network::NetID network);
 
 	bool requestTC10Sleep(Network::NetID network);
 
-	// Reboot the device. When safe is true the device boots the Linux rescue image and does not
-	// load coremini ("safe boot"); otherwise it reboots normally. The device reboots in response,
-	// so no reply is expected. Only supported on devices where supportsReboot() is true.
-	bool reboot(bool safe = false);
-
 	std::optional<TC10StatusMessage> getTC10Status(Network::NetID network);
 	std::optional<GPTPStatus> getGPTPStatus(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
 
@@ -907,19 +880,11 @@ public:
 	bool unlockAllNetworks();
 	std::shared_ptr<NetworkMutexMessage> getNetworkMutexStatus(Network::NetID network);
 
-	void startHeartbeat();
-	void stopHeartbeat();
-	void restartHeartbeat();
-
-	bool iso15765Enable(const Network& network);
-	bool iso15765DisableAll(void);
-	bool iso15765TransmitMessage(const Network& network, const Iso15765MessageArgs& msg, const std::chrono::milliseconds& timeout);
-	bool iso15765SetupRxFlowControl(const Network& network, const Iso15765MessageArgs& msg);
-
 protected:
 	bool online = false;
 	int messagePollingCallbackID = 0;
 	int internalHandlerCallbackID = 0;
+	device_eventhandler_t report;
 
 	std::mutex ioMutex;
 	std::optional<bool> ethActivationStatus;
@@ -952,7 +917,7 @@ protected:
 			std::move(decoder)
 		);
 		setupCommunication(*com);
-		settings = makeSettings<Settings>(this);
+		settings = makeSettings<Settings>(com);
 		setupSettings(*settings);
 		diskReadDriver = std::unique_ptr<DiskRead>(new DiskRead());
 		diskWriteDriver = std::unique_ptr<DiskWrite>(new DiskWrite());
@@ -965,7 +930,7 @@ protected:
 
 	virtual device_eventhandler_t makeEventHandler() {
 		return [this](APIEvent::Type type, APIEvent::Severity severity) {
-			EventManager::GetInstance().add(type, severity, weak_from_this());
+			EventManager::GetInstance().add(type, severity, this);
 		};
 	}
 
@@ -988,8 +953,8 @@ protected:
 	}
 
 	template<typename Settings>
-	std::shared_ptr<IDeviceSettings> makeSettings(Device* device) {
-		return std::make_shared<Settings>(device);
+	std::shared_ptr<IDeviceSettings> makeSettings(std::shared_ptr<Communication> comm) {
+		return std::make_shared<Settings>(comm);
 	}
 	virtual void setupSettings(IDeviceSettings&) {}
 
@@ -1054,6 +1019,10 @@ private:
 	
 	APIEvent::Type attemptToBeginCommunication();
 
+	// Use heartbeatSuppressed instead when reading
+	std::atomic<int> heartbeatSuppressedByUser{0};
+	bool heartbeatSuppressed() const { return heartbeatSuppressedByUser > 0 || (settings && settings->applyingSettings); }
+
 	void handleNeoVIMessage(std::shared_ptr<CANMessage> message);
 
 	bool firmwareUpdateSupported();
@@ -1064,6 +1033,10 @@ private:
 	moodycamel::BlockingConcurrentQueue<std::shared_ptr<Message>> pollingContainer;
 	void enforcePollingMessageLimit();
 
+	std::atomic<bool> stopHeartbeatThread{false};
+	std::mutex heartbeatMutex;
+	std::thread heartbeatThread;
+
 	std::mutex diskMutex;
 
 	// Wireless neoVI Stack
@@ -1184,26 +1157,8 @@ private:
 
 	bool enableNetworkCommunication(bool enable, uint32_t timeout = 0);
 
-	bool J2534_Transaction(const Network& network, J2534CommandMessage&& msg, const std::chrono::milliseconds& timeout);
-	bool J2534_ClearRxFilters(const Network& network);
-	bool J2534_SetupCanRxFilter(const Network& network, const J2534_RxCanFilter& rxCanFilter);
-	bool J2534_EnableFiltering(const Network& network, const bool enable);
-
-	bool J2534_EnableIso15765(const Network& network, const bool enable);
-	bool J2534_ClearRxFilter(const Network& network, unsigned int iIndex);
-	bool J2534_EnableFirmwareUsbPassFilters(const Network& network, const bool enable);
-
-	struct NetworkHash {
-		size_t operator()(const Network& x) const {
-			return (size_t)x.getNetID();
-		}
-	};
-	std::unordered_map<Network, bool, NetworkHash> iso15765FirmwareEnabled;
-
-
 	// Keeponline (keepalive for online)
 	std::unique_ptr<Periodic> keeponline;
-	std::unique_ptr<Heartbeat> heartbeat;
 
 	std::optional<uint32_t> assignedClientId;
 	std::unordered_set<icsneo::Network::NetID> lockedNetworks;

include/icsneo/device/devicetype.h

@@ -52,7 +52,6 @@ public:
 		RADEpsilon = icsneoc2_devicetype_rad_epsilon,
 		RADEpsilonXL = icsneoc2_devicetype_rad_epsilon_xl,
 		RADGalaxy2 = icsneoc2_devicetype_rad_galaxy2,
-		RADwBMS = icsneoc2_devicetype_rad_wbms,
 		RADMoon3 = icsneoc2_devicetype_rad_moon3,
 		RADComet2 = icsneoc2_devicetype_rad_comet2,
 		FIRE3_FlexRay = icsneoc2_devicetype_fire3_flexray,
@@ -217,8 +216,6 @@ public:
 				return "neoVI Connect";
 			case RADGigastar2:
 				return "RAD-Gigastar 2";
-			case RADwBMS:
-				return "RAD-wBMS";
 			case DONT_REUSE0:
 			case DONT_REUSE1:
 			case DONT_REUSE2:
@@ -271,7 +268,6 @@ private:
 #define ICSNEO_DEVICETYPE_RADEPSILON ((devicetype_t)icsneoc2_devicetype_rad_epsilon)
 #define ICSNEO_DEVICETYPE_RADEPSILONXL ((devicetype_t)icsneoc2_devicetype_rad_epsilon_xl)
 #define ICSNEO_DEVICETYPE_RADGALAXY2 ((devicetype_t)icsneoc2_devicetype_rad_galaxy2)
-#define ICSNEO_DEVICETYPE_RADWBMS ((devicetype_t)icsneoc2_devicetype_rad_wbms)
 #define ICSNEO_DEVICETYPE_RADMoon3 ((devicetype_t)icsneoc2_devicetype_rad_moon3)
 #define ICSNEO_DEVICETYPE_RADCOMET2 ((devicetype_t)icsneoc2_devicetype_rad_comet2)
 #define ICSNEO_DEVICETYPE_FIRE3FLEXRAY ((devicetype_t)icsneoc2_devicetype_fire3_flexray)

include/icsneo/device/idevicesettings.h

@@ -613,18 +613,6 @@ enum : uint8_t
 	RESISTOR_OFF
 };
 
-enum RADGPTPProfile : icsneoc2_gptp_profile_t {
-	RAD_GPTP_PROFILE_STANDARD   = icsneoc2_gptp_profile_standard,
-	RAD_GPTP_PROFILE_AUTOMOTIVE = icsneoc2_gptp_profile_automotive,
-};
-
-enum RADGPTPRole : icsneoc2_gptp_role_t {
-	RAD_GPTP_ROLE_DISABLED = icsneoc2_gptp_role_disabled,
-	RAD_GPTP_ROLE_PASSIVE  = icsneoc2_gptp_role_passive,
-	RAD_GPTP_ROLE_MASTER   = icsneoc2_gptp_role_master,
-	RAD_GPTP_ROLE_SLAVE    = icsneoc2_gptp_role_slave,
-};
-
 /* Mode in LIN_SETTINGS */
 enum LINMode
 {
@@ -753,75 +741,16 @@ typedef struct
 	uint16_t cmp_device_id;
 } CMP_GLOBAL_DATA;
 
-/* wBMS Structs */
-
-typedef union
-{
-	uint8_t byte;
-	struct
-	{
-		uint8_t onboard_external : 1;
-		uint8_t type : 1;
-		uint8_t mode: 3;
-		uint8_t reserved : 3;
-	} config;
-} sSPI_PORT_SETTING;
-
-typedef struct
-{
-	sSPI_PORT_SETTING port_a; //1
-	sSPI_PORT_SETTING port_b; //1
-} sSPI_PORT_SETTINGS;
-
-#define WBMS_GATEWAY_NETWORK_NONE			(0)
-#define WBMS_GATEWAY_NETWORK_DWCAN_01		(1)
-#define WBMS_GATEWAY_NETWORK_DWCAN_02		(2)
-#define WBMS_GATEWAY_NETWORK_UDP_MULTICAST	(3)
-
-typedef struct
-{
-	uint8_t wbms1_network;
-	uint8_t wbms1_canfd_enable;
-	uint8_t wbms2_network;
-	uint8_t wbms2_canfd_enable;
-	uint16_t reserved[6];
-} WBMSGatewaySettings;
-
-typedef struct
-{
-	uint8_t wBMSDeviceID;
-	uint8_t enabled;
-} sWIL_FAULT_SERVICING_SETTINGS;
-
-typedef struct
-{
-	uint8_t enabled;
-} sWIL_NETWORK_DATA_CAPTURE_SETTINGS;
-
-typedef struct
-{
-	uint8_t using_port_a;
-	uint8_t using_port_b;
-	uint8_t attemptConnect;
-	sWIL_FAULT_SERVICING_SETTINGS fault_servicing_config;
-	sWIL_NETWORK_DATA_CAPTURE_SETTINGS network_data_capture_config;
-	uint16_t sensor_buffer_size;
-} sWIL_CONNECTION_SETTINGS;
-
 #pragma pack(pop)
 
 #ifdef __cplusplus
-#include "icsneo/communication/network.h"
-#include "icsneo/api/event.h"
-#include "icsneo/api/eventmanager.h"
+#include "icsneo/communication/communication.h"
 #include <optional>
 #include <iostream>
 #include <atomic>
 
 namespace icsneo {
 
-class Device;
-
 enum class MiscIOAnalogVoltage : uint8_t
 {
 	V0 = icsneoc2_misc_io_analog_voltage_v0,
@@ -832,13 +761,6 @@ enum class MiscIOAnalogVoltage : uint8_t
 	V5 = icsneoc2_misc_io_analog_voltage_v5
 };
 
-// Selects which Ethernet port(s) are reserved for the Linux configuration interface.
-enum class LinuxConfigurationPort : icsneoc2_linux_configuration_port_t
-{
-	USB = icsneoc2_linux_configuration_port_usb,    // Linux configuration interface accessed over USB (default)
-	ETH01 = icsneoc2_linux_configuration_port_eth01 // ETH 01 reserved for Linux configuration
-};
-
 class IDeviceSettings {
 public:
 	using TerminationGroup = std::vector<Network>;
@@ -849,7 +771,7 @@ public:
 	static int64_t GetBaudrateValueForEnum(CANBaudrate enumValue);
 	static bool ValidateLINBaudrate(int64_t baudrate);
 
-	IDeviceSettings(Device* device, size_t size);
+	IDeviceSettings(std::shared_ptr<Communication> com, size_t size) : com(com), report(com->report), structSize(size) {}
 	virtual ~IDeviceSettings() {}
 	bool ok() const { return !disabled && settingsLoaded; }
 
@@ -1343,45 +1265,9 @@ public:
 		return false;
 	}
 
-	virtual std::optional<bool> isPerfTestEnabled() const {
-		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
-		return std::nullopt;
-	}
-
-	virtual bool setPerfTestEnable(bool enable) {
-		(void)enable;
-		return false;
-	}
-
 	virtual bool setMiscIOAnalogOutputEnabled(uint8_t pin, bool enabled);
 	virtual bool setMiscIOAnalogOutput(uint8_t pin, MiscIOAnalogVoltage voltage);
 
-	// gPTP methods
-	std::optional<RADGPTPProfile> getGPTPProfile() const;
-	bool setGPTPProfile(RADGPTPProfile profile);
-	std::optional<RADGPTPRole> getGPTPRole() const;
-	bool setGPTPRole(RADGPTPRole role);
-	std::optional<uint8_t> getGPTPEnabledPort() const;
-	bool setGPTPEnabledPort(uint8_t port);
-	std::optional<bool> isGPTPClockSyntonizationEnabled() const;
-	bool setGPTPClockSyntonizationEnabled(bool enable);
-	virtual const RAD_GPTP_SETTINGS* getGPTPSettings() const { return nullptr; }
-	virtual RAD_GPTP_SETTINGS* getMutableGPTPSettings() { return nullptr; }
-
-	/* Linux operating-system settings (Fire3 family devices) */
-
-	// Whether the device is allowed to boot its Linux operating system.
-	std::optional<bool> getLinuxBootEnabled();
-	bool setLinuxBootEnabled(bool enabled);
-
-	// Whether the external WiFi antenna is used (true) instead of the internal antenna (false).
-	std::optional<bool> getExternalWifiAntennaEnabled();
-	bool setExternalWifiAntennaEnabled(bool enabled);
-
-	// Which Ethernet port(s) are reserved for the Linux configuration interface.
-	std::optional<LinuxConfigurationPort> getLinuxConfigurationPort();
-	bool setLinuxConfigurationPort(LinuxConfigurationPort port);
-
 	const void* getRawStructurePointer() const { return settingsInDeviceRAM.data(); }
 	void* getMutableRawStructurePointer() { return settings.data(); }
 	template<typename T> const T* getStructurePointer() const { return reinterpret_cast<const T*>(getRawStructurePointer()); }
@@ -1396,8 +1282,10 @@ public:
 	bool disabled = false;
 
 	bool readonly = false;
+
+	std::atomic<bool> applyingSettings{false};
 protected:
-	Device* device;
+	std::shared_ptr<Communication> com;
 	device_eventhandler_t report;
 	size_t structSize;
 
@@ -1409,13 +1297,8 @@ protected:
 
 	// Parameter createInoperableSettings exists because it is serving as a warning that you probably don't want to do this
 	typedef void* warn_t;
-	IDeviceSettings(warn_t createInoperableSettings, Device* device);
-
-	// Devices that embed a Fire3LinuxSettings block in their settings structure override these to
-	// expose it; all other devices report not-available (nullptr / nullopt) and the Linux accessors
-	// report not-available in turn.
-	virtual const Fire3LinuxSettings* getLinuxSettings() const { return nullptr; }
-	virtual std::optional<Fire3LinuxSettings*> getMutableLinuxSettings() { return std::nullopt; }
+	IDeviceSettings(warn_t createInoperableSettings, std::shared_ptr<Communication> com)
+		: disabled(true), readonly(true), report(com->report), structSize(0) { (void)createInoperableSettings; }
 
 	virtual ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const { return nullptr; }
 	virtual ICSNEO_UNALIGNED(uint64_t*) getMutableTerminationEnables() {

include/icsneo/device/nullsettings.h

@@ -12,7 +12,7 @@ namespace icsneo {
 class NullSettings : public IDeviceSettings {
 public:
 	// Calls the protected base constructor with "createInoperableSettings"
-	NullSettings(Device* device) : IDeviceSettings(nullptr, device) {}
+	NullSettings(std::shared_ptr<Communication> com) : IDeviceSettings(nullptr, com) {}
 };
 
 }

include/icsneo/device/tree/etherbadge/etherbadgesettings.h

@@ -69,7 +69,7 @@ static_assert(sizeof(etherbadge_settings_t) == 316, "EtherBadge settings size mi
 
 class EtherBADGESettings : public IDeviceSettings {
 public:
-	EtherBADGESettings(Device* device) : IDeviceSettings(device, sizeof(etherbadge_settings_t)) {}
+	EtherBADGESettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(etherbadge_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<etherbadge_settings_t>();
 		if(cfg == nullptr)
@@ -81,7 +81,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<etherbadge_settings_t>();
 		if(cfg == nullptr)
@@ -93,7 +92,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const LIN_SETTINGS* getLINSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<etherbadge_settings_t>();
 		if(cfg == nullptr)
@@ -105,23 +103,6 @@ public:
 				return nullptr;
 		}
 	}
-
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<etherbadge_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-	
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<etherbadge_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
 };
 
 }

include/icsneo/device/tree/neoviconnect/neoviconnect.h

@@ -34,8 +34,6 @@ public:
 		return supportedNetworks;
 	}
 
-	bool supportsReboot() const override { return true; }
-
 	ProductID getProductID() const override {
 		return ProductID::Connect;
 	}

include/icsneo/device/tree/neoviconnect/neoviconnectsettings.h

@@ -88,17 +88,7 @@ static_assert(sizeof(neoviconnect_settings_t) == 628, "NeoVIConnect settings siz
 
 class NeoVIConnectSettings : public IDeviceSettings {
 public:
-	NeoVIConnectSettings(Device* device) : IDeviceSettings(device, sizeof(neoviconnect_settings_t)) {}
-	const Fire3LinuxSettings* getLinuxSettings() const override {
-		auto cfg = getStructurePointer<neoviconnect_settings_t>();
-		return cfg ? &cfg->os_settings : nullptr;
-	}
-	std::optional<Fire3LinuxSettings*> getMutableLinuxSettings() override {
-		auto cfg = getMutableStructurePointer<neoviconnect_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		return &cfg->os_settings;
-	}
+	NeoVIConnectSettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(neoviconnect_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neoviconnect_settings_t>();
 		if(cfg == nullptr)
@@ -124,7 +114,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neoviconnect_settings_t>();
 		if(cfg == nullptr)
@@ -150,7 +139,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const LIN_SETTINGS* getLINSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neoviconnect_settings_t>();
 		if(cfg == nullptr)
@@ -164,32 +152,6 @@ public:
                 return nullptr;
         }
 	}
-
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<neoviconnect_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-	
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<neoviconnect_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
-
-	const RAD_GPTP_SETTINGS* getGPTPSettings() const override {
-		auto cfg = getStructurePointer<neoviconnect_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
-	RAD_GPTP_SETTINGS* getMutableGPTPSettings() override {
-		auto cfg = getMutableStructurePointer<neoviconnect_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
 };
 
 }

include/icsneo/device/tree/neovifire/neovifiresettings.h

@@ -101,7 +101,7 @@ static_assert(sizeof(neovifire_settings_t) == 744, "NeoVIFire settings size mism
 
 class NeoVIFIRESettings : public IDeviceSettings {
 public:
-	NeoVIFIRESettings(Device* device) : IDeviceSettings(device, sizeof(neovifire_settings_t)) {}
+	NeoVIFIRESettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(neovifire_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire_settings_t>();
 		if(cfg == nullptr)
@@ -121,7 +121,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const CAN_SETTINGS* getLSFTCANSettingsFor(Network net) const override { return getCANSettingsFor(net); }
 	const SWCAN_SETTINGS* getSWCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire_settings_t>();
@@ -134,7 +133,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const LIN_SETTINGS* getLINSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire_settings_t>();
 		if(cfg == nullptr)
@@ -152,23 +150,6 @@ public:
 				return nullptr;
 		}
 	}
-
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<neovifire_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-	
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<neovifire_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
 };
 
 }

include/icsneo/device/tree/neovifire2/neovifire2settings.h

@@ -125,7 +125,7 @@ static_assert(sizeof(neovifire2_settings_t) == 936, "NeoVIFire2 settings size mi
 
 class NeoVIFIRE2Settings : public IDeviceSettings {
 public:
-	NeoVIFIRE2Settings(Device* device) : IDeviceSettings(device, sizeof(neovifire2_settings_t)) {}
+	NeoVIFIRE2Settings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(neovifire2_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire2_settings_t>();
 		if(cfg == nullptr)
@@ -155,7 +155,6 @@ public:
 				return nullptr;
 		}
 	}
-
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire2_settings_t>();
 		if(cfg == nullptr)
@@ -181,7 +180,6 @@ public:
 				return nullptr;
 		}
 	}
-	
 	const CAN_SETTINGS* getLSFTCANSettingsFor(Network net) const override { return getCANSettingsFor(net); }
 	const SWCAN_SETTINGS* getSWCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire2_settings_t>();
@@ -236,23 +234,6 @@ public:
 		}
 	}
 
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<neovifire2_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<neovifire2_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
-
 protected:
 	ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const override {
 		auto cfg = getStructurePointer<neovifire2_settings_t>();

include/icsneo/device/tree/neovifire3/neovifire3.h

@@ -46,15 +46,11 @@ public:
 			Network::NetID::LIN_06,
 			Network::NetID::LIN_07,
 			Network::NetID::LIN_08,
-
-			Network::NetID::MDIO_01,
 		};
 		return supportedNetworks;
 	}
 	size_t getEthernetActivationLineCount() const override { return 2; }
 
-	bool supportsReboot() const override { return true; }
-
 	ProductID getProductID() const override {
 		return ProductID::neoVIFIRE3;
 	}
@@ -71,7 +67,6 @@ public:
 
 	BootloaderPipeline getBootloader() override {
 		return BootloaderPipeline()
-			.add<EnterBootloaderPhase>()
 			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)

include/icsneo/device/tree/neovifire3/neovifire3settings.h

@@ -166,17 +166,7 @@ static_assert(sizeof(neovifire3_settings_t) == 1722, "NeoVIFire3 settings size m
 
 class NeoVIFIRE3Settings : public IDeviceSettings {
 public:
-	NeoVIFIRE3Settings(Device* device) : IDeviceSettings(device, sizeof(neovifire3_settings_t)) {}
-	const Fire3LinuxSettings* getLinuxSettings() const override {
-		auto cfg = getStructurePointer<neovifire3_settings_t>();
-		return cfg ? &cfg->os_settings : nullptr;
-	}
-	std::optional<Fire3LinuxSettings*> getMutableLinuxSettings() override {
-		auto cfg = getMutableStructurePointer<neovifire3_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		return &cfg->os_settings;
-	}
+	NeoVIFIRE3Settings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(neovifire3_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3_settings_t>();
 		if(cfg == nullptr)
@@ -218,7 +208,6 @@ public:
 				return nullptr;
 		}
 	}
-	
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3_settings_t>();
 		if(cfg == nullptr)
@@ -262,29 +251,18 @@ public:
 	}
 
 	virtual std::vector<TerminationGroup> getTerminationGroups() const override {
-		// FIRE3 has two physical termination banks: DW CAN 01-08 and DW CAN 09-16.
-		// Termination within a bank is actually independent (any number may be
-		// enabled at once).
 		return {
 			{
 				Network(Network::NetID::DWCAN_01),
-				Network(Network::NetID::DWCAN_02),
 				Network(Network::NetID::DWCAN_03),
-				Network(Network::NetID::DWCAN_04),
 				Network(Network::NetID::DWCAN_05),
-				Network(Network::NetID::DWCAN_06),
-				Network(Network::NetID::DWCAN_07),
-				Network(Network::NetID::DWCAN_08)
+				Network(Network::NetID::DWCAN_07)
 			},
 			{
-				Network(Network::NetID::DWCAN_09),
-				Network(Network::NetID::DWCAN_10),
-				Network(Network::NetID::DWCAN_11),
-				Network(Network::NetID::DWCAN_12),
-				Network(Network::NetID::DWCAN_13),
-				Network(Network::NetID::DWCAN_14),
-				Network(Network::NetID::DWCAN_15),
-				Network(Network::NetID::DWCAN_16)
+				Network(Network::NetID::DWCAN_08),
+				Network(Network::NetID::DWCAN_02),
+				Network(Network::NetID::DWCAN_04),
+				Network(Network::NetID::DWCAN_06)
 			}
 		};
 	}
@@ -419,23 +397,6 @@ public:
 		}
 	}
 
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<neovifire3_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<neovifire3_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
-
 protected:
 	ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const override {
 		auto cfg = getStructurePointer<neovifire3_settings_t>();
@@ -443,15 +404,6 @@ protected:
 			return nullptr;
 		return &cfg->termination_enables;
 	}
-
-	const RAD_GPTP_SETTINGS* getGPTPSettings() const override {
-		auto cfg = getStructurePointer<neovifire3_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
-	RAD_GPTP_SETTINGS* getMutableGPTPSettings() override {
-		auto cfg = getMutableStructurePointer<neovifire3_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
 };
 
 }

include/icsneo/device/tree/neovifire3flexray/neovifire3flexray.h

@@ -49,14 +49,10 @@ public:
 			Network::NetID::FLEXRAY_02,
 			Network::NetID::FLEXRAY_02A,
 			Network::NetID::FLEXRAY_02B,
-
-			Network::NetID::MDIO_01,
 		};
 		return supportedNetworks;
 	}
 
-	bool supportsReboot() const override { return true; }
-
 	ProductID getProductID() const override {
 		return ProductID::neoVIFIRE3;
 	}
@@ -74,7 +70,6 @@ public:
 
 	BootloaderPipeline getBootloader() override {
 		return BootloaderPipeline()
-			.add<EnterBootloaderPhase>()
 			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)

include/icsneo/device/tree/neovifire3flexray/neovifire3flexraysettings.h

@@ -149,17 +149,7 @@ static_assert(sizeof(neovifire3flexray_settings_t) == 1372, "NeoVIFire3Flexray s
 
 class NeoVIFIRE3FlexRaySettings : public IDeviceSettings {
 public:
-	NeoVIFIRE3FlexRaySettings(Device* device) : IDeviceSettings(device, sizeof(neovifire3flexray_settings_t)) {}
-	const Fire3LinuxSettings* getLinuxSettings() const override {
-		auto cfg = getStructurePointer<neovifire3flexray_settings_t>();
-		return cfg ? &cfg->os_settings : nullptr;
-	}
-	std::optional<Fire3LinuxSettings*> getMutableLinuxSettings() override {
-		auto cfg = getMutableStructurePointer<neovifire3flexray_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		return &cfg->os_settings;
-	}
+	NeoVIFIRE3FlexRaySettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(neovifire3flexray_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3flexray_settings_t>();
 		if(cfg == nullptr)
@@ -185,7 +175,6 @@ public:
 				return nullptr;
 		}
 	}
-	
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3flexray_settings_t>();
 		if(cfg == nullptr)
@@ -213,28 +202,18 @@ public:
 	}
 
 	virtual std::vector<TerminationGroup> getTerminationGroups() const override {
-		// FIRE3 FlexRay has two physical termination banks: DW CAN 01-08 and
-		// DW CAN 09-15 (DW CAN 16 is used by FlexRay). Termination within a bank is
-		// actually independent (any number may be enabled at once).
 		return {
 			{
 				Network(Network::NetID::DWCAN_01),
-				Network(Network::NetID::DWCAN_02),
 				Network(Network::NetID::DWCAN_03),
-				Network(Network::NetID::DWCAN_04),
 				Network(Network::NetID::DWCAN_05),
-				Network(Network::NetID::DWCAN_06),
-				Network(Network::NetID::DWCAN_07),
-				Network(Network::NetID::DWCAN_08)
+				Network(Network::NetID::DWCAN_07)
 			},
 			{
-				Network(Network::NetID::DWCAN_09),
-				Network(Network::NetID::DWCAN_10),
-				Network(Network::NetID::DWCAN_11),
-				Network(Network::NetID::DWCAN_12),
-				Network(Network::NetID::DWCAN_13),
-				Network(Network::NetID::DWCAN_14),
-				Network(Network::NetID::DWCAN_15)
+				Network(Network::NetID::DWCAN_08),
+				Network(Network::NetID::DWCAN_02),
+				Network(Network::NetID::DWCAN_04),
+				Network(Network::NetID::DWCAN_06)
 			}
 		};
 	}
@@ -257,23 +236,6 @@ public:
 		}
 	}
 
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<neovifire3flexray_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<neovifire3flexray_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
-
 protected:
 	ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const override {
 		auto cfg = getStructurePointer<neovifire3flexray_settings_t>();
@@ -281,15 +243,6 @@ protected:
 			return nullptr;
 		return &cfg->termination_enables;
 	}
-
-	const RAD_GPTP_SETTINGS* getGPTPSettings() const override {
-		auto cfg = getStructurePointer<neovifire3flexray_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
-	RAD_GPTP_SETTINGS* getMutableGPTPSettings() override {
-		auto cfg = getMutableStructurePointer<neovifire3flexray_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
 };
 
 }

include/icsneo/device/tree/neovifire3t1slin/neovifire3t1slin.h

@@ -53,16 +53,12 @@ public:
 			Network::NetID::AE_06,
 			Network::NetID::AE_07,
 			Network::NetID::AE_08,
-
-			Network::NetID::MDIO_01,
 		};
 		return supportedNetworks;
 	}
 
 	bool supportsTC10() const override { return true; }
 
-	bool supportsReboot() const override { return true; }
-
 	ProductID getProductID() const override {
 		return ProductID::neoVIFIRE3;
 	}
@@ -79,7 +75,6 @@ public:
 
 	BootloaderPipeline getBootloader() override {
 		return BootloaderPipeline()
-			.add<EnterBootloaderPhase>()
 			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)

include/icsneo/device/tree/neovifire3t1slin/neovifire3t1slinsettings.h

@@ -158,17 +158,7 @@ static_assert(sizeof(neovifire3t1slin_settings_t) == 1594, "NeoVIFire3T1SLIN set
 
 class NeoVIFIRE3T1SLINSettings : public IDeviceSettings {
 public:
-	NeoVIFIRE3T1SLINSettings(Device* device) : IDeviceSettings(device, sizeof(neovifire3t1slin_settings_t)) {}
-	const Fire3LinuxSettings* getLinuxSettings() const override {
-		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
-		return cfg ? &cfg->os_settings : nullptr;
-	}
-	std::optional<Fire3LinuxSettings*> getMutableLinuxSettings() override {
-		auto cfg = getMutableStructurePointer<neovifire3t1slin_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		return &cfg->os_settings;
-	}
+	NeoVIFIRE3T1SLINSettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(neovifire3t1slin_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
 		if(cfg == nullptr)
@@ -194,7 +184,6 @@ public:
 				return nullptr;
 		}
 	}
-	
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
 		if(cfg == nullptr)
@@ -222,19 +211,18 @@ public:
 	}
 
 	virtual std::vector<TerminationGroup> getTerminationGroups() const override {
-		// FIRE3 T1S-LIN has a single physical termination bank: DW CAN 01-08.
-		// Termination within the bank is actually independent (any number may be
-		// enabled at once).
 		return {
 			{
 				Network(Network::NetID::DWCAN_01),
-				Network(Network::NetID::DWCAN_02),
 				Network(Network::NetID::DWCAN_03),
-				Network(Network::NetID::DWCAN_04),
 				Network(Network::NetID::DWCAN_05),
-				Network(Network::NetID::DWCAN_06),
-				Network(Network::NetID::DWCAN_07),
-				Network(Network::NetID::DWCAN_08)
+				Network(Network::NetID::DWCAN_07)
+			},
+			{
+				Network(Network::NetID::DWCAN_08),
+				Network(Network::NetID::DWCAN_02),
+				Network(Network::NetID::DWCAN_04),
+				Network(Network::NetID::DWCAN_06)
 			}
 		};
 	}
@@ -478,23 +466,6 @@ public:
 		return true;
 	}
 
-	std::optional<bool> isPerfTestEnabled() const override {
-		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
-		if(cfg == nullptr)
-			return std::nullopt;
-		
-		return std::make_optional<bool>(cfg->perf_en != 0);
-	}
-
-	bool setPerfTestEnable(bool enable) override {
-		auto cfg = getMutableStructurePointer<neovifire3t1slin_settings_t>();
-		if(cfg == nullptr)
-			return false;
-
-		cfg->perf_en = !!enable;
-		return true;
-	}
-
 private:
 	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
@@ -583,15 +554,6 @@ protected:
 			return nullptr;
 		return &cfg->termination_enables;
 	}
-
-	const RAD_GPTP_SETTINGS* getGPTPSettings() const override {
-		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
-	RAD_GPTP_SETTINGS* getMutableGPTPSettings() override {
-		auto cfg = getMutableStructurePointer<neovifire3t1slin_settings_t>();
-		return cfg ? &cfg->gPTP : nullptr;
-	}
 };
 
 }

include/icsneo/device/tree/neovired2/neovired2.h

@@ -30,17 +30,13 @@ public:
 			Network::NetID::ETHERNET_02,
 
 			Network::NetID::LIN_01,
-			Network::NetID::LIN_02,
-
-			Network::NetID::MDIO_01,
+			Network::NetID::LIN_02
 		};
 		return supportedNetworks;
 	}
 
 	bool supportsGPTP() const override { return true; }
 
-	bool supportsReboot() const override { return true; }
-
 	ProductID getProductID() const override {
 		return ProductID::neoVIFIRE3;
 	}
@@ -56,7 +52,6 @@ public:
 
 	BootloaderPipeline getBootloader() override {
 		return BootloaderPipeline()
-			.add<EnterBootloaderPhase>()
 			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
 			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)