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

@@ -303,7 +303,8 @@ build python/linux/amd64:
     CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: x86_64
-    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install
+    CIBW_ENVIRONMENT: PCAP_ROOT=/project/libpcap/install
+    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=/project/icspb
   script:
     - sh ci/build-wheel-posix.sh
   artifacts:
@@ -318,7 +319,8 @@ build python/linux/arm64:
     CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: aarch64
-    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install
+    CIBW_ENVIRONMENT: PCAP_ROOT=/project/libpcap/install
+    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=/project/icspb
   script:
     - sh ci/build-wheel-posix.sh
   artifacts:
@@ -332,7 +334,8 @@ build python/macos:
   variables:
     CIBW_BEFORE_ALL: sh ci/bootstrap-libpcap.sh
     CIBW_ARCHS: arm64
-    CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=$CI_PROJECT_DIR/libpcap/install
+    CIBW_ENVIRONMENT: PCAP_ROOT=$CI_PROJECT_DIR/libpcap/install
+    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=$CI_PROJECT_DIR/icspb
     MACOSX_DEPLOYMENT_TARGET: 10.14
   script:
     - sh ci/build-wheel-posix.sh
@@ -347,6 +350,7 @@ build python/windows:
   variables:
     CIBW_ARCHS: AMD64
     CIBW_ENVIRONMENT: CMAKE_GENERATOR=Ninja
+    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=$CI_PROJECT_DIR/icspb
   script:
     - cmd /c ci\build-wheel-windows.bat
   artifacts:

CMakeLists.txt

@@ -1,5 +1,43 @@
 cmake_minimum_required(VERSION 3.16)
-project(libicsneo VERSION 1.0.0)
+
+function(git_tag_version VERSION_RESULT)
+	set(${VERSION_RESULT} "0.0.0.0" PARENT_SCOPE)
+	find_package(Git)
+	if(NOT Git_FOUND)
+		return()
+	endif()
+	execute_process(
+		COMMAND ${GIT_EXECUTABLE} describe --tags --abbrev=0
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+		OUTPUT_VARIABLE LAST_TAG
+		RESULT_VARIABLE RESULT
+		ERROR_QUIET
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+	)
+	if(NOT RESULT EQUAL 0)
+		return()
+	endif()
+	execute_process(
+		COMMAND ${GIT_EXECUTABLE} rev-list ${LAST_TAG}..HEAD --count
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+		OUTPUT_VARIABLE COMMIT_COUNT_SINCE_TAG
+		RESULT_VARIABLE RESULT
+		ERROR_QUIET
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+	)
+	if(NOT RESULT EQUAL 0)
+		return()
+	endif()
+	set(${VERSION_RESULT} "${LAST_TAG}.${COMMIT_COUNT_SINCE_TAG}" PARENT_SCOPE)
+endfunction()
+
+git_tag_version(LIBICSNEO_VERSION)
+
+if(LIBICSNEO_VERSION STREQUAL "0.0.0.0")
+	message(WARNING "Unable to parse version from git history")
+endif()
+
+project(libicsneo VERSION ${LIBICSNEO_VERSION})
 
 cmake_policy(SET CMP0074 NEW)
 if(POLICY CMP0135)
@@ -192,6 +230,7 @@ set(SRC_FILES
 	communication/message/logdatamessage.cpp
 	communication/message/tc10statusmessage.cpp
 	communication/message/gptpstatusmessage.cpp
+	communication/message/allmacaddressesmessage.cpp
 	communication/message/ethernetstatusmessage.cpp
 	communication/message/networkmutexmessage.cpp
 	communication/message/clientidmessage.cpp

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
-- RADComet
 - ValueCAN 3
 - ValueCAN 4
 

api/icsneoc2/icsneoc2.cpp

@@ -14,6 +14,7 @@
 #include <optional>
 #include <sstream>
 #include <fstream>
+#include <cstring>
 
 using namespace icsneo;
 
@@ -84,6 +85,61 @@ icsneoc2_error_t icsneoc2_error_code_get(icsneoc2_error_t error_code, char* valu
 	return safe_str_copy(value, value_length, error_strings[error_code]) ? icsneoc2_error_success : icsneoc2_error_string_copy_failed;
 }
 
+icsneoc2_error_t icsneoc2_supported_devices_enumerate(icsneoc2_supported_device_t** supported_devices) {
+	if(!supported_devices) {
+		return icsneoc2_error_invalid_parameters;
+	}
+
+	auto device_types = DeviceFinder::GetSupportedDevices();
+	icsneoc2_supported_device_t* head = nullptr;
+	icsneoc2_supported_device_t* tail = nullptr;
+	for(auto& device_type : device_types) {
+		auto* node = new (std::nothrow) icsneoc2_supported_device_t;
+		if(!node) {
+			return icsneoc2_error_out_of_memory;
+		}
+		node->device_type = device_type;
+		node->next = nullptr;
+		if(!head) {
+			head = node;
+		} else {
+			tail->next = node;
+		}
+		tail = node;
+	}
+
+	*supported_devices = head;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_supported_devices_free(icsneoc2_supported_device_t* supported_devices) {
+	if(!supported_devices) {
+		return icsneoc2_error_invalid_parameters;
+	}
+
+	while(supported_devices) {
+		auto* next = supported_devices->next;
+		delete supported_devices;
+		supported_devices = next;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_supported_device_t* icsneoc2_supported_devices_next(const icsneoc2_supported_device_t* supported_device) {
+	if(!supported_device) {
+		return nullptr;
+	}
+	return supported_device->next;
+}
+
+icsneoc2_error_t icsneoc2_supported_device_get(const icsneoc2_supported_device_t* supported_device, icsneoc2_devicetype_t* device_type) {
+	if(!supported_device || !device_type) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	*device_type = static_cast<icsneoc2_devicetype_t>(supported_device->device_type);
+	return icsneoc2_error_success;
+}
+
 icsneoc2_error_t icsneoc2_device_type_name_get(icsneoc2_devicetype_t device_type, char* value, size_t* value_length) {
 	if(!value || !value_length) {
 		return icsneoc2_error_invalid_parameters;
@@ -251,12 +307,12 @@ icsneoc2_error_t icsneoc2_device_open_serial(const char* serial, icsneoc2_open_o
 	std::string_view target(serial);
 	for(auto* cur = devs; cur; cur = cur->next) {
 		if(cur->device && cur->device->getSerial() == target) {
-			if (res = icsneoc2_device_create(cur, device); res != icsneoc2_error_success) {
+			if(res = icsneoc2_device_create(cur, device); res != icsneoc2_error_success) {
 				icsneoc2_enumeration_free(devs);
 				return res;
 			}
 			res = open_device_with_options((*device)->device, options);
-			if (res != icsneoc2_error_success) {
+			if(res != icsneoc2_error_success) {
 				icsneoc2_device_free(*device);
 				*device = nullptr;
 			}
@@ -279,12 +335,12 @@ icsneoc2_error_t icsneoc2_device_open_first(icsneoc2_devicetype_t device_type, i
 	}
 	for(auto* cur = devs; cur; cur = cur->next) {
 		if(cur->device && !cur->device->isOpen()) {
-			if (res = icsneoc2_device_create(cur, device); res != icsneoc2_error_success) {
+			if(res = icsneoc2_device_create(cur, device); res != icsneoc2_error_success) {
 				icsneoc2_enumeration_free(devs);
 				return res;
 			}
 			res = open_device_with_options((*device)->device, options);
-			if (res != icsneoc2_error_success) {
+			if(res != icsneoc2_error_success) {
 				icsneoc2_device_free(*device);
 				*device = nullptr;
 			}
@@ -302,7 +358,7 @@ icsneoc2_error_t icsneoc2_device_reconnect(icsneoc2_device_t* device, icsneoc2_o
 		return res;
 	}
 	// If the device is currently open, close it first before trying to reconnect
-	if (device->device->isOpen()) {
+	if(device->device->isOpen()) {
 		res = icsneoc2_device_close(device);
 		if(res != icsneoc2_error_success) {
 			return res;
@@ -342,7 +398,7 @@ icsneoc2_error_t icsneoc2_device_free(icsneoc2_device_t* device) {
 	if(res != icsneoc2_error_success) {
 		return res;
 	}
-	if (device->device->isOpen()) {
+	if(device->device->isOpen()) {
 		res = icsneoc2_device_close(device);
 		if(res != icsneoc2_error_success) {
 			return res;
@@ -403,27 +459,78 @@ icsneoc2_error_t icsneoc2_device_pcb_serial_get(const icsneoc2_device_t* device,
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_device_mac_address_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length) {
+icsneoc2_error_t icsneoc2_device_mac_addresses_enumerate(const icsneoc2_device_t* device, icsneoc2_mac_addr_entry_t** mac_entries) {
 	auto res = icsneoc2_device_is_valid(device);
 	if(res != icsneoc2_error_success) {
 		return res;
 	}
-	if(!value_length) {
+	if(!mac_entries) {
 		return icsneoc2_error_invalid_parameters;
 	}
-	auto macAddress = device->device->getMACAddress();
-	if(!macAddress.has_value()) {
+	const auto result = device->device->getMACAddresses();
+	if(result.empty()) {
 		return icsneoc2_error_invalid_type;
 	}
-	const auto& data = *macAddress;
-	if(value) {
-		size_t copyLen = std::min(*value_length, data.size());
-		std::copy(data.begin(), data.begin() + copyLen, value);
+	icsneoc2_mac_addr_entry_t* head = nullptr;
+	icsneoc2_mac_addr_entry_t* tail = nullptr;
+	for(auto addr_pair : result) {
+		auto* node = new (std::nothrow) icsneoc2_mac_addr_entry_t;
+		if(!node) {
+			icsneoc2_mac_addresses_free(head);
+			return icsneoc2_error_out_of_memory;
+		}
+		node->network_id = static_cast<uint16_t>(addr_pair.first);
+		std::copy(addr_pair.second.begin(), addr_pair.second.end(), node->address);
+		node->next = nullptr;
+		if(!head) {
+			head = node;
+		} else {
+			tail->next = node;
+		}
+		tail = node;
 	}
-	*value_length = data.size();
 	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) {
+	if(!mac_address || !network_id) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	*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 || !value_length) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	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);
+	}
+	*value_length = static_cast<size_t>(ICSNEO_MAC_ADDRESS_LEN);
+	return icsneoc2_error_success;
+}
+
+icsneoc2_mac_addr_entry_t* icsneoc2_mac_addresses_next(const icsneoc2_mac_addr_entry_t* mac_address) {
+	if(!mac_address) {
+		return nullptr;
+	}
+	return mac_address->next;
+}
+
+icsneoc2_error_t icsneoc2_mac_addresses_free(icsneoc2_mac_addr_entry_t* mac_address) {
+	if(!mac_address) {
+		return icsneoc2_error_invalid_parameters;
+	}
+
+	while(mac_address) {
+		auto* next = mac_address->next;
+		delete mac_address;
+		mac_address = next;
+	}
+	return icsneoc2_error_success;
+}
 
 icsneoc2_error_t icsneoc2_device_go_online(const icsneoc2_device_t* device, bool go_online) {
 	auto res = icsneoc2_device_is_valid(device);
@@ -671,10 +778,10 @@ icsneoc2_error_t icsneoc2_device_tc10_status_get(const icsneoc2_device_t* device
 	if(!cpp_status.has_value()) {
 		return icsneoc2_error_invalid_type;
 	}
-	if (sleep_status) {
+	if(sleep_status) {
 		*sleep_status = static_cast<icsneoc2_tc10_sleep_status_t>(cpp_status->sleepStatus);
 	}
-	if (wake_status) {
+	if(wake_status) {
 		*wake_status = static_cast<icsneoc2_tc10_wake_status_t>(cpp_status->wakeStatus);
 	}
 	return icsneoc2_error_success;
@@ -1208,3 +1315,84 @@ icsneoc2_error_t icsneoc2_script_status_max_coremini_size_kb_get(const icsneoc2_
 	*value = script_status->status->maxCoreminiSizeKB;
 	return icsneoc2_error_success;
 }
+
+icsneoc2_error_t icsneoc2_device_chip_versions_enumerate(const icsneoc2_device_t* device, icsneoc2_chip_versions_t** chip_versions, bool refresh, size_t* count) {
+	auto res = icsneoc2_device_is_valid(device);
+	if(res != icsneoc2_error_success) {
+		return res;
+	}
+	if(!chip_versions) {
+		return icsneoc2_error_invalid_parameters;
+	}
+
+	auto version_reports = device->device->getChipVersions(refresh);
+	if(count) {
+		*count = version_reports.size();
+	}
+
+	icsneoc2_chip_versions_t* head = nullptr;
+	icsneoc2_chip_versions_t* tail = nullptr;
+	for(auto& version_report : version_reports) {
+		auto* node = new (std::nothrow) icsneoc2_chip_versions_t;
+		if(!node) {
+			icsneoc2_chip_versions_free(head);
+			return icsneoc2_error_out_of_memory;
+		}
+		node->version_report = version_report;
+		node->next = nullptr;
+		if(!head) {
+			head = node;
+		} else {
+			tail->next = node;
+		}
+		tail = node;
+	}
+
+	*chip_versions = head;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_chip_versions_free(icsneoc2_chip_versions_t* chip_versions) {
+	if(!chip_versions) {
+		return icsneoc2_error_invalid_parameters;
+	}
+
+	while(chip_versions) {
+		auto* next = chip_versions->next;
+		delete chip_versions;
+		chip_versions = next;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_chip_versions_t* icsneoc2_chip_versions_next(const icsneoc2_chip_versions_t* chip_versions) {
+	if(!chip_versions) {
+		return nullptr;
+	}
+	return chip_versions->next;
+}
+
+icsneoc2_error_t icsneoc2_chip_versions_props_get(const icsneoc2_chip_versions_t* chip_versions, char* name, size_t* name_length, uint8_t* major, uint8_t* minor, uint8_t* maintenance, uint8_t* build) {
+	if(!chip_versions) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto& report = chip_versions->version_report;
+	if(name && name_length) {
+		if(!safe_str_copy(name,name_length, report.name)) {
+			return icsneoc2_error_string_copy_failed;
+		}
+	}
+	if(major) {
+		*major = report.major;
+	}
+	if(minor) {
+		*minor = report.minor;
+	}
+	if(maintenance) {
+		*maintenance = report.maintenance;
+	}
+	if(build) {
+		*build = report.build;
+	}
+	return icsneoc2_error_success;
+}

api/icsneoc2/icsneoc2_internal.h

@@ -13,6 +13,11 @@
 
 using namespace icsneo;
 
+typedef struct icsneoc2_supported_device_t {
+	DeviceType device_type;
+	icsneoc2_supported_device_t* next;
+} icsneoc2_supported_device_t;
+
 typedef struct icsneoc2_message_t {
 	std::shared_ptr<Message> message;
 } icsneoc2_message_t;
@@ -38,6 +43,17 @@ typedef struct icsneoc2_script_status_t {
 	std::shared_ptr<ScriptStatusMessage> status;
 } icsneoc2_script_status_t;
 
+typedef struct icsneoc2_chip_versions_t {
+	VersionReport version_report;
+	icsneoc2_chip_versions_t* next;
+} icsneoc2_chip_versions_t;
+
+typedef struct icsneoc2_mac_addr_entry_t {
+	uint16_t network_id;
+	uint8_t address[ICSNEO_MAC_ADDRESS_LEN];
+	icsneoc2_mac_addr_entry_t* next;
+} icsneoc2_mac_addr_entry_t;
+
 /**
  * Safely copies a std::string to a char array.
  *

api/icsneoc2/icsneoc2messages.cpp

@@ -126,6 +126,28 @@ icsneoc2_error_t icsneoc2_message_data_get(icsneoc2_message_t* message, uint8_t*
 	return icsneoc2_error_success;
 }
 
+icsneoc2_error_t icsneoc2_message_timestamp_set(icsneoc2_message_t* message, uint64_t timestamp) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	if(!message->message) {
+		return icsneoc2_error_invalid_message;
+	}
+	message->message->timestamp = timestamp;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_timestamp_get(icsneoc2_message_t* message, uint64_t* timestamp) {
+	if(!message || !timestamp) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	if(!message->message) {
+		return icsneoc2_error_invalid_message;
+	}
+	*timestamp = message->message->timestamp;
+	return icsneoc2_error_success;
+}
+
 icsneoc2_error_t icsneoc2_message_can_create(icsneoc2_message_t** message) {
 	if(!message) {
 		return icsneoc2_error_invalid_parameters;

api/icsneocpp/eventmanager.cpp

@@ -7,8 +7,8 @@
 using namespace icsneo;
 
 EventManager& EventManager::GetInstance() {
-	static EventManager inst;
-	return inst;
+	static EventManager* inst = new EventManager();
+	return *inst;
 }
 
 void EventManager::downgradeErrorsOnCurrentThread() {

bindings/python/CMakeLists.txt

@@ -31,6 +31,7 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/tc10statusmessage.cpp
     icsneopy/communication/message/mdiomessage.cpp
     icsneopy/communication/message/gptpstatusmessage.cpp
+    icsneopy/communication/message/allmacaddressesmessage.cpp
     icsneopy/communication/message/ethernetstatusmessage.cpp
     icsneopy/communication/message/spimessage.cpp
     icsneopy/communication/message/scriptstatusmessage.cpp

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

@@ -0,0 +1,13 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "icsneo/communication/message/allmacaddressesmessage.h"
+
+namespace icsneo {
+
+void init_allmacaddressesmessage(pybind11::module_& m) {
+	pybind11::classh<AllMACAddressesMessage, Message>(m, "AllMACAddressesMessage")
+		.def_readonly("addresses", &AllMACAddressesMessage::addresses);
+}
+
+} // namespace icsneo

bindings/python/icsneopy/device/chipid.cpp

@@ -120,7 +120,7 @@ void init_chipid(pybind11::module_& m) {
 		.value("VEM_01_8DW_ZCHIP", ChipID::VEM_01_8DW_ZCHIP)
 		.value("RADGalaxy_FFG_Zynq", ChipID::RADGalaxy_FFG_Zynq)
 		.value("RADMoon3_MCHIP", ChipID::RADMoon3_MCHIP)
-		.value("RADComet_ZYNQ", ChipID::RADComet_ZYNQ)
+		.value("RADComet2_ZYNQ", ChipID::RADComet2_ZYNQ)
 		.value("VEM_02_FR_ZCHIP", ChipID::VEM_02_FR_ZCHIP)
 		.value("RADA2B_REVB_ZCHIP", ChipID::RADA2B_REVB_ZCHIP)
 		.value("RADGigastar_FFG_ZYNQ", ChipID::RADGigastar_FFG_ZYNQ)

bindings/python/icsneopy/device/device.cpp

@@ -33,7 +33,7 @@ void init_device(pybind11::module_& m) {
 		.def("get_serial_number", &Device::getSerialNumber)
 		.def("get_serial", &Device::getSerial)
 		.def("get_pcb_serial", &Device::getPCBSerial, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_mac_address", &Device::getMACAddress, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_mac_addresses", &Device::getMACAddresses, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
 		.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
 		.def("get_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())

bindings/python/icsneopy/device/devicetype.cpp

@@ -38,7 +38,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
 		.value("RADGemini", DeviceType::Enum::RADGemini)
-		.value("RADComet", DeviceType::Enum::RADComet)
+		.value("RADComet2", DeviceType::Enum::RADComet2)
 		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)
 		.value("FIRE3_T1S_LIN", DeviceType::Enum::FIRE3_T1S_LIN)
 		.value("FIRE3_T1S_SENT", DeviceType::Enum::FIRE3_T1S_SENT)

bindings/python/icsneopy/icsneocpp.cpp

@@ -19,6 +19,7 @@ void init_ethernetmessage(pybind11::module_&);
 void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
 void init_gptpstatusmessage(pybind11::module_&);
+void init_allmacaddressesmessage(pybind11::module_&);
 void init_mdiomessage(pybind11::module_&);
 void init_spimessage(pybind11::module_&);
 void init_ethernetstatusmessage(pybind11::module_&);
@@ -59,6 +60,7 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_linmessage(m);
 	init_tc10statusmessage(m);
 	init_gptpstatusmessage(m);
+	init_allmacaddressesmessage(m);
 	init_mdiomessage(m);
 	init_ethernetstatusmessage(m);
 	init_macsecconfig(m);

communication/decoder.cpp

@@ -21,6 +21,7 @@
 #include "icsneo/communication/message/hardwareinfo.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
 #include "icsneo/communication/message/gptpstatusmessage.h"
+#include "icsneo/communication/message/allmacaddressesmessage.h"
 #include "icsneo/communication/message/apperrormessage.h"
 #include "icsneo/communication/message/ethernetstatusmessage.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
@@ -343,6 +344,9 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::GetTC10Status:
 							result = TC10StatusMessage::DecodeToMessage(packet->data);
 							return true;
+						case ExtendedCommand::GetAllMACAddresses:
+							result = AllMACAddressesMessage::DecodeToMessage(packet->data);
+							return true;
 						case ExtendedCommand::GetGPTPStatus: {
 							result = GPTPStatus::DecodeToMessage(packet->data, report);
 							return true;

communication/message/allmacaddressesmessage.cpp

@@ -0,0 +1,51 @@
+#include "icsneo/communication/message/allmacaddressesmessage.h"
+#include "icsneo/communication/command.h"
+#include "icsneo/communication/network.h"
+
+#include <cstring>
+
+using namespace icsneo;
+
+#pragma pack(push, 2)
+struct ResponseHeader {
+	ExtendedCommand command;
+	uint16_t length;
+	uint16_t count;
+};
+
+struct MacAddrEntryPacket {
+	uint16_t networkId;
+	uint8_t address[MACAddressLength];
+};
+#pragma pack(pop)
+
+std::shared_ptr<AllMACAddressesMessage> AllMACAddressesMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	if(bytestream.size() < sizeof(ResponseHeader))
+		return nullptr;
+
+	const auto* hdr = reinterpret_cast<const ResponseHeader*>(bytestream.data());
+
+	if(hdr->command != ExtendedCommand::GetAllMACAddresses)
+		return nullptr;
+
+	if(hdr->count > MaxMACAddressCount)
+		return nullptr;
+
+	const size_t required = sizeof(ResponseHeader) + hdr->count * sizeof(MacAddrEntryPacket);
+	if(bytestream.size() < required)
+		return nullptr;
+
+	auto msg = std::make_shared<AllMACAddressesMessage>();
+
+	const auto* entries = reinterpret_cast<const MacAddrEntryPacket*>(bytestream.data() + sizeof(ResponseHeader));
+	for(uint16_t i = 0; i < hdr->count; ++i) {
+		// The firmware sends CoreMini network IDs — convert to NetID for consistent use in libicsneo
+		Network::NetID netId = Network::GetNetIDFromCoreMiniNetwork(static_cast<Network::CoreMini>(entries[i].networkId));
+		auto addr = entries[i].address;
+		MACAddress arrAddr; 
+		std::copy(addr, addr + MACAddressLength, arrAddr.begin());
+		msg->addresses.emplace(std::make_pair(netId, arrAddr));
+	}
+
+	return msg;
+}

core/macseccfg.cpp

@@ -230,6 +230,7 @@ MACsecConfig::MACsecConfig(const DeviceType& deviceType) : type(deviceType) {
 		case icsneo::DeviceType::Enum::RADMoon2:
 		case icsneo::DeviceType::Enum::RADMoon3:
 		case icsneo::DeviceType::Enum::RADEpsilon:
+		case icsneo::DeviceType::Enum::RADGigastar2:
 			maxSecY = 2;
 			maxRule = 2;
 			maxSa = 4;

device/device.cpp

@@ -2263,13 +2263,34 @@ std::optional<std::vector<uint8_t>> Device::getPCBSerial() {
 	return std::vector<uint8_t>(serialMsg->pcbSerial, serialMsg->pcbSerial + sizeof(serialMsg->pcbSerial));
 }
 
-std::optional<std::vector<uint8_t>> Device::getMACAddress() {
-	auto serialMsg = com->getSerialNumberSync();
-	if(!serialMsg || !serialMsg->hasMacAddress) {
-		return std::nullopt;
+std::unordered_map<Network::NetID, MACAddress> Device::getMACAddresses() {
+	if(supportsGetAllMACAddresses()) {
+		if(!isOpen()) {
+			report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+			return {};
+		}
+		auto msg = com->waitForMessageSync(
+			[this](){ return com->sendCommand(ExtendedCommand::GetAllMACAddresses, {}); },
+			std::make_shared<MessageFilter>(Message::Type::AllMACAddresses),
+			std::chrono::milliseconds(100)
+		);
+		if(msg) {
+			const auto typed = std::dynamic_pointer_cast<AllMACAddressesMessage>(msg);
+			if(typed)
+				return typed->addresses;
+		}
 	}
 
-	return std::vector<uint8_t>(serialMsg->macAddress, serialMsg->macAddress + sizeof(serialMsg->macAddress));
+	auto serialMsg = com->getSerialNumberSync();
+	if(!serialMsg || !serialMsg->hasMacAddress)
+		return {};
+
+	std::unordered_map<Network::NetID, MACAddress> addresses;
+	auto addr = serialMsg->macAddress;
+	MACAddress arrAddr;
+	std::copy(addr, addr + MACAddressLength, arrAddr.begin());
+	addresses.emplace(std::make_pair(Network::NetID::ETHERNET_01, arrAddr));
+	return addresses;
 }
 
 std::optional<std::set<SupportedFeature>> Device::getSupportedFeatures() {

device/devicefinder.cpp

@@ -165,10 +165,6 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADA2B>(dev, newFoundDevices);
 		#endif
 
-		#ifdef __RADCOMET_H_
-		makeIfSerialRangeMatches<RADComet>(dev, newFoundDevices);
-		#endif
-
 		#ifdef __RADCOMET2_H_
 		makeIfSerialRangeMatches<RADComet2>(dev, newFoundDevices);
 		#endif
@@ -340,8 +336,8 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADA2B::DEVICE_TYPE,
 		#endif
 
-		#ifdef __RADCOMET_H_
-		RADComet::DEVICE_TYPE,
+		#ifdef __RADCOMET2_H_
+		RADComet2::DEVICE_TYPE,
 		#endif
 
 		#ifdef __RADCOMET3_H_

docs/icsneoc2/examples.rst

@@ -10,6 +10,14 @@ Simple
 .. literalinclude:: ../../examples/c2/simple/src/main.c
    :language: c
 
+Supported Devices
+=================
+
+:download:`Download example <../../examples/c2/supported_devices/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/supported_devices/src/main.c
+   :language: c
+
 Disk Format
 ===========
 

examples/CMakeLists.txt

@@ -2,10 +2,12 @@ option(LIBICSNEO_BUILD_C_INTERACTIVE_EXAMPLE "Build the command-line interactive
 option(LIBICSNEO_BUILD_C_SIMPLE_EXAMPLE "Build the command-line simple C example." ON)
 option(LIBICSNEO_BUILD_C_LEGACY_EXAMPLE "Build the command-line simple C example." ON)
 option(LIBICSNEO_BUILD_C2_SIMPLE_EXAMPLE "Build the simple C2 example." ON)
+option(LIBICSNEO_BUILD_C2_SUPPORTED_DEVICES_EXAMPLE "Build the C2 supported devices example." ON)
 option(LIBICSNEO_BUILD_C2_READ_MESSAGES_EXAMPLE "Build the C2 read messages example." ON)
 option(LIBICSNEO_BUILD_C2_DISKFORMAT_EXAMPLE "Build the C2 disk format example." ON)
 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_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)
@@ -13,6 +15,7 @@ option(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE "Build the C2 ethernet receiv
 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_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)
 option(LIBICSNEO_BUILD_CPP_A2B_EXAMPLE "Build the A2B example." ON)
 option(LIBICSNEO_BUILD_CPP_LIN_EXAMPLE "Build the LIN example." ON)
@@ -47,6 +50,10 @@ if(LIBICSNEO_BUILD_C2_SIMPLE_EXAMPLE)
 	add_subdirectory(c2/simple)
 endif()
 
+if(LIBICSNEO_BUILD_C2_SUPPORTED_DEVICES_EXAMPLE)
+	add_subdirectory(c2/supported_devices)
+endif()
+
 if(LIBICSNEO_BUILD_C2_READ_MESSAGES_EXAMPLE)
 	add_subdirectory(c2/read_messages)
 endif()
@@ -63,6 +70,10 @@ if(LIBICSNEO_BUILD_C2_DEVICE_INFO_EXAMPLE)
 	add_subdirectory(c2/device_info)
 endif()
 
+if(LIBICSNEO_BUILD_C2_CHIP_VERSIONS_EXAMPLE)
+	add_subdirectory(c2/chip_versions)
+endif()
+
 if(LIBICSNEO_BUILD_C2_LIN_EXAMPLE)
 	add_subdirectory(c2/lin)
 endif()
@@ -91,6 +102,10 @@ if(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE)
 	add_subdirectory(cpp/simple)
 endif()
 
+if(LIBICSNEO_BUILD_CPP_DEVICE_INFO_EXAMPLE)
+	add_subdirectory(cpp/device_info)
+endif()
+
 if(LIBICSNEO_BUILD_CPP_INTERACTIVE_EXAMPLE)
 	add_subdirectory(cpp/interactive)
 endif()

examples/c2/chip_versions/CMakeLists.txt

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

examples/c2/chip_versions/src/main.c

@@ -0,0 +1,59 @@
+#include <icsneo/icsneoc2.h>
+
+#include <stdio.h>
+#include <inttypes.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_chip_versions_t* chip_versions = NULL;
+	res = icsneoc2_device_chip_versions_enumerate(device, &chip_versions, true, &count);
+	if(res != icsneoc2_error_success) {
+		print_error_code("Failed to enumerate chip versions", res);
+		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
+		return 1;
+	}
+
+	printf("Found %zu chip version(s):\n", count);
+	for(icsneoc2_chip_versions_t* cur = chip_versions; cur; cur = icsneoc2_chip_versions_next(cur)) {
+		char name[64] = {0};
+		size_t name_length = sizeof(name);
+		uint8_t major = 0, minor = 0, maintenance = 0, build = 0;
+		res = icsneoc2_chip_versions_props_get(cur, name, &name_length, &major, &minor, &maintenance, &build);
+		if(res != icsneoc2_error_success) {
+			print_error_code("Failed to get chip version properties", res);
+			continue;
+		}
+		printf("  %s: %u.%u.%u.%u\n", name, major, minor, maintenance, build);
+	}
+
+	icsneoc2_chip_versions_free(chip_versions);
+	icsneoc2_device_close(device);
+	icsneoc2_device_free(device);
+	return 0;
+}

examples/c2/device_info/src/main.c

@@ -102,19 +102,31 @@ int main() {
 		print_error_code("Failed to get PCB serial (device may not support it)", res);
 	}
 
-	/* ===== MAC Address ===== */
-	uint8_t mac[6] = {0};
-	size_t mac_len = sizeof(mac);
-	res = icsneoc2_device_mac_address_get(device, mac, &mac_len);
+	/* ===== MAC Addresses ===== */
+	icsneoc2_mac_addr_entry_t* macs = NULL;
+	res = icsneoc2_device_mac_addresses_enumerate(device, &macs);
 	if(res == icsneoc2_error_success) {
-		printf("MAC:        ");
-		for(size_t i = 0; i < mac_len; i++) {
-			if(i > 0) printf(":");
-			printf("%02X", mac[i]);
+		uint16_t mac_count = 0;
+		for(icsneoc2_mac_addr_entry_t* cur = macs; cur; cur = icsneoc2_mac_addresses_next(cur)) {
+			mac_count++;
 		}
-		printf("\n");
+		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_mac_network_id_get(cur, &network_id);
+			printf("  Network %-5u  ", (unsigned)network_id);
+			uint8_t address[6];
+			size_t address_size = 6;
+			icsneoc2_mac_address_get(cur, address, &address_size);
+			for(int j = 0; j < 6; j++) {
+				if(j > 0) printf(":");
+				printf("%02X", (unsigned)address[j]);
+			}
+			printf("\n");
+		}
+		icsneoc2_mac_addresses_free(macs);
 	} else {
-		print_error_code("Failed to get MAC address (device may not support it)", res);
+		print_error_code("Failed to get MAC addresses (device may not support it)", res);
 	}
 
 	/* Cleanup */

examples/c2/ethernet_receive/src/main.c

@@ -68,6 +68,7 @@ void print_mac(const char* label, const uint8_t* mac) {
 
 int process_ethernet_message(icsneoc2_message_t* message, size_t index) {
 	icsneoc2_netid_t netid = 0;
+	uint64_t timestamp = 0;
 	char netid_name[128] = {0};
 	size_t netid_name_length = 128;
 
@@ -79,6 +80,10 @@ int process_ethernet_message(icsneoc2_message_t* message, size_t index) {
 	if(res != icsneoc2_error_success) {
 		return print_error_code("\tFailed to get netid name", res);
 	}
+	res = icsneoc2_message_timestamp_get(message, &timestamp);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("\tFailed to get timestamp", res);
+	}
 
 	/* Get data length first */
 	size_t data_length = 0;
@@ -88,6 +93,7 @@ int process_ethernet_message(icsneoc2_message_t* message, size_t index) {
 	}
 
 	printf("\t%zu) Ethernet Frame on %s (0x%x) - %zu bytes\n", index, netid_name, netid, data_length);
+	printf("\t  Timestamp: %" PRIu64 " ns since 2007-01-01 UTC\n", timestamp);
 
 	/* Get MAC addresses and EtherType if we have enough data */
 	uint8_t dst_mac[6] = {0};

examples/c2/lin/src/main.c

@@ -86,6 +86,8 @@ void process_lin_messages(icsneoc2_message_t** messages, size_t count) {
 
 		icsneoc2_netid_t netid = 0;
 		icsneoc2_message_netid_get(messages[i], &netid);
+		uint64_t timestamp = 0;
+		icsneoc2_message_timestamp_get(messages[i], &timestamp);
 		char netid_name[128] = {0};
 		size_t netid_name_length = 128;
 		icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
@@ -98,6 +100,7 @@ void process_lin_messages(icsneoc2_message_t** messages, size_t count) {
 		icsneoc2_message_lin_err_flags_get(messages[i], &err_flags);
 
 		printf("\t%s RX | ID: 0x%02x | Protected ID: 0x%02x\n", netid_name, id, protected_id);
+		printf("\tTimestamp: %" PRIu64 " ns since 2007-01-01 UTC\n", timestamp);
 		printf("\tData: [");
 		for(size_t x = 0; x < data_length; x++) {
 			printf(" 0x%02x", data[x]);

examples/c2/read_messages/src/main.c

@@ -244,6 +244,7 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 
 		printf("\t%zd) network type: %s (%u)\n", i, network_type_name, network_type);
 		if(network_type == icsneoc2_network_type_can) {
+			uint64_t timestamp = 0;
 			uint64_t arbid = 0;
 			int32_t dlc = 0;
 			icsneoc2_netid_t netid = 0;
@@ -256,6 +257,7 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 			bool is_tx = false;
 			icsneoc2_error_t result = icsneoc2_message_netid_get(message, &netid);
 			result += icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
+			result += icsneoc2_message_timestamp_get(message, &timestamp);
 			result += icsneoc2_message_can_props_get(message, &arbid, &can_flags);
 			result += icsneoc2_message_data_get(message, data, &data_length);
 			result += icsneoc2_message_is_transmit(message, &is_tx);
@@ -276,6 +278,7 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 			dlc = (int32_t)data_length;
 
 			printf("\t  %s%s\n", is_tx ? "TX" : "RX", is_error ? " [Error]" : "");
+			printf("\t  Timestamp: %" PRIu64 " ns since 2007-01-01 UTC\n", timestamp);
 			printf("\t  NetID: %s (0x%x)\tArbID: 0x%llx\tDLC: %u\tLen: %zu\n", netid_name, netid, (unsigned long long)arbid, dlc, data_length);
 			printf("\t  Flags:%s%s%s%s%s%s%s%s\n",
 				is_remote ? " RTR" : "",

examples/c2/simple/src/main.c

@@ -426,6 +426,7 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 		printf("\t%zd) network type: %s (%u)\n", i, network_type_name, network_type);
 
 		if(network_type == icsneoc2_network_type_can) {
+			uint64_t timestamp = 0;
 			uint64_t arbid = 0;
 			int32_t dlc = 0;
 			icsneoc2_netid_t netid = 0;
@@ -436,6 +437,7 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 			size_t netid_name_length = 128;
 			icsneoc2_error_t result = icsneoc2_message_netid_get(message, &netid);
 			result += icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
+			result += icsneoc2_message_timestamp_get(message, &timestamp);
 			result += icsneoc2_message_can_props_get(message, &arbid, &can_flags);
 			result += icsneoc2_message_data_get(message, data, &data_length);
 			if(result != icsneoc2_error_success) {
@@ -452,6 +454,7 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 			bool tx_error = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR) != 0;
 			dlc = (int32_t)data_length;
 
+			printf("\t  Timestamp: %" PRIu64 " ns since 2007-01-01 UTC\n", timestamp);
 			printf("\t  NetID: %s (0x%x)\tArbID: 0x%llx\tDLC: %u\tLen: %zu\n", netid_name, netid, (unsigned long long)arbid, dlc, data_length);
 			printf("\t  Flags:%s%s%s%s%s%s%s%s\n",
 				is_remote ? " RTR" : "",

examples/c2/supported_devices/CMakeLists.txt

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

examples/c2/supported_devices/src/main.c

@@ -0,0 +1,55 @@
+#include <icsneo/icsneoc2.h>
+
+#include <stdio.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) {
+		printf("%s: failed to get string for error code %u\n", message, error);
+		return (int)res;
+	}
+	printf("%s: %s (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+int main(void) {
+	icsneoc2_supported_device_t* supported_devices = NULL;
+	icsneoc2_error_t res = icsneoc2_supported_devices_enumerate(&supported_devices);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to enumerate supported devices", res);
+	}
+
+	if(!supported_devices) {
+		printf("No supported devices found.\n");
+		return 0;
+	}
+
+	printf("Supported devices:\n");
+	for(icsneoc2_supported_device_t* cur = supported_devices; cur != NULL; cur = icsneoc2_supported_devices_next(cur)) {
+		icsneoc2_devicetype_t device_type = 0;
+		res = icsneoc2_supported_device_get(cur, &device_type);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_supported_devices_free(supported_devices);
+			return print_error_code("Failed to get supported device type", res);
+		}
+
+		char name[128] = {0};
+		size_t name_len = sizeof(name);
+		res = icsneoc2_device_type_name_get(device_type, name, &name_len);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_supported_devices_free(supported_devices);
+			return print_error_code("Failed to get supported device type name", res);
+		}
+
+		printf("  %s (%u)\n", name, (unsigned int)device_type);
+	}
+
+	res = icsneoc2_supported_devices_free(supported_devices);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to free supported device list", res);
+	}
+
+	return 0;
+}

examples/c2/t1s_loopback/src/main.c

@@ -468,6 +468,7 @@ static int message_matches_loopback_frame(icsneoc2_message_t* message, const uin
 
 static int print_ethernet_message(icsneoc2_message_t* message, const char* direction_label) {
 	icsneoc2_netid_t netid = 0;
+	uint64_t timestamp = 0;
 	char netid_name[64] = {0};
 	uint8_t dst_mac[6] = {0};
 	uint8_t src_mac[6] = {0};
@@ -483,11 +484,14 @@ static int print_ethernet_message(icsneoc2_message_t* message, const char* direc
 	res = icsneoc2_message_netid_get(message, &netid);
 	if(res != icsneoc2_error_success) return print_error_code("Failed to get message netid", res);
 	if(get_netid_name(netid, netid_name, sizeof(netid_name)) != 0) return 1;
+	res = icsneoc2_message_timestamp_get(message, &timestamp);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to get message timestamp", res);
 
 	res = icsneoc2_message_data_get(message, data, &data_length);
 	if(res != icsneoc2_error_success) return print_error_code("Failed to get Ethernet data", res);
 
 	printf("%s on %s: %zu bytes\n", direction_label, netid_name, data_length);
+	printf("  Timestamp: %" PRIu64 " ns since 2007-01-01 UTC\n", timestamp);
 
 	res = icsneoc2_message_eth_mac_get(message, dst_mac, src_mac);
 	if(res == icsneoc2_error_success) {
@@ -640,4 +644,4 @@ static int poll_for_loopback_messages(icsneoc2_device_t* device,
 
 	printf("Loopback complete: TX echo on %s and RX frame on %s were both observed.\n", tx_name, rx_name);
 	return 0;
-}
+}

examples/cpp/device_info/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_executable(libicsneocpp-device-info-example src/DeviceInfoExample.cpp)
+target_link_libraries(libicsneocpp-device-info-example icsneocpp)

examples/cpp/device_info/src/DeviceInfoExample.cpp

@@ -0,0 +1,80 @@
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+
+#include "icsneo/icsneocpp.h"
+
+static std::string formatMAC(const std::array<uint8_t, icsneo::MACAddressLength> addr) {
+	std::ostringstream oss;
+	for(size_t i = 0; i < icsneo::MACAddressLength; i++) {
+		if(i > 0) {
+			oss << ':';
+		}
+		oss << std::hex << std::uppercase << std::setw(2) << std::setfill('0') << static_cast<unsigned>(addr[i]);
+	}
+	return oss.str();
+}
+
+int main() {
+	// ===== Device Selection =====
+	std::cout << "Searching for devices...\n";
+	auto devices = icsneo::FindAllDevices();
+
+	if(devices.empty()) {
+		std::cout << "No devices found.\n";
+		return 1;
+	}
+
+	for(size_t i = 0; i < devices.size(); i++) {
+		std::cout << "  [" << (i + 1) << "] " << devices[i]->describe() << "\n";
+	}
+
+	int choice;
+	std::cout << "Select device (1-" << devices.size() << "): ";
+	if(!(std::cin >> choice) || choice < 1 || choice > (int)devices.size()) {
+		std::cout << "Invalid selection.\n";
+		return 1;
+	}
+
+	auto& device = devices[choice - 1];
+
+	std::cout << "\nOpening " << device->describe() << "... ";
+	if(!device->open()) {
+		std::cout << "FAIL\n" << icsneo::GetLastError() << "\n";
+		return 1;
+	}
+	std::cout << "OK\n\n";
+
+	// ===== Serial Number =====
+	std::cout << "Serial:     " << device->getSerial() << "\n";
+
+	// ===== PCB Serial Number =====
+	auto pcbSerial = device->getPCBSerial();
+	if(pcbSerial.has_value()) {
+		std::cout << "PCB Serial: ";
+		for(auto b : *pcbSerial)
+			std::cout << (char)b;
+		std::cout << "\n";
+	} else {
+		std::cout << "PCB Serial: Not supported\n";
+	}
+
+	auto macs = device->getMACAddresses();
+	if(!macs.empty()) {
+		std::cout << "MACs:       " << macs.size()
+		          << (macs.size() == 1 ? " entry" : " entries") << "\n";
+		for(auto macPair : macs) {
+			std::cout << "  " << std::left << std::setw(20)
+			          << icsneo::Network::GetNetIDString(static_cast<icsneo::Network::NetID>(macPair.first))
+			          << "  " << formatMAC(macPair.second) << "\n";
+		}
+	} else {
+		std::cout << "MACs:       Not supported\n";
+	}
+
+	// ===== Cleanup =====
+	std::cout << "\nClosing device... ";
+	std::cout << (device->close() ? "OK" : "FAIL") << "\n";
+
+	return 0;
+}

include/icsneo/communication/command.h

@@ -64,6 +64,7 @@ enum class ExtendedCommand : uint16_t {
 	RequestTC10Wake = 0x003D,
 	RequestTC10Sleep = 0x003E,
 	GetTC10Status = 0x003F,
+	GetAllMACAddresses = 0x0040,
 	ProtobufAPI = 0x0041,
 	TransmitMessage = 0x0042,
 };

include/icsneo/communication/message/allmacaddressesmessage.h

@@ -0,0 +1,35 @@
+#ifndef __ALLMACADDRESSESMESSAGE_H_
+#define __ALLMACADDRESSESMESSAGE_H_
+
+#define ICSNEO_MAC_ADDRESS_LEN 6
+#define ICSNEO_MAX_MAC_COUNT 32
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+
+#include <memory>
+#include <vector>
+#include <unordered_map>
+#include <array>
+namespace icsneo {
+
+static constexpr uint16_t MaxMACAddressCount = ICSNEO_MAX_MAC_COUNT;
+static constexpr uint8_t MACAddressLength = ICSNEO_MAC_ADDRESS_LEN;
+
+using MACAddress = std::array<uint8_t, MACAddressLength>;
+
+class AllMACAddressesMessage : public Message {
+public:
+	static std::shared_ptr<AllMACAddressesMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+
+	AllMACAddressesMessage() : Message(Type::AllMACAddresses) {}
+
+	std::unordered_map<Network::NetID, MACAddress> addresses;
+};
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __ALLMACADDRESSESMESSAGE_H_

include/icsneo/communication/message/message.h

@@ -47,6 +47,7 @@ public:
 		LogData = 0x8015,
 		NetworkMutex = 0x8016,
 		ClientId = 0x8017,
+		AllMACAddresses = 0x8018,
 	};
 
 	Message(Type t) : type(t) {}

include/icsneo/device/chipid.h

@@ -1,142 +1,144 @@
 #ifndef __CHIP_ID_H_
 #define __CHIP_ID_H_
 
+#include "icsneo/icsneoc2types.h"
+
 #ifdef __cplusplus
 
 #include <cstdint>
 
 namespace icsneo {
 
-enum class ChipID : uint8_t {
-	neoVIFIRE_MCHIP = 0,
-	neoVIFIRE_LCHIP = 1,
-	neoVIFIRE_UCHIP = 2,
-	neoVIFIRE_JCHIP = 3,
-	ValueCAN3_MCHIP = 4,
-	neoVIECU_MPIC = 6,
-	neoVIIEVB_MPIC = 7,
-	neoVIPENDANT_MPIC = 8,
-	neoVIFIRE_VNET_MCHIP = 9,
-	neoVIFIRE_VNET_LCHIP = 10,
-	neoVIPLASMA_Core = 11,
-	neoVIPLASMA_HID = 12,
-	neoVIANALOG_MPIC = 13,
-	neoVIPLASMA_ANALOG_Core = 14,
-	neoVIPLASMA_FlexRay_Core = 15,
-	neoVIPLASMA_Core_1_12 = 16,
-	neoVIFIRE_Slave_VNET_MCHIP = 17,
-	neoVIFIRE_Slave_VNET_LCHIP = 18,
-	neoVIION_Core = 19,
-	neoVIION_HID = 20,
-	neoVIION_Core_Loader = 21,
-	neoVIION_HID_Loader = 22,
-	neoVIION_FPGA_BIT = 23,
-	neoVIFIRE_VNET_EP_MCHIP = 24,
-	neoVIFIRE_VNET_EP_LCHIP = 25,
-	neoVIAnalogOut_MCHIP = 26,
-	neoVIMOST25_MCHIP = 27,
-	neoVIMOST50_MCHIP = 28,
-	neoVIMOST150_MCHIP = 29,
-	ValueCAN4_4_MCHIP = 30,
-	ValueCAN4_4_SCHIP = 31,
-	cmProbe_ZYNQ = 33,
-	EEVB_STM32 = 34,
-	neoVIFIRE_Slave_VNET_EP_MCHIP = 35,
-	neoVIFIRE_Slave_VNET_EP_LCHIP = 36,
-	RADStar_MCHIP = 37,
-	ValueCANrf_MCHIP = 38,
-	neoVIFIRE2_MCHIP = 39,
-	neoVIFIRE2_CCHIP = 40,
-	neoVIFIRE2_Core = 41,
-	neoVIFIRE2_BLECHIP = 42,
-	neoVIFIRE2_ZYNQ = 43, // FIRE2 MVNET Z - Zynq
-	neoVIFIRE2_SECURITYCHIP = 44,
-	RADGalaxy_ZYNQ = 45,
-	neoVIFIRE2_VNET_MCHIP = 46,
-	neoVIFIRE2_Slave_VNET_A_MCHIP = 47,
-	neoVIFIRE2_Slave_VNET_A_CCHIP = 48,
-	neoVIFIRE2_VNET_CCHIP = 49,
-	neoVIFIRE2_VNET_Core = 50,
-	RADStar2_ZYNQ = 51,
-	VividCAN_MCHIP = 52,
-	neoOBD2SIM_MCHIP = 53,
-	neoVIFIRE2_VNETZ_MCHIP = 54,
-	neoVIFIRE2_VNETZ_ZYNQ = 55,
-	neoVIFIRE2_Slave_VNETZ_A_MCHIP = 56,
-	neoVIFIRE2_Slave_VNETZ_A_ZYNQ = 57,
-	VividCAN_EXT_FLASH = 58,
-	VividCAN_NRF52 = 59,
-	cmProbe_ZYNQ_Unused = 60, // Double defined
-	neoOBD2PRO_MCHIP = 61,
-	ValueCAN4_1_MCHIP = 62,
-	ValueCAN4_2_MCHIP = 63,
-	ValueCAN4_4_2EL_Core = 64,
-	neoOBD2PRO_SCHIP = 65,
-	ValueCAN4_2EL_MCHIP = 67,
-	neoECUAVBTSN_MCHIP = 68,
-	neoOBD2PRO_Core = 69,
-	RADSupermoon_ZYNQ = 70,
-	RADMoon2_ZYNQ = 71,
-	VividCANPRO_MCHIP = 72,
-	VividCANPRO_EXT_FLASH = 73,
-	RADPluto_MCHIP = 74,
-	RADMars_ZYNQ = 75,
-	neoECU12_MCHIP = 76,
-	RADIOCANHUB_MCHIP = 77,
-	FlexRay_VNETZ_ZCHIP = 78,
-	neoOBD2_LCBADGE_MCHIP = 79,
-	neoOBD2_LCBADGE_SCHIP = 80,
-	RADMoonDuo_MCHIP = 81,
-	neoVIFIRE3_ZCHIP = 82,
-	FlexRay_VNETZ_FCHIP = 83,
-	RADJupiter_MCHIP = 84,
-	ValueCAN4Industrial_MCHIP = 85,
-	EtherBADGE_MCHIP = 86,
-	RADMars_3_ZYNQ = 87,
-	RADGigastar_USBZ_ZYNQ = 88,
-	RADGigastar_ZYNQ = 89,
-	RAD4G_MCHIP = 90,
-	neoVIFIRE3_SCHIP = 91,
-	RADEpsilon_MCHIP = 92,
-	RADA2B_ZCHIP = 93,
-	neoOBD2Dev_MCHIP = 94,
-	neoOBD2Dev_SCHIP = 95,
-	neoOBD2SIMDoIP_MCHIP = 96,
-	SFPModule_88q2112_MCHIP = 97,
-	RADEpsilonT_MCHIP = 98,
-	RADEpsilonExpress_MCHIP = 99,
-	RADProxima_MCHIP = 100,
-	NewDevice57_ZCHIP = 101,
-	RAD_GALAXY_2_ZMPCHIP_ID = 102,
-	NewDevice59_MCHIP = 103,
-	RADMoon2_Z7010_ZYNQ = 104,
-	neoVIFIRE2_Core_SG4 = 105,
-	RADBMS_MCHIP = 106,
-	RADMoon2_ZL_MCHIP = 107,
-	RADGigastar_USBZ_Z7010_ZYNQ = 108,
-	neoVIFIRE3_LINUX = 109,
-	RADGigastar_USBZ_Z7007S_ZYNQ = 110,
-	VEM_01_8DW_ZCHIP = 111,
-	RADGalaxy_FFG_Zynq = 112,
-	RADMoon3_MCHIP = 113,
-	RADComet_ZYNQ = 114,
-	VEM_02_FR_ZCHIP = 115,
-	RADA2B_REVB_ZCHIP = 116,
-	RADGigastar_FFG_ZYNQ = 117,
-	VEM_02_FR_FCHIP = 118,
-	Connect_ZCHIP = 121,
-	SFPModule_88q2221_MCHIP = 122,
-	RADGALAXY2_SYSMON_CHIP = 123,
-	SFPModule_88q3244_MCHIP = 124,
-	RADCOMET3_ZCHIP = 125,
-	Connect_LINUX = 126,
-	SFPModule_lan8670_MCHIP = 127,
-	VEM_04_T1S_LIN_ZCHIP = 129,
-	RADMOONT1S_ZCHIP = 130,
-	RADGigastar2_ZYNQ = 131,
-	SFPModule_ent11100_MCHIP = 132,
-	RADGemini_MCHIP = 135,
-	Invalid = 255
+enum class ChipID : icsneoc2_chip_id_t {
+	neoVIFIRE_MCHIP = icsneoc2_chip_id_neovifire_mchip,
+	neoVIFIRE_LCHIP = icsneoc2_chip_id_neovifire_lchip,
+	neoVIFIRE_UCHIP = icsneoc2_chip_id_neovifire_uchip,
+	neoVIFIRE_JCHIP = icsneoc2_chip_id_neovifire_jchip,
+	ValueCAN3_MCHIP = icsneoc2_chip_id_valuecan3_mchip,
+	neoVIECU_MPIC = icsneoc2_chip_id_neoviecu_mpic,
+	neoVIIEVB_MPIC = icsneoc2_chip_id_neoviievb_mpic,
+	neoVIPENDANT_MPIC = icsneoc2_chip_id_neovipendant_mpic,
+	neoVIFIRE_VNET_MCHIP = icsneoc2_chip_id_neovifire_vnet_mchip,
+	neoVIFIRE_VNET_LCHIP = icsneoc2_chip_id_neovifire_vnet_lchip,
+	neoVIPLASMA_Core = icsneoc2_chip_id_neoviplasma_core,
+	neoVIPLASMA_HID = icsneoc2_chip_id_neoviplasma_hid,
+	neoVIANALOG_MPIC = icsneoc2_chip_id_neovianalog_mpic,
+	neoVIPLASMA_ANALOG_Core = icsneoc2_chip_id_neoviplasma_analog_core,
+	neoVIPLASMA_FlexRay_Core = icsneoc2_chip_id_neoviplasma_flexray_core,
+	neoVIPLASMA_Core_1_12 = icsneoc2_chip_id_neoviplasma_core_1_12,
+	neoVIFIRE_Slave_VNET_MCHIP = icsneoc2_chip_id_neovifire_slave_vnet_mchip,
+	neoVIFIRE_Slave_VNET_LCHIP = icsneoc2_chip_id_neovifire_slave_vnet_lchip,
+	neoVIION_Core = icsneoc2_chip_id_neoviion_core,
+	neoVIION_HID = icsneoc2_chip_id_neoviion_hid,
+	neoVIION_Core_Loader = icsneoc2_chip_id_neoviion_core_loader,
+	neoVIION_HID_Loader = icsneoc2_chip_id_neoviion_hid_loader,
+	neoVIION_FPGA_BIT = icsneoc2_chip_id_neoviion_fpga_bit,
+	neoVIFIRE_VNET_EP_MCHIP = icsneoc2_chip_id_neovifire_vnet_ep_mchip,
+	neoVIFIRE_VNET_EP_LCHIP = icsneoc2_chip_id_neovifire_vnet_ep_lchip,
+	neoVIAnalogOut_MCHIP = icsneoc2_chip_id_neovianalogout_mchip,
+	neoVIMOST25_MCHIP = icsneoc2_chip_id_neovimost25_mchip,
+	neoVIMOST50_MCHIP = icsneoc2_chip_id_neovimost50_mchip,
+	neoVIMOST150_MCHIP = icsneoc2_chip_id_neovimost150_mchip,
+	ValueCAN4_4_MCHIP = icsneoc2_chip_id_valuecan4_4_mchip,
+	ValueCAN4_4_SCHIP = icsneoc2_chip_id_valuecan4_4_schip,
+	cmProbe_ZYNQ = icsneoc2_chip_id_cmprobe_zynq,
+	EEVB_STM32 = icsneoc2_chip_id_eevb_stm32,
+	neoVIFIRE_Slave_VNET_EP_MCHIP = icsneoc2_chip_id_neovifire_slave_vnet_ep_mchip,
+	neoVIFIRE_Slave_VNET_EP_LCHIP = icsneoc2_chip_id_neovifire_slave_vnet_ep_lchip,
+	RADStar_MCHIP = icsneoc2_chip_id_radstar_mchip,
+	ValueCANrf_MCHIP = icsneoc2_chip_id_valuecanrf_mchip,
+	neoVIFIRE2_MCHIP = icsneoc2_chip_id_neovifire2_mchip,
+	neoVIFIRE2_CCHIP = icsneoc2_chip_id_neovifire2_cchip,
+	neoVIFIRE2_Core = icsneoc2_chip_id_neovifire2_core,
+	neoVIFIRE2_BLECHIP = icsneoc2_chip_id_neovifire2_blechip,
+	neoVIFIRE2_ZYNQ = icsneoc2_chip_id_neovifire2_zynq, // FIRE2 MVNET Z - Zynq
+	neoVIFIRE2_SECURITYCHIP = icsneoc2_chip_id_neovifire2_securitychip,
+	RADGalaxy_ZYNQ = icsneoc2_chip_id_radgalaxy_zynq,
+	neoVIFIRE2_VNET_MCHIP = icsneoc2_chip_id_neovifire2_vnet_mchip,
+	neoVIFIRE2_Slave_VNET_A_MCHIP = icsneoc2_chip_id_neovifire2_slave_vnet_a_mchip,
+	neoVIFIRE2_Slave_VNET_A_CCHIP = icsneoc2_chip_id_neovifire2_slave_vnet_a_cchip,
+	neoVIFIRE2_VNET_CCHIP = icsneoc2_chip_id_neovifire2_vnet_cchip,
+	neoVIFIRE2_VNET_Core = icsneoc2_chip_id_neovifire2_vnet_core,
+	RADStar2_ZYNQ = icsneoc2_chip_id_radstar2_zynq,
+	VividCAN_MCHIP = icsneoc2_chip_id_vividcan_mchip,
+	neoOBD2SIM_MCHIP = icsneoc2_chip_id_neoobd2sim_mchip,
+	neoVIFIRE2_VNETZ_MCHIP = icsneoc2_chip_id_neovifire2_vnetz_mchip,
+	neoVIFIRE2_VNETZ_ZYNQ = icsneoc2_chip_id_neovifire2_vnetz_zynq,
+	neoVIFIRE2_Slave_VNETZ_A_MCHIP = icsneoc2_chip_id_neovifire2_slave_vnetz_a_mchip,
+	neoVIFIRE2_Slave_VNETZ_A_ZYNQ = icsneoc2_chip_id_neovifire2_slave_vnetz_a_zynq,
+	VividCAN_EXT_FLASH = icsneoc2_chip_id_vividcan_ext_flash,
+	VividCAN_NRF52 = icsneoc2_chip_id_vividcan_nrf52,
+	cmProbe_ZYNQ_Unused = icsneoc2_chip_id_cmprobe_zynq_unused, // Double defined
+	neoOBD2PRO_MCHIP = icsneoc2_chip_id_neoobd2pro_mchip,
+	ValueCAN4_1_MCHIP = icsneoc2_chip_id_valuecan4_1_mchip,
+	ValueCAN4_2_MCHIP = icsneoc2_chip_id_valuecan4_2_mchip,
+	ValueCAN4_4_2EL_Core = icsneoc2_chip_id_valuecan4_4_2el_core,
+	neoOBD2PRO_SCHIP = icsneoc2_chip_id_neoobd2pro_schip,
+	ValueCAN4_2EL_MCHIP = icsneoc2_chip_id_valuecan4_2el_mchip,
+	neoECUAVBTSN_MCHIP = icsneoc2_chip_id_neoecuavbtsn_mchip,
+	neoOBD2PRO_Core = icsneoc2_chip_id_neoobd2pro_core,
+	RADSupermoon_ZYNQ = icsneoc2_chip_id_radsupermoon_zynq,
+	RADMoon2_ZYNQ = icsneoc2_chip_id_radmoon2_zynq,
+	VividCANPRO_MCHIP = icsneoc2_chip_id_vividcanpro_mchip,
+	VividCANPRO_EXT_FLASH = icsneoc2_chip_id_vividcanpro_ext_flash,
+	RADPluto_MCHIP = icsneoc2_chip_id_radpluto_mchip,
+	RADMars_ZYNQ = icsneoc2_chip_id_radmars_zynq,
+	neoECU12_MCHIP = icsneoc2_chip_id_neoecu12_mchip,
+	RADIOCANHUB_MCHIP = icsneoc2_chip_id_radiocanhub_mchip,
+	FlexRay_VNETZ_ZCHIP = icsneoc2_chip_id_flexray_vnetz_zchip,
+	neoOBD2_LCBADGE_MCHIP = icsneoc2_chip_id_neoobd2_lcbadge_mchip,
+	neoOBD2_LCBADGE_SCHIP = icsneoc2_chip_id_neoobd2_lcbadge_schip,
+	RADMoonDuo_MCHIP = icsneoc2_chip_id_radmoonduo_mchip,
+	neoVIFIRE3_ZCHIP = icsneoc2_chip_id_neovifire3_zchip,
+	FlexRay_VNETZ_FCHIP = icsneoc2_chip_id_flexray_vnetz_fchip,
+	RADJupiter_MCHIP = icsneoc2_chip_id_radjupiter_mchip,
+	ValueCAN4Industrial_MCHIP = icsneoc2_chip_id_valuecan4industrial_mchip,
+	EtherBADGE_MCHIP = icsneoc2_chip_id_etherbadge_mchip,
+	RADMars_3_ZYNQ = icsneoc2_chip_id_radmars_3_zynq,
+	RADGigastar_USBZ_ZYNQ = icsneoc2_chip_id_radgigastar_usbz_zynq,
+	RADGigastar_ZYNQ = icsneoc2_chip_id_radgigastar_zynq,
+	RAD4G_MCHIP = icsneoc2_chip_id_rad4g_mchip,
+	neoVIFIRE3_SCHIP = icsneoc2_chip_id_neovifire3_schip,
+	RADEpsilon_MCHIP = icsneoc2_chip_id_radepsilon_mchip,
+	RADA2B_ZCHIP = icsneoc2_chip_id_rada2b_zchip,
+	neoOBD2Dev_MCHIP = icsneoc2_chip_id_neoobd2dev_mchip,
+	neoOBD2Dev_SCHIP = icsneoc2_chip_id_neoobd2dev_schip,
+	neoOBD2SIMDoIP_MCHIP = icsneoc2_chip_id_neoobd2simdoip_mchip,
+	SFPModule_88q2112_MCHIP = icsneoc2_chip_id_sfpmodule_88q2112_mchip,
+	RADEpsilonT_MCHIP = icsneoc2_chip_id_radepsilont_mchip,
+	RADEpsilonExpress_MCHIP = icsneoc2_chip_id_radepsilonexpress_mchip,
+	RADProxima_MCHIP = icsneoc2_chip_id_radproxima_mchip,
+	NewDevice57_ZCHIP = icsneoc2_chip_id_newdevice57_zchip,
+	RAD_GALAXY_2_ZMPCHIP_ID = icsneoc2_chip_id_rad_galaxy_2_zmpchip_id,
+	NewDevice59_MCHIP = icsneoc2_chip_id_newdevice59_mchip,
+	RADMoon2_Z7010_ZYNQ = icsneoc2_chip_id_radmoon2_z7010_zynq,
+	neoVIFIRE2_Core_SG4 = icsneoc2_chip_id_neovifire2_core_sg4,
+	RADBMS_MCHIP = icsneoc2_chip_id_radbms_mchip,
+	RADMoon2_ZL_MCHIP = icsneoc2_chip_id_radmoon2_zl_mchip,
+	RADGigastar_USBZ_Z7010_ZYNQ = icsneoc2_chip_id_radgigastar_usbz_z7010_zynq,
+	neoVIFIRE3_LINUX = icsneoc2_chip_id_neovifire3_linux,
+	RADGigastar_USBZ_Z7007S_ZYNQ = icsneoc2_chip_id_radgigastar_usbz_z7007s_zynq,
+	VEM_01_8DW_ZCHIP = icsneoc2_chip_id_vem_01_8dw_zchip,
+	RADGalaxy_FFG_Zynq = icsneoc2_chip_id_radgalaxy_ffg_zynq,
+	RADMoon3_MCHIP = icsneoc2_chip_id_radmoon3_mchip,
+	RADComet2_ZYNQ = icsneoc2_chip_id_radcomet2_zynq,
+	VEM_02_FR_ZCHIP = icsneoc2_chip_id_vem_02_fr_zchip,
+	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,
+	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,
+	SFPModule_88q3244_MCHIP = icsneoc2_chip_id_sfpmodule_88q3244_mchip,
+	RADCOMET3_ZCHIP = icsneoc2_chip_id_radcomet3_zchip,
+	Connect_LINUX = icsneoc2_chip_id_connect_linux,
+	SFPModule_lan8670_MCHIP = icsneoc2_chip_id_sfpmodule_lan8670_mchip,
+	VEM_04_T1S_LIN_ZCHIP = icsneoc2_chip_id_vem_04_t1s_lin_zchip,
+	RADMOONT1S_ZCHIP = icsneoc2_chip_id_radmoont1s_zchip,
+	RADGigastar2_ZYNQ = icsneoc2_chip_id_radgigastar2_zynq,
+	SFPModule_ent11100_MCHIP = icsneoc2_chip_id_sfpmodule_ent11100_mchip,
+	RADGemini_MCHIP = icsneoc2_chip_id_radgemini_mchip,
+	Invalid = icsneoc2_chip_id_invalid
 };
 
 }

include/icsneo/device/device.h

@@ -59,6 +59,7 @@
 #include "icsneo/communication/message/versionmessage.h"
 #include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
+#include "icsneo/communication/message/allmacaddressesmessage.h"
 
 #define ICSNEO_FINDABLE_DEVICE_BASE(className, type) \
 	static constexpr DeviceType::Enum DEVICE_TYPE = type; \
@@ -133,7 +134,7 @@ public:
 		SFPModule_88q2112 = 41,
 		RADGalaxy2 = 47,
 		RADMoon3 = 49,
-		RADComet = 50,
+		RADComet2 = 50,
 		Connect = 51,
 		SFPModule_88q2221m = 52,
 		SFPModule_88q4364 = 53,
@@ -183,7 +184,7 @@ public:
 	std::string getSerial() const { return data.serial; }
 	uint32_t getSerialNumber() const { return Device::SerialStringToNum(getSerial()); }
 	std::optional<std::vector<uint8_t>> getPCBSerial();
-	std::optional<std::vector<uint8_t>> getMACAddress();
+	std::unordered_map<Network::NetID, MACAddress> getMACAddresses();
 	const neodevice_t& getNeoDevice() const { return data; }
 	virtual std::string getProductName() const { return getType().getGenericProductName(); }
 	std::string describe() const;
@@ -858,7 +859,7 @@ public:
 	}
 
 	virtual bool supportsTC10() const { return false; }
-	
+
 	virtual bool supportsGPTP() const { return false; }
 
 	bool requestTC10Wake(Network::NetID network);
@@ -998,6 +999,8 @@ protected:
 
 	bool supportsNetworkMutex = false;
 
+	virtual bool supportsGetAllMACAddresses() const { return true; }
+
 private:
 	neodevice_t data;
 	std::shared_ptr<ResetStatusMessage> latestResetStatus;

include/icsneo/device/devicetype.h

@@ -53,7 +53,7 @@ public:
 		RADEpsilonXL = icsneoc2_devicetype_rad_epsilon_xl,
 		RADGalaxy2 = icsneoc2_devicetype_rad_galaxy2,
 		RADMoon3 = icsneoc2_devicetype_rad_moon3,
-		RADComet = icsneoc2_devicetype_rad_comet,
+		RADComet2 = icsneoc2_devicetype_rad_comet2,
 		FIRE3_FlexRay = icsneoc2_devicetype_fire3_flexray,
 		Connect = icsneoc2_devicetype_connect,
 		RADComet3 = icsneoc2_devicetype_rad_comet3,
@@ -154,8 +154,8 @@ public:
 				return "RAD-Moon 3";
 			case RADGemini:
 				return "RAD-Gemini";
-			case RADComet:
-				return "RAD-Comet";
+			case RADComet2:
+				return "RAD-Comet 2";
 			case RED:
 				return "neoVI RED";
 			case ECU:
@@ -269,7 +269,7 @@ private:
 #define ICSNEO_DEVICETYPE_RADEPSILONXL ((devicetype_t)icsneoc2_devicetype_rad_epsilon_xl)
 #define ICSNEO_DEVICETYPE_RADGALAXY2 ((devicetype_t)icsneoc2_devicetype_rad_galaxy2)
 #define ICSNEO_DEVICETYPE_RADMoon3 ((devicetype_t)icsneoc2_devicetype_rad_moon3)
-#define ICSNEO_DEVICETYPE_RADCOMET ((devicetype_t)icsneoc2_devicetype_rad_comet)
+#define ICSNEO_DEVICETYPE_RADCOMET2 ((devicetype_t)icsneoc2_devicetype_rad_comet2)
 #define ICSNEO_DEVICETYPE_FIRE3FLEXRAY ((devicetype_t)icsneoc2_devicetype_fire3_flexray)
 #define ICSNEO_DEVICETYPE_CONNECT ((devicetype_t)icsneoc2_devicetype_connect)
 #define ICSNEO_DEVICETYPE_RADCOMET3 ((devicetype_t)icsneoc2_devicetype_rad_comet3)

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

@@ -62,6 +62,9 @@ protected:
 		return true;
 	}
 
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/neoobd2pro/neoobd2pro.h

@@ -26,6 +26,11 @@ public:
 		return ProductID::neoOBD2Pro;
 	}
 
+protected:
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
+
 private:
 	NeoOBD2PRO(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize(makeDriver);

include/icsneo/device/tree/neoobd2sim/neoobd2sim.h

@@ -25,6 +25,12 @@ public:
 	ProductID getProductID() const override {
 		return ProductID::neoOBD2Sim;
 	}
+
+protected:
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
+	
 private:
 	NeoOBD2SIM(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize(makeDriver);

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

@@ -93,7 +93,6 @@ protected:
 	}
 
 	bool supportsGPTP() const override { return true; }
-	
 	size_t getDiskCount() const override {
 		return 2;
 	}

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

@@ -60,6 +60,12 @@ public:
 	ProductID getProductID() const override {
 		return ProductID::neoVIFIRE;
 	}
+
+protected:
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
+	
 private:
 	NeoVIFIRE(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIFIRESettings>(makeDriver);

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

@@ -109,7 +109,7 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool supportsWiVI() const override { return true; }
-	
+
 	bool supportsLiveData() const override { return true; }
 
 	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {

include/icsneo/device/tree/plasion/plasion.h

@@ -92,6 +92,10 @@ protected:
 	}
 
 	bool supportsWiVI() const override { return true; }
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/radcomet/radcomet.h

@@ -1,34 +0,0 @@
-#ifndef __RADCOMET_H_
-#define __RADCOMET_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/device/tree/radcomet/radcometbase.h"
-#include "icsneo/device/tree/radcomet/radcometsettings.h"
-
-namespace icsneo {
-
-class RADComet : public RADCometBase {
-public:
-
-	// Serial numbers start with RC
-	// USB PID is 0x1207, standard driver is DXX
-	// Ethernet MAC allocation is 0x1D, standard driver is Raw
-	ICSNEO_FINDABLE_DEVICE_BY_SERIAL_RANGE(RADComet, DeviceType::RADComet, "RC0000", "RC0299");
-
-	std::string getProductName() const override {
-		return "RAD-Comet";
-	}
-
-protected:
-	RADComet(neodevice_t neodevice, const driver_factory_t& makeDriver) : RADCometBase(neodevice) {
-		initialize<RADCometSettings>(makeDriver);
-	}
-
-};
-
-}
-
-#endif // __cplusplus
-
-#endif

include/icsneo/device/tree/radcomet/radcomet2.h

@@ -1,45 +0,0 @@
-#ifndef __RADCOMET2_H_
-#define __RADCOMET2_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/device/tree/radcomet/radcometbase.h"
-#include "icsneo/device/tree/radcomet/radcometsettings.h"
-
-namespace icsneo {
-
-class RADComet2 : public RADCometBase {
-public:
-
-	// Serial numbers start with RC, Comet2 starts at RC0300
-	// USB PID is 0x1207, standard driver is DXX
-	// Ethernet MAC allocation is 0x1D, standard driver is Raw
-	ICSNEO_FINDABLE_DEVICE_BY_SERIAL_RANGE(RADComet2, DeviceType::RADComet, "RC0300", "RCZZZZ");
-
-	std::string getProductName() const override {
-		return "RAD-Comet 2";
-	}
-
-	const std::vector<Network>& GetSupportedNetworks() override {
-		static std::vector<Network> supportedNetworks = RADCometBase::GetSupportedNetworks();
-		supportedNetworks.push_back(Network::NetID::AE_03);
-		supportedNetworks.push_back(Network::NetID::MDIO_04);
-		supportedNetworks.push_back(Network::NetID::LIN_01);
-		supportedNetworks.push_back(Network::NetID::ISO9141_01);
-		return supportedNetworks;
-	}
-
-	bool supportsTC10() const override { return true; }
-
-protected:
-	RADComet2(neodevice_t neodevice, const driver_factory_t& makeDriver) : RADCometBase(neodevice) {
-		initialize<RADCometSettings>(makeDriver);
-	}
-
-};
-
-}
-
-#endif // __cplusplus
-
-#endif

include/icsneo/device/tree/radcomet2/radcomet2.h

@@ -1,16 +1,23 @@
-#ifndef __RADCOMETBASE_H_
-#define __RADCOMETBASE_H_
+#ifndef __RADCOMET2_H_
+#define __RADCOMET2_H_
 
 #ifdef __cplusplus
 
 #include "icsneo/device/device.h"
 #include "icsneo/device/devicetype.h"
+#include "icsneo/device/tree/radcomet2/radcomet2settings.h"
 
 namespace icsneo {
 
-class RADCometBase : public Device {
+class RADComet2 : public Device {
 public:
-	virtual const std::vector<Network>& GetSupportedNetworks() {
+
+	// Serial numbers start with RC
+	// USB PID is 0x1207, standard driver is DXX
+	// Ethernet MAC allocation is 0x1D, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE_BY_SERIAL_RANGE(RADComet2, DeviceType::RADComet2, "RC0300", "RCZZZZ");
+
+	static const std::vector<Network>& GetSupportedNetworks() {
 		static std::vector<Network> supportedNetworks = {
 			Network::NetID::DWCAN_01,
 			Network::NetID::DWCAN_02,
@@ -19,39 +26,51 @@ public:
 
 			Network::NetID::AE_01,
 			Network::NetID::AE_02,
+			Network::NetID::AE_03,
 
 			Network::NetID::MDIO_01,
 			Network::NetID::MDIO_02,
 			Network::NetID::MDIO_03,
+			Network::NetID::MDIO_04,
+
+			Network::NetID::LIN_01,
+			Network::NetID::ISO9141_01,
 		};
 		return supportedNetworks;
 	}
 
+	std::string getProductName() const override {
+		return "RAD-Comet 2";
+	}
+
 	bool getEthPhyRegControlSupported() const override { return true; }
+	bool supportsTC10() const override { return true; }
 	bool supportsGPTP() const override { return true; }
 
 	ProductID getProductID() const override {
-		return ProductID::RADComet;
+		return ProductID::RADComet2;
 	}
 
 	const std::vector<ChipInfo>& getChipInfo() const override {
 		static std::vector<ChipInfo> chips = {
-			{ChipID::RADComet_ZYNQ, true, "ZCHIP", "RADComet_SW_bin", 0, FirmwareType::Zip},
+			{ChipID::RADComet2_ZYNQ, true, "ZCHIP", "RADComet_SW_bin", 0, FirmwareType::Zip},
 		};
 		return chips;
 	}
 
-	BootloaderPipeline getBootloader() override { 
+	BootloaderPipeline getBootloader() override {
 		return BootloaderPipeline()
 			.add<EnterBootloaderPhase>()
-			.add<FlashPhase>(ChipID::RADComet_ZYNQ, BootloaderCommunication::RAD)
-			.add<EnterApplicationPhase>(ChipID::RADComet_ZYNQ)
+			.add<FlashPhase>(ChipID::RADComet2_ZYNQ, BootloaderCommunication::RAD)
+			.add<EnterApplicationPhase>(ChipID::RADComet2_ZYNQ)
 			.add<WaitPhase>(std::chrono::milliseconds(3000))
 			.add<ReconnectPhase>();
 	}
 
 protected:
-	using Device::Device;
+	RADComet2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		initialize<RADComet2Settings>(makeDriver);
+	}
 
 	void setupPacketizer(Packetizer& packetizer) override {
 		Device::setupPacketizer(packetizer);
@@ -61,13 +80,13 @@ protected:
 
 	void setupEncoder(Encoder& encoder) override {
 		Device::setupEncoder(encoder);
-		encoder.supportCANFD = true;		
+		encoder.supportCANFD = true;
 		encoder.supportEthPhy = true;
 	}
 
 	void setupDecoder(Decoder& decoder) override {
 		Device::setupDecoder(decoder);
-		decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns
+		decoder.timestampResolution = 10;
 	}
 
 	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
@@ -75,7 +94,6 @@ protected:
 			rxNetworks.emplace_back(netid);
 	}
 
-	// The supported TX networks are the same as the supported RX networks for this device
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
@@ -88,4 +106,4 @@ protected:
 
 #endif // __cplusplus
 
-#endif
+#endif

include/icsneo/device/tree/radcomet2/radcomet2settings.h

@@ -1,5 +1,5 @@
-#ifndef __RADCOMETSETTINGS_H_
-#define __RADCOMETSETTINGS_H_
+#ifndef __RADCOMET2SETTINGS_H_
+#define __RADCOMET2SETTINGS_H_
 
 #include <stdint.h>
 #include "icsneo/device/idevicesettings.h"
@@ -74,7 +74,7 @@ typedef struct {
 	// 10T1S Extended settings
 	ETHERNET10T1S_SETTINGS_EXT t1s1Ext;
 	ETHERNET10T1S_SETTINGS_EXT t1s2Ext;
-} radcomet_settings_t;
+} radcomet2_settings_t;
 #pragma pack(pop)
 
 #ifdef _MSC_VER
@@ -83,15 +83,15 @@ typedef struct {
 
 #ifdef __cplusplus
 
-static_assert(sizeof(radcomet_settings_t) == 498, "RADComet settings size mismatch");
+static_assert(sizeof(radcomet2_settings_t) == 498, "RADComet2 settings size mismatch");
 
 #include <iostream>
 
-class RADCometSettings : public IDeviceSettings {
+class RADComet2Settings : public IDeviceSettings {
 public:
-	RADCometSettings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(radcomet_settings_t)) {}
+	RADComet2Settings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(radcomet2_settings_t)) {}
 	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
-		auto cfg = getStructurePointer<radcomet_settings_t>();
+		auto cfg = getStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
 		switch(net.getNetID()) {
@@ -104,7 +104,7 @@ public:
 		}
 	}
 	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
-		auto cfg = getStructurePointer<radcomet_settings_t>();
+		auto cfg = getStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
 		switch(net.getNetID()) {
@@ -246,7 +246,7 @@ public:
 
 private:
 	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
-		auto cfg = getStructurePointer<radcomet_settings_t>();
+		auto cfg = getStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
 		
@@ -260,7 +260,7 @@ private:
 	}
 
 	ETHERNET10T1S_SETTINGS* getMutableT1SSettingsFor(Network net) {
-		auto cfg = getMutableStructurePointer<radcomet_settings_t>();
+		auto cfg = getMutableStructurePointer<radcomet2_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
 		

include/icsneo/device/tree/radepsilon/radepsilon.h

@@ -79,6 +79,10 @@ protected:
 	size_t getDiskCount() const override {
 		return 1;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/radepsilonxl/radepsilonxl.h

@@ -85,6 +85,10 @@ protected:
 	size_t getDiskCount() const override {
 		return 1;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }; // namespace icsneo

include/icsneo/device/tree/radjupiter/radjupiter.h

@@ -80,6 +80,10 @@ protected:
 	bool supportsEraseMemory() const override {
 		return true;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/radmoonduo/radmoonduo.h

@@ -60,6 +60,10 @@ protected:
 	bool supportsEraseMemory() const override {
 		return true;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/radstar2/radstar2.h

@@ -71,6 +71,10 @@ protected:
 	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
 		return 0;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/valuecan3/valuecan3.h

@@ -25,6 +25,11 @@ public:
 	ProductID getProductID() const override {
 		return ProductID::ValueCAN3;
 	}
+
+protected:
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 private:
 	ValueCAN3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<ValueCAN3Settings>(makeDriver);

include/icsneo/device/tree/valuecan4/valuecan4.h

@@ -28,6 +28,10 @@ protected:
 	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
 		return 0;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/device/tree/vividcan/vividcan.h

@@ -68,6 +68,10 @@ protected:
 	bool supportsEraseMemory() const override {
 		return true;
 	}
+
+	bool supportsGetAllMACAddresses() const override {
+		return false;
+	}
 };
 
 }

include/icsneo/icsnVC40.h

@@ -223,7 +223,7 @@ typedef unsigned __int64 uint64_t;
 #define NEODEVICE_RAD_GALAXY_2 (0x00000021)
 #define NEODEVICE_RAD_BMS (0x00000022)
 #define NEODEVICE_RADMOON3 (0x00000023)
-#define NEODEVICE_RADCOMET (0x00000024)
+#define NEODEVICE_RADCOMET2 (0x00000024)
 #define NEODEVICE_FIRE3_FLEXRAY (0x00000025)
 #define NEODEVICE_RED2_OEM (0x00000026)
 #define NEODEVICE_RADCOMET3 (0x00000027)

include/icsneo/icsneoc2.h

@@ -19,6 +19,8 @@ typedef struct icsneoc2_message_t icsneoc2_message_t;
 
 typedef struct icsneoc2_event_t icsneoc2_event_t;
 
+typedef struct icsneoc2_supported_device_t icsneoc2_supported_device_t;
+
 typedef enum _icsneoc2_error_t {
 	icsneoc2_error_success, // Function was successful
 	icsneoc2_error_invalid_parameters, // Invalid parameters, typically because of a NULL reference.
@@ -65,6 +67,44 @@ static const icsneoc2_open_options_t icsneoc2_open_options_default =
  */
 icsneoc2_error_t icsneoc2_error_code_get(icsneoc2_error_t error_code, char* value, size_t* value_length);
 
+/**
+ * Enumerate supported device types.
+ * 
+ * @param[out] supported_devices Pointer to receive the head of the supported device types linked list. Must be freed with icsneoc2_supported_devices_free().
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_supported_devices_enumerate(icsneoc2_supported_device_t** supported_devices);
+
+/**
+ * Free a supported device types list returned by icsneoc2_supported_devices_enumerate().
+ *
+ * @param[in] supported_devices The head of the supported device types linked list to free.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_supported_devices_free(icsneoc2_supported_device_t* supported_devices);
+
+/**
+ * Advance to the next supported device type in a list.
+ *
+ * @param[in] supported_device The current supported device type node.
+ *
+ * @return The next supported device type node, or NULL at the end of the list.
+ */
+
+icsneoc2_supported_device_t* icsneoc2_supported_devices_next(const icsneoc2_supported_device_t* supported_device);
+
+/**
+ * Get the device type from a supported device node.
+ * 
+ * @param[in] supported_device The supported device node.
+ * @param[out] device_type Pointer to receive the device type.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_supported_device_get(const icsneoc2_supported_device_t* supported_device, icsneoc2_devicetype_t* device_type);
+
 /**
  * Get the device type string for a icsneoc2_devicetype_t.
  *
@@ -303,15 +343,52 @@ icsneoc2_error_t icsneoc2_device_serial_get(const icsneoc2_device_t* device, cha
 icsneoc2_error_t icsneoc2_device_pcb_serial_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length);
 
 /**
- * Get the MAC address of a device.
+ * Enumerate MAC addresses from a device.
  *
- * @param[in] device The device to get the MAC address of.
- * @param[out] value Pointer to a buffer to copy the MAC address into. If NULL, only value_length is written.
- * @param[in,out] value_length Size of the value buffer in bytes. Modified with the length of the MAC address.
+ * @param[in] device The device to query.
+ * @param[out] mac_entries Pointer to receive the head of the MAC addresses linked list.
  *
- * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if the device does not have a MAC address.
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters on failure.
  */
-icsneoc2_error_t icsneoc2_device_mac_address_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length);
+icsneoc2_error_t icsneoc2_device_mac_addresses_enumerate(const icsneoc2_device_t* device, icsneoc2_mac_addr_entry_t** mac_entries);
+
+/**
+ * Get the network ID of a MAC address.
+ * 
+ * @param[in] mac_address The MAC address object to get the network ID of.
+ * @param[out] network_id Pointer to an icsneoc2_netid_t to copy the network ID into.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error success if successful, icsneoc2_error_invalid_parameters on failure.
+ */
+icsneoc2_error_t icsneoc2_mac_network_id_get(const icsneoc2_mac_addr_entry_t* mac_address, _icsneoc2_netid_t* network_id);
+
+/**
+ * Get the MAC Address bytes of a MAC address.
+ * 
+ * @param[in] mac_address The MAC address object to get the MAC address bytes of.
+ * @param[out] value Pointer to a buffer to copy the MAC address into. If NULL, only value_length is written.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters on failure.
+ */
+icsneoc2_error_t icsneoc2_mac_address_get(const icsneoc2_mac_addr_entry_t* mac_address, uint8_t* value, size_t* value_length);
+
+/**
+ * Advance to the next MAC address in an enumeration list.
+ * 
+ * @param[in] mac_address The current MAC address node.
+ * 
+ * @return icsneoc2_mac_addr_entry_t The next MAC address node.
+ */
+icsneoc2_mac_addr_entry_t* icsneoc2_mac_addresses_next(const icsneoc2_mac_addr_entry_t* mac_address);
+
+/**
+ * Free all MAC addresses in enumeration handle returned by icsneoc2_device_mac_addresses_enumerate().
+ *
+ * @param[in] mac_address The head of the MAC address enumeration to free. May be NULL.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_mac_addresses_free(icsneoc2_mac_addr_entry_t* mac_address);
 
 /**
  * Set the online state of a device.
@@ -993,6 +1070,50 @@ icsneoc2_error_t icsneoc2_script_status_diagnostic_error_code_count_get(const ic
  */
 icsneoc2_error_t icsneoc2_script_status_max_coremini_size_kb_get(const icsneoc2_script_status_t* script_status, uint16_t* value);
 
+/**
+ * Get the list of chip versions on the device.
+ * 
+ * @param[in] device The device to query.
+ * @param[out] chip_versions Receives a newly allocated chip versions handle. The caller owns this handle and must free it with icsneoc2_chip_versions_free() when done.
+ * @param[in] refresh Whether to refresh the chip versions from the device.
+ * @param[out] count Receives the number of chip versions. May be NULL if not needed.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_device_chip_versions_enumerate(const icsneoc2_device_t* device, icsneoc2_chip_versions_t** chip_versions, bool refresh, size_t* count);
+
+/**
+ * Free a chip versions handle returned by icsneoc2_device_chip_versions_enumerate().
+ *
+ * @param[in] chip_versions The chip versions handle to free. May be NULL.
+ */
+icsneoc2_error_t icsneoc2_chip_versions_free(icsneoc2_chip_versions_t* chip_versions);
+
+/**
+ * Advance to the next chip version in an enumeration list.
+ *
+ * @param[in] chip_versions The current chip versions handle.
+ *
+ * @return The next chip version handle, or NULL at the end of the list.
+ */
+icsneoc2_chip_versions_t* icsneoc2_chip_versions_next(const icsneoc2_chip_versions_t* chip_versions);
+
+/**
+ * Get the properties of a chip version.
+ *
+ * @param[in] chip_versions The chip versions handle to query.
+ * @param[out] name Pointer to a buffer to copy the null-terminated chip name into. May be NULL if the name is not needed.
+ * @param[in,out] name_length On input, the size of the name buffer. On output, the length of the chip name. May be NULL if the name is not needed.
+ * @param[out] major Pointer to receive the major version number. May be NULL.
+ * @param[out] minor Pointer to receive the minor version number. May be NULL.
+ * @param[out] maintenance Pointer to receive the maintenance version number. May be NULL.
+ * @param[out] build Pointer to receive the build version number. May be NULL.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_string_copy_failed otherwise.
+ */
+icsneoc2_error_t icsneoc2_chip_versions_props_get(const icsneoc2_chip_versions_t* chip_versions, char* name, size_t* name_length, uint8_t* major, uint8_t* minor, uint8_t* maintenance, uint8_t* build);
+
+
 #ifdef __cplusplus
 }
 #endif

include/icsneo/icsneoc2messages.h

@@ -118,9 +118,33 @@ icsneoc2_error_t icsneoc2_message_data_set(icsneoc2_message_t* message, uint8_t*
  *
  * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
  */
-icsneoc2_error_t icsneoc2_message_data_get(icsneoc2_message_t* message, uint8_t* data, size_t* data_length);
-
-#define ICSNEOC2_MESSAGE_CAN_FLAGS_RTR 0x01         // Remote Transmission Request
+icsneoc2_error_t icsneoc2_message_data_get(icsneoc2_message_t* message, uint8_t* data, size_t* data_length);
+
+/**
+ * Set the timestamp of a message.
+ *
+ * Timestamps are in nanoseconds since 2007-01-01 UTC.
+ *
+ * @param[in] message The message to modify.
+ * @param[in] timestamp The timestamp value to set.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_message otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_timestamp_set(icsneoc2_message_t* message, uint64_t timestamp);
+
+/**
+ * Get the timestamp of a message.
+ *
+ * Timestamps are in nanoseconds since 2007-01-01 UTC.
+ *
+ * @param[in] message The message to check.
+ * @param[out] timestamp Pointer to a uint64_t to copy the timestamp into.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_message otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_timestamp_get(icsneoc2_message_t* message, uint64_t* timestamp);
+
+#define ICSNEOC2_MESSAGE_CAN_FLAGS_RTR 0x01         // Remote Transmission Request
 #define ICSNEOC2_MESSAGE_CAN_FLAGS_IDE 0x02         // Identifier Extension
 #define ICSNEOC2_MESSAGE_CAN_FLAGS_FDF 0x04         // FD Format Indicator
 #define ICSNEOC2_MESSAGE_CAN_FLAGS_BRS 0x08         // Bit Rate Switch (FD only)

include/icsneo/icsneoc2types.h

@@ -43,7 +43,7 @@ typedef enum _icsneoc2_devicetype_t {
 	icsneoc2_devicetype_rad_epsilon_xl = 0x0000001e,
 	icsneoc2_devicetype_rad_galaxy2 = 0x00000021,
 	icsneoc2_devicetype_rad_moon3 = 0x00000023,
-	icsneoc2_devicetype_rad_comet = 0x00000024,
+	icsneoc2_devicetype_rad_comet2 = 0x00000024,
 	icsneoc2_devicetype_fire3_flexray = 0x00000025,
 	icsneoc2_devicetype_connect = 0x00000026,
 	icsneoc2_devicetype_rad_comet3 = 0x00000027,
@@ -444,6 +444,147 @@ typedef enum _icsneoc2_tc10_sleep_status_t {
 
 typedef uint8_t icsneoc2_tc10_sleep_status_t;
 
+typedef struct icsneoc2_chip_versions_t icsneoc2_chip_versions_t;
+
+typedef enum _icsneoc2_chip_id_t {
+	icsneoc2_chip_id_neovifire_mchip = 0,
+	icsneoc2_chip_id_neovifire_lchip = 1,
+	icsneoc2_chip_id_neovifire_uchip = 2,
+	icsneoc2_chip_id_neovifire_jchip = 3,
+	icsneoc2_chip_id_valuecan3_mchip = 4,
+	icsneoc2_chip_id_neoviecu_mpic = 6,
+	icsneoc2_chip_id_neoviievb_mpic = 7,
+	icsneoc2_chip_id_neovipendant_mpic = 8,
+	icsneoc2_chip_id_neovifire_vnet_mchip = 9,
+	icsneoc2_chip_id_neovifire_vnet_lchip = 10,
+	icsneoc2_chip_id_neoviplasma_core = 11,
+	icsneoc2_chip_id_neoviplasma_hid = 12,
+	icsneoc2_chip_id_neovianalog_mpic = 13,
+	icsneoc2_chip_id_neoviplasma_analog_core = 14,
+	icsneoc2_chip_id_neoviplasma_flexray_core = 15,
+	icsneoc2_chip_id_neoviplasma_core_1_12 = 16,
+	icsneoc2_chip_id_neovifire_slave_vnet_mchip = 17,
+	icsneoc2_chip_id_neovifire_slave_vnet_lchip = 18,
+	icsneoc2_chip_id_neoviion_core = 19,
+	icsneoc2_chip_id_neoviion_hid = 20,
+	icsneoc2_chip_id_neoviion_core_loader = 21,
+	icsneoc2_chip_id_neoviion_hid_loader = 22,
+	icsneoc2_chip_id_neoviion_fpga_bit = 23,
+	icsneoc2_chip_id_neovifire_vnet_ep_mchip = 24,
+	icsneoc2_chip_id_neovifire_vnet_ep_lchip = 25,
+	icsneoc2_chip_id_neovianalogout_mchip = 26,
+	icsneoc2_chip_id_neovimost25_mchip = 27,
+	icsneoc2_chip_id_neovimost50_mchip = 28,
+	icsneoc2_chip_id_neovimost150_mchip = 29,
+	icsneoc2_chip_id_valuecan4_4_mchip = 30,
+	icsneoc2_chip_id_valuecan4_4_schip = 31,
+	icsneoc2_chip_id_cmprobe_zynq = 33,
+	icsneoc2_chip_id_eevb_stm32 = 34,
+	icsneoc2_chip_id_neovifire_slave_vnet_ep_mchip = 35,
+	icsneoc2_chip_id_neovifire_slave_vnet_ep_lchip = 36,
+	icsneoc2_chip_id_radstar_mchip = 37,
+	icsneoc2_chip_id_valuecanrf_mchip = 38,
+	icsneoc2_chip_id_neovifire2_mchip = 39,
+	icsneoc2_chip_id_neovifire2_cchip = 40,
+	icsneoc2_chip_id_neovifire2_core = 41,
+	icsneoc2_chip_id_neovifire2_blechip = 42,
+	icsneoc2_chip_id_neovifire2_zynq = 43, // FIRE2 MVNET Z - Zynq
+	icsneoc2_chip_id_neovifire2_securitychip = 44,
+	icsneoc2_chip_id_radgalaxy_zynq = 45,
+	icsneoc2_chip_id_neovifire2_vnet_mchip = 46,
+	icsneoc2_chip_id_neovifire2_slave_vnet_a_mchip = 47,
+	icsneoc2_chip_id_neovifire2_slave_vnet_a_cchip = 48,
+	icsneoc2_chip_id_neovifire2_vnet_cchip = 49,
+	icsneoc2_chip_id_neovifire2_vnet_core = 50,
+	icsneoc2_chip_id_radstar2_zynq = 51,
+	icsneoc2_chip_id_vividcan_mchip = 52,
+	icsneoc2_chip_id_neoobd2sim_mchip = 53,
+	icsneoc2_chip_id_neovifire2_vnetz_mchip = 54,
+	icsneoc2_chip_id_neovifire2_vnetz_zynq = 55,
+	icsneoc2_chip_id_neovifire2_slave_vnetz_a_mchip = 56,
+	icsneoc2_chip_id_neovifire2_slave_vnetz_a_zynq = 57,
+	icsneoc2_chip_id_vividcan_ext_flash = 58,
+	icsneoc2_chip_id_vividcan_nrf52 = 59,
+	icsneoc2_chip_id_cmprobe_zynq_unused = 60, // Double defined
+	icsneoc2_chip_id_neoobd2pro_mchip = 61,
+	icsneoc2_chip_id_valuecan4_1_mchip = 62,
+	icsneoc2_chip_id_valuecan4_2_mchip = 63,
+	icsneoc2_chip_id_valuecan4_4_2el_core = 64,
+	icsneoc2_chip_id_neoobd2pro_schip = 65,
+	icsneoc2_chip_id_valuecan4_2el_mchip = 67,
+	icsneoc2_chip_id_neoecuavbtsn_mchip = 68,
+	icsneoc2_chip_id_neoobd2pro_core = 69,
+	icsneoc2_chip_id_radsupermoon_zynq = 70,
+	icsneoc2_chip_id_radmoon2_zynq = 71,
+	icsneoc2_chip_id_vividcanpro_mchip = 72,
+	icsneoc2_chip_id_vividcanpro_ext_flash = 73,
+	icsneoc2_chip_id_radpluto_mchip = 74,
+	icsneoc2_chip_id_radmars_zynq = 75,
+	icsneoc2_chip_id_neoecu12_mchip = 76,
+	icsneoc2_chip_id_radiocanhub_mchip = 77,
+	icsneoc2_chip_id_flexray_vnetz_zchip = 78,
+	icsneoc2_chip_id_neoobd2_lcbadge_mchip = 79,
+	icsneoc2_chip_id_neoobd2_lcbadge_schip = 80,
+	icsneoc2_chip_id_radmoonduo_mchip = 81,
+	icsneoc2_chip_id_neovifire3_zchip = 82,
+	icsneoc2_chip_id_flexray_vnetz_fchip = 83,
+	icsneoc2_chip_id_radjupiter_mchip = 84,
+	icsneoc2_chip_id_valuecan4industrial_mchip = 85,
+	icsneoc2_chip_id_etherbadge_mchip = 86,
+	icsneoc2_chip_id_radmars_3_zynq = 87,
+	icsneoc2_chip_id_radgigastar_usbz_zynq = 88,
+	icsneoc2_chip_id_radgigastar_zynq = 89,
+	icsneoc2_chip_id_rad4g_mchip = 90,
+	icsneoc2_chip_id_neovifire3_schip = 91,
+	icsneoc2_chip_id_radepsilon_mchip = 92,
+	icsneoc2_chip_id_rada2b_zchip = 93,
+	icsneoc2_chip_id_neoobd2dev_mchip = 94,
+	icsneoc2_chip_id_neoobd2dev_schip = 95,
+	icsneoc2_chip_id_neoobd2simdoip_mchip = 96,
+	icsneoc2_chip_id_sfpmodule_88q2112_mchip = 97,
+	icsneoc2_chip_id_radepsilont_mchip = 98,
+	icsneoc2_chip_id_radepsilonexpress_mchip = 99,
+	icsneoc2_chip_id_radproxima_mchip = 100,
+	icsneoc2_chip_id_newdevice57_zchip = 101,
+	icsneoc2_chip_id_rad_galaxy_2_zmpchip_id = 102,
+	icsneoc2_chip_id_newdevice59_mchip = 103,
+	icsneoc2_chip_id_radmoon2_z7010_zynq = 104,
+	icsneoc2_chip_id_neovifire2_core_sg4 = 105,
+	icsneoc2_chip_id_radbms_mchip = 106,
+	icsneoc2_chip_id_radmoon2_zl_mchip = 107,
+	icsneoc2_chip_id_radgigastar_usbz_z7010_zynq = 108,
+	icsneoc2_chip_id_neovifire3_linux = 109,
+	icsneoc2_chip_id_radgigastar_usbz_z7007s_zynq = 110,
+	icsneoc2_chip_id_vem_01_8dw_zchip = 111,
+	icsneoc2_chip_id_radgalaxy_ffg_zynq = 112,
+	icsneoc2_chip_id_radmoon3_mchip = 113,
+	icsneoc2_chip_id_radcomet2_zynq = 114,
+	icsneoc2_chip_id_vem_02_fr_zchip = 115,
+	icsneoc2_chip_id_rada2b_revb_zchip = 116,
+	icsneoc2_chip_id_radgigastar_ffg_zynq = 117,
+	icsneoc2_chip_id_vem_02_fr_fchip = 118,
+	icsneoc2_chip_id_connect_zchip = 121,
+	icsneoc2_chip_id_sfpmodule_88q2221_mchip = 122,
+	icsneoc2_chip_id_radgalaxy2_sysmon_chip = 123,
+	icsneoc2_chip_id_sfpmodule_88q3244_mchip = 124,
+	icsneoc2_chip_id_radcomet3_zchip = 125,
+	icsneoc2_chip_id_connect_linux = 126,
+	icsneoc2_chip_id_sfpmodule_lan8670_mchip = 127,
+	icsneoc2_chip_id_vem_04_t1s_lin_zchip = 129,
+	icsneoc2_chip_id_radmoont1s_zchip = 130,
+	icsneoc2_chip_id_radgigastar2_zynq = 131,
+	icsneoc2_chip_id_sfpmodule_ent11100_mchip = 132,
+	icsneoc2_chip_id_radgemini_mchip = 135,
+	icsneoc2_chip_id_maxsize, // Must be last entry, Don't use as a chip ID.
+
+	// Used for unknown or invalid chip ID
+	icsneoc2_chip_id_invalid = 255
+} _icsneoc2_chip_id_t;
+
+typedef uint8_t icsneoc2_chip_id_t;
+
+typedef struct icsneoc2_mac_addr_entry_t icsneoc2_mac_addr_entry_t;
+
 #ifdef __cplusplus
 }
 #endif

include/icsneo/platform/posix/devices.h

@@ -14,8 +14,7 @@
 #include "icsneo/device/tree/plasion/neoviion.h"
 #include "icsneo/device/tree/plasion/neoviplasma.h"
 #include "icsneo/device/tree/rada2b/rada2b.h"
-#include "icsneo/device/tree/radcomet/radcomet.h"
-#include "icsneo/device/tree/radcomet/radcomet2.h"
+#include "icsneo/device/tree/radcomet2/radcomet2.h"
 #include "icsneo/device/tree/radcomet3/radcomet3.h"
 #include "icsneo/device/tree/radmoont1s/radmoont1s.h"
 #include "icsneo/device/tree/radepsilon/radepsilon.h"

include/icsneo/platform/windows/devices.h

@@ -14,8 +14,7 @@
 #include "icsneo/device/tree/plasion/neoviion.h"
 #include "icsneo/device/tree/plasion/neoviplasma.h"
 #include "icsneo/device/tree/rada2b/rada2b.h"
-#include "icsneo/device/tree/radcomet/radcomet.h"
-#include "icsneo/device/tree/radcomet/radcomet2.h"
+#include "icsneo/device/tree/radcomet2/radcomet2.h"
 #include "icsneo/device/tree/radcomet3/radcomet3.h"
 #include "icsneo/device/tree/radmoont1s/radmoont1s.h"
 #include "icsneo/device/tree/radepsilon/radepsilon.h"

platform/dxx.cpp

@@ -31,7 +31,7 @@ void DXX::Find(std::vector<FoundDevice>& found) {
 		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1203 } }, // RAD-Gigalog
 		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1204 } }, // RAD-Gigastar
 		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1206 } }, // RAD-A2B Rev B
-		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1207 } }, // RAD-Comet
+		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1207 } }, // RAD-Comet2
 		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1208 } }, // RAD-Comet3
 		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1209 } }, // RAD-MoonT1S
 		{ LIBREDXX_DEVICE_TYPE_D3XX, { ICS_USB_VID, 0x1210 } }, // RAD-Gigastar 2

platform/posix/darwin/cdcacmdarwin.cpp

@@ -108,8 +108,9 @@ void CDCACM::Find(std::vector<FoundDevice>& found) {
 			releasers.emplace_back(parent);
 			current = parent;
 			// On old macOSes, IOUSBDevice is the type of the class we want
-			// On newer macOSes, IOUSBDevice may further be subclassed as IOUSBHostDevice
-			if(IOObjectConformsTo(parent, kIOUSBDeviceClassName)) {
+			// On macOS 12+, IOUSBHostDevice is the main USB device class (separate hierarchy from IOUSBDevice)
+			if(IOObjectConformsTo(parent, kIOUSBDeviceClassName) ||
+			   IOObjectConformsTo(parent, "IOUSBHostDevice")) {
 				usb = parent;
 				break;
 			}

pyproject.toml

@@ -51,4 +51,4 @@ CMAKE_MSVC_RUNTIME_LIBRARY = "MultiThreaded"
 
 [tool.cibuildwheel]
 skip = "pp*"
-environment-pass = ["ICS_IPA_CA_CRT", "LIBICSNEO_ICSPB_REPO"]
+environment-pass = ["ICS_IPA_CA_CRT", "LIBICSNEO_ICSPB_REPO", "SKBUILD_CMAKE_DEFINE"]

test/unit/icsneoc2.cpp

@@ -3,7 +3,9 @@
 #include <icsneo/icsneoc2settings.h>
 #include <icsneo/icsneoc2messages.h>
 #include "../../api/icsneoc2/icsneoc2_internal.h"
+#include <icsneo/device/devicefinder.h>
 #include <icsneo/device/devicetype.h>
+#include <icsneo/device/chipid.h>
 #include <icsneo/communication/message/linmessage.h>
 #include <icsneo/communication/message/canmessage.h>
 #include <icsneo/communication/message/canerrormessage.h>
@@ -89,6 +91,34 @@ TEST(icsneoc2, test_icsneoc2_device_enumerate)
 	icsneoc2_enumeration_free(devices);
 }
 
+TEST(icsneoc2, test_icsneoc2_supported_devices_enumerate)
+{
+	icsneoc2_supported_device_t* supported_devices = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_supported_devices_enumerate(&supported_devices));
+	ASSERT_NE(nullptr, supported_devices);
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_supported_device_get(supported_devices, nullptr));
+
+	const auto& expected_devices = icsneo::DeviceFinder::GetSupportedDevices();
+	size_t count = 0;
+	for(icsneoc2_supported_device_t* cur = supported_devices; cur != nullptr; cur = icsneoc2_supported_devices_next(cur)) {
+		ASSERT_LT(count, expected_devices.size());
+
+		icsneoc2_devicetype_t device_type = 0;
+		ASSERT_EQ(icsneoc2_error_success, icsneoc2_supported_device_get(cur, &device_type));
+		ASSERT_EQ(static_cast<icsneoc2_devicetype_t>(expected_devices[count].getDeviceType()), device_type);
+
+		char name[ICSNEO_DEVICETYPE_LONGEST_NAME] = {0};
+		size_t name_len = sizeof(name);
+		ASSERT_EQ(icsneoc2_error_success, icsneoc2_device_type_name_get(device_type, name, &name_len));
+		ASSERT_STREQ(icsneo::DeviceType::GetGenericProductName(expected_devices[count].getDeviceType()), name);
+
+		count++;
+	}
+
+	ASSERT_EQ(expected_devices.size(), count);
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_supported_devices_free(supported_devices));
+}
+
 TEST(icsneoc2, test_icsneoc2_device_is_valid)
 {
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_valid(NULL));
@@ -112,6 +142,10 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 
 	// All of these don't have a device parameter
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_enumerate(0, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_supported_devices_enumerate(NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_supported_devices_free(NULL));
+	ASSERT_EQ(nullptr, icsneoc2_supported_devices_next(NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_supported_device_get(NULL, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_network_type_name_get(0, NULL, NULL));
 
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_event_description_get(eventPlaceHolder, placeholderStr, &placeholderSizeT));
@@ -127,6 +161,8 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_data_get(NULL, NULL, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_data_set(NULL, NULL, 0));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_timestamp_get(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_timestamp_set(NULL, 0));
 
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_netid_get(NULL, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_netid_set(NULL, 0));
@@ -178,7 +214,10 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_rtc_set(NULL, 0));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_serial_get(NULL, placeholderStr, &placeholderSizeT));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_pcb_serial_get(NULL, &placeholderInteger8, &placeholderSizeT));
-	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_mac_address_get(NULL, &placeholderInteger8, &placeholderSizeT));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_mac_addresses_enumerate(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_mac_network_id_get(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_mac_address_get(NULL, &placeholderInteger8, &placeholderSizeT));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_mac_addresses_free(NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_supports_tc10(NULL, &placeholderBool));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_tc10_wake_request(NULL, icsneoc2_netid_dwcan_01));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_tc10_sleep_request(NULL, icsneoc2_netid_dwcan_01));
@@ -367,7 +406,7 @@ TEST(icsneoc2, test_icsneoc2_devicetype_t)
 	ASSERT_EQ(icsneoc2_devicetype_rad_epsilon_xl, 0x0000001e);
 	ASSERT_EQ(icsneoc2_devicetype_rad_galaxy2, 0x00000021);
 	ASSERT_EQ(icsneoc2_devicetype_rad_moon3, 0x00000023);
-	ASSERT_EQ(icsneoc2_devicetype_rad_comet, 0x00000024);
+	ASSERT_EQ(icsneoc2_devicetype_rad_comet2, 0x00000024);
 	ASSERT_EQ(icsneoc2_devicetype_fire3_flexray, 0x00000025);
 	ASSERT_EQ(icsneoc2_devicetype_connect, 0x00000026);
 	ASSERT_EQ(icsneoc2_devicetype_rad_comet3, 0x00000027);
@@ -430,7 +469,7 @@ TEST(icsneoc2, test_devicetype_enum_alignment)
 	ASSERT_EQ(icsneo::DeviceType::RADEpsilon, icsneoc2_devicetype_rad_epsilon);
 	ASSERT_EQ(icsneo::DeviceType::RADEpsilonXL, icsneoc2_devicetype_rad_epsilon_xl);
 	ASSERT_EQ(icsneo::DeviceType::RADMoon3, icsneoc2_devicetype_rad_moon3);
-	ASSERT_EQ(icsneo::DeviceType::RADComet, icsneoc2_devicetype_rad_comet);
+	ASSERT_EQ(icsneo::DeviceType::RADComet2, icsneoc2_devicetype_rad_comet2);
 	ASSERT_EQ(icsneo::DeviceType::FIRE3_FlexRay, icsneoc2_devicetype_fire3_flexray);
 	ASSERT_EQ(icsneo::DeviceType::Connect, icsneoc2_devicetype_connect);
 	ASSERT_EQ(icsneo::DeviceType::RADComet3, icsneoc2_devicetype_rad_comet3);
@@ -713,6 +752,360 @@ TEST(icsneoc2, test_icsneoc2_netid_t)
 	ASSERT_EQ(icsneoc2_netid_maxsize, 571);
 }
 
+TEST(icsneoc2, test_icsneoc2_chip_id_t)
+{
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_mchip, 0);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_lchip, 1);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_uchip, 2);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_jchip, 3);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan3_mchip, 4);
+	ASSERT_EQ(icsneoc2_chip_id_neoviecu_mpic, 6);
+	ASSERT_EQ(icsneoc2_chip_id_neoviievb_mpic, 7);
+	ASSERT_EQ(icsneoc2_chip_id_neovipendant_mpic, 8);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_vnet_mchip, 9);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_vnet_lchip, 10);
+	ASSERT_EQ(icsneoc2_chip_id_neoviplasma_core, 11);
+	ASSERT_EQ(icsneoc2_chip_id_neoviplasma_hid, 12);
+	ASSERT_EQ(icsneoc2_chip_id_neovianalog_mpic, 13);
+	ASSERT_EQ(icsneoc2_chip_id_neoviplasma_analog_core, 14);
+	ASSERT_EQ(icsneoc2_chip_id_neoviplasma_flexray_core, 15);
+	ASSERT_EQ(icsneoc2_chip_id_neoviplasma_core_1_12, 16);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_slave_vnet_mchip, 17);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_slave_vnet_lchip, 18);
+	ASSERT_EQ(icsneoc2_chip_id_neoviion_core, 19);
+	ASSERT_EQ(icsneoc2_chip_id_neoviion_hid, 20);
+	ASSERT_EQ(icsneoc2_chip_id_neoviion_core_loader, 21);
+	ASSERT_EQ(icsneoc2_chip_id_neoviion_hid_loader, 22);
+	ASSERT_EQ(icsneoc2_chip_id_neoviion_fpga_bit, 23);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_vnet_ep_mchip, 24);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_vnet_ep_lchip, 25);
+	ASSERT_EQ(icsneoc2_chip_id_neovianalogout_mchip, 26);
+	ASSERT_EQ(icsneoc2_chip_id_neovimost25_mchip, 27);
+	ASSERT_EQ(icsneoc2_chip_id_neovimost50_mchip, 28);
+	ASSERT_EQ(icsneoc2_chip_id_neovimost150_mchip, 29);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4_4_mchip, 30);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4_4_schip, 31);
+	ASSERT_EQ(icsneoc2_chip_id_cmprobe_zynq, 33);
+	ASSERT_EQ(icsneoc2_chip_id_eevb_stm32, 34);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_slave_vnet_ep_mchip, 35);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire_slave_vnet_ep_lchip, 36);
+	ASSERT_EQ(icsneoc2_chip_id_radstar_mchip, 37);
+	ASSERT_EQ(icsneoc2_chip_id_valuecanrf_mchip, 38);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_mchip, 39);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_cchip, 40);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_core, 41);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_blechip, 42);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_zynq, 43);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_securitychip, 44);
+	ASSERT_EQ(icsneoc2_chip_id_radgalaxy_zynq, 45);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_vnet_mchip, 46);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_slave_vnet_a_mchip, 47);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_slave_vnet_a_cchip, 48);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_vnet_cchip, 49);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_vnet_core, 50);
+	ASSERT_EQ(icsneoc2_chip_id_radstar2_zynq, 51);
+	ASSERT_EQ(icsneoc2_chip_id_vividcan_mchip, 52);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2sim_mchip, 53);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_vnetz_mchip, 54);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_vnetz_zynq, 55);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_slave_vnetz_a_mchip, 56);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_slave_vnetz_a_zynq, 57);
+	ASSERT_EQ(icsneoc2_chip_id_vividcan_ext_flash, 58);
+	ASSERT_EQ(icsneoc2_chip_id_vividcan_nrf52, 59);
+	ASSERT_EQ(icsneoc2_chip_id_cmprobe_zynq_unused, 60);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2pro_mchip, 61);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4_1_mchip, 62);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4_2_mchip, 63);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4_4_2el_core, 64);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2pro_schip, 65);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4_2el_mchip, 67);
+	ASSERT_EQ(icsneoc2_chip_id_neoecuavbtsn_mchip, 68);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2pro_core, 69);
+	ASSERT_EQ(icsneoc2_chip_id_radsupermoon_zynq, 70);
+	ASSERT_EQ(icsneoc2_chip_id_radmoon2_zynq, 71);
+	ASSERT_EQ(icsneoc2_chip_id_vividcanpro_mchip, 72);
+	ASSERT_EQ(icsneoc2_chip_id_vividcanpro_ext_flash, 73);
+	ASSERT_EQ(icsneoc2_chip_id_radpluto_mchip, 74);
+	ASSERT_EQ(icsneoc2_chip_id_radmars_zynq, 75);
+	ASSERT_EQ(icsneoc2_chip_id_neoecu12_mchip, 76);
+	ASSERT_EQ(icsneoc2_chip_id_radiocanhub_mchip, 77);
+	ASSERT_EQ(icsneoc2_chip_id_flexray_vnetz_zchip, 78);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2_lcbadge_mchip, 79);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2_lcbadge_schip, 80);
+	ASSERT_EQ(icsneoc2_chip_id_radmoonduo_mchip, 81);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire3_zchip, 82);
+	ASSERT_EQ(icsneoc2_chip_id_flexray_vnetz_fchip, 83);
+	ASSERT_EQ(icsneoc2_chip_id_radjupiter_mchip, 84);
+	ASSERT_EQ(icsneoc2_chip_id_valuecan4industrial_mchip, 85);
+	ASSERT_EQ(icsneoc2_chip_id_etherbadge_mchip, 86);
+	ASSERT_EQ(icsneoc2_chip_id_radmars_3_zynq, 87);
+	ASSERT_EQ(icsneoc2_chip_id_radgigastar_usbz_zynq, 88);
+	ASSERT_EQ(icsneoc2_chip_id_radgigastar_zynq, 89);
+	ASSERT_EQ(icsneoc2_chip_id_rad4g_mchip, 90);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire3_schip, 91);
+	ASSERT_EQ(icsneoc2_chip_id_radepsilon_mchip, 92);
+	ASSERT_EQ(icsneoc2_chip_id_rada2b_zchip, 93);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2dev_mchip, 94);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2dev_schip, 95);
+	ASSERT_EQ(icsneoc2_chip_id_neoobd2simdoip_mchip, 96);
+	ASSERT_EQ(icsneoc2_chip_id_sfpmodule_88q2112_mchip, 97);
+	ASSERT_EQ(icsneoc2_chip_id_radepsilont_mchip, 98);
+	ASSERT_EQ(icsneoc2_chip_id_radepsilonexpress_mchip, 99);
+	ASSERT_EQ(icsneoc2_chip_id_radproxima_mchip, 100);
+	ASSERT_EQ(icsneoc2_chip_id_newdevice57_zchip, 101);
+	ASSERT_EQ(icsneoc2_chip_id_rad_galaxy_2_zmpchip_id, 102);
+	ASSERT_EQ(icsneoc2_chip_id_newdevice59_mchip, 103);
+	ASSERT_EQ(icsneoc2_chip_id_radmoon2_z7010_zynq, 104);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire2_core_sg4, 105);
+	ASSERT_EQ(icsneoc2_chip_id_radbms_mchip, 106);
+	ASSERT_EQ(icsneoc2_chip_id_radmoon2_zl_mchip, 107);
+	ASSERT_EQ(icsneoc2_chip_id_radgigastar_usbz_z7010_zynq, 108);
+	ASSERT_EQ(icsneoc2_chip_id_neovifire3_linux, 109);
+	ASSERT_EQ(icsneoc2_chip_id_radgigastar_usbz_z7007s_zynq, 110);
+	ASSERT_EQ(icsneoc2_chip_id_vem_01_8dw_zchip, 111);
+	ASSERT_EQ(icsneoc2_chip_id_radgalaxy_ffg_zynq, 112);
+	ASSERT_EQ(icsneoc2_chip_id_radmoon3_mchip, 113);
+	ASSERT_EQ(icsneoc2_chip_id_radcomet2_zynq, 114);
+	ASSERT_EQ(icsneoc2_chip_id_vem_02_fr_zchip, 115);
+	ASSERT_EQ(icsneoc2_chip_id_rada2b_revb_zchip, 116);
+	ASSERT_EQ(icsneoc2_chip_id_radgigastar_ffg_zynq, 117);
+	ASSERT_EQ(icsneoc2_chip_id_vem_02_fr_fchip, 118);
+	ASSERT_EQ(icsneoc2_chip_id_connect_zchip, 121);
+	ASSERT_EQ(icsneoc2_chip_id_sfpmodule_88q2221_mchip, 122);
+	ASSERT_EQ(icsneoc2_chip_id_radgalaxy2_sysmon_chip, 123);
+	ASSERT_EQ(icsneoc2_chip_id_sfpmodule_88q3244_mchip, 124);
+	ASSERT_EQ(icsneoc2_chip_id_radcomet3_zchip, 125);
+	ASSERT_EQ(icsneoc2_chip_id_connect_linux, 126);
+	ASSERT_EQ(icsneoc2_chip_id_sfpmodule_lan8670_mchip, 127);
+	ASSERT_EQ(icsneoc2_chip_id_vem_04_t1s_lin_zchip, 129);
+	ASSERT_EQ(icsneoc2_chip_id_radmoont1s_zchip, 130);
+	ASSERT_EQ(icsneoc2_chip_id_radgigastar2_zynq, 131);
+	ASSERT_EQ(icsneoc2_chip_id_sfpmodule_ent11100_mchip, 132);
+	ASSERT_EQ(icsneoc2_chip_id_radgemini_mchip, 135);
+	ASSERT_EQ(icsneoc2_chip_id_maxsize, 136);
+	
+	ASSERT_EQ(icsneoc2_chip_id_invalid, 255);
+
+	ASSERT_EQ(sizeof(icsneoc2_chip_id_t), sizeof(uint8_t));
+}
+
+TEST(icsneoc2, test_chip_id_enum_alignment)
+{
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_MCHIP), icsneoc2_chip_id_neovifire_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_LCHIP), icsneoc2_chip_id_neovifire_lchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_UCHIP), icsneoc2_chip_id_neovifire_uchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_JCHIP), icsneoc2_chip_id_neovifire_jchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN3_MCHIP), icsneoc2_chip_id_valuecan3_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIECU_MPIC), icsneoc2_chip_id_neoviecu_mpic);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIIEVB_MPIC), icsneoc2_chip_id_neoviievb_mpic);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIPENDANT_MPIC), icsneoc2_chip_id_neovipendant_mpic);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_VNET_MCHIP), icsneoc2_chip_id_neovifire_vnet_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_VNET_LCHIP), icsneoc2_chip_id_neovifire_vnet_lchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIPLASMA_Core), icsneoc2_chip_id_neoviplasma_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIPLASMA_HID), icsneoc2_chip_id_neoviplasma_hid);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIANALOG_MPIC), icsneoc2_chip_id_neovianalog_mpic);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIPLASMA_ANALOG_Core), icsneoc2_chip_id_neoviplasma_analog_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIPLASMA_FlexRay_Core), icsneoc2_chip_id_neoviplasma_flexray_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIPLASMA_Core_1_12), icsneoc2_chip_id_neoviplasma_core_1_12);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_Slave_VNET_MCHIP), icsneoc2_chip_id_neovifire_slave_vnet_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_Slave_VNET_LCHIP), icsneoc2_chip_id_neovifire_slave_vnet_lchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIION_Core), icsneoc2_chip_id_neoviion_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIION_HID), icsneoc2_chip_id_neoviion_hid);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIION_Core_Loader), icsneoc2_chip_id_neoviion_core_loader);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIION_HID_Loader), icsneoc2_chip_id_neoviion_hid_loader);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIION_FPGA_BIT), icsneoc2_chip_id_neoviion_fpga_bit);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_VNET_EP_MCHIP), icsneoc2_chip_id_neovifire_vnet_ep_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_VNET_EP_LCHIP), icsneoc2_chip_id_neovifire_vnet_ep_lchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIAnalogOut_MCHIP), icsneoc2_chip_id_neovianalogout_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIMOST25_MCHIP), icsneoc2_chip_id_neovimost25_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIMOST50_MCHIP), icsneoc2_chip_id_neovimost50_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIMOST150_MCHIP), icsneoc2_chip_id_neovimost150_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4_4_MCHIP), icsneoc2_chip_id_valuecan4_4_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4_4_SCHIP), icsneoc2_chip_id_valuecan4_4_schip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::cmProbe_ZYNQ), icsneoc2_chip_id_cmprobe_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::EEVB_STM32), icsneoc2_chip_id_eevb_stm32);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_Slave_VNET_EP_MCHIP), icsneoc2_chip_id_neovifire_slave_vnet_ep_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE_Slave_VNET_EP_LCHIP), icsneoc2_chip_id_neovifire_slave_vnet_ep_lchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADStar_MCHIP), icsneoc2_chip_id_radstar_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCANrf_MCHIP), icsneoc2_chip_id_valuecanrf_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_MCHIP), icsneoc2_chip_id_neovifire2_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_CCHIP), icsneoc2_chip_id_neovifire2_cchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_Core), icsneoc2_chip_id_neovifire2_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_BLECHIP), icsneoc2_chip_id_neovifire2_blechip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_ZYNQ), icsneoc2_chip_id_neovifire2_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_SECURITYCHIP), icsneoc2_chip_id_neovifire2_securitychip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGalaxy_ZYNQ), icsneoc2_chip_id_radgalaxy_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_VNET_MCHIP), icsneoc2_chip_id_neovifire2_vnet_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_Slave_VNET_A_MCHIP), icsneoc2_chip_id_neovifire2_slave_vnet_a_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_Slave_VNET_A_CCHIP), icsneoc2_chip_id_neovifire2_slave_vnet_a_cchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_VNET_CCHIP), icsneoc2_chip_id_neovifire2_vnet_cchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_VNET_Core), icsneoc2_chip_id_neovifire2_vnet_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADStar2_ZYNQ), icsneoc2_chip_id_radstar2_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VividCAN_MCHIP), icsneoc2_chip_id_vividcan_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2SIM_MCHIP), icsneoc2_chip_id_neoobd2sim_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_VNETZ_MCHIP), icsneoc2_chip_id_neovifire2_vnetz_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_VNETZ_ZYNQ), icsneoc2_chip_id_neovifire2_vnetz_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_Slave_VNETZ_A_MCHIP), icsneoc2_chip_id_neovifire2_slave_vnetz_a_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_Slave_VNETZ_A_ZYNQ), icsneoc2_chip_id_neovifire2_slave_vnetz_a_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VividCAN_EXT_FLASH), icsneoc2_chip_id_vividcan_ext_flash);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VividCAN_NRF52), icsneoc2_chip_id_vividcan_nrf52);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::cmProbe_ZYNQ_Unused), icsneoc2_chip_id_cmprobe_zynq_unused);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2PRO_MCHIP), icsneoc2_chip_id_neoobd2pro_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4_1_MCHIP), icsneoc2_chip_id_valuecan4_1_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4_2_MCHIP), icsneoc2_chip_id_valuecan4_2_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4_4_2EL_Core), icsneoc2_chip_id_valuecan4_4_2el_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2PRO_SCHIP), icsneoc2_chip_id_neoobd2pro_schip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4_2EL_MCHIP), icsneoc2_chip_id_valuecan4_2el_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoECUAVBTSN_MCHIP), icsneoc2_chip_id_neoecuavbtsn_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2PRO_Core), icsneoc2_chip_id_neoobd2pro_core);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADSupermoon_ZYNQ), icsneoc2_chip_id_radsupermoon_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMoon2_ZYNQ), icsneoc2_chip_id_radmoon2_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VividCANPRO_MCHIP), icsneoc2_chip_id_vividcanpro_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VividCANPRO_EXT_FLASH), icsneoc2_chip_id_vividcanpro_ext_flash);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADPluto_MCHIP), icsneoc2_chip_id_radpluto_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMars_ZYNQ), icsneoc2_chip_id_radmars_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoECU12_MCHIP), icsneoc2_chip_id_neoecu12_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADIOCANHUB_MCHIP), icsneoc2_chip_id_radiocanhub_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::FlexRay_VNETZ_ZCHIP), icsneoc2_chip_id_flexray_vnetz_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2_LCBADGE_MCHIP), icsneoc2_chip_id_neoobd2_lcbadge_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2_LCBADGE_SCHIP), icsneoc2_chip_id_neoobd2_lcbadge_schip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMoonDuo_MCHIP), icsneoc2_chip_id_radmoonduo_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE3_ZCHIP), icsneoc2_chip_id_neovifire3_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::FlexRay_VNETZ_FCHIP), icsneoc2_chip_id_flexray_vnetz_fchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADJupiter_MCHIP), icsneoc2_chip_id_radjupiter_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::ValueCAN4Industrial_MCHIP), icsneoc2_chip_id_valuecan4industrial_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::EtherBADGE_MCHIP), icsneoc2_chip_id_etherbadge_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMars_3_ZYNQ), icsneoc2_chip_id_radmars_3_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGigastar_USBZ_ZYNQ), icsneoc2_chip_id_radgigastar_usbz_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGigastar_ZYNQ), icsneoc2_chip_id_radgigastar_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RAD4G_MCHIP), icsneoc2_chip_id_rad4g_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE3_SCHIP), icsneoc2_chip_id_neovifire3_schip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADEpsilon_MCHIP), icsneoc2_chip_id_radepsilon_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADA2B_ZCHIP), icsneoc2_chip_id_rada2b_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2Dev_MCHIP), icsneoc2_chip_id_neoobd2dev_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2Dev_SCHIP), icsneoc2_chip_id_neoobd2dev_schip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoOBD2SIMDoIP_MCHIP), icsneoc2_chip_id_neoobd2simdoip_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::SFPModule_88q2112_MCHIP), icsneoc2_chip_id_sfpmodule_88q2112_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADEpsilonT_MCHIP), icsneoc2_chip_id_radepsilont_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADEpsilonExpress_MCHIP), icsneoc2_chip_id_radepsilonexpress_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADProxima_MCHIP), icsneoc2_chip_id_radproxima_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::NewDevice57_ZCHIP), icsneoc2_chip_id_newdevice57_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RAD_GALAXY_2_ZMPCHIP_ID), icsneoc2_chip_id_rad_galaxy_2_zmpchip_id);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::NewDevice59_MCHIP), icsneoc2_chip_id_newdevice59_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMoon2_Z7010_ZYNQ), icsneoc2_chip_id_radmoon2_z7010_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE2_Core_SG4), icsneoc2_chip_id_neovifire2_core_sg4);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADBMS_MCHIP), icsneoc2_chip_id_radbms_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMoon2_ZL_MCHIP), icsneoc2_chip_id_radmoon2_zl_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGigastar_USBZ_Z7010_ZYNQ), icsneoc2_chip_id_radgigastar_usbz_z7010_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::neoVIFIRE3_LINUX), icsneoc2_chip_id_neovifire3_linux);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGigastar_USBZ_Z7007S_ZYNQ), icsneoc2_chip_id_radgigastar_usbz_z7007s_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VEM_01_8DW_ZCHIP), icsneoc2_chip_id_vem_01_8dw_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGalaxy_FFG_Zynq), icsneoc2_chip_id_radgalaxy_ffg_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMoon3_MCHIP), icsneoc2_chip_id_radmoon3_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADComet2_ZYNQ), icsneoc2_chip_id_radcomet2_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VEM_02_FR_ZCHIP), icsneoc2_chip_id_vem_02_fr_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADA2B_REVB_ZCHIP), icsneoc2_chip_id_rada2b_revb_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGigastar_FFG_ZYNQ), icsneoc2_chip_id_radgigastar_ffg_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VEM_02_FR_FCHIP), icsneoc2_chip_id_vem_02_fr_fchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::Connect_ZCHIP), icsneoc2_chip_id_connect_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::SFPModule_88q2221_MCHIP), icsneoc2_chip_id_sfpmodule_88q2221_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGALAXY2_SYSMON_CHIP), icsneoc2_chip_id_radgalaxy2_sysmon_chip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::SFPModule_88q3244_MCHIP), icsneoc2_chip_id_sfpmodule_88q3244_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADCOMET3_ZCHIP), icsneoc2_chip_id_radcomet3_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::Connect_LINUX), icsneoc2_chip_id_connect_linux);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::SFPModule_lan8670_MCHIP), icsneoc2_chip_id_sfpmodule_lan8670_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::VEM_04_T1S_LIN_ZCHIP), icsneoc2_chip_id_vem_04_t1s_lin_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADMOONT1S_ZCHIP), icsneoc2_chip_id_radmoont1s_zchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGigastar2_ZYNQ), icsneoc2_chip_id_radgigastar2_zynq);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::SFPModule_ent11100_MCHIP), icsneoc2_chip_id_sfpmodule_ent11100_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::RADGemini_MCHIP), icsneoc2_chip_id_radgemini_mchip);
+	ASSERT_EQ(static_cast<icsneoc2_chip_id_t>(icsneo::ChipID::Invalid), icsneoc2_chip_id_invalid);
+}
+
+TEST(icsneoc2, test_icsneoc2_chip_versions_invalid_parameters)
+{
+	size_t count = 0;
+	icsneoc2_chip_versions_t* chip_versions = nullptr;
+
+	// enumerate: NULL device
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_chip_versions_enumerate(NULL, &chip_versions, false, &count));
+
+	// props_get: NULL handle
+	uint8_t major = 0, minor = 0, maintenance = 0, build = 0;
+	char name[32] = {0};
+	size_t name_length = sizeof(name);
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_chip_versions_props_get(NULL, name, &name_length, &major, &minor, &maintenance, &build));
+
+	// free: NULL handle
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_chip_versions_free(NULL));
+
+	// next: NULL handle returns NULL
+	ASSERT_EQ(nullptr, icsneoc2_chip_versions_next(NULL));
+}
+
+TEST(icsneoc2, test_icsneoc2_chip_versions_props_get)
+{
+	// Build an in-memory list of two chip_versions nodes
+	icsneoc2_chip_versions_t second{};
+	second.version_report.id = icsneo::ChipID::RADGemini_MCHIP;
+	second.version_report.name = "second";
+	second.version_report.major = 9;
+	second.version_report.minor = 8;
+	second.version_report.maintenance = 7;
+	second.version_report.build = 6;
+	second.next = nullptr;
+
+	icsneoc2_chip_versions_t first{};
+	first.version_report.id = icsneo::ChipID::neoVIFIRE_MCHIP;
+	first.version_report.name = "first";
+	first.version_report.major = 1;
+	first.version_report.minor = 2;
+	first.version_report.maintenance = 3;
+	first.version_report.build = 4;
+	first.next = &second;
+
+	// next() walks the list
+	ASSERT_EQ(&second, icsneoc2_chip_versions_next(&first));
+	ASSERT_EQ(nullptr, icsneoc2_chip_versions_next(&second));
+
+	// props_get: full extraction
+	char name[32] = {0};
+	size_t name_length = sizeof(name);
+	uint8_t major = 0, minor = 0, maintenance = 0, build = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_chip_versions_props_get(&first, name, &name_length, &major, &minor, &maintenance, &build));
+	ASSERT_STREQ(name, "first");
+	ASSERT_EQ(name_length, 5u);
+	ASSERT_EQ(major, 1);
+	ASSERT_EQ(minor, 2);
+	ASSERT_EQ(maintenance, 3);
+	ASSERT_EQ(build, 4);
+
+	// props_get: all output pointers optional (NULL allowed)
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_chip_versions_props_get(&second, NULL, NULL, NULL, NULL, NULL, NULL));
+
+	// props_get: only some output pointers
+	major = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_chip_versions_props_get(&second, NULL, NULL, &major, NULL, NULL, NULL));
+	ASSERT_EQ(major, 9);
+
+	// props_get: name buffer too small returns string_copy_failed
+	char tiny[2] = {0};
+	size_t tiny_length = sizeof(tiny);
+	ASSERT_EQ(icsneoc2_error_string_copy_failed, icsneoc2_chip_versions_props_get(&first, tiny, &tiny_length, NULL, NULL, NULL, NULL));
+}
+
+TEST(icsneoc2, test_icsneoc2_chip_versions_free_list)
+{
+	// Allocate a two-node list the same way the API does, so free() walks and deletes it.
+	auto* head = new icsneoc2_chip_versions_t{};
+	head->version_report.name = "a";
+	head->next = new icsneoc2_chip_versions_t{};
+	head->next->version_report.name = "b";
+	head->next->next = nullptr;
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_chip_versions_free(head));
+}
+
 TEST(icsneoc2, test_icsneoc2_open_options_default)
 {
 	icsneoc2_open_options_t expected = ICSNEOC2_OPEN_OPTIONS_GO_ONLINE | ICSNEOC2_OPEN_OPTIONS_SYNC_RTC | ICSNEOC2_OPEN_OPTIONS_ENABLE_AUTO_UPDATE;
@@ -764,6 +1157,29 @@ TEST(icsneoc2, test_icsneoc2_message_can_props_get_can_tx_flags)
 		ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR);
 }
 
+TEST(icsneoc2, test_icsneoc2_message_timestamp_accessors)
+{
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&message));
+
+	uint64_t timestamp = 1;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_timestamp_get(message, &timestamp));
+	ASSERT_EQ(0u, timestamp);
+
+	const uint64_t expected_timestamp = 1234567890123ULL;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_timestamp_set(message, expected_timestamp));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_timestamp_get(message, &timestamp));
+	ASSERT_EQ(expected_timestamp, timestamp);
+
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_timestamp_get(message, nullptr));
+
+	icsneoc2_message_free(message);
+
+	icsneoc2_message_t invalid_message;
+	ASSERT_EQ(icsneoc2_error_invalid_message, icsneoc2_message_timestamp_set(&invalid_message, expected_timestamp));
+	ASSERT_EQ(icsneoc2_error_invalid_message, icsneoc2_message_timestamp_get(&invalid_message, &timestamp));
+}
+
 TEST(icsneoc2, test_icsneoc2_message_can_error_props_get_invalid_type_for_can_message)
 {
 	icsneoc2_message_t message;