Merge 31d4a750d8 into a68b64c641

.gitlab-ci.yml

@@ -119,30 +119,6 @@ unit_test windows/x86:
     - linux-build
   timeout: 5m
 
-build linux/ubuntu/2204/amd64/gcc:
-  <<: *build_linux_ubuntu_gcc
-  image: ubuntu:22.04
-
-unit_test linux/ubuntu/2204/amd64/gcc:
-  <<: *test_linux_ubuntu_gcc
-  image: ubuntu:22.04
-  dependencies:
-    - build linux/ubuntu/2204/amd64/gcc
-  needs:
-    - build linux/ubuntu/2204/amd64/gcc
-
-build linux/ubuntu/2204/amd64/clang:
-  <<: *build_linux_ubuntu_clang
-  image: ubuntu:22.04
-
-unit_test linux/ubuntu/2204/amd64/clang:
-  <<: *test_linux_ubuntu_clang
-  image: ubuntu:22.04
-  dependencies:
-    - build linux/ubuntu/2204/amd64/clang
-  needs:
-    - build linux/ubuntu/2204/amd64/clang
-
 build linux/ubuntu/2404/amd64/gcc:
   <<: *build_linux_ubuntu_gcc
   image: ubuntu:24.04
@@ -167,6 +143,30 @@ unit_test linux/ubuntu/2404/amd64/clang:
   needs:
     - build linux/ubuntu/2404/amd64/clang
 
+build linux/ubuntu/2604/amd64/gcc:
+  <<: *build_linux_ubuntu_gcc
+  image: ubuntu:26.04
+
+unit_test linux/ubuntu/2604/amd64/gcc:
+  <<: *test_linux_ubuntu_gcc
+  image: ubuntu:26.04
+  dependencies:
+    - build linux/ubuntu/2604/amd64/gcc
+  needs:
+    - build linux/ubuntu/2604/amd64/gcc
+
+build linux/ubuntu/2604/amd64/clang:
+  <<: *build_linux_ubuntu_clang
+  image: ubuntu:26.04
+
+unit_test linux/ubuntu/2604/amd64/clang:
+  <<: *test_linux_ubuntu_clang
+  image: ubuntu:26.04
+  dependencies:
+    - build linux/ubuntu/2604/amd64/clang
+  needs:
+    - build linux/ubuntu/2604/amd64/clang
+
 #-------------------------------------------------------------------------------
 # Fedora
 #-------------------------------------------------------------------------------
@@ -243,30 +243,6 @@ unit_test linux/ubuntu/2404/amd64/clang:
     - linux-build
   timeout: 5m
 
-build linux/fedora/42/amd64/gcc:
-  <<: *build_linux_fedora_gcc
-  image: fedora:42
-
-unit_test linux/fedora/42/amd64/gcc:
-  <<: *test_linux_fedora_gcc
-  image: fedora:42
-  dependencies:
-    - build linux/fedora/42/amd64/gcc
-  needs:
-    - build linux/fedora/42/amd64/gcc
-
-build linux/fedora/42/amd64/clang:
-  <<: *build_linux_fedora_clang
-  image: fedora:42
-
-unit_test linux/fedora/42/amd64/clang:
-  <<: *test_linux_fedora_clang
-  image: fedora:42
-  dependencies:
-    - build linux/fedora/42/amd64/clang
-  needs:
-    - build linux/fedora/42/amd64/clang
-
 build linux/fedora/43/amd64/gcc:
   <<: *build_linux_fedora_gcc
   image: fedora:43
@@ -291,6 +267,30 @@ unit_test linux/fedora/43/amd64/clang:
   needs:
     - build linux/fedora/43/amd64/clang
 
+build linux/fedora/44/amd64/gcc:
+  <<: *build_linux_fedora_gcc
+  image: fedora:44
+
+unit_test linux/fedora/44/amd64/gcc:
+  <<: *test_linux_fedora_gcc
+  image: fedora:44
+  dependencies:
+    - build linux/fedora/44/amd64/gcc
+  needs:
+    - build linux/fedora/44/amd64/gcc
+
+build linux/fedora/44/amd64/clang:
+  <<: *build_linux_fedora_clang
+  image: fedora:44
+
+unit_test linux/fedora/44/amd64/clang:
+  <<: *test_linux_fedora_clang
+  image: fedora:44
+  dependencies:
+    - build linux/fedora/44/amd64/clang
+  needs:
+    - build linux/fedora/44/amd64/clang
+
 #-------------------------------------------------------------------------------
 # Python Module
 #-------------------------------------------------------------------------------

api/icsneoc2/icsneoc2.cpp

@@ -43,7 +43,7 @@ bool safe_str_copy(char* dest, size_t* dest_size, std::string_view src) {
 }
 
 icsneoc2_error_t icsneoc2_error_code_get(icsneoc2_error_t error_code, char* value, size_t* value_length) {
-	static const char* error_strings[icsneoc2_error_maxsize] = {
+	static const char* error_strings[] = {
 		"Success",                          // icsneoc2_error_success
 		"Invalid function parameters",      // icsneoc2_error_invalid_parameters
 		"Open failed",                      // icsneoc2_error_open_failed
@@ -66,6 +66,9 @@ icsneoc2_error_t icsneoc2_error_code_get(icsneoc2_error_t error_code, char* valu
 		"Script clear failed",              // icsneoc2_error_script_clear_failed
 		"Script upload failed",             // icsneoc2_error_script_upload_failed
 		"Script load prepare failed",       // icsneoc2_error_script_load_prepare_failed
+		"Close failed",                     // icsneoc2_error_close_failed
+		"Reconnect failed",                 // icsneoc2_error_reconnect_failed
+		"Invalid data",                     // icsneoc2_error_invalid_data
 	};
 	static_assert(std::size(error_strings) == icsneoc2_error_maxsize,
 		"error_strings is out of sync with _icsneoc2_error_t enum - update both together");
@@ -194,37 +197,27 @@ icsneoc2_error_t icsneoc2_device_is_open(const icsneoc2_device_t* device, bool*
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_device_is_disconnected(const icsneoc2_device_t* device, bool* is_disconnected) {
-	auto res = icsneoc2_device_is_valid(device);
-	if(res != icsneoc2_error_success) {
-		return res;
-	}
-	if(!is_disconnected) {
+icsneoc2_error_t icsneoc2_device_create(const icsneoc2_device_info_t* device_info, icsneoc2_device_t** device) {
+	if(!device_info || !device_info->device || !device) {
 		return icsneoc2_error_invalid_parameters;
 	}
-	auto dev = device->device;
-	*is_disconnected = dev->isDisconnected();
-
+	auto* new_device = new (std::nothrow) icsneoc2_device_t;
+	if(!new_device) {
+		return icsneoc2_error_out_of_memory;
+	}
+	new_device->device = device_info->device;
+	*device = new_device;
 	return icsneoc2_error_success;
 }
 
-static icsneoc2_error_t open_device_with_options(std::shared_ptr<Device> dev, icsneoc2_open_options_t options, icsneoc2_device_t** device) {
+static icsneoc2_error_t open_device_with_options(std::shared_ptr<Device> dev, icsneoc2_open_options_t options) {
 	if(!dev) {
 		return icsneoc2_error_invalid_device;
 	}
-	// Nothing to do if already open
-	if(dev->isOpen()) {
-		*device = new (std::nothrow) icsneoc2_device_t;
-		if(!*device) {
-			return icsneoc2_error_out_of_memory;
-		}
-		(*device)->device = dev;
-		return icsneoc2_error_success;
-	}
 	if(!dev->enableMessagePolling(std::make_optional<MessageFilter>())) {
 		return icsneoc2_error_enable_message_polling_failed;
 	}
-	if(!dev->open()) {
+	if(!dev->isOpen() && !dev->open()) {
 		return icsneoc2_error_open_failed;
 	}
 	if((options & ICSNEOC2_OPEN_OPTIONS_SYNC_RTC) && !dev->setRTC(std::chrono::system_clock::now())) {
@@ -235,23 +228,15 @@ static icsneoc2_error_t open_device_with_options(std::shared_ptr<Device> dev, ic
 		dev->close();
 		return icsneoc2_error_go_online_failed;
 	}
-	*device = new (std::nothrow) icsneoc2_device_t;
-	if(!*device) {
-		dev->close();
-		return icsneoc2_error_out_of_memory;
-	}
-	(*device)->device = dev;
 	return icsneoc2_error_success;
 }
 
-icsneoc2_error_t icsneoc2_device_open(const icsneoc2_device_info_t* device_info, icsneoc2_open_options_t options, icsneoc2_device_t** device) {
-	if(!device_info || !device) {
-		return icsneoc2_error_invalid_parameters;
+icsneoc2_error_t icsneoc2_device_open(const icsneoc2_device_t* device, icsneoc2_open_options_t options) {
+	auto res = icsneoc2_device_is_valid(device);
+	if(res != icsneoc2_error_success) {
+		return res;
 	}
-	if(!device_info->device) {
-		return icsneoc2_error_invalid_device;
-	}
-	return open_device_with_options(device_info->device, options, device);
+	return open_device_with_options(device->device, options);
 }
 
 icsneoc2_error_t icsneoc2_device_open_serial(const char* serial, icsneoc2_open_options_t options, icsneoc2_device_t** device) {
@@ -266,7 +251,15 @@ 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) {
-			res = open_device_with_options(cur->device, options, device);
+			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) {
+				icsneoc2_device_free(*device);
+				*device = nullptr;
+			}
 			icsneoc2_enumeration_free(devs);
 			return res;
 		}
@@ -286,7 +279,15 @@ 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()) {
-			res = open_device_with_options(cur->device, options, device);
+			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) {
+				icsneoc2_device_free(*device);
+				*device = nullptr;
+			}
 			icsneoc2_enumeration_free(devs);
 			return res;
 		}
@@ -295,6 +296,34 @@ icsneoc2_error_t icsneoc2_device_open_first(icsneoc2_devicetype_t device_type, i
 	return icsneoc2_error_invalid_device;
 }
 
+icsneoc2_error_t icsneoc2_device_reconnect(icsneoc2_device_t* device, icsneoc2_open_options_t options, uint32_t timeout_ms) {
+	auto res = icsneoc2_device_is_valid(device);
+	if(res != icsneoc2_error_success) {
+		return res;
+	}
+	// If the device is currently open, close it first before trying to reconnect
+	if (device->device->isOpen()) {
+		res = icsneoc2_device_close(device);
+		if(res != icsneoc2_error_success) {
+			return res;
+		}
+	}
+	
+	const auto timeout = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
+	while(std::chrono::steady_clock::now() < timeout) {
+		icsneoc2_device_t* new_device = nullptr;
+		res = icsneoc2_device_open_serial(device->device->getSerial().c_str(), options, &new_device);
+		if(res == icsneoc2_error_success) {
+			device->device = new_device->device;
+			delete new_device;
+			return icsneoc2_error_success;
+		}
+		// Avoid busy looping
+		std::this_thread::sleep_for(std::chrono::milliseconds(100));
+	}
+	return icsneoc2_error_reconnect_failed;
+}
+
 icsneoc2_error_t icsneoc2_device_close(icsneoc2_device_t* device) {
 	auto res = icsneoc2_device_is_valid(device);
 	if(res != icsneoc2_error_success) {
@@ -304,7 +333,21 @@ icsneoc2_error_t icsneoc2_device_close(icsneoc2_device_t* device) {
 	if(!dev->isOpen()) {
 		return icsneoc2_error_success;
 	}
-	dev->close();
+	
+	return dev->close() ? icsneoc2_error_success : icsneoc2_error_close_failed;
+}
+
+icsneoc2_error_t icsneoc2_device_free(icsneoc2_device_t* device) {
+	auto res = icsneoc2_device_is_valid(device);
+	if(res != icsneoc2_error_success) {
+		return res;
+	}
+	if (device->device->isOpen()) {
+		res = icsneoc2_device_close(device);
+		if(res != icsneoc2_error_success) {
+			return res;
+		}
+	}
 	delete device;
 	return icsneoc2_error_success;
 }
@@ -339,6 +382,48 @@ icsneoc2_error_t icsneoc2_device_serial_get(const icsneoc2_device_t* device, cha
 	return safe_str_copy(value, value_length, dev->getSerial()) ? icsneoc2_error_success : icsneoc2_error_string_copy_failed;
 }
 
+icsneoc2_error_t icsneoc2_device_pcb_serial_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length) {
+	auto res = icsneoc2_device_is_valid(device);
+	if(res != icsneoc2_error_success) {
+		return res;
+	}
+	if(!value_length) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto pcbSerial = device->device->getPCBSerial();
+	if(!pcbSerial.has_value()) {
+		return icsneoc2_error_invalid_type;
+	}
+	const auto& data = *pcbSerial;
+	if(value) {
+		size_t copyLen = std::min(*value_length, data.size());
+		std::copy(data.begin(), data.begin() + copyLen, value);
+	}
+	*value_length = data.size();
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_device_mac_address_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length) {
+	auto res = icsneoc2_device_is_valid(device);
+	if(res != icsneoc2_error_success) {
+		return res;
+	}
+	if(!value_length) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto macAddress = device->device->getMACAddress();
+	if(!macAddress.has_value()) {
+		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);
+	}
+	*value_length = data.size();
+	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);

api/icsneoc2/icsneoc2messages.cpp

@@ -6,6 +6,7 @@
 #include "icsneo/icsneocpp.h"
 #include "icsneo/communication/message/message.h"
 #include "icsneo/communication/message/canmessage.h"
+#include "icsneo/communication/message/canerrormessage.h"
 #include "icsneo/communication/message/linmessage.h"
 #include "icsneo/communication/message/ethernetmessage.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -34,6 +35,19 @@ icsneoc2_error_t icsneoc2_message_is_transmit(icsneoc2_message_t* message, bool*
 	return icsneoc2_error_success;
 }
 
+icsneoc2_error_t icsneoc2_message_is_error(icsneoc2_message_t* message, bool* value) {
+	if(!message || !value) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto frame = std::dynamic_pointer_cast<Frame>(message->message);
+	if(!frame) {
+		return icsneoc2_error_invalid_type;
+	}
+	*value = frame->error;
+
+	return icsneoc2_error_success;
+}
+
 icsneoc2_error_t icsneoc2_message_netid_get(icsneoc2_message_t* message, icsneoc2_netid_t* netid) {
 	if(!message || !netid) {
 		return icsneoc2_error_invalid_parameters;
@@ -176,6 +190,15 @@ icsneoc2_error_t icsneoc2_message_can_props_get(icsneoc2_message_t* message, uin
 		if(can_msg->errorStateIndicator) {
 			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_ESI;
 		}
+		if(can_msg->txAborted) {
+			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED;
+		}
+		if(can_msg->txLostArb) {
+			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB;
+		}
+		if(can_msg->txError) {
+			*flags |= ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR;
+		}
 	}
 	return icsneoc2_error_success;
 }
@@ -214,5 +237,373 @@ icsneoc2_error_t icsneoc2_message_is_can(icsneoc2_message_t* message, bool* is_c
 	}
 	*is_can = std::dynamic_pointer_cast<CANMessage>(message->message) != nullptr;
 	return icsneoc2_error_success;
-
+}
+
+icsneoc2_error_t icsneoc2_message_is_can_error(icsneoc2_message_t* message, bool* is_can_error) {
+	if(!message || !is_can_error) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	*is_can_error = std::dynamic_pointer_cast<CANErrorMessage>(message->message) != nullptr;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_can_error_props_get(
+    icsneoc2_message_t *message, uint8_t *tx_err_count, uint8_t *rx_err_count,
+    icsneoc2_can_error_code_t *error_code,
+    icsneoc2_can_error_code_t *data_error_code,
+    icsneoc2_message_can_error_flags_t *flags) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto can_err = std::dynamic_pointer_cast<CANErrorMessage>(message->message);
+	if(!can_err) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(tx_err_count) {
+		*tx_err_count = can_err->transmitErrorCount;
+	}
+	if(rx_err_count) {
+		*rx_err_count = can_err->receiveErrorCount;
+	}
+	if(error_code) {
+		*error_code = static_cast<icsneoc2_can_error_code_t>(can_err->errorCode);
+	}
+	if(data_error_code) {
+		*data_error_code = static_cast<icsneoc2_can_error_code_t>(can_err->dataErrorCode);
+	}
+	if(flags) {
+		*flags = 0;
+		if(can_err->busOff) {
+			*flags |= ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF;
+		}
+		if(can_err->errorPassive) {
+			*flags |= ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE;
+		}
+		if(can_err->errorWarn) {
+			*flags |= ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN;
+		}
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_is_lin(icsneoc2_message_t* message, bool* is_lin) {
+	if(!message || !is_lin) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	*is_lin = std::dynamic_pointer_cast<LINMessage>(message->message) != nullptr;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_lin_create(icsneoc2_message_t** message, uint8_t id) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	try {
+		*message = new icsneoc2_message_t;
+		(*message)->message = std::make_shared<LINMessage>(id);
+	} catch(const std::bad_alloc&) {
+		return icsneoc2_error_out_of_memory;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_lin_props_get(const icsneoc2_message_t* message,
+	uint8_t* id, uint8_t* protected_id, uint8_t* checksum,
+	icsneoc2_lin_msg_type_t* msg_type, bool* is_enhanced_checksum) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
+	if(!lin_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(id) {
+		*id = lin_msg->ID;
+	}
+	if(protected_id) {
+		*protected_id = lin_msg->protectedID;
+	}
+	if(checksum) {
+		*checksum = lin_msg->checksum;
+	}
+	if(msg_type) {
+		*msg_type = static_cast<icsneoc2_lin_msg_type_t>(lin_msg->linMsgType);
+	}
+	if(is_enhanced_checksum) {
+		*is_enhanced_checksum = lin_msg->isEnhancedChecksum;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_lin_props_set(icsneoc2_message_t* message,
+	const uint8_t* id, const uint8_t* checksum,
+	const icsneoc2_lin_msg_type_t* msg_type, const bool* is_enhanced_checksum) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
+	if(!lin_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(id) {
+		lin_msg->ID = *id & 0x3Fu;
+		lin_msg->protectedID = lin_msg->calcProtectedID(lin_msg->ID);
+	}
+	if(checksum) {
+		lin_msg->checksum = *checksum;
+	}
+	if(msg_type) {
+		lin_msg->linMsgType = static_cast<LINMessage::Type>(*msg_type);
+	}
+	if(is_enhanced_checksum) {
+		lin_msg->isEnhancedChecksum = *is_enhanced_checksum;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_lin_err_flags_get(const icsneoc2_message_t* message, icsneoc2_lin_err_flags_t* err_flags) {
+	if(!message || !err_flags) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
+	if(!lin_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	*err_flags = 0;
+	if(lin_msg->errFlags.ErrRxBreakOnly) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_ONLY;
+	if(lin_msg->errFlags.ErrRxBreakSyncOnly) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_SYNC_ONLY;
+	if(lin_msg->errFlags.ErrTxRxMismatch) *err_flags |= ICSNEOC2_LIN_ERR_TX_RX_MISMATCH;
+	if(lin_msg->errFlags.ErrRxBreakNotZero) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_NOT_ZERO;
+	if(lin_msg->errFlags.ErrRxBreakTooShort) *err_flags |= ICSNEOC2_LIN_ERR_RX_BREAK_TOO_SHORT;
+	if(lin_msg->errFlags.ErrRxSyncNot55) *err_flags |= ICSNEOC2_LIN_ERR_RX_SYNC_NOT_55;
+	if(lin_msg->errFlags.ErrRxDataLenOver8) *err_flags |= ICSNEOC2_LIN_ERR_RX_DATA_LEN_OVER_8;
+	if(lin_msg->errFlags.ErrFrameSync) *err_flags |= ICSNEOC2_LIN_ERR_FRAME_SYNC;
+	if(lin_msg->errFlags.ErrFrameMessageID) *err_flags |= ICSNEOC2_LIN_ERR_FRAME_MESSAGE_ID;
+	if(lin_msg->errFlags.ErrFrameResponderData) *err_flags |= ICSNEOC2_LIN_ERR_FRAME_RESPONDER_DATA;
+	if(lin_msg->errFlags.ErrChecksumMatch) *err_flags |= ICSNEOC2_LIN_ERR_CHECKSUM_MATCH;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_lin_status_flags_get(const icsneoc2_message_t* message, icsneoc2_lin_status_flags_t* status_flags) {
+	if(!message || !status_flags) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
+	if(!lin_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	*status_flags = 0;
+	if(lin_msg->statusFlags.TxChecksumEnhanced) *status_flags |= ICSNEOC2_LIN_STATUS_TX_CHECKSUM_ENHANCED;
+	if(lin_msg->statusFlags.TxCommander) *status_flags |= ICSNEOC2_LIN_STATUS_TX_COMMANDER;
+	if(lin_msg->statusFlags.TxResponder) *status_flags |= ICSNEOC2_LIN_STATUS_TX_RESPONDER;
+	if(lin_msg->statusFlags.TxAborted) *status_flags |= ICSNEOC2_LIN_STATUS_TX_ABORTED;
+	if(lin_msg->statusFlags.UpdateResponderOnce) *status_flags |= ICSNEOC2_LIN_STATUS_UPDATE_RESPONDER_ONCE;
+	if(lin_msg->statusFlags.HasUpdatedResponderOnce) *status_flags |= ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE;
+	if(lin_msg->statusFlags.BusRecovered) *status_flags |= ICSNEOC2_LIN_STATUS_BUS_RECOVERED;
+	if(lin_msg->statusFlags.BreakOnly) *status_flags |= ICSNEOC2_LIN_STATUS_BREAK_ONLY;
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_lin_calc_checksum(icsneoc2_message_t* message) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto lin_msg = std::dynamic_pointer_cast<LINMessage>(message->message);
+	if(!lin_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	LINMessage::calcChecksum(*lin_msg);
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_create(icsneoc2_message_t** message) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	try {
+		*message = new icsneoc2_message_t;
+		(*message)->message = std::make_shared<EthernetMessage>();
+	} catch(const std::bad_alloc&) {
+		return icsneoc2_error_out_of_memory;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_props_set(icsneoc2_message_t* message, const icsneoc2_message_eth_flags_t* flags, const bool* has_fcs, const uint32_t* fcs) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
+	if(!eth_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(flags) {
+		eth_msg->frameTooShort = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT);
+		eth_msg->noPadding = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING);
+		eth_msg->fcsVerified = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED);
+		eth_msg->txAborted = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED);
+		eth_msg->crcError = (*flags & ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR);
+	}
+	if(has_fcs && !*has_fcs) {
+		eth_msg->fcs = std::nullopt;
+	} else if(has_fcs && *has_fcs) {
+		// I'm pretty sure we can leave this alone, setting fcs below will take care of the behavior,
+		// otherwise we get into a weird state where we have to set fcs to zero if fcs is null but has_fcs is true.
+	}
+	if (fcs) {
+		eth_msg->fcs = *fcs;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_props_get(icsneoc2_message_t* message, icsneoc2_message_eth_flags_t* flags, bool* has_fcs, uint32_t* fcs) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
+	if(!eth_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(flags) {
+		*flags = 0;
+		if(eth_msg->noPadding)
+			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING;
+		if(eth_msg->fcsVerified)
+			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED;
+		if(eth_msg->txAborted)
+			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED;
+		if(eth_msg->crcError)
+			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR;
+		if(eth_msg->frameTooShort)
+			*flags |= ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT;
+	}
+	if(has_fcs) {
+		*has_fcs = eth_msg->fcs.has_value();
+	}
+	if(fcs) {
+		if(eth_msg->fcs) {
+			*fcs = eth_msg->fcs.value();
+		} else {
+			*fcs = 0;
+		}
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_mac_get(icsneoc2_message_t* message, uint8_t* dst_mac, uint8_t* src_mac) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
+	if(!eth_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(dst_mac) {
+		if(auto mac = eth_msg->getDestinationMAC(); mac.has_value()) {
+			const auto& mac_value = mac.value();
+			std::memcpy(dst_mac, mac_value.data(), mac_value.size());
+		} else {
+			return icsneoc2_error_invalid_data;
+		}
+	}
+	if(src_mac) {
+		if(auto mac = eth_msg->getSourceMAC(); mac.has_value()) {
+			const auto& mac_value = mac.value();
+			std::memcpy(src_mac, mac_value.data(), mac_value.size());
+		} else {
+			return icsneoc2_error_invalid_data;
+		}
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_ether_type_get(icsneoc2_message_t* message, uint16_t* ether_type) {
+	if(!message || !ether_type) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
+	if(!eth_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if (auto et = eth_msg->getEtherType(); et.has_value()) {
+		*ether_type = et.value();
+	} else {
+		return icsneoc2_error_invalid_data;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_t1s_props_set(icsneoc2_message_t* message, const icsneoc2_message_eth_t1s_flags_t* flags, const uint8_t* node_id, const uint8_t* burst_count, const uint8_t* symbol_type) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
+	if(!eth_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	// If all parameters are null/zero, clear the T1S state. Otherwise, if any parameters are set and we don't have a T1S state, create it.
+	if(!flags && !node_id && !burst_count && !symbol_type) {
+		eth_msg->t1s = std::nullopt;
+		return icsneoc2_error_success;
+	}
+	if((flags || node_id || burst_count || symbol_type) && !eth_msg->t1s.has_value()) {
+		eth_msg->t1s.emplace();
+	}
+	if(flags) {
+		eth_msg->t1s->isSymbol = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL);
+		eth_msg->t1s->isBurst = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST);
+		eth_msg->t1s->txCollision = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION);
+		eth_msg->t1s->isWake = (*flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE);
+	}
+	if(node_id) {
+		eth_msg->t1s->nodeId = *node_id;
+	}
+	if(burst_count) {
+		eth_msg->t1s->burstCount = *burst_count;
+	}
+	if(symbol_type) {
+		eth_msg->t1s->symbolType = *symbol_type;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_eth_t1s_props_get(icsneoc2_message_t* message, icsneoc2_message_eth_t1s_flags_t* flags, uint8_t* node_id, uint8_t* burst_count, uint8_t* symbol_type) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	auto eth_msg = std::dynamic_pointer_cast<EthernetMessage>(message->message);
+	if(!eth_msg) {
+		return icsneoc2_error_invalid_type;
+	}
+	if(flags) {
+		*flags = 0;
+		if(eth_msg->t1s.has_value()) {
+			if(eth_msg->t1s->isSymbol)
+				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL;
+			if(eth_msg->t1s->isBurst)
+				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST;
+			if(eth_msg->t1s->txCollision)
+				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION;
+			if(eth_msg->t1s->isWake)
+				*flags |= ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE;
+		}
+	}
+	if(node_id) {
+		*node_id = eth_msg->t1s.has_value() ? eth_msg->t1s->nodeId : 0;
+	}
+	if(burst_count) {
+		*burst_count = eth_msg->t1s.has_value() ? eth_msg->t1s->burstCount : 0;
+	}
+	if(symbol_type) {
+		*symbol_type = eth_msg->t1s.has_value() ? eth_msg->t1s->symbolType : 0;
+	}
+	return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_message_is_ethernet(icsneoc2_message_t* message, bool* is_ethernet) {
+	if(!message) {
+		return icsneoc2_error_invalid_parameters;
+	}
+	*is_ethernet = std::dynamic_pointer_cast<EthernetMessage>(message->message) != nullptr;
+	return icsneoc2_error_success;
 }

api/icsneoc2/icsneoc2settings.cpp

@@ -600,6 +600,36 @@ icsneoc2_error_t icsneoc2_settings_t1s_tx_opp_timer_set(icsneoc2_device_t* devic
     return icsneoc2_error_success;
 }
 
+icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->getT1SBurstTimerFor(network); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = 0;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1SBurstTimerFor(network, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
 icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
     // Make sure the device is valid
     auto res = icsneoc2_device_is_valid(device);
@@ -632,6 +662,186 @@ icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_set(icsneoc2_device_t
     return icsneoc2_error_success;
 }
 
+icsneoc2_error_t icsneoc2_settings_t1s_local_id_alternate_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->getT1SLocalIDAlternateFor(network); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = 0;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_local_id_alternate_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1SLocalIDAlternateFor(network, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_is_termination_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->isT1STerminationEnabledFor(network); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = false;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_termination_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1STerminationFor(network, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_is_bus_decoding_beacons_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->isT1SBusDecodingBeaconsEnabledFor(network); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = false;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_bus_decoding_beacons_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1SBusDecodingBeaconsFor(network, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_is_bus_decoding_all_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->isT1SBusDecodingAllEnabledFor(network); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = false;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_bus_decoding_all_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1SBusDecodingAllFor(network, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_enable_mask_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->getT1SMultiIDEnableMaskFor(network); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = 0;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_enable_mask_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1SMultiIDEnableMaskFor(network, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t index, uint8_t* value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    if(!value) {
+        return icsneoc2_error_invalid_parameters;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(auto result = device->device->settings->getT1SMultiIDFor(network, index); result.has_value()) {
+        *value = result.value();
+        return icsneoc2_error_success;
+    } else {
+        *value = 0;
+        return icsneoc2_error_get_settings_failure;
+    }
+}
+
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t index, uint8_t value) {
+    auto res = icsneoc2_device_is_valid(device);
+    if(res != icsneoc2_error_success) {
+        return res;
+    }
+    auto network = Network(static_cast<Network::NetID>(netid));
+    if(!device->device->settings->setT1SMultiIDFor(network, index, value)) {
+        return icsneoc2_error_set_settings_failure;
+    }
+    return icsneoc2_error_success;
+}
+
 icsneoc2_error_t icsneoc2_settings_misc_io_analog_output_enabled_set(icsneoc2_device_t* device, uint8_t pin, uint8_t value) {
     // Make sure the device is valid
     auto res = icsneoc2_device_is_valid(device);

bindings/python/CMakeLists.txt

@@ -9,7 +9,7 @@ else()
     FetchContent_Declare(
         pybind11
         GIT_REPOSITORY https://github.com/pybind/pybind11.git
-        GIT_TAG v3.0.1
+        GIT_TAG v3.0.3
     )
     FetchContent_MakeAvailable(pybind11)
 endif()

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

@@ -15,7 +15,10 @@ void init_canmessage(pybind11::module_& m) {
 		.def_readwrite("isExtended", &CANMessage::isExtended)
 		.def_readwrite("isCANFD", &CANMessage::isCANFD)
 		.def_readwrite("baudrateSwitch", &CANMessage::baudrateSwitch)
-		.def_readwrite("errorStateIndicator", &CANMessage::errorStateIndicator);
+		.def_readwrite("errorStateIndicator", &CANMessage::errorStateIndicator)
+		.def_readwrite("txAborted", &CANMessage::txAborted)
+		.def_readwrite("txLostArb", &CANMessage::txLostArb)
+		.def_readwrite("txError", &CANMessage::txError);
 }
 
 } // namespace icsneo 

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

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

bindings/python/icsneopy/device/chipid.cpp

@@ -103,7 +103,7 @@ void init_chipid(pybind11::module_& m) {
 		.value("neoOBD2Dev_MCHIP", ChipID::neoOBD2Dev_MCHIP)
 		.value("neoOBD2Dev_SCHIP", ChipID::neoOBD2Dev_SCHIP)
 		.value("neoOBD2SIMDoIP_MCHIP", ChipID::neoOBD2SIMDoIP_MCHIP)
-		.value("SFPModule_MCHIP", ChipID::SFPModule_MCHIP)
+		.value("SFPModule_88q2112_MCHIP", ChipID::SFPModule_88q2112_MCHIP)
 		.value("RADEpsilonT_MCHIP", ChipID::RADEpsilonT_MCHIP)
 		.value("RADEpsilonExpress_MCHIP", ChipID::RADEpsilonExpress_MCHIP)
 		.value("RADProxima_MCHIP", ChipID::RADProxima_MCHIP)
@@ -126,10 +126,14 @@ void init_chipid(pybind11::module_& m) {
 		.value("RADGigastar_FFG_ZYNQ", ChipID::RADGigastar_FFG_ZYNQ)
 		.value("VEM_02_FR_FCHIP", ChipID::VEM_02_FR_FCHIP)
 		.value("Connect_ZCHIP", ChipID::Connect_ZCHIP)
+		.value("SFPModule_88q2221_MCHIP", ChipID::SFPModule_88q2221_MCHIP)
 		.value("RADGALAXY2_SYSMON_CHIP", ChipID::RADGALAXY2_SYSMON_CHIP)
+		.value("SFPModule_88q3244_MCHIP", ChipID::SFPModule_88q3244_MCHIP)
 		.value("RADCOMET3_ZCHIP", ChipID::RADCOMET3_ZCHIP)
 		.value("Connect_LINUX", ChipID::Connect_LINUX)
+		.value("SFPModule_lan8670_MCHIP", ChipID::SFPModule_lan8670_MCHIP)
 		.value("RADGigastar2_ZYNQ", ChipID::RADGigastar2_ZYNQ)
+		.value("SFPModule_ent11100_MCHIP", ChipID::SFPModule_ent11100_MCHIP)
 		.value("RADGemini_MCHIP", ChipID::RADGemini_MCHIP)
 		.value("Invalid", ChipID::Invalid)
 		.finalize();

bindings/python/icsneopy/device/idevicesettings.cpp

@@ -104,6 +104,18 @@ void init_idevicesettings(pybind11::module_& m) {
         .def("set_t1s_max_burst", &IDeviceSettings::setT1SMaxBurstFor, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("get_t1s_burst_timer", &IDeviceSettings::getT1SBurstTimerFor, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("set_t1s_burst_timer", &IDeviceSettings::setT1SBurstTimerFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("get_t1s_local_id_alternate", &IDeviceSettings::getT1SLocalIDAlternateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_t1s_local_id_alternate", &IDeviceSettings::setT1SLocalIDAlternateFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("is_t1s_termination_enabled", &IDeviceSettings::isT1STerminationEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_t1s_termination", &IDeviceSettings::setT1STerminationFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("is_t1s_bus_decoding_beacons_enabled", &IDeviceSettings::isT1SBusDecodingBeaconsEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_t1s_bus_decoding_beacons", &IDeviceSettings::setT1SBusDecodingBeaconsFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("is_t1s_bus_decoding_all_enabled", &IDeviceSettings::isT1SBusDecodingAllEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_t1s_bus_decoding_all", &IDeviceSettings::setT1SBusDecodingAllFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("get_t1s_multi_id_enable_mask", &IDeviceSettings::getT1SMultiIDEnableMaskFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_t1s_multi_id_enable_mask", &IDeviceSettings::setT1SMultiIDEnableMaskFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("get_t1s_multi_id", &IDeviceSettings::getT1SMultiIDFor, pybind11::call_guard<pybind11::gil_scoped_release>())
+        .def("set_t1s_multi_id", &IDeviceSettings::setT1SMultiIDFor, pybind11::call_guard<pybind11::gil_scoped_release>())
         
         .def("set_misc_io_analog_output_enabled", &IDeviceSettings::setMiscIOAnalogOutputEnabled, pybind11::call_guard<pybind11::gil_scoped_release>())
         .def("set_misc_io_analog_output", &IDeviceSettings::setMiscIOAnalogOutput, pybind11::call_guard<pybind11::gil_scoped_release>())

communication/decoder.cpp

@@ -326,11 +326,15 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::GenericBinaryInfo:
 							result = GenericBinaryStatusPacket::DecodeToMessage(packet->data);
 							return true;
+						case ExtendedCommand::SoftwareUpdate: {
+							result = std::make_shared<ExtendedResponseMessage>(ExtendedCommand::SoftwareUpdate, ExtendedResponse::OperationPending, packet->data);
+							return true;
+						}
 						case ExtendedCommand::GenericReturn: {
 							if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
 								break;
 							const auto& packedResp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
-							result = std::make_shared<ExtendedResponseMessage>(packedResp.command, packedResp.returnCode);
+							result = std::make_shared<ExtendedResponseMessage>(packedResp.command, packedResp.returnCode, packet->data);
 							return true;
 						}
 						case ExtendedCommand::LiveData:

communication/message/neomessage.cpp

@@ -48,7 +48,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 			case Network::Type::AutomotiveEthernet: {
 				neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg;
 				auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
-				eth.preemptionFlags = ethmsg->preemptionFlags;
+				eth.preemptionFlags = ethmsg->preemptionFlags.value_or(0);
 				eth.status.incompleteFrame = ethmsg->frameTooShort;
 				// TODO Fill in extra status bits
 				//eth.status.xyz = ethmsg->preemptionEnabled;

communication/message/transmitmessage.cpp

@@ -102,10 +102,71 @@ static std::vector<uint8_t> EncodeFromMessageCAN(std::shared_ptr<Frame> frame, c
 	return encoded;
 }
 
-static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> /* frame */, const device_eventhandler_t& report) {
-	// TODO
-	report(APIEvent::Type::UnsupportedTXNetwork, APIEvent::Severity::Error);
-	return {};
+static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> frame, const device_eventhandler_t& report) {
+	auto linmsg = std::dynamic_pointer_cast<LINMessage>(frame);
+	if(!linmsg) {
+		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+		return {};
+	}
+	if(linmsg->linMsgType == LINMessage::Type::NOT_SET) {
+		report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+		return {};
+	}
+
+	size_t dataLen = std::min<size_t>(8, linmsg->data.size());
+	std::vector<uint8_t> encoded;
+	encoded.resize(sizeof(TransmitMessage));
+
+	TransmitMessage* const msg = (TransmitMessage*)encoded.data();
+	HardwareLINPacket* const linpacket = (HardwareLINPacket*)(msg->commonHeader);
+	memset(linpacket, 0, sizeof(HardwareLINPacket));
+
+	// Protected ID and ID
+	linmsg->protectedID = linmsg->calcProtectedID(linmsg->ID);
+	linpacket->CoreMiniBitsLIN.ID = linmsg->protectedID & 0x3F;
+
+	// LIN message type flags
+	switch(linmsg->linMsgType) {
+		case LINMessage::Type::LIN_COMMANDER_MSG:
+			linpacket->CoreMiniBitsLIN.TXCommander = 1;
+			break;
+		case LINMessage::Type::LIN_HEADER_ONLY:
+			linpacket->CoreMiniBitsLIN.TXCommander = 1;
+			break;
+		case LINMessage::Type::LIN_UPDATE_RESPONDER:
+			linpacket->CoreMiniBitsLIN.TXResponder = 1;
+			break;
+		case LINMessage::Type::LIN_BREAK_ONLY:
+			linpacket->CoreMiniBitsLIN.BreakOnly = 1;
+			break;
+		default:
+			break;
+	}
+
+	// Enhanced checksum
+	linpacket->CoreMiniBitsLIN.TxChkSumEnhanced = linmsg->isEnhancedChecksum ? 1 : 0;
+
+	// Data and checksum
+	bool hasData = (linmsg->linMsgType == LINMessage::Type::LIN_COMMANDER_MSG ||
+	                linmsg->linMsgType == LINMessage::Type::LIN_UPDATE_RESPONDER) && dataLen > 0;
+
+	if(hasData) {
+		// len includes data bytes + 1 checksum byte
+		linpacket->CoreMiniBitsLIN.len = static_cast<uint16_t>(dataLen + 1);
+		std::copy(linmsg->data.begin(), linmsg->data.begin() + dataLen, linpacket->data);
+		// Checksum goes after data: in data[dataLen] if < 8, otherwise in LINByte9
+		if(dataLen < 8)
+			linpacket->data[dataLen] = linmsg->checksum;
+		else
+			linpacket->CoreMiniBitsLIN.LINByte9 = linmsg->checksum;
+	} else {
+		linpacket->CoreMiniBitsLIN.len = 0;
+	}
+
+	// Description/stats and network
+	linpacket->stats = linmsg->description;
+
+	return encoded;
 }
 
 std::vector<uint8_t> TransmitMessage::EncodeFromMessage(std::shared_ptr<Frame> frame, uint32_t client_id, const device_eventhandler_t& report) {
@@ -127,6 +188,8 @@ std::vector<uint8_t> TransmitMessage::EncodeFromMessage(std::shared_ptr<Frame> f
 			return result;
 	}
 	// common fields
+	if(result.empty())
+		return result;
 	TransmitMessage* const msg = (TransmitMessage*)result.data();
 	msg->options.clientId = client_id;
 	msg->options.networkId = static_cast<uint32_t>(frame->network.getNetID());

communication/packet/canpacket.cpp

@@ -119,7 +119,12 @@ std::shared_ptr<Message> HardwareCANPacket::DecodeToMessage(const std::vector<ui
 		}
 
 		msg->transmitted = data->eid.TXMSG;
+		// Set the generic frame error state
 		msg->error = data->eid.TXAborted || data->eid.TXError || data->eid.TXLostArb;
+		// Set specific error states for CANError
+		msg->txAborted = data->eid.TXAborted;
+		msg->txLostArb = data->eid.TXLostArb;
+		msg->txError = data->eid.TXError;
 		msg->description = data->stats;
 
 		return msg;

communication/packet/ethernetpacket.cpp

@@ -1,6 +1,7 @@
 #include "icsneo/communication/packet/ethernetpacket.h"
 #include <algorithm>
 #include <iostream>
+#include <optional>
 
 using namespace icsneo;
 
@@ -24,9 +25,6 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	message.transmitted = packet->eid.TXMSG;
 	if(message.transmitted)
 		message.description = packet->stats;
-	message.preemptionEnabled = packet->header.PREEMPTION_ENABLED;
-	if(message.preemptionEnabled)
-		message.preemptionFlags = (uint8_t)((rawWords[0] & 0x03F8) >> 4);
 	message.frameTooShort = packet->header.RUNT_FRAME;
 	message.noPadding = !packet->header.ENABLE_PADDING;
 	message.fcsVerified = packet->header.FCS_VERIFIED;
@@ -39,15 +37,21 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	// Decoder will fix as it has information about the timestampResolution increments
 	message.timestamp = packet->timestamp.TS;
 
+	// Ethernet Frame Preemption for TSN
+	if(packet->header.PREEMPTION_ENABLED) {
+		message.preemptionFlags = static_cast<uint8_t>((rawWords[0] & 0x03F8) >> 4);
+	}
+
 	// Check if this is a T1S packet and populate T1S-specific fields
-	message.isT1S = packet->header.T1S_ETHERNET;
-	if(message.isT1S) {
-		message.isT1SSymbol = packet->eid.T1S_SYMBOL;
-		message.isT1SBurst = packet->eid.T1S_BURST;
-		message.txCollision = packet->t1s_status.TXCollision;
-		message.isT1SWake = packet->t1s_status.T1SWake;
-		message.t1sNodeId = packet->t1s_node.T1S_NODE_ID;
-		message.t1sBurstCount = packet->t1s_node.T1S_BURST_COUNT;
+	if(packet->header.T1S_ETHERNET) {
+		auto& t1s = message.t1s.emplace();
+
+		t1s.isSymbol = packet->eid.T1S_SYMBOL;
+		t1s.isBurst = packet->eid.T1S_BURST;
+		t1s.txCollision = packet->t1s_status.TXCollision;
+		t1s.isWake = packet->t1s_status.T1SWake;
+		t1s.nodeId = packet->t1s_node.T1S_NODE_ID;
+		t1s.burstCount = packet->t1s_node.T1S_BURST_COUNT;
 	}
 
 	const std::vector<uint8_t>::const_iterator databegin = bytestream.begin() + sizeof(HardwareEthernetPacket);
@@ -72,7 +76,7 @@ bool HardwareEthernetPacket::EncodeFromMessage(const EthernetMessage& message, s
 	if(description & 0x8000)
 		return false;
 
-	const bool preempt = message.preemptionEnabled;
+	const bool preempt = message.preemptionFlags.has_value();
 	// full header including parent
 	const size_t headerByteCount = preempt ? 15 : 14;
 	// local header for netID, description, and flags
@@ -121,12 +125,15 @@ bool HardwareEthernetPacket::EncodeFromMessage(const EthernetMessage& message, s
 	uint8_t flags = 0x00;
 	if(!message.noPadding) flags |= FLAG_PADDING;
 	if(message.fcs) flags |= FLAG_FCS;
-	if(message.preemptionEnabled) flags |= FLAG_PREEMPTION;
+	if(message.preemptionFlags.has_value()) {
+		flags |= FLAG_PREEMPTION;
+	}
 
 	bytestream.push_back(flags);
 
-	if(preempt)
-		bytestream.push_back(static_cast<uint8_t>(message.preemptionFlags));
+	if(preempt) {
+		bytestream.push_back(message.preemptionFlags.value());
+	}
 
 	bytestream.insert(bytestream.end(), message.data.begin(), message.data.end());
 

device/device.cpp

@@ -395,7 +395,7 @@ bool Device::open(OpenFlags flags, OpenStatusHandler handler) {
 				if(heartbeatCV.wait_for(recvLk, std::chrono::milliseconds(3500), [&](){ return receivedMessage; })) {
 					receivedMessage = false;
 				} else {
-					if(!stopHeartbeatThread && !isDisconnected()) {
+					if(!stopHeartbeatThread) {
 						close();
 						report(APIEvent::Type::DeviceDisconnected, APIEvent::Severity::Error);
 					}
@@ -560,7 +560,7 @@ bool Device::goOnline() {
 			return false;
 	}
 
-	if(supportsNetworkMutex()) {
+	if(supportsNetworkMutex) {
 		assignedClientId = com->getClientIDSync();
 		if(assignedClientId) {
 			std::set<Network::NetID> nets;
@@ -3927,7 +3927,7 @@ std::shared_ptr<DiskDetails> Device::getDiskDetails(std::chrono::milliseconds ti
 
 [[nodiscard]] std::optional<int> Device::lockNetworks(const std::set<Network::NetID>& networks, uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event)
 {
-	if(!supportsNetworkMutex()) {
+	if(!supportsNetworkMutex) {
 		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
 		return std::nullopt;
 	}
@@ -3977,7 +3977,7 @@ std::shared_ptr<DiskDetails> Device::getDiskDetails(std::chrono::milliseconds ti
 
 bool Device::unlockNetworks(const std::set<Network::NetID>& networks)
 {
-	if(!supportsNetworkMutex()) {
+	if(!supportsNetworkMutex) {
 		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
 		return false;
 	}
@@ -4017,7 +4017,7 @@ bool Device::unlockNetworks(const std::set<Network::NetID>& networks)
 
 std::shared_ptr<NetworkMutexMessage> Device::getNetworkMutexStatus(Network::NetID network)
 {
-	if(!supportsNetworkMutex()) {
+	if(!supportsNetworkMutex) {
 		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
 		return nullptr;
 	}
@@ -4039,7 +4039,7 @@ std::shared_ptr<NetworkMutexMessage> Device::getNetworkMutexStatus(Network::NetI
 
 [[nodiscard]] std::optional<int> Device::lockAllNetworks(uint32_t priority, uint32_t ttlMs, NetworkMutexType type, std::function<void(std::shared_ptr<Message>)>&& on_event)
 {
-	if(!supportsNetworkMutex()) {
+	if(!supportsNetworkMutex) {
 		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
 		return std::nullopt;
 	}
@@ -4086,7 +4086,7 @@ std::shared_ptr<NetworkMutexMessage> Device::getNetworkMutexStatus(Network::NetI
 
 bool Device::unlockAllNetworks() 
 {
-	if(!supportsNetworkMutex()) {
+	if(!supportsNetworkMutex) {
 		report(APIEvent::Type::NotSupported, APIEvent::Severity::Error);
 		return false;
 	}

docs/icsneoc2/examples.rst

@@ -25,3 +25,51 @@ Read Messages
 
 .. literalinclude:: ../../examples/c2/read_messages/src/main.c
    :language: c
+
+Device Info
+===========
+
+:download:`Download example <../../examples/c2/device_info/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/device_info/src/main.c
+   :language: c
+
+LIN
+===
+
+:download:`Download example <../../examples/c2/lin/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/lin/src/main.c
+   :language: c
+
+LIN Transmit
+============
+
+:download:`Download example <../../examples/c2/lin_transmit/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/lin_transmit/src/main.c
+   :language: c
+
+Ethernet Transmit
+=================
+
+:download:`Download example <../../examples/c2/ethernet_transmit/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/ethernet_transmit/src/main.c
+   :language: c
+
+Ethernet Receive
+================
+
+:download:`Download example <../../examples/c2/ethernet_receive/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/ethernet_receive/src/main.c
+   :language: c
+
+T1S Loopback
+============
+
+:download:`Download example <../../examples/c2/t1s_loopback/src/main.c>`
+
+.. literalinclude:: ../../examples/c2/t1s_loopback/src/main.c
+   :language: c

docs/icsneopy/can_getting_started.rst

@@ -6,7 +6,7 @@ Prerequisites
 =============
 
 - Python 3.8 or higher
-- icsneopy library installed
+- icsneopy installed (see :doc:`installation`)
 - CAN hardware device connected
 
 :download:`Download complete example <../../examples/python/can/can_complete_example.py>`

docs/icsneopy/ethernet_getting_started.rst

@@ -8,7 +8,7 @@ Prerequisites
 =============
 
 - Python 3.8 or higher
-- icsneopy library installed
+- icsneopy installed (see :doc:`installation`)
 - Intrepid Control Systems Device
 
 :download:`Download complete example <../../examples/python/ethernet/ethernet_complete_example.py>`

docs/icsneopy/examples.rst

@@ -92,6 +92,14 @@ SPI Example for 10BASE-T1S
 .. literalinclude:: ../../examples/python/spi/spi_example.py
    :language: python
 
+10BASE-T1S Settings Configuration
+=================================
+
+:download:`Download example <../../examples/python/t1s/t1s_settings.py>`
+
+.. literalinclude:: ../../examples/python/t1s/t1s_settings.py
+   :language: python
+
 Analog Output Control
 =====================
 

docs/icsneopy/flexray_getting_started.rst

@@ -5,7 +5,7 @@ FlexRay Getting Started
 Prerequisites
 =============
 
-- icsneopy library installed
+- icsneopy installed (see :doc:`installation`)
 - FlexRay hardware device connected (e.g., Fire3 Flexray)
 - Proper FlexRay bus termination (100Ω on each channel end)
 

docs/icsneopy/index.rst

@@ -5,6 +5,7 @@ icsneopy
 .. toctree::
    :maxdepth: 2
 
+   installation
    can_getting_started
    ethernet_getting_started
    flexray_getting_started

docs/icsneopy/installation.rst

@@ -0,0 +1,38 @@
+============
+Installation
+============
+
+icsneopy is available on PyPI at https://pypi.org/project/icsneopy/ and can be installed with pip:
+
+.. code-block:: bash
+
+   pip install icsneopy
+
+Pre-release
+===========
+
+For the latest features, install with the ``--pre`` flag to include pre-release versions:
+
+.. code-block:: bash
+
+   pip install --pre icsneopy
+
+Upgrading
+=========
+
+To upgrade an existing installation:
+
+.. code-block:: bash
+
+   pip install --pre --upgrade icsneopy
+
+Linux udev Rules
+================
+
+Linux users may want to install the included udev rules to run icsneopy-based
+applications without root. The rules file can be found in the libicsneo source
+repository at https://github.com/intrepidcs/libicsneo/.
+
+.. code-block:: bash
+
+   sudo cp 99-intrepidcs.rules /etc/udev/rules.d/

docs/index.rst

@@ -14,3 +14,18 @@ communication library. The source code for libicsneo can be found on GitHub:
    icsneopy/index
    icsneoc/index
    icsneoc2/index
+
+Linux Installation
+==================
+
+Applications that use raw Ethernet device discovery, such as PCAP-backed
+discovery, need permission to open raw network sockets. Instead of running your
+application with ``sudo``, grant the installed executable the required Linux
+capabilities:
+
+.. code-block:: bash
+
+   sudo setcap cap_net_raw,cap_net_admin=eip /usr/bin/your-app
+
+Replace ``/usr/bin/your-app`` with the full path to the application executable.
+

examples/CMakeLists.txt

@@ -4,6 +4,13 @@ option(LIBICSNEO_BUILD_C_LEGACY_EXAMPLE "Build the command-line simple C example
 option(LIBICSNEO_BUILD_C2_SIMPLE_EXAMPLE "Build the simple C2 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_LIN_EXAMPLE "Build the C2 LIN example." ON)
+option(LIBICSNEO_BUILD_C2_LIN_TRANSMIT_EXAMPLE "Build the C2 LIN transmit example." ON)
+option(LIBICSNEO_BUILD_C2_ETHERNET_TRANSMIT_EXAMPLE "Build the C2 ethernet transmit example." ON)
+option(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE "Build the C2 ethernet receive example." ON)
+option(LIBICSNEO_BUILD_C2_T1S_LOOPBACK_EXAMPLE "Build the C2 RAD-Comet3 T1S loopback example." ON)
 option(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE "Build the simple C++ 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)
@@ -19,6 +26,7 @@ option(LIBICSNEO_BUILD_CPP_SPI_EXAMPLE "Build the SPI example." ON)
 option(LIBICSNEO_BUILD_CPP_MUTEX_EXAMPLE "Build the NetworkMutex example." ON)
 option(LIBICSNEO_BUILD_CPP_ANALOG_OUT_EXAMPLE "Build the analog output example." ON)
 option(LIBICSNEO_BUILD_CPP_DISKFORMAT_EXAMPLE "Build the disk format example." ON)
+option(LIBICSNEO_BUILD_CPP_T1S_EXAMPLE "Build the T1S example." ON)
 
 add_compile_options(${LIBICSNEO_COMPILER_WARNINGS})
 
@@ -46,6 +54,34 @@ if(LIBICSNEO_BUILD_C2_DISKFORMAT_EXAMPLE)
 	add_subdirectory(c2/diskformat)
 endif()
 
+if(LIBICSNEO_BUILD_C2_RECONNECT_EXAMPLE)
+	add_subdirectory(c2/reconnect)
+endif()
+
+if(LIBICSNEO_BUILD_C2_DEVICE_INFO_EXAMPLE)
+	add_subdirectory(c2/device_info)
+endif()
+
+if(LIBICSNEO_BUILD_C2_LIN_EXAMPLE)
+	add_subdirectory(c2/lin)
+endif()
+
+if(LIBICSNEO_BUILD_C2_LIN_TRANSMIT_EXAMPLE)
+	add_subdirectory(c2/lin_transmit)
+endif()
+
+if(LIBICSNEO_BUILD_C2_ETHERNET_TRANSMIT_EXAMPLE)
+	add_subdirectory(c2/ethernet_transmit)
+endif()
+
+if(LIBICSNEO_BUILD_C2_ETHERNET_RECEIVE_EXAMPLE)
+	add_subdirectory(c2/ethernet_receive)
+endif()
+
+if(LIBICSNEO_BUILD_C2_T1S_LOOPBACK_EXAMPLE)
+	add_subdirectory(c2/t1s_loopback)
+endif()
+
 if(LIBICSNEO_BUILD_CPP_SIMPLE_EXAMPLE)
 	add_subdirectory(cpp/simple)
 endif()
@@ -105,3 +141,7 @@ endif()
 if(LIBICSNEO_BUILD_CPP_DISKFORMAT_EXAMPLE)
 	add_subdirectory(cpp/diskformat)
 endif()
+
+if(LIBICSNEO_BUILD_CPP_T1S_EXAMPLE)
+	add_subdirectory(cpp/t1s)
+endif()

examples/c2/device_info/CMakeLists.txt

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

examples/c2/device_info/src/main.c

@@ -0,0 +1,127 @@
+#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 %d with error code %d\n", message, error, res);
+		return res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+int main() {
+	icsneoc2_error_t res;
+
+	/* ===== Device Selection ===== */
+	printf("Searching for devices...\n");
+	icsneoc2_device_info_t* found_devices = NULL;
+	res = icsneoc2_device_enumerate(0, &found_devices);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to enumerate devices", res);
+	}
+	if(!found_devices) {
+		printf("No devices found.\n");
+		return 1;
+	}
+
+	/* Count and display devices */
+	int device_count = 0;
+	for(icsneoc2_device_info_t* cur = found_devices; cur; cur = icsneoc2_device_info_next(cur)) {
+		char desc[128] = {0};
+		size_t desc_len = sizeof(desc);
+		icsneoc2_device_info_description_get(cur, desc, &desc_len);
+
+		char serial[32] = {0};
+		size_t serial_len = sizeof(serial);
+		icsneoc2_device_info_serial_get(cur, serial, &serial_len);
+
+		printf("  [%d] %s (Serial: %s)\n", device_count + 1, desc, serial);
+		device_count++;
+	}
+
+	int device_choice;
+	printf("Select device (1-%d): ", device_count);
+	if(scanf("%d", &device_choice) != 1 || device_choice < 1 || device_choice > device_count) {
+		printf("Invalid selection.\n");
+		icsneoc2_enumeration_free(found_devices);
+		return 1;
+	}
+
+	/* Find the selected device_info node */
+	icsneoc2_device_info_t* selected_info = found_devices;
+	for(int i = 1; i < device_choice; i++) {
+		selected_info = icsneoc2_device_info_next(selected_info);
+	}
+
+	/* Open the selected device */
+	icsneoc2_device_t* device = NULL;
+	res = icsneoc2_device_create(selected_info, &device);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_enumeration_free(found_devices);
+		return print_error_code("Failed to create device from device info", res);
+	}
+	res = icsneoc2_device_open(device, icsneoc2_open_options_default);
+	icsneoc2_enumeration_free(found_devices);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to open device", res);
+	}
+
+	char description[128] = {0};
+	size_t description_length = sizeof(description);
+	icsneoc2_device_description_get(device, description, &description_length);
+	printf("\nOpened device: %s\n\n", description);
+
+	/* ===== Serial Number ===== */
+	char serial[32] = {0};
+	size_t serial_len = sizeof(serial);
+	res = icsneoc2_device_serial_get(device, serial, &serial_len);
+	if(res == icsneoc2_error_success) {
+		printf("Serial:     %s\n", serial);
+	} else {
+		print_error_code("Failed to get serial", res);
+	}
+
+	/* ===== PCB Serial Number ===== */
+	uint8_t pcbsn[16] = {0};
+	size_t pcbsn_len = sizeof(pcbsn);
+	res = icsneoc2_device_pcb_serial_get(device, pcbsn, &pcbsn_len);
+	if(res == icsneoc2_error_success) {
+		printf("PCB Serial: ");
+		for(size_t i = 0; i < pcbsn_len; i++) {
+			printf("%c", pcbsn[i]);
+		}
+		printf("\n");
+	} else {
+		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);
+	if(res == icsneoc2_error_success) {
+		printf("MAC:        ");
+		for(size_t i = 0; i < mac_len; i++) {
+			if(i > 0) printf(":");
+			printf("%02X", mac[i]);
+		}
+		printf("\n");
+	} else {
+		print_error_code("Failed to get MAC address (device may not support it)", res);
+	}
+
+	/* Cleanup */
+	printf("\nClosing device... ");
+	res = icsneoc2_device_close(device);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	icsneoc2_device_free(device);
+	return 0;
+}

examples/c2/diskformat/src/main.c

@@ -48,6 +48,7 @@ int main() {
 	size_t description_length = sizeof(description);
 	res = icsneoc2_device_description_get(device, description, &description_length);
 	if(res != icsneoc2_error_success) {
+		icsneoc2_device_free(device);
 		return print_error_code("\tFailed to get device description", res);
 	}
 	printf("\tOpened device: %s\n", description);
@@ -58,11 +59,13 @@ int main() {
 	if(res != icsneoc2_error_success) {
 		print_error_code("\tFailed to check disk formatting support", res);
 		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
 		return -1;
 	}
 	if(!supported) {
 		printf("\terror: %s does not support disk formatting\n", description);
 		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
 		return -1;
 	}
 
@@ -79,6 +82,7 @@ int main() {
 		printf("FAIL\n");
 		print_error_code("\tFailed to get disk details", res);
 		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
 		return -1;
 	}
 	printf("OK\n");
@@ -122,6 +126,7 @@ int main() {
 		printf("\n\terror: no disks are present in the device\n");
 		icsneoc2_disk_details_free(details);
 		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
 		return -1;
 	}
 
@@ -133,6 +138,7 @@ int main() {
 		printf("\tAborted.\n");
 		icsneoc2_disk_details_free(details);
 		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
 		return 0;
 	}
 
@@ -145,6 +151,7 @@ int main() {
 		print_error_code("\tFormat failed", res);
 		icsneoc2_disk_details_free(details);
 		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
 		return -1;
 	}
 	printf("\tFormat complete!\n");
@@ -171,5 +178,6 @@ int main() {
 
 	printf("\tClosing device: %s...\n", description);
 	icsneoc2_device_close(device);
+	icsneoc2_device_free(device);
 	return 0;
 }

examples/c2/ethernet_receive/CMakeLists.txt

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

examples/c2/ethernet_receive/src/main.c

@@ -0,0 +1,223 @@
+#include <icsneo/icsneoc2.h>
+#include <icsneo/icsneoc2messages.h>
+
+#include <stdio.h>
+#include <inttypes.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+void sleep_ms(uint32_t ms) {
+#ifdef _WIN32
+	Sleep(ms);
+#else
+	sleep(ms / 1000);
+#endif
+}
+
+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 %d with error code %d\n", message, error, res);
+		return res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+void print_events(void) {
+	icsneoc2_event_t* events[256] = {0};
+	size_t events_count = 256;
+	for(size_t i = 0; i < events_count; ++i) {
+		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
+		if(res != icsneoc2_error_success) {
+			(void)print_error_code("\tFailed to get events", res);
+			return;
+		}
+		if(events[i] == NULL) {
+			events_count = i;
+			break;
+		}
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		char description[255] = {0};
+		size_t description_length = 255;
+		icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
+		if(res != icsneoc2_error_success) {
+			print_error_code("\tFailed to get event description", res);
+			continue;
+		}
+		printf("\tEvent %zu: %s\n", i, description);
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		icsneoc2_event_free(events[i]);
+	}
+	if(events_count > 0) {
+		printf("\tReceived %zu events\n", events_count);
+	}
+}
+
+void print_mac(const char* label, const uint8_t* mac) {
+	printf("%s: %02x:%02x:%02x:%02x:%02x:%02x", label, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+}
+
+int process_ethernet_message(icsneoc2_message_t* message, size_t index) {
+	icsneoc2_netid_t netid = 0;
+	char netid_name[128] = {0};
+	size_t netid_name_length = 128;
+
+	icsneoc2_error_t res = icsneoc2_message_netid_get(message, &netid);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("\tFailed to get netid", res);
+	}
+	res = icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("\tFailed to get netid name", res);
+	}
+
+	/* Get data length first */
+	size_t data_length = 0;
+	res = icsneoc2_message_data_get(message, NULL, &data_length);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("\tFailed to get data length", res);
+	}
+
+	printf("\t%zu) Ethernet Frame on %s (0x%x) - %zu bytes\n", index, netid_name, netid, data_length);
+
+	/* Get MAC addresses and EtherType if we have enough data */
+	uint8_t dst_mac[6] = {0};
+	uint8_t src_mac[6] = {0};
+	uint16_t ether_type = 0;
+
+	res = icsneoc2_message_eth_mac_get(message, dst_mac, src_mac);
+	if(res == icsneoc2_error_success) {
+		printf("\t  ");
+		print_mac("Dst", dst_mac);
+		printf("  ");
+		print_mac("Src", src_mac);
+		printf("\n");
+	}
+
+	res = icsneoc2_message_eth_ether_type_get(message, &ether_type);
+	if(res == icsneoc2_error_success) {
+		printf("\t  EtherType: 0x%04x\n", ether_type);
+	}
+
+	/* Get flags */
+	icsneoc2_message_eth_flags_t flags = 0;
+	res = icsneoc2_message_eth_props_get(message, &flags, NULL, NULL);
+	if(res == icsneoc2_error_success && flags != 0) {
+		printf("\t  Flags: 0x%" PRIx64, flags);
+		if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR) printf(" [CRC_ERROR]");
+		if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT) printf(" [FRAME_TOO_SHORT]");
+		if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED) printf(" [TX_ABORTED]");
+		if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED) printf(" [FCS_VERIFIED]");
+		if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_PREEMPTION_ENABLED) printf(" [PREEMPTION]");
+		if(flags & ICSNEOC2_MESSAGE_ETH_FLAGS_IS_T1S) printf(" [T1S]");
+		printf("\n");
+	}
+
+	/* Print data bytes */
+	uint8_t data[1600] = {0};
+	res = icsneoc2_message_data_get(message, data, &data_length);
+	if(res == icsneoc2_error_success) {
+		printf("\t  Data:\n\t    ");
+		for(size_t x = 0; x < data_length; x++) {
+			printf("0x%02x ", data[x]);
+			if((x + 1) % 20 == 0 && x + 1 < data_length) {
+				printf("\n\t    ");
+			}
+		}
+		printf("\n");
+	}
+
+	return icsneoc2_error_success;
+}
+
+int main(void) {
+	/* Open the first available device */
+	printf("Opening first available device...\n");
+	icsneoc2_device_t* device = NULL;
+	icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to open first device", res);
+	}
+
+	/* Get a description of the opened device */
+	char description[255] = {0};
+	size_t description_length = 255;
+	res = icsneoc2_device_description_get(device, description, &description_length);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to get device description", res);
+	}
+	printf("Opened device: %s\n", description);
+
+	/* Wait for Ethernet frames to arrive */
+	const int duration_seconds = 10;
+	printf("Listening for Ethernet frames for %d seconds...\n", duration_seconds);
+	sleep_ms(duration_seconds * 1000);
+
+	/* Retrieve and process messages */
+	icsneoc2_message_t* messages[20000] = {0};
+	size_t message_count = 20000;
+	size_t eth_count = 0;
+
+	for(size_t i = 0; i < message_count; ++i) {
+		res = icsneoc2_device_message_get(device, &messages[i], 0);
+		if(res != icsneoc2_error_success) {
+			print_events();
+			return print_error_code("Failed to get messages", res);
+		}
+		if(messages[i] == NULL) {
+			message_count = i;
+			break;
+		}
+	}
+
+	printf("Got %zu messages total, filtering for Ethernet...\n", message_count);
+
+	for(size_t i = 0; i < message_count; i++) {
+		icsneoc2_message_t* message = messages[i];
+
+		/* Check if this is a TX echo (skip it) */
+		bool is_tx = false;
+		res = icsneoc2_message_is_transmit(message, &is_tx);
+		if(res != icsneoc2_error_success || is_tx) {
+			continue;
+		}
+
+		/* Check if this is an Ethernet message */
+		bool is_ethernet = false;
+		res = icsneoc2_message_is_ethernet(message, &is_ethernet);
+		if(res != icsneoc2_error_success || !is_ethernet) {
+			continue;
+		}
+
+		process_ethernet_message(message, eth_count);
+		eth_count++;
+	}
+
+	printf("Received %zu Ethernet frames out of %zu total messages\n", eth_count, message_count);
+
+	/* Free all messages */
+	for(size_t i = 0; i < message_count; ++i) {
+		icsneoc2_message_free(messages[i]);
+	}
+
+	/* Print any events */
+	print_events();
+
+	/* Close the device */
+	printf("Closing device...\n");
+	res = icsneoc2_device_close(device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to close device", res);
+	}
+
+	return 0;
+}

examples/c2/ethernet_transmit/CMakeLists.txt

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

examples/c2/ethernet_transmit/src/main.c

@@ -0,0 +1,204 @@
+#include <icsneo/icsneoc2.h>
+#include <icsneo/icsneoc2messages.h>
+
+#include <stdio.h>
+#include <inttypes.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+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 %d with error code %d\n", message, error, res);
+		return res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+void print_events(void) {
+	icsneoc2_event_t* events[256] = {0};
+	size_t events_count = 256;
+	for(size_t i = 0; i < events_count; ++i) {
+		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
+		if(res != icsneoc2_error_success) {
+			(void)print_error_code("\tFailed to get events", res);
+			return;
+		}
+		if(events[i] == NULL) {
+			events_count = i;
+			break;
+		}
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		char description[255] = {0};
+		size_t description_length = 255;
+		icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
+		if(res != icsneoc2_error_success) {
+			print_error_code("\tFailed to get event description", res);
+			continue;
+		}
+		printf("\tEvent %zu: %s\n", i, description);
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		icsneoc2_event_free(events[i]);
+	}
+	if(events_count > 0) {
+		printf("\tReceived %zu events\n", events_count);
+	}
+}
+
+int main(void) {
+	/* Open the first available device */
+	printf("Opening first available device...\n");
+	icsneoc2_device_t* device = NULL;
+	icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to open first device", res);
+	}
+
+	/* Get a description of the opened device */
+	char description[255] = {0};
+	size_t description_length = 255;
+	res = icsneoc2_device_description_get(device, description, &description_length);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to get device description", res);
+	}
+	printf("Opened device: %s\n", description);
+
+	icsneoc2_netid_t tx_networks[255] = {0};
+    size_t tx_net_count = sizeof(tx_networks) / sizeof(tx_networks[0]);
+	res = icsneoc2_device_supported_tx_networks_get(device, tx_networks, &tx_net_count);
+	if(res != icsneoc2_error_success) {
+		print_events();
+		return print_error_code("Failed to get TX networks", res);
+	}
+
+	/* Filter for Ethernet/AutomotiveEthernet networks */
+	icsneoc2_netid_t eth_networks[64] = {0};
+	char eth_names[64][128] = {{0}};
+	size_t eth_count = 0;
+	for(size_t i = 0; i < tx_net_count && eth_count < 64; i++) {
+		/* Create a temporary message to check network type */
+		icsneoc2_message_t* tmp = NULL;
+		res = icsneoc2_message_eth_create(&tmp);
+		if(res != icsneoc2_error_success) continue;
+		res = icsneoc2_message_netid_set(tmp, tx_networks[i]);
+		if(res != icsneoc2_error_success) { icsneoc2_message_free(tmp); continue; }
+		icsneoc2_network_type_t ntype = 0;
+		res = icsneoc2_message_network_type_get(tmp, &ntype);
+		icsneoc2_message_free(tmp);
+		if(res != icsneoc2_error_success) continue;
+		if(ntype == icsneoc2_network_type_ethernet || ntype == icsneoc2_network_type_automotive_ethernet) {
+			eth_networks[eth_count] = tx_networks[i];
+			size_t name_len = 128;
+			icsneoc2_netid_name_get(tx_networks[i], eth_names[eth_count], &name_len);
+			eth_count++;
+		}
+	}
+
+	if(eth_count == 0) {
+		printf("No Ethernet TX networks available on this device.\n");
+		icsneoc2_device_close(device);
+		return 0;
+	}
+
+	/* Let the user pick */
+	printf("Available Ethernet TX networks:\n");
+	for(size_t i = 0; i < eth_count; i++) {
+		printf("  %zu) %s\n", i + 1, eth_names[i]);
+	}
+	printf("Select network [1-%zu]: ", eth_count);
+	int selection = 0;
+	if(scanf("%d", &selection) != 1 || selection < 1 || (size_t)selection > eth_count) {
+		printf("Invalid selection, using first available.\n");
+		selection = 1;
+	}
+	icsneoc2_netid_t netid = eth_networks[selection - 1];
+	printf("Selected: %s\n", eth_names[selection - 1]);
+	/* Transmit Ethernet frames */
+	const size_t msg_count = 10;
+	printf("Transmitting %zu Ethernet frames on %s...\n", msg_count, eth_names[selection - 1]);
+
+	for(size_t i = 0; i < msg_count; i++) {
+		/* Create an Ethernet message */
+		icsneoc2_message_t* message = NULL;
+		res = icsneoc2_message_eth_create(&message);
+		if(res != icsneoc2_error_success) {
+			print_events();
+			return print_error_code("Failed to create Ethernet message", res);
+		}
+
+		/* Set the network ID */
+		res = icsneoc2_message_netid_set(message, netid );
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
+			print_events();
+			return print_error_code("Failed to set netid", res);
+		}
+
+		/* Build Ethernet frame data:
+		 * Bytes 0-5:   Destination MAC (00:FC:70:00:01:02)
+		 * Bytes 6-11:  Source MAC      (00:FC:70:00:01:01)
+		 * Bytes 12-13: EtherType       (0x0800 = IPv4)
+		 * Bytes 14+:   Payload
+		 */
+		uint8_t frame_data[] = {
+			0x00, 0xFC, 0x70, 0x00, 0x01, 0x02, /* Destination MAC */
+			0x00, 0xFC, 0x70, 0x00, 0x01, 0x01, /* Source MAC */
+			0x08, 0x00,                           /* EtherType (IPv4) */
+			0x45, 0x00, 0x00, 0x20,               /* IPv4: ver/IHL, DSCP, total length (32) */
+			0x00, 0x00, 0x00, 0x00,               /* Identification, flags/fragment offset */
+			0x40, 0x11, 0x00, 0x00,               /* TTL (64), protocol (UDP), checksum (0) */
+			0xC0, 0xA8, 0x01, 0x01,               /* Source IP (192.168.1.1) */
+			0xC0, 0xA8, 0x01, 0x02,               /* Destination IP (192.168.1.2) */
+			0xC3, 0x50, 0xC3, 0x51,               /* UDP: src port (50000), dst port (50001) */
+			0x00, 0x0C, 0x00, 0x00,               /* UDP: length (12), checksum (0) */
+			0x00, 0x00, 0x00, 0x00                /* UDP payload (4 bytes, frame counter) */
+		};
+
+		/* Put the frame counter in the UDP payload */
+		frame_data[42] = (uint8_t)((i >> 24) & 0xFF);
+		frame_data[43] = (uint8_t)((i >> 16) & 0xFF);
+		frame_data[44] = (uint8_t)((i >> 8) & 0xFF);
+		frame_data[45] = (uint8_t)(i & 0xFF);
+
+		res = icsneoc2_message_data_set(message, frame_data, sizeof(frame_data));
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
+			print_events();
+			return print_error_code("Failed to set frame data", res);
+		}
+
+		/* Transmit the message */
+		res = icsneoc2_device_message_transmit(device, message);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
+			print_events();
+			return print_error_code("Failed to transmit Ethernet frame", res);
+		}
+
+		icsneoc2_message_free(message);
+		printf("\tTransmitted frame %zu\n", i + 1);
+	}
+
+	printf("Successfully transmitted %zu Ethernet frames\n", msg_count);
+
+	/* Print any events */
+	print_events();
+
+	/* Close the device */
+	printf("Closing device...\n");
+	res = icsneoc2_device_close(device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to close device", res);
+	}
+
+	return 0;
+}

examples/c2/lin/CMakeLists.txt

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

examples/c2/lin/src/main.c

@@ -0,0 +1,311 @@
+/* Note: This example requires LIN 1 and LIN 2 channels to be connected on the device */
+
+#include <icsneo/icsneoc2.h>
+#include <icsneo/icsneoc2messages.h>
+#include <icsneo/icsneoc2settings.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <inttypes.h>
+
+void sleep_ms(uint32_t ms) {
+#ifdef _WIN32
+	Sleep(ms);
+#else
+	sleep(ms / 1000);
+#endif
+}
+
+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 %d with error code %d\n", message, error, res);
+		return res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+void print_events(const char* device_description) {
+	icsneoc2_event_t* events[1024] = {0};
+	size_t events_count = 1024;
+	for(size_t i = 0; i < events_count; ++i) {
+		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
+		if(res != icsneoc2_error_success) {
+			for(size_t j = 0; j < i; ++j) {
+				icsneoc2_event_free(events[j]);
+			}
+			(void)print_error_code("\tFailed to get device events", res);
+			return;
+		}
+		if(events[i] == NULL) {
+			events_count = i;
+			break;
+		}
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		char event_description[255] = {0};
+		size_t event_description_length = 255;
+		icsneoc2_error_t res = icsneoc2_event_description_get(events[i], event_description, &event_description_length);
+		if(res != icsneoc2_error_success) {
+			print_error_code("\tFailed to get event description", res);
+			continue;
+		}
+		printf("\t%s: Event %zu: %s\n", device_description, i, event_description);
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		icsneoc2_event_free(events[i]);
+	}
+	printf("\t%s: Received %zu events\n", device_description, events_count);
+}
+
+void process_lin_messages(icsneoc2_message_t** messages, size_t count) {
+	for(size_t i = 0; i < count; i++) {
+		bool is_lin = false;
+		icsneoc2_error_t res = icsneoc2_message_is_lin(messages[i], &is_lin);
+		if(res != icsneoc2_error_success || !is_lin)
+			continue;
+
+		uint8_t id = 0;
+		uint8_t protected_id = 0;
+		uint8_t checksum = 0;
+		icsneoc2_lin_msg_type_t msg_type = 0;
+		bool is_enhanced_checksum = false;
+		res = icsneoc2_message_lin_props_get(messages[i], &id, &protected_id, &checksum, &msg_type, &is_enhanced_checksum);
+		if(res != icsneoc2_error_success) {
+			print_error_code("\tFailed to get LIN properties", res);
+			continue;
+		}
+
+		icsneoc2_netid_t netid = 0;
+		icsneoc2_message_netid_get(messages[i], &netid);
+		char netid_name[128] = {0};
+		size_t netid_name_length = 128;
+		icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
+
+		uint8_t data[64] = {0};
+		size_t data_length = 64;
+		icsneoc2_message_data_get(messages[i], data, &data_length);
+
+		icsneoc2_lin_err_flags_t err_flags = 0;
+		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("\tData: [");
+		for(size_t x = 0; x < data_length; x++) {
+			printf(" 0x%02x", data[x]);
+		}
+		printf(" ]\n");
+		printf("\tChecksum type: %s\n", is_enhanced_checksum ? "Enhanced" : "Classic");
+		printf("\tChecksum: 0x%02x\n", checksum);
+		printf("\tChecksum valid: %s\n\n", (!(err_flags & ICSNEOC2_LIN_ERR_CHECKSUM_MATCH)) ? "yes" : "no");
+	}
+}
+
+int main() {
+	/* Open the first available device */
+	printf("Opening first available device...\n");
+	icsneoc2_device_t* device = NULL;
+	icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("\tFailed to open first device", res);
+	}
+
+	char description[255] = {0};
+	size_t description_length = 255;
+	res = icsneoc2_device_description_get(device, description, &description_length);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_device_close(device);
+		return print_error_code("\tFailed to get device description", res);
+	}
+	printf("\tOpened device: %s\n\n", description);
+
+	/* Configure LIN settings */
+	int64_t baud = 19200;
+
+	printf("Enable LIN 01 commander resistor... ");
+	res = icsneoc2_settings_commander_resistor_set(device, icsneoc2_netid_lin_01, true);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	printf("Disable LIN 02 commander resistor... ");
+	res = icsneoc2_settings_commander_resistor_set(device, icsneoc2_netid_lin_02, false);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	printf("Setting LIN 01 baudrate to %" PRId64 " bit/s... ", baud);
+	res = icsneoc2_settings_baudrate_set(device, icsneoc2_netid_lin_01, baud);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	printf("Setting LIN 02 baudrate to %" PRId64 " bit/s... ", baud);
+	res = icsneoc2_settings_baudrate_set(device, icsneoc2_netid_lin_02, baud);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	printf("Setting LIN 01 mode to NORMAL... ");
+	res = icsneoc2_settings_lin_mode_set(device, icsneoc2_netid_lin_01, icsneoc2_lin_mode_normal);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	printf("Setting LIN 02 mode to NORMAL... ");
+	res = icsneoc2_settings_lin_mode_set(device, icsneoc2_netid_lin_02, icsneoc2_lin_mode_normal);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	printf("Applying settings... ");
+	res = icsneoc2_settings_apply(device);
+	if(res != icsneoc2_error_success) {
+		print_events(description);
+		icsneoc2_device_close(device);
+		return print_error_code("\tFailed to apply settings", res);
+	}
+	printf("OK\n");
+
+	printf("Getting LIN 01 baudrate... ");
+	int64_t read_baud = 0;
+	res = icsneoc2_settings_baudrate_get(device, icsneoc2_netid_lin_01, &read_baud);
+	if(res == icsneoc2_error_success)
+		printf("OK, %" PRId64 " bit/s\n", read_baud);
+	else
+		printf("FAIL\n");
+
+	printf("Getting LIN 02 baudrate... ");
+	res = icsneoc2_settings_baudrate_get(device, icsneoc2_netid_lin_02, &read_baud);
+	if(res == icsneoc2_error_success)
+		printf("OK, %" PRId64 " bit/s\n\n", read_baud);
+	else
+		printf("FAIL\n\n");
+
+	/* Transmit a LIN responder data update on LIN 02 */
+	printf("Transmitting a LIN 02 responder data frame... ");
+	{
+		icsneoc2_message_t* msg = NULL;
+		res = icsneoc2_message_lin_create(&msg, 0x11);
+		if(res != icsneoc2_error_success) {
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to create LIN message", res);
+		}
+		icsneoc2_lin_msg_type_t msg_type = icsneoc2_lin_msg_type_update_responder;
+		res = icsneoc2_message_lin_props_set(msg, NULL, NULL, &msg_type, NULL);
+		uint8_t data[] = {0xaa, 0xbb, 0xcc, 0xdd, 0x11, 0x22, 0x33, 0x44};
+		res += icsneoc2_message_data_set(msg, data, sizeof(data));
+		res += icsneoc2_message_netid_set(msg, icsneoc2_netid_lin_02);
+        res += icsneoc2_message_lin_calc_checksum(msg);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(msg);
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to set LIN message properties", res);
+		}
+		res = icsneoc2_device_message_transmit(device, msg);
+		icsneoc2_message_free(msg);
+		if(res != icsneoc2_error_success) {
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to transmit LIN responder message", res);
+		}
+		printf("OK\n");
+	}
+
+	/* Transmit a LIN commander header on LIN 01 */
+	printf("Transmitting a LIN 01 commander header... ");
+	{
+		icsneoc2_message_t* msg = NULL;
+		res = icsneoc2_message_lin_create(&msg, 0x11);
+		if(res != icsneoc2_error_success) {
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to create LIN message", res);
+		}
+		icsneoc2_lin_msg_type_t msg_type = icsneoc2_lin_msg_type_header_only;
+		res = icsneoc2_message_lin_props_set(msg, NULL, NULL, &msg_type, NULL);
+		res += icsneoc2_message_netid_set(msg, icsneoc2_netid_lin_01);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(msg);
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to set LIN message properties", res);
+		}
+		res = icsneoc2_device_message_transmit(device, msg);
+		icsneoc2_message_free(msg);
+		if(res != icsneoc2_error_success) {
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to transmit LIN header", res);
+		}
+		printf("OK\n\n");
+	}
+
+	sleep_ms(100);
+
+	/* Transmit a LIN commander message with data on LIN 01 */
+	printf("Transmitting a LIN 01 commander frame with data... ");
+	{
+		icsneoc2_message_t* msg = NULL;
+		res = icsneoc2_message_lin_create(&msg, 0x22);
+		if(res != icsneoc2_error_success) {
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to create LIN message", res);
+		}
+		icsneoc2_lin_msg_type_t msg_type = icsneoc2_lin_msg_type_commander_msg;
+		bool enhanced = true;
+		res = icsneoc2_message_lin_props_set(msg, NULL, NULL, &msg_type, &enhanced);
+		uint8_t data[] = {0x11, 0x22, 0x33, 0x44, 0xaa, 0xbb, 0xcc, 0xdd};
+		res += icsneoc2_message_data_set(msg, data, sizeof(data));
+		res += icsneoc2_message_netid_set(msg, icsneoc2_netid_lin_01);
+        res += icsneoc2_message_lin_calc_checksum(msg);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(msg);
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to set LIN message properties", res);
+		}
+		res = icsneoc2_device_message_transmit(device, msg);
+		icsneoc2_message_free(msg);
+		if(res != icsneoc2_error_success) {
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to transmit LIN commander message", res);
+		}
+		printf("OK\n\n");
+	}
+
+	sleep_ms(100);
+
+	/* Read back any received messages and display LIN frames */
+	icsneoc2_message_t* messages[2048] = {0};
+	size_t message_count = 2048;
+	printf("Getting messages...\n");
+	for(size_t i = 0; i < message_count; ++i) {
+		res = icsneoc2_device_message_get(device, &messages[i], 0);
+		if(res != icsneoc2_error_success) {
+			for(size_t j = 0; j < i; ++j) {
+				icsneoc2_message_free(messages[j]);
+			}
+			print_events(description);
+			icsneoc2_device_close(device);
+			return print_error_code("\tFailed to get messages", res);
+		}
+		if(messages[i] == NULL) {
+			message_count = i;
+			break;
+		}
+	}
+	printf("\tReceived %zu messages\n", message_count);
+	process_lin_messages(messages, message_count);
+	for(size_t i = 0; i < message_count; ++i) {
+		icsneoc2_message_free(messages[i]);
+	}
+
+	/* Cleanup */
+	print_events(description);
+	printf("Closing device... ");
+	res = icsneoc2_device_close(device);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+
+	return 0;
+}

examples/c2/lin_transmit/CMakeLists.txt

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

examples/c2/lin_transmit/src/main.c

@@ -0,0 +1,276 @@
+#include <icsneo/icsneoc2.h>
+#include <icsneo/icsneoc2messages.h>
+#include <icsneo/icsneoc2settings.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+void sleep_ms(uint32_t ms) {
+#ifdef _WIN32
+	Sleep(ms);
+#else
+	sleep(ms / 1000);
+#endif
+}
+
+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 %d with error code %d\n", message, error, res);
+		return res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+int read_int(const char* prompt, int min_val, int max_val) {
+	int value;
+	while(1) {
+		printf("%s", prompt);
+		if(scanf("%d", &value) != 1) {
+			/* Clear invalid input */
+			int c;
+			while((c = getchar()) != '\n' && c != EOF) {}
+			printf("Invalid input, try again.\n");
+			continue;
+		}
+		if(value < min_val || value > max_val) {
+			printf("Please enter a value between %d and %d.\n", min_val, max_val);
+			continue;
+		}
+		return value;
+	}
+}
+
+int read_hex(const char* prompt, int min_val, int max_val) {
+	int value;
+	while(1) {
+		printf("%s", prompt);
+		if(scanf("%x", &value) != 1) {
+			/* Clear invalid input */
+			int c;
+			while((c = getchar()) != '\n' && c != EOF) {}
+			printf("Invalid input, try again.\n");
+			continue;
+		}
+		if(value < min_val || value > max_val) {
+			printf("Please enter a value between 0x%X and 0x%X.\n", min_val, max_val);
+			continue;
+		}
+		return value;
+	}
+}
+
+int main() {
+	icsneoc2_error_t res;
+
+	/* ===== Device Selection ===== */
+	printf("Searching for devices...\n");
+	icsneoc2_device_info_t* found_devices = NULL;
+	res = icsneoc2_device_enumerate(0, &found_devices);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to enumerate devices", res);
+	}
+	if(!found_devices) {
+		printf("No devices found.\n");
+		return 1;
+	}
+
+	/* Count and display devices */
+	int device_count = 0;
+	for(icsneoc2_device_info_t* cur = found_devices; cur; cur = icsneoc2_device_info_next(cur)) {
+		char desc[128] = {0};
+		size_t desc_len = sizeof(desc);
+		icsneoc2_device_info_description_get(cur, desc, &desc_len);
+		printf("  [%d] %s\n", device_count + 1, desc);
+		device_count++;
+	}
+
+	int device_choice = read_int("Select device: ", 1, device_count);
+
+	/* Find the selected device_info node */
+	icsneoc2_device_info_t* selected_info = found_devices;
+	for(int i = 1; i < device_choice; i++) {
+		selected_info = icsneoc2_device_info_next(selected_info);
+	}
+
+	/* Open the selected device */
+	icsneoc2_device_t* device = NULL;
+	res = icsneoc2_device_create(selected_info, &device);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_enumeration_free(found_devices);
+		return print_error_code("Failed to create device from device info", res);
+	}
+	res = icsneoc2_device_open(device, icsneoc2_open_options_default);
+	icsneoc2_enumeration_free(found_devices);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to open 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);
+
+	/* ===== LIN Network Selection ===== */
+	/* Get all supported TX networks */
+	size_t tx_net_count = 0;
+	res = icsneoc2_device_supported_tx_networks_get(device, NULL, &tx_net_count);
+	if(res != icsneoc2_error_success || tx_net_count == 0) {
+		printf("No supported TX networks.\n");
+		icsneoc2_device_close(device);
+		return 1;
+	}
+
+	icsneoc2_netid_t* tx_networks = (icsneoc2_netid_t*)malloc(tx_net_count * sizeof(icsneoc2_netid_t));
+	if(!tx_networks) {
+		printf("Out of memory.\n");
+		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
+		return 1;
+	}
+	res = icsneoc2_device_supported_tx_networks_get(device, tx_networks, &tx_net_count);
+	if(res != icsneoc2_error_success) {
+		free(tx_networks);
+		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to get TX networks", res);
+	}
+
+	/* Filter for LIN networks */
+	icsneoc2_netid_t lin_networks[64] = {0};
+	char lin_names[64][128] = {{0}};
+	size_t lin_count = 0;
+	for(size_t i = 0; i < tx_net_count && lin_count < 64; i++) {
+		icsneoc2_message_t* tmp = NULL;
+		res = icsneoc2_message_lin_create(&tmp, 0);
+		if(res != icsneoc2_error_success) continue;
+		res = icsneoc2_message_netid_set(tmp, tx_networks[i]);
+		if(res != icsneoc2_error_success) { icsneoc2_message_free(tmp); continue; }
+		icsneoc2_network_type_t ntype = 0;
+		res = icsneoc2_message_network_type_get(tmp, &ntype);
+		icsneoc2_message_free(tmp);
+		if(res != icsneoc2_error_success) continue;
+		if(ntype == icsneoc2_network_type_lin) {
+			lin_networks[lin_count] = tx_networks[i];
+			size_t name_len = 128;
+			icsneoc2_netid_name_get(tx_networks[i], lin_names[lin_count], &name_len);
+			lin_count++;
+		}
+	}
+	free(tx_networks);
+
+	if(lin_count == 0) {
+		printf("No LIN networks available on this device.\n");
+		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
+		return 1;
+	}
+
+	printf("Available LIN networks:\n");
+	for(size_t i = 0; i < lin_count; i++) {
+		printf("  [%zu] %s\n", i + 1, lin_names[i]);
+	}
+
+	int lin_choice = read_int("Select LIN network: ", 1, (int)lin_count);
+	icsneoc2_netid_t selected_netid = lin_networks[lin_choice - 1];
+	printf("Selected: %s\n\n", lin_names[lin_choice - 1]);
+
+	/* ===== Commander / Responder Selection ===== */
+	printf("Message type:\n");
+	printf("  [1] Commander frame\n");
+	printf("  [2] Responder frame (update responder + header only)\n");
+	int type_choice = read_int("Select message type: ", 1, 2);
+	bool is_commander = (type_choice == 1);
+	printf("Selected: %s\n\n", is_commander ? "Commander" : "Responder");
+
+	uint8_t id_choice = (uint8_t)read_hex("Select LIN ID (0x00-0x3F): ", 0, 0x3F);
+	printf("Selected: 0x%02X\n\n", id_choice);
+
+	/* ===== Configure LIN ===== */
+	printf("Configuring %s... ", lin_names[lin_choice - 1]);
+	res = icsneoc2_settings_commander_resistor_set(device, selected_netid, is_commander);
+	res += icsneoc2_settings_baudrate_set(device, selected_netid, 19200);
+	res += icsneoc2_settings_lin_mode_set(device, selected_netid, icsneoc2_lin_mode_normal);
+	res += icsneoc2_settings_apply(device);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_device_close(device);
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to configure LIN", res);
+	}
+	printf("OK\n\n");
+
+	/* ===== Transmit Loop ===== */
+	printf("Transmitting on %s every second for 10 seconds...\n", lin_names[lin_choice - 1]);
+	uint8_t counter = 0;
+	for(int i = 0; i < 10; i++) {
+		icsneoc2_message_t* msg = NULL;
+		res = icsneoc2_message_lin_create(&msg, id_choice);
+		if(res != icsneoc2_error_success) {
+			print_error_code("\tFailed to create LIN message", res);
+			break;
+		}
+
+		uint8_t data[] = {counter, counter + 1, counter + 2, counter + 3, 0xAA, 0xBB, 0xCC, 0xDD};
+		bool enhanced = true;
+
+		if(is_commander) {
+			/* Commander: send header-only frame to poll the bus */
+			icsneoc2_lin_msg_type_t msg_type = icsneoc2_lin_msg_type_header_only;
+			res = icsneoc2_message_lin_props_set(msg, NULL, NULL, &msg_type, &enhanced);
+			res += icsneoc2_message_netid_set(msg, selected_netid);
+			if(res != icsneoc2_error_success) {
+				icsneoc2_message_free(msg);
+				print_error_code("\tFailed to set commander properties", res);
+				break;
+			}
+			res = icsneoc2_device_message_transmit(device, msg);
+			icsneoc2_message_free(msg);
+			if(res != icsneoc2_error_success) {
+				print_error_code("\tFailed to transmit header", res);
+				break;
+			}
+		} else {
+			/* Responder: update the responder table with new data */
+			icsneoc2_lin_msg_type_t msg_type = icsneoc2_lin_msg_type_update_responder;
+			res = icsneoc2_message_lin_props_set(msg, NULL, NULL, &msg_type, &enhanced);
+			res += icsneoc2_message_data_set(msg, data, sizeof(data));
+			res += icsneoc2_message_lin_calc_checksum(msg);
+			res += icsneoc2_message_netid_set(msg, selected_netid);
+			if(res != icsneoc2_error_success) {
+				icsneoc2_message_free(msg);
+				print_error_code("\tFailed to update responder", res);
+				break;
+			}
+			res = icsneoc2_device_message_transmit(device, msg);
+			icsneoc2_message_free(msg);
+			if(res != icsneoc2_error_success) {
+				print_error_code("\tFailed to transmit responder update", res);
+				break;
+			}
+		}
+		printf("[%2d/10] Transmitted %s msg ID=0x%02X, counter=%u\n",
+			i + 1, is_commander ? "commander" : "responder", id_choice, counter);
+		counter += 4;
+		sleep_ms(1000);
+	}
+
+	/* Cleanup */
+	printf("\nClosing device... ");
+	res = icsneoc2_device_close(device);
+	printf("%s\n", res == icsneoc2_error_success ? "OK" : "FAIL");
+	icsneoc2_device_free(device);
+
+	return 0;
+}

examples/c2/read_messages/src/main.c

@@ -69,6 +69,8 @@ int print_error_code(const char* message, icsneoc2_error_t error) {
  */
 int process_message(icsneoc2_message_t** messages, size_t messages_count);
 
+int transmit_can_messages(icsneoc2_device_t* device);
+
 int main() {
 	// Open the first available device with default options
 	printf("Opening first available device...\n");
@@ -83,10 +85,15 @@ int main() {
 	size_t description_length = 255;
 	res = icsneoc2_device_description_get(open_device, description, &description_length);
 	if(res != icsneoc2_error_success) {
+		icsneoc2_device_free(open_device);
 		return print_error_code("\tFailed to get device description", res);
 	};
 	printf("\tOpened device: %s\n", description);
 
+	// Transmit messages for debugging purposes
+	// transmit_can_messages(open_device);
+	// sleep_ms(1000);
+
 	// Get the messages
 	icsneoc2_message_t* messages[20000] = {0};
 	size_t message_count = 20000;
@@ -96,6 +103,7 @@ int main() {
 		res = icsneoc2_device_message_get(open_device, &messages[i], 0);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
 			return print_error_code("\tFailed to get messages from device", res);
 		};
 		if(messages[i] == NULL) {
@@ -106,6 +114,7 @@ int main() {
 	}
 	if(res != icsneoc2_error_success) {
 		print_events(description);
+		icsneoc2_device_free(open_device);
 		return print_error_code("\tFailed to get messages from device", res);
 	}
 	time_t end_time = time(NULL);
@@ -114,6 +123,7 @@ int main() {
 	res = process_message(messages, message_count);
 	if(res != icsneoc2_error_success) {
 		print_events(description);
+		icsneoc2_device_free(open_device);
 		return print_error_code("\tFailed to process messages", res);
 	}
 	// Finally, close the device.
@@ -121,8 +131,10 @@ int main() {
 	res = icsneoc2_device_close(open_device);
 	if(res != icsneoc2_error_success) {
 		print_events(description);
+		icsneoc2_device_free(open_device);
 		return print_error_code("\tFailed to close device", res);
 	};
+	icsneoc2_device_free(open_device);
 
 	printf("\n");
 	return 0;
@@ -163,10 +175,49 @@ void print_events(const char* device_description) {
 int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 	// Print the type and bus type of each message
 	size_t tx_count = 0;
+	size_t can_error_count = 0;
+	icsneoc2_error_t res = icsneoc2_error_success;
 	for(size_t i = 0; i < messages_count; i++) {
 		icsneoc2_message_t* message = messages[i];
+
+		bool is_can_error = false;
+		res = icsneoc2_message_is_can_error(message, &is_can_error);
+		if(res != icsneoc2_error_success) {
+			return print_error_code("\tFailed to check if message is a CAN error", res);
+		}
+		if(is_can_error) {
+			icsneoc2_network_type_t network_type;
+			uint8_t tec = 0;
+			uint8_t rec = 0;
+			icsneoc2_can_error_code_t error_code = 0;
+			icsneoc2_can_error_code_t data_error_code = 0;
+			icsneoc2_message_can_error_flags_t error_flags = 0;
+			icsneoc2_netid_t netid = 0;
+			char network_type_name[128] = {0};
+			size_t network_type_name_length = 128;
+			char netid_name[128] = {0};
+			size_t netid_name_length = 128;
+
+			res = icsneoc2_message_network_type_get(message, &network_type);
+			res += icsneoc2_network_type_name_get(network_type, network_type_name, &network_type_name_length);
+			res += icsneoc2_message_netid_get(message, &netid);
+			res += icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
+			res += icsneoc2_message_can_error_props_get(message, &tec, &rec, &error_code, &data_error_code, &error_flags);
+			if(res != icsneoc2_error_success) {
+				return print_error_code("\tFailed to get CAN error properties", res);
+			}
+
+			printf("\t%zd) CAN Error on %s [%s] (0x%x): TEC=%u REC=%u ErrorCode=%u DataErrorCode=%u%s%s%s\n",
+				i, netid_name, network_type_name, netid, tec, rec, error_code, data_error_code,
+				(error_flags & ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF) ? " [BusOff]" : "",
+				(error_flags & ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE) ? " [ErrorPassive]" : "",
+				(error_flags & ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN) ? " [ErrorWarn]" : "");
+			can_error_count++;
+			continue;
+		}
+
 		bool is_frame = false;
-		icsneoc2_error_t res = icsneoc2_message_is_frame(message, &is_frame);
+		res = icsneoc2_message_is_frame(message, &is_frame);
 		if(res != icsneoc2_error_success) {
 			return print_error_code("\tFailed to check if message is a frame", res);
 		}
@@ -186,37 +237,55 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 		if(res != icsneoc2_error_success) {
 			return print_error_code("\tFailed to get message bus type name", res);
 		}
-		bool is_tx = false;
-		res = icsneoc2_message_is_transmit(message, &is_tx);
+		
 		if(res != icsneoc2_error_success) {
 			return print_error_code("\tFailed to get message is transmit", res);
 		}
-		if(is_tx) {
-			tx_count++;
-			continue;
-		}
 
 		printf("\t%zd) network type: %s (%u)\n", i, network_type_name, network_type);
-
 		if(network_type == icsneoc2_network_type_can) {
-			uint32_t arbid = 0;
+			uint64_t arbid = 0;
 			int32_t dlc = 0;
 			icsneoc2_netid_t netid = 0;
-			bool is_remote = false;
-			bool is_canfd = false;
-			bool is_extended = false;
+			icsneoc2_message_can_flags_t can_flags = 0;
 			uint8_t data[64] = {0};
 			size_t data_length = 64;
 			char netid_name[128] = {0};
 			size_t netid_name_length = 128;
+			bool is_error = false;
+			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_can_props_get(message, &arbid, &can_flags);
 			result += icsneoc2_message_data_get(message, data, &data_length);
+			result += icsneoc2_message_is_transmit(message, &is_tx);
+			result += icsneoc2_message_is_error(message, &is_error);
 			if(result != icsneoc2_error_success) {
 				printf("\tFailed get get CAN parameters (error: %u) for index %zu\n", result, i);
 				continue;
 			}
-			printf("\t  NetID: %s (0x%x)\tArbID: 0x%x\t DLC: %u\t Remote: %d\t CANFD: %d\t Extended: %d\t Data length: %zu\n", netid_name, netid, arbid, dlc, is_remote, is_canfd, is_extended, data_length);
+			tx_count += is_tx ? 1 : 0;
+			bool is_remote = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_RTR) != 0;
+			bool is_extended = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_IDE) != 0;
+			bool is_canfd = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_FDF) != 0;
+			bool is_brs = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_BRS) != 0;
+			bool is_esi = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_ESI) != 0;
+			bool tx_aborted = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED) != 0;
+			bool tx_lost_arb = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB) != 0;
+			bool tx_error = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR) != 0;
+			dlc = (int32_t)data_length;
+
+			printf("\t  %s%s\n", is_tx ? "TX" : "RX", is_error ? " [Error]" : "");
+			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" : "",
+				is_extended ? " IDE" : "",
+				is_canfd ? " FDF" : "",
+				is_brs ? " BRS" : "",
+				is_esi ? " ESI" : "",
+				tx_aborted ? " TX_ABORTED" : "",
+				tx_lost_arb ? " TX_LOST_ARB" : "",
+				tx_error ? " TX_ERROR" : "");
 			printf("\t  Data: [");
 			for(size_t x = 0; x < data_length; x++) {
 				printf(" 0x%x", data[x]);
@@ -224,14 +293,14 @@ int process_message(icsneoc2_message_t** messages, size_t messages_count) {
 			printf(" ]\n");
 		}
 	}
-	printf("\tReceived %zu messages total, %zu were TX messages\n", messages_count, tx_count);
+	printf("\tReceived %zu messages total, %zu were TX messages, %zu were CAN errors\n", messages_count, tx_count, can_error_count);
 
 	return icsneoc2_error_success;
 }
 
 int transmit_can_messages(icsneoc2_device_t* device) {
 	uint64_t counter = 0;
-	const size_t msg_count = 100;
+	const size_t msg_count = 10;
 	printf("\tTransmitting %zd messages...\n", msg_count);
 	for(size_t i = 0; i < msg_count; i++) {
 		// Create the message
@@ -242,8 +311,12 @@ int transmit_can_messages(icsneoc2_device_t* device) {
 		}
 		// Set the message attributes
 		res = icsneoc2_message_netid_set(message, icsneoc2_netid_dwcan_01);
+		uint64_t arb_id = 0x10;
+		uint64_t flags = 0;
+		res += icsneoc2_message_can_props_set(message, &arb_id, &flags);
 		res += icsneoc2_message_data_set(message, (uint8_t*)&counter, sizeof(counter));
 		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
 			return print_error_code("\tFailed to modify message", res);
 		}
 		res = icsneoc2_device_message_transmit(device, message);

examples/c2/reconnect/CMakeLists.txt

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

examples/c2/reconnect/src/main.c

@@ -0,0 +1,132 @@
+#include <icsneo/icsneoc2.h>
+
+#include <stdio.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+void sleep_ms(uint32_t ms) {
+#ifdef _WIN32
+	Sleep(ms);
+#else
+	usleep(ms * 1000);
+#endif
+}
+
+int print_error_code(const char* message, icsneoc2_error_t error) {
+	char error_str[64];
+	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 %d with error code %d\n", message, error, res);
+		return res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+void print_events(void) {
+	icsneoc2_event_t* events[256] = {0};
+	size_t events_count = 256;
+	for(size_t i = 0; i < events_count; ++i) {
+		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
+		if(res != icsneoc2_error_success) {
+			(void)print_error_code("\tFailed to get events", res);
+			return;
+		}
+		if(events[i] == NULL) {
+			events_count = i;
+			break;
+		}
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		char description[255] = {0};
+		size_t description_length = 255;
+		icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
+		if(res != icsneoc2_error_success) {
+			print_error_code("\tFailed to get event description", res);
+			continue;
+		}
+		printf("\tEvent %zu: %s\n", i, description);
+	}
+	for(size_t i = 0; i < events_count; i++) {
+		icsneoc2_event_free(events[i]);
+	}
+	if(events_count > 0) {
+		printf("\tReceived %zu events\n", events_count);
+	}
+}
+
+int main(void) {
+	/* Open the first available device */
+	printf("Opening first available device...\n");
+	icsneoc2_device_t* device = NULL;
+	icsneoc2_error_t res = icsneoc2_device_open_first(0, icsneoc2_open_options_default, &device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to open first device", res);
+	}
+
+	/* Get a description of the opened device */
+	char description[255] = {0};
+	size_t description_length = 255;
+	res = icsneoc2_device_description_get(device, description, &description_length);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to get device description", res);
+	}
+	printf("Opened device: %s\n", description);
+
+	/* Wait for the device to disconnect */
+	printf("Waiting for device to disconnect (unplug device from PC)...\n");
+	for(;;) {
+		bool is_open = true;
+		res = icsneoc2_device_is_open(device, &is_open);
+		if(res != icsneoc2_error_success) {
+			print_events();
+			icsneoc2_device_free(device);
+			return print_error_code("Failed to check open status", res);
+		}
+		if(!is_open) {
+			printf("Device disconnected!\n");
+			break;
+		}
+		sleep_ms(500);
+	}
+
+	/* Attempt to reconnect */
+	uint32_t timeout_ms = 20000; // 20 second timeout
+	printf("Attempting to reconnect (%u second timeout)...\n", timeout_ms / 1000);
+	res = icsneoc2_device_reconnect(device, icsneoc2_open_options_default, timeout_ms);
+	if(res != icsneoc2_error_success) {
+		print_events();
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to reconnect", res);
+	}
+
+	printf("Reconnected successfully!\n");
+
+	/* Verify by getting the description again */
+	description_length = 255;
+	res = icsneoc2_device_description_get(device, description, &description_length);
+	if(res == icsneoc2_error_success) {
+		printf("Device: %s\n", description);
+	}
+
+	/* Print any events */
+	print_events();
+
+	/* Close the device */
+	printf("Closing device...\n");
+	res = icsneoc2_device_close(device);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_device_free(device);
+		return print_error_code("Failed to close device", res);
+	}
+	icsneoc2_device_free(device);
+
+	printf("Done.\n");
+	return 0;
+}

examples/c2/simple/src/main.c

@@ -116,6 +116,7 @@ int main() {
 		size_t description_length = 255;
 		res = icsneoc2_device_info_description_get(cur, description, &description_length);
 		if(res != icsneoc2_error_success) {
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to get device description", res);
 		};
 		printf("%.*s\n", (int)description_length, description);
@@ -126,8 +127,15 @@ int main() {
 		printf("\tDevice open options: 0x%x\n", options);
 		printf("\tOpening device: %s...\n", description);
 		icsneoc2_device_t* open_device = NULL;
-		res = icsneoc2_device_open(cur, options, &open_device);
+		res = icsneoc2_device_create(cur, &open_device);
 		if(res != icsneoc2_error_success) {
+			icsneoc2_enumeration_free(found_devices);
+			return print_error_code("\tFailed to create device", res);
+		}
+		res = icsneoc2_device_open(open_device, options);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to open device", res);
 		};
 
@@ -137,6 +145,8 @@ int main() {
 		res = icsneoc2_device_timestamp_resolution_get(open_device, &timestamp_resolution);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to get timestamp resolution", res);
 		}
 		printf("%uns\n", timestamp_resolution);
@@ -146,6 +156,8 @@ int main() {
 		res = icsneoc2_settings_baudrate_get(open_device, icsneoc2_netid_dwcan_01, &baudrate);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to get baudrate", res);
 		};
 		printf("%" PRIu64 "mbit/s\n", baudrate);
@@ -155,6 +167,8 @@ int main() {
 		res = icsneoc2_settings_canfd_baudrate_get(open_device, icsneoc2_netid_dwcan_01, &fd_baudrate);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to get FD baudrate", res);
 		};
 		printf("%" PRIu64 "mbit/s\n", fd_baudrate);
@@ -165,6 +179,8 @@ int main() {
 		res = icsneoc2_settings_baudrate_set(open_device, icsneoc2_netid_dwcan_01, baudrate);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to set baudrate", res);
 		};
 		printf("Ok\n");
@@ -173,6 +189,8 @@ int main() {
 		res = icsneoc2_settings_canfd_baudrate_set(open_device, icsneoc2_netid_dwcan_01, fd_baudrate);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to set FD baudrate", res);
 		};
 		printf("Ok\n");
@@ -181,6 +199,8 @@ int main() {
 		res = get_and_print_rtc(open_device);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to get RTC", res);
 		}
 		// Set RTC
@@ -189,6 +209,8 @@ int main() {
 		res = icsneoc2_device_rtc_set(open_device, current_time);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to set RTC", res);
 		}
 		printf("Ok\n");
@@ -197,6 +219,8 @@ int main() {
 		res = get_and_print_rtc(open_device);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to get RTC", res);
 		}
 		// Go online, start acking traffic
@@ -204,6 +228,8 @@ int main() {
 		res = icsneoc2_device_go_online(open_device, true);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to go online", res);
 		}
 		// Redundant check to show how to check if the device is online, if the previous
@@ -212,6 +238,8 @@ int main() {
 		res = icsneoc2_device_is_online(open_device, &is_online);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to check if online", res);
 		}
 		printf("%s\n", is_online ? "Online" : "Offline");
@@ -219,6 +247,8 @@ int main() {
 		res = transmit_can_messages(open_device);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to transmit CAN messages", res);
 		}
 		// Wait for the bus to collect some messages, requires an active bus to get messages
@@ -231,7 +261,12 @@ int main() {
 		for(size_t i = 0; i < message_count; ++i) {
 			res = icsneoc2_device_message_get(open_device, &messages[i], 0);
 			if(res != icsneoc2_error_success) {
+				for(size_t j = 0; j < i; ++j) {
+					icsneoc2_message_free(messages[j]);
+				}
 				print_events(description);
+				icsneoc2_device_free(open_device);
+				icsneoc2_enumeration_free(found_devices);
 				return print_error_code("\tFailed to get messages from device", res);
 			};
 			if(messages[i] == NULL) {
@@ -243,7 +278,12 @@ int main() {
 		// Process the messages
 		res = process_messages(messages, message_count);
 		if(res != icsneoc2_error_success) {
+			for(size_t i = 0; i < message_count; ++i) {
+				icsneoc2_message_free(messages[i]);
+			}
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to process messages", res);
 		}
 		for(size_t i = 0; i < message_count; ++i) {
@@ -254,11 +294,13 @@ int main() {
 		res = icsneoc2_device_close(open_device);
 		if(res != icsneoc2_error_success) {
 			print_events(description);
+			icsneoc2_device_free(open_device);
+			icsneoc2_enumeration_free(found_devices);
 			return print_error_code("\tFailed to close device", res);
 		};
 		// Print device events
 		print_events(description);
-
+		icsneoc2_device_free(open_device);
 	}
 	icsneoc2_enumeration_free(found_devices);
 	printf("\n");
@@ -285,6 +327,9 @@ void print_events(const char* device_description) {
 		// no device filter, get all events
 		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
 		if(res != icsneoc2_error_success) {
+			for(size_t j = 0; j < i; ++j) {
+				icsneoc2_event_free(events[j]);
+			}
 			(void)print_error_code("\tFailed to get device events", res);
 			return;
 		}
@@ -313,10 +358,42 @@ void print_events(const char* device_description) {
 int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 	// Print the type and bus type of each message
 	size_t tx_count = 0;
+	size_t can_error_count = 0;
 	for(size_t i = 0; i < messages_count; i++) {
 		icsneoc2_message_t* message = messages[i];
+
+		// Check for CAN error messages
+		bool is_can_error = false;
+		icsneoc2_error_t res = icsneoc2_message_is_can_error(message, &is_can_error);
+		if(res != icsneoc2_error_success) {
+			return print_error_code("\tFailed to check if message is a CAN error", res);
+		}
+		if(is_can_error) {
+			uint8_t tec = 0;
+			uint8_t rec = 0;
+			icsneoc2_can_error_code_t error_code = 0;
+			icsneoc2_can_error_code_t data_error_code = 0;
+			icsneoc2_message_can_error_flags_t error_flags = 0;
+			icsneoc2_netid_t netid = 0;
+			res = icsneoc2_message_netid_get(message, &netid);
+			res += icsneoc2_message_can_error_props_get(message, &tec, &rec, &error_code, &data_error_code, &error_flags);
+			if(res != icsneoc2_error_success) {
+				return print_error_code("\tFailed to get CAN error properties", res);
+			}
+			char netid_name[128] = {0};
+			size_t netid_name_length = 128;
+			icsneoc2_netid_name_get(netid, netid_name, &netid_name_length);
+			printf("\t%zd) CAN Error on %s (0x%x): TEC=%u REC=%u ErrorCode=%u DataErrorCode=%u%s%s%s\n",
+				i, netid_name, netid, tec, rec, error_code, data_error_code,
+				(error_flags & ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF) ? " [BusOff]" : "",
+				(error_flags & ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE) ? " [ErrorPassive]" : "",
+				(error_flags & ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN) ? " [ErrorWarn]" : "");
+			can_error_count++;
+			continue;
+		}
+
 		bool is_frame = false;
-		icsneoc2_error_t res = icsneoc2_message_is_frame(message, &is_frame);
+		res = icsneoc2_message_is_frame(message, &is_frame);
 		if(res != icsneoc2_error_success) {
 			return print_error_code("\tFailed to check if message is a frame", res);
 		}
@@ -349,24 +426,42 @@ 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) {
-			uint32_t arbid = 0;
+			uint64_t arbid = 0;
 			int32_t dlc = 0;
 			icsneoc2_netid_t netid = 0;
-			bool is_remote = false;
-			bool is_canfd = false;
-			bool is_extended = false;
+			icsneoc2_message_can_flags_t can_flags = 0;
 			uint8_t data[64] = {0};
 			size_t data_length = 64;
 			char netid_name[128] = {0};
 			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_can_props_get(message, &arbid, &can_flags);
 			result += icsneoc2_message_data_get(message, data, &data_length);
 			if(result != icsneoc2_error_success) {
 				printf("\tFailed get get CAN parameters (error: %u) for index %zu\n", result, i);
 				continue;
 			}
-			printf("\t  NetID: %s (0x%x)\tArbID: 0x%x\t DLC: %u\t Remote: %d\t CANFD: %d\t Extended: %d\t Data length: %zu\n", netid_name, netid, arbid, dlc, is_remote, is_canfd, is_extended, data_length);
+			bool is_remote = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_RTR) != 0;
+			bool is_extended = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_IDE) != 0;
+			bool is_canfd = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_FDF) != 0;
+			bool is_brs = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_BRS) != 0;
+			bool is_esi = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_ESI) != 0;
+			bool tx_aborted = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED) != 0;
+			bool tx_lost_arb = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB) != 0;
+			bool tx_error = (can_flags & ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR) != 0;
+			dlc = (int32_t)data_length;
+
+			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" : "",
+				is_extended ? " IDE" : "",
+				is_canfd ? " FDF" : "",
+				is_brs ? " BRS" : "",
+				is_esi ? " ESI" : "",
+				tx_aborted ? " TX_ABORTED" : "",
+				tx_lost_arb ? " TX_LOST_ARB" : "",
+				tx_error ? " TX_ERROR" : "");
 			printf("\t  Data: [");
 			for(size_t x = 0; x < data_length; x++) {
 				printf(" 0x%x", data[x]);
@@ -374,7 +469,7 @@ int process_messages(icsneoc2_message_t** messages, size_t messages_count) {
 			printf(" ]\n");
 		}
 	}
-	printf("\tReceived %zu messages total, %zu were TX messages\n", messages_count, tx_count);
+	printf("\tReceived %zu messages total, %zu were TX messages, %zu were CAN errors\n", messages_count, tx_count, can_error_count);
 
 	return icsneoc2_error_success;
 }
@@ -397,6 +492,7 @@ int transmit_can_messages(icsneoc2_device_t* device) {
 		res += icsneoc2_message_can_props_set(message, &arb_id, &flags);
 		res += icsneoc2_message_data_set(message, (uint8_t*)&counter, sizeof(counter));
 		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
 			return print_error_code("\tFailed to modify message", res);
 		}
 		res = icsneoc2_device_message_transmit(device, message);

examples/c2/t1s_loopback/CMakeLists.txt

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

examples/c2/t1s_loopback/src/main.c

@@ -0,0 +1,643 @@
+#include <icsneo/icsneoc2.h>
+#include <icsneo/icsneoc2messages.h>
+#include <icsneo/icsneoc2settings.h>
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#define TX_LOCAL_ID 0u
+#define RX_LOCAL_ID 1u
+#define T1S_MAX_NODES 8u
+#define T1S_TX_OPP_TIMER 20u
+#define T1S_BURST_TIMER 64u
+#define T1S_MAX_BURST 128u
+#define LOOPBACK_ETHER_TYPE 0x9000u
+#define LOOPBACK_FRAME_SIZE 60u
+
+typedef struct selectable_network {
+	icsneoc2_netid_t netid;
+	char name[64];
+} selectable_network_t;
+
+/* Sleep for a short period while waiting for the device to apply settings. */
+static void sleep_ms(uint32_t ms);
+
+/* Print a readable error string and return the same failure code to the caller. */
+static int print_error_code(const char* message, icsneoc2_error_t error);
+
+/* Drain and print queued library events when the example encounters an error. */
+static void print_events(void);
+
+/* Convert a netid to a readable name such as "AE 02". */
+static int get_netid_name(icsneoc2_netid_t netid, char* buffer, size_t buffer_size);
+
+/* Gather the device's TX and RX networks, keeping only automotive Ethernet ports. */
+static int get_available_networks(const icsneoc2_device_t* device,
+		selectable_network_t* tx_networks,
+		size_t* tx_count,
+		selectable_network_t* rx_networks,
+		size_t* rx_count);
+
+/* Prompt the user to choose one TX or RX network from the filtered list. */
+static int prompt_for_network_selection(const char* label, const selectable_network_t* networks, size_t count, icsneoc2_netid_t* selected_netid, char* selected_name, size_t selected_name_size);
+
+/* Apply the small set of T1S settings needed for this two-port loopback example. */
+static int configure_t1s_port(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t local_id);
+
+/* Print a MAC address in a compact human-readable form. */
+static void print_mac(const char* label, const uint8_t* mac);
+
+/* Print payload bytes as hex for the TX echo and RX frame output. */
+static void print_payload_hex(const uint8_t* data, size_t length);
+
+/* Build one recognizable Ethernet frame that both transmit and receive paths share. */
+static void build_loopback_frame(uint8_t* frame_data, size_t frame_size, const char* tx_name, const char* rx_name);
+
+/* Check whether a received Ethernet frame matches the loopback frame this example sent. */
+static int message_matches_loopback_frame(icsneoc2_message_t* message, const uint8_t* expected, size_t expected_length, bool* matches);
+
+/* Print the key details of an Ethernet message found during the loopback test. */
+static int print_ethernet_message(icsneoc2_message_t* message, const char* direction_label);
+
+/* Transmit the loopback Ethernet frame on the selected TX port. */
+static int transmit_loopback_frame(icsneoc2_device_t* device, icsneoc2_netid_t tx_netid, const char* tx_name, const char* rx_name);
+
+/* Poll until the example sees both the TX echo and the matching RX frame. */
+static int poll_for_loopback_messages(icsneoc2_device_t* device,
+		icsneoc2_netid_t tx_netid,
+		icsneoc2_netid_t rx_netid,
+		const char* tx_name,
+		const char* rx_name,
+		const uint8_t* expected_frame,
+		size_t expected_frame_length);
+
+int main(void) {
+	icsneoc2_device_t* device = NULL;
+	icsneoc2_error_t res;
+	char description[255] = {0};
+	char serial[64] = {0};
+	size_t description_length = sizeof(description);
+	size_t serial_length = sizeof(serial);
+	selectable_network_t available_tx_networks[128] = {0};
+	selectable_network_t available_rx_networks[128] = {0};
+	size_t available_tx_count = 0;
+	size_t available_rx_count = 0;
+	icsneoc2_netid_t tx_netid = 0;
+	icsneoc2_netid_t rx_netid = 0;
+	uint8_t expected_frame[LOOPBACK_FRAME_SIZE] = {0};
+	char tx_name[64] = {0};
+	char rx_name[64] = {0};
+	int status = 1;
+
+	printf("RAD-Comet3 C2 T1S loopback example\n");
+	printf("Opening first available RAD-Comet3...\n");
+
+	res = icsneoc2_device_open_first(icsneoc2_devicetype_rad_comet3, icsneoc2_open_options_default, &device);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to open a RAD-Comet3", res);
+	}
+
+	res = icsneoc2_device_description_get(device, description, &description_length);
+	if(res != icsneoc2_error_success) {
+		print_error_code("Failed to get device description", res);
+		goto cleanup;
+	}
+	res = icsneoc2_device_serial_get(device, serial, &serial_length);
+	if(res != icsneoc2_error_success) {
+		print_error_code("Failed to get device serial", res);
+		goto cleanup;
+	}
+	printf("Opened device: %s [%s]\n", description, serial);
+
+	if(get_available_networks(device, available_tx_networks, &available_tx_count, available_rx_networks, &available_rx_count) != 0) {
+		goto cleanup;
+	}
+
+	if(prompt_for_network_selection("TX", available_tx_networks, available_tx_count, &tx_netid, tx_name, sizeof(tx_name)) != 0) {
+		goto cleanup;
+	}
+	if(prompt_for_network_selection("RX", available_rx_networks, available_rx_count, &rx_netid, rx_name, sizeof(rx_name)) != 0) {
+		goto cleanup;
+	}
+
+	printf("Selected loopback wiring: %s connected to %s\n", tx_name, rx_name);
+
+	if(tx_netid == rx_netid) {
+		printf("TX and RX networks are the same. This example is intended for a physical loopback between two ports.\n");
+		goto cleanup;
+	}
+
+	// Use the same expected frame bytes for transmit and for receive-side matching.
+	build_loopback_frame(expected_frame, sizeof(expected_frame), tx_name, rx_name);
+
+	res = icsneoc2_settings_refresh(device);
+	if(res != icsneoc2_error_success) {
+		print_error_code("Failed to refresh device settings", res);
+		goto cleanup;
+	}
+
+	if(configure_t1s_port(device, tx_netid, TX_LOCAL_ID) != 0) {
+		goto cleanup;
+	}
+	if(configure_t1s_port(device, rx_netid, RX_LOCAL_ID) != 0) {
+		goto cleanup;
+	}
+
+	printf("Applying T1S settings to the device.\n");
+	printf("Note: icsneoc2_settings_apply() persists these settings on the device.\n");
+	res = icsneoc2_settings_apply(device);
+	if(res != icsneoc2_error_success) {
+		print_error_code("Failed to apply T1S settings", res);
+		goto cleanup;
+	}
+
+	sleep_ms(500);
+
+	if(transmit_loopback_frame(device, tx_netid, tx_name, rx_name) != 0) {
+		goto cleanup;
+	}
+
+	if(poll_for_loopback_messages(device, tx_netid, rx_netid, tx_name, rx_name, expected_frame, sizeof(expected_frame)) != 0) {
+		print_events();
+		goto cleanup;
+	}
+
+	status = 0;
+
+cleanup:
+	if(device != NULL) {
+		res = icsneoc2_device_close(device);
+		if(res != icsneoc2_error_success) {
+			(void)print_error_code("Failed to close device", res);
+		}
+		res = icsneoc2_device_free(device);
+		if(res != icsneoc2_error_success) {
+			(void)print_error_code("Failed to free device", res);
+		}
+	}
+
+	return status;
+}
+
+static void sleep_ms(uint32_t ms) {
+#ifdef _WIN32
+	Sleep(ms);
+#else
+	usleep(ms * 1000);
+#endif
+}
+
+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 with error code %u\n", message, error, res);
+		return (int)res;
+	}
+	printf("%s: \"%s\" (%u)\n", message, error_str, error);
+	return (int)error;
+}
+
+static void print_events(void) {
+	icsneoc2_event_t* events[64] = {0};
+	size_t count = sizeof(events) / sizeof(events[0]);
+
+	for(size_t i = 0; i < count; ++i) {
+		icsneoc2_error_t res = icsneoc2_event_get(&events[i], NULL);
+		if(res != icsneoc2_error_success) {
+			(void)print_error_code("Failed to get events", res);
+			return;
+		}
+		if(events[i] == NULL) {
+			count = i;
+			break;
+		}
+	}
+
+	for(size_t i = 0; i < count; ++i) {
+		char description[255] = {0};
+		size_t description_length = sizeof(description);
+		icsneoc2_error_t res = icsneoc2_event_description_get(events[i], description, &description_length);
+		if(res == icsneoc2_error_success) {
+			printf("Event %zu: %s\n", i, description);
+		}
+		icsneoc2_event_free(events[i]);
+	}
+}
+
+static int get_netid_name(icsneoc2_netid_t netid, char* buffer, size_t buffer_size) {
+	size_t length = buffer_size;
+	icsneoc2_error_t res = icsneoc2_netid_name_get(netid, buffer, &length);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to get netid name", res);
+	}
+	return 0;
+}
+
+static int get_available_networks(const icsneoc2_device_t* device,
+		selectable_network_t* tx_networks,
+		size_t* tx_count,
+		selectable_network_t* rx_networks,
+		size_t* rx_count) {
+	icsneoc2_netid_t supported_tx_networks[128] = {0};
+	icsneoc2_netid_t supported_rx_networks[128] = {0};
+	size_t tx_supported_count = sizeof(supported_tx_networks) / sizeof(supported_tx_networks[0]);
+	size_t rx_supported_count = sizeof(supported_rx_networks) / sizeof(supported_rx_networks[0]);
+	icsneoc2_message_t* probe = NULL;
+	icsneoc2_network_type_t network_type = 0;
+	icsneoc2_error_t res = icsneoc2_device_supported_tx_networks_get(device, supported_tx_networks, &tx_supported_count);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to get supported TX networks", res);
+	}
+	res = icsneoc2_device_supported_rx_networks_get(device, supported_rx_networks, &rx_supported_count);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to get supported RX networks", res);
+	}
+
+	*tx_count = 0;
+	*rx_count = 0;
+
+	// Reuse one temporary Ethernet message to classify each netid by network type.
+	res = icsneoc2_message_eth_create(&probe);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to create temporary Ethernet message", res);
+	}
+
+	for(size_t i = 0; i < tx_supported_count; ++i) {
+		res = icsneoc2_message_netid_set(probe, supported_tx_networks[i]);
+		if(res != icsneoc2_error_success) {
+			continue;
+		}
+		res = icsneoc2_message_network_type_get(probe, &network_type);
+		if(res != icsneoc2_error_success || network_type != icsneoc2_network_type_automotive_ethernet) {
+			continue;
+		}
+		tx_networks[*tx_count].netid = supported_tx_networks[i];
+		if(get_netid_name(supported_tx_networks[i], tx_networks[*tx_count].name, sizeof(tx_networks[*tx_count].name)) != 0) {
+			icsneoc2_message_free(probe);
+			return 1;
+		}
+		(*tx_count)++;
+	}
+
+	for(size_t i = 0; i < rx_supported_count; ++i) {
+		res = icsneoc2_message_netid_set(probe, supported_rx_networks[i]);
+		if(res != icsneoc2_error_success) {
+			continue;
+		}
+		res = icsneoc2_message_network_type_get(probe, &network_type);
+		if(res != icsneoc2_error_success || network_type != icsneoc2_network_type_automotive_ethernet) {
+			continue;
+		}
+		rx_networks[*rx_count].netid = supported_rx_networks[i];
+		if(get_netid_name(supported_rx_networks[i], rx_networks[*rx_count].name, sizeof(rx_networks[*rx_count].name)) != 0) {
+			icsneoc2_message_free(probe);
+			return 1;
+		}
+		(*rx_count)++;
+	}
+	icsneoc2_message_free(probe);
+
+	if(*tx_count == 0) {
+		printf("No automotive Ethernet TX networks are available on this device.\n");
+		return 1;
+	}
+	if(*rx_count == 0) {
+		printf("No automotive Ethernet RX networks are available on this device.\n");
+		return 1;
+	}
+	return 0;
+}
+
+static int prompt_for_network_selection(const char* label, const selectable_network_t* networks, size_t count, icsneoc2_netid_t* selected_netid, char* selected_name, size_t selected_name_size) {
+	char input[32] = {0};
+	char* end_ptr = NULL;
+	long selected_index = 0;
+
+	if(!label || !networks || count == 0 || !selected_netid || !selected_name || selected_name_size == 0) {
+		return print_error_code("Invalid network selection parameters", icsneoc2_error_invalid_parameters);
+	}
+
+	printf("Available automotive Ethernet %s networks:\n", label);
+	for(size_t i = 0; i < count; ++i) {
+		printf("  %zu) %s\n", i + 1, networks[i].name);
+	}
+	printf("Select %s network [1-%zu, default 1]: ", label, count);
+
+	if(fgets(input, sizeof(input), stdin) == NULL || input[0] == '\n') {
+		selected_index = 1;
+	} else {
+		selected_index = strtol(input, &end_ptr, 10);
+		if(end_ptr == input || selected_index < 1 || (size_t)selected_index > count) {
+			printf("Invalid selection, using %s.\n", networks[0].name);
+			selected_index = 1;
+		}
+	}
+
+	*selected_netid = networks[selected_index - 1].netid;
+	strncpy(selected_name, networks[selected_index - 1].name, selected_name_size - 1);
+	selected_name[selected_name_size - 1] = '\0';
+	return 0;
+}
+
+static int configure_t1s_port(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t local_id) {
+	char netid_name[64] = {0};
+	icsneoc2_error_t res;
+	bool termination = false;
+
+	if(get_netid_name(netid, netid_name, sizeof(netid_name)) != 0) {
+		return 1;
+	}
+
+	printf("Configuring %s: PLCA on, LocalID=%u, MaxNodes=%u, TxOpp=%u, BurstTimer=%u, MaxBurst=%u\n",
+		netid_name,
+		(unsigned)local_id,
+		(unsigned)T1S_MAX_NODES,
+		(unsigned)T1S_TX_OPP_TIMER,
+		(unsigned)T1S_BURST_TIMER,
+		(unsigned)T1S_MAX_BURST);
+
+	// Keep the example explicit about the small set of T1S settings needed for loopback.
+	res = icsneoc2_settings_t1s_plca_enabled_for_set(device, netid, true);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to enable T1S PLCA", res);
+	res = icsneoc2_settings_t1s_local_id_set(device, netid, local_id);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S local ID", res);
+	res = icsneoc2_settings_t1s_max_nodes_set(device, netid, T1S_MAX_NODES);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S max nodes", res);
+	res = icsneoc2_settings_t1s_tx_opp_timer_set(device, netid, T1S_TX_OPP_TIMER);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S TX opportunity timer", res);
+	res = icsneoc2_settings_t1s_burst_timer_set(device, netid, T1S_BURST_TIMER);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S burst timer", res);
+	res = icsneoc2_settings_t1s_max_burst_timer_for_set(device, netid, T1S_MAX_BURST);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S max burst", res);
+
+	res = icsneoc2_settings_t1s_is_termination_enabled_for(device, netid, &termination);
+	if(res == icsneoc2_error_success) {
+		res = icsneoc2_settings_t1s_termination_for_set(device, netid, true);
+		if(res != icsneoc2_error_success) return print_error_code("Failed to enable T1S termination", res);
+	} else if(res != icsneoc2_error_get_settings_failure) {
+		return print_error_code("Failed to query T1S termination support", res);
+	}
+
+	return 0;
+}
+
+static void print_mac(const char* label, const uint8_t* mac) {
+	printf("%s %02x:%02x:%02x:%02x:%02x:%02x", label, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+}
+
+static void print_payload_hex(const uint8_t* data, size_t length) {
+	for(size_t i = 0; i < length; ++i) {
+		printf("%02x", data[i]);
+		if(i + 1 < length) {
+			printf(" ");
+		}
+	}
+	printf("\n");
+}
+
+static void build_loopback_frame(uint8_t* frame_data, size_t frame_size, const char* tx_name, const char* rx_name) {
+	const char* tx_label = tx_name ? tx_name : "TX";
+	const char* rx_label = rx_name ? rx_name : "RX";
+
+	// Build one recognizable Ethernet frame so the receive side can match exactly what we sent.
+	memset(frame_data, 0, frame_size);
+	frame_data[0] = 0x00;
+	frame_data[1] = 0xFC;
+	frame_data[2] = 0x70;
+	frame_data[3] = 0x00;
+	frame_data[4] = 0x00;
+	frame_data[5] = 0x02;
+	frame_data[6] = 0x00;
+	frame_data[7] = 0xFC;
+	frame_data[8] = 0x70;
+	frame_data[9] = 0x00;
+	frame_data[10] = 0x00;
+	frame_data[11] = 0x01;
+	frame_data[12] = (uint8_t)((LOOPBACK_ETHER_TYPE >> 8) & 0xFF);
+	frame_data[13] = (uint8_t)(LOOPBACK_ETHER_TYPE & 0xFF);
+	snprintf((char*)&frame_data[14], frame_size - 14, "C2 T1S loopback %s->%s", tx_label, rx_label);
+}
+
+static int message_matches_loopback_frame(icsneoc2_message_t* message, const uint8_t* expected, size_t expected_length, bool* matches) {
+	uint8_t data[1600] = {0};
+	size_t data_length = sizeof(data);
+	uint16_t ether_type = 0;
+	icsneoc2_error_t res;
+
+	if(!expected || !matches || expected_length < 14) {
+		return print_error_code("Invalid loopback match output", icsneoc2_error_invalid_parameters);
+	}
+
+	*matches = false;
+
+	res = icsneoc2_message_eth_ether_type_get(message, &ether_type);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to read loopback EtherType", res);
+	}
+	if(ether_type != LOOPBACK_ETHER_TYPE) {
+		return 0;
+	}
+
+	res = icsneoc2_message_data_get(message, data, &data_length);
+	if(res != icsneoc2_error_success) {
+		return print_error_code("Failed to read loopback frame data", res);
+	}
+
+	if(data_length < 14) {
+		return 0;
+	}
+
+	if(data_length >= expected_length) {
+		*matches = memcmp(data, expected, expected_length) == 0;
+	} else {
+		*matches = memcmp(data, expected, data_length) == 0;
+	}
+	return 0;
+}
+
+static int print_ethernet_message(icsneoc2_message_t* message, const char* direction_label) {
+	icsneoc2_netid_t netid = 0;
+	char netid_name[64] = {0};
+	uint8_t dst_mac[6] = {0};
+	uint8_t src_mac[6] = {0};
+	uint16_t ether_type = 0;
+	icsneoc2_message_eth_t1s_flags_t t1s_flags = 0;
+	uint8_t node_id = 0;
+	uint8_t burst_count = 0;
+	uint8_t symbol_type = 0;
+	uint8_t data[1600] = {0};
+	size_t data_length = sizeof(data);
+	icsneoc2_error_t res;
+
+	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_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);
+
+	res = icsneoc2_message_eth_mac_get(message, dst_mac, src_mac);
+	if(res == icsneoc2_error_success) {
+		print_mac("  Dst", dst_mac);
+		printf("  ");
+		print_mac("Src", src_mac);
+		printf("\n");
+	}
+
+	res = icsneoc2_message_eth_ether_type_get(message, &ether_type);
+	if(res == icsneoc2_error_success) {
+		printf("  EtherType: 0x%04x\n", ether_type);
+	}
+
+	res = icsneoc2_message_eth_t1s_props_get(message, &t1s_flags, &node_id, &burst_count, &symbol_type);
+	if(res == icsneoc2_error_success && (t1s_flags != 0 || node_id != 0 || burst_count != 0 || symbol_type != 0)) {
+		printf("  T1S: node=%u burst=%u symbol=%u", (unsigned)node_id, (unsigned)burst_count, (unsigned)symbol_type);
+		if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL) printf(" [SYMBOL]");
+		if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST) printf(" [BURST]");
+		if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION) printf(" [TX_COLLISION]");
+		if(t1s_flags & ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE) printf(" [WAKE]");
+		printf("\n");
+	}
+
+	printf("  Payload bytes: ");
+	if(data_length > 14) {
+		print_payload_hex(&data[14], data_length - 14);
+	} else {
+		printf("<none>\n");
+	}
+
+	return 0;
+}
+
+static int transmit_loopback_frame(icsneoc2_device_t* device, icsneoc2_netid_t tx_netid, const char* tx_name, const char* rx_name) {
+	icsneoc2_message_t* message = NULL;
+	icsneoc2_error_t res;
+	uint8_t frame_data[LOOPBACK_FRAME_SIZE] = {0};
+
+	build_loopback_frame(frame_data, sizeof(frame_data), tx_name, rx_name);
+
+	res = icsneoc2_message_eth_create(&message);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to create Ethernet message", res);
+
+	res = icsneoc2_message_netid_set(message, tx_netid);
+	if(res != icsneoc2_error_success) {
+		icsneoc2_message_free(message);
+		return print_error_code("Failed to set Ethernet netid", res);
+	}
+
+	res = icsneoc2_message_data_set(message, frame_data, sizeof(frame_data));
+	if(res != icsneoc2_error_success) {
+		icsneoc2_message_free(message);
+		return print_error_code("Failed to set Ethernet payload", res);
+	}
+
+	printf("Transmitting one T1S loopback frame on %s...\n", tx_name ? tx_name : "selected TX network");
+	res = icsneoc2_device_message_transmit(device, message);
+	icsneoc2_message_free(message);
+	if(res != icsneoc2_error_success) return print_error_code("Failed to transmit loopback frame", res);
+
+	return 0;
+}
+
+static int poll_for_loopback_messages(icsneoc2_device_t* device,
+		icsneoc2_netid_t tx_netid,
+		icsneoc2_netid_t rx_netid,
+		const char* tx_name,
+		const char* rx_name,
+		const uint8_t* expected_frame,
+		size_t expected_frame_length) {
+	bool saw_tx_echo = false;
+	bool saw_rx_frame = false;
+
+	printf("Polling for TX echo on %s and RX frame on %s...\n", tx_name, rx_name);
+	for(size_t attempt = 0; attempt < 60 && !(saw_tx_echo && saw_rx_frame); ++attempt) {
+		icsneoc2_message_t* message = NULL;
+		icsneoc2_error_t res = icsneoc2_device_message_get(device, &message, 100);
+		if(res != icsneoc2_error_success) {
+			return print_error_code("Failed while polling for loopback messages", res);
+		}
+		if(message == NULL) {
+			continue;
+		}
+
+		bool is_ethernet = false;
+		bool matches_loopback = false;
+		res = icsneoc2_message_is_ethernet(message, &is_ethernet);
+		if(res != icsneoc2_error_success || !is_ethernet) {
+			icsneoc2_message_free(message);
+			continue;
+		}
+
+		icsneoc2_netid_t netid = 0;
+		res = icsneoc2_message_netid_get(message, &netid);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
+			return print_error_code("Failed to get polled netid", res);
+		}
+
+		if(netid != tx_netid && netid != rx_netid) {
+			icsneoc2_message_free(message);
+			continue;
+		}
+
+		// Ignore unrelated traffic on the selected ports and only count the frame this example transmitted.
+		if(message_matches_loopback_frame(message, expected_frame, expected_frame_length, &matches_loopback) != 0) {
+			icsneoc2_message_free(message);
+			return 1;
+		}
+		if(!matches_loopback) {
+			icsneoc2_message_free(message);
+			continue;
+		}
+
+		bool is_tx = false;
+		res = icsneoc2_message_is_transmit(message, &is_tx);
+		if(res != icsneoc2_error_success) {
+			icsneoc2_message_free(message);
+			return print_error_code("Failed to determine TX status", res);
+		}
+
+		if(netid == tx_netid && is_tx && !saw_tx_echo) {
+			if(print_ethernet_message(message, "TX echo") != 0) {
+				icsneoc2_message_free(message);
+				return 1;
+			}
+			saw_tx_echo = true;
+		} else if(netid == rx_netid && !saw_rx_frame) {
+			if(print_ethernet_message(message, "RX frame") != 0) {
+				icsneoc2_message_free(message);
+				return 1;
+			}
+			if(is_tx) {
+				printf("  Note: RX port message was also marked as transmit.\n");
+			}
+			saw_rx_frame = true;
+		}
+
+		icsneoc2_message_free(message);
+	}
+
+	if(!saw_tx_echo || !saw_rx_frame) {
+		printf("Loopback incomplete: saw_tx_echo=%s, saw_rx_frame=%s\n",
+			saw_tx_echo ? "true" : "false",
+			saw_rx_frame ? "true" : "false");
+		printf("Confirm %s is physically connected to %s and both ports are configured for 10BASE-T1S.\n", tx_name, rx_name);
+		return 1;
+	}
+
+	printf("Loopback complete: TX echo on %s and RX frame on %s were both observed.\n", tx_name, rx_name);
+	return 0;
+}

examples/cpp/interactive/src/InteractiveExample.cpp

@@ -223,8 +223,30 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
 					std::cout << "\t\t  Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n";
 
 					// The MACAddress may be printed directly or accessed with the `data` member
-					std::cout << "\t\t  Source:\t" << ethMessage->getSourceMAC() << "\n";
-					std::cout << "\t\t  Destination:\t" << ethMessage->getDestinationMAC();
+					auto printMAC = [](const icsneo::MACAddress& mac) {
+						std::ostringstream oss;
+						for(size_t i = 0; i < mac.size(); i++) {
+							oss << std::hex << std::setw(2) << std::setfill('0') << (uint32_t)mac[i];
+							if(i != mac.size() - 1)
+								oss << ':';
+						}
+						return oss.str();
+					};
+					if (auto destMAC = ethMessage->getDestinationMAC(); destMAC.has_value()) {
+						std::cout << "\t\t  Destination:\t" << printMAC(*destMAC) << "\n";
+					} else {
+						std::cout << "\t\t  Destination:\t N/A\n";
+					}
+					if (auto srcMAC = ethMessage->getSourceMAC(); srcMAC.has_value()) {
+						std::cout << "\t\t  Source:\t" << printMAC(*srcMAC) << "\n";
+					} else {
+						std::cout << "\t\t  Source:\t N/A\n";
+					}
+					if (auto etherType = ethMessage->getEtherType(); etherType.has_value()) {
+						std::cout << "\t\t  EtherType:\t" << std::hex << std::setw(4) << std::setfill('0') << *etherType << "\n";
+					} else {
+						std::cout << "\t\t  EtherType:\t N/A\n";
+					}
 
 					// Print the data
 					for(size_t i = 0; i < ethMessage->data.size(); i++) {

examples/cpp/simple/src/SimpleExample.cpp

@@ -208,8 +208,26 @@ int main() {
 							std::cout << "\t\t  Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n";
 
 							// The MACAddress may be printed directly or accessed with the `data` member
-							std::cout << "\t\t  Source:\t" << ethMessage->getSourceMAC() << "\n";
-							std::cout << "\t\t  Destination:\t" << ethMessage->getDestinationMAC();
+							// The MACAddress may be printed directly or accessed with the `data` member
+							auto printMAC = [](const icsneo::MACAddress& mac) {
+								std::ostringstream oss;
+								for(size_t i = 0; i < mac.size(); i++) {
+									oss << std::hex << std::setw(2) << std::setfill('0') << (uint32_t)mac[i];
+									if(i != mac.size() - 1)
+										oss << ':';
+								}
+								return oss.str();
+							};
+							if (auto destMAC = ethMessage->getDestinationMAC(); destMAC.has_value()) {
+								std::cout << "\t\t  Destination:\t" << printMAC(*destMAC) << "\n";
+							} else {
+								std::cout << "\t\t  Destination:\t N/A\n";
+							}
+							if (auto srcMAC = ethMessage->getSourceMAC(); srcMAC.has_value()) {
+								std::cout << "\t\t  Source:\t" << printMAC(*srcMAC) << "\n";
+							} else {
+								std::cout << "\t\t  Source:\t N/A\n";
+							}
 
 							// Print the data
 							for(size_t i = 0; i < ethMessage->data.size(); i++) {

examples/cpp/t1s/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(libicsneocpp-t1s-settings src/T1SSettingsExample.cpp)
+target_link_libraries(libicsneocpp-t1s-settings icsneocpp)
+
+add_executable(libicsneocpp-t1s-symbol-decoding src/T1SSymbolDecodingExample.cpp)
+target_link_libraries(libicsneocpp-t1s-symbol-decoding icsneocpp)

examples/cpp/t1s/src/T1SSettingsExample.cpp

@@ -0,0 +1,327 @@
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <optional>
+#include <string>
+#include <limits>
+#include <sstream>
+#include <algorithm>
+
+#include "icsneo/icsneocpp.h"
+
+template<typename T>
+std::string optToString(const std::optional<T>& opt) {
+	if (!opt.has_value())
+		return "N/A";
+	if constexpr (std::is_same_v<T, bool>)
+		return opt.value() ? "true" : "false";
+	else
+		return std::to_string(opt.value());
+}
+
+bool getUserConfirmation(const std::string& prompt) {
+	std::string input;
+	std::cout << prompt << " (y/n): " << std::flush;
+	std::getline(std::cin, input);
+	if (!input.empty()) {
+		char c = static_cast<char>(std::tolower(input[0]));
+		return (c == 'y');
+	}
+	return false;
+}
+
+std::vector<icsneo::Network::NetID> selectNetworks(const std::vector<icsneo::Network::NetID>& availableNetworks) {
+	std::vector<icsneo::Network::NetID> selectedNetworks;
+	
+	std::cout << "\n" << std::string(70, '=') << std::endl;
+	std::cout << "Select T1S Networks to Configure" << std::endl;
+	std::cout << std::string(70, '=') << std::endl;
+	
+	for (size_t i = 0; i < availableNetworks.size(); i++) {
+		std::cout << "  [" << (i + 1) << "] " << icsneo::Network(availableNetworks[i]) << std::endl;
+	}
+	
+	std::cout << "\nEnter network numbers to configure (e.g., '1,3' or '1-3' or 'all'): " << std::flush;
+	std::string input;
+	std::getline(std::cin, input);
+	
+	if (input.empty())
+		return selectedNetworks;
+	
+	std::transform(input.begin(), input.end(), input.begin(),
+		[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+	
+	if (input == "all") {
+		return availableNetworks;
+	}
+	
+	std::stringstream ss(input);
+	std::string token;
+	while (std::getline(ss, token, ',')) {
+		token.erase(0, token.find_first_not_of(" \t"));
+		token.erase(token.find_last_not_of(" \t") + 1);
+		
+		size_t dashPos = token.find('-');
+		if (dashPos != std::string::npos) {
+			try {
+				int start = std::stoi(token.substr(0, dashPos));
+				int end = std::stoi(token.substr(dashPos + 1));
+				for (int i = start; i <= end; i++) {
+					if (i >= 1 && i <= (int)availableNetworks.size()) {
+						selectedNetworks.push_back(availableNetworks[i - 1]);
+					}
+				}
+			} catch (...) {}
+		} else {
+			try {
+				int num = std::stoi(token);
+				if (num >= 1 && num <= (int)availableNetworks.size()) {
+					selectedNetworks.push_back(availableNetworks[num - 1]);
+				}
+			} catch (...) {}
+		}
+	}
+	
+	return selectedNetworks;
+}
+
+uint8_t getUint8Input(const std::string& prompt, uint8_t defaultValue) {
+	std::string input;
+	std::cout << prompt << " [" << (int)defaultValue << "]: " << std::flush;
+	std::getline(std::cin, input);
+	if (input.empty())
+		return defaultValue;
+	try {
+		int val = std::stoi(input);
+		if (val >= 0 && val <= 255)
+			return static_cast<uint8_t>(val);
+	} catch (...) {}
+	return defaultValue;
+}
+
+uint16_t getUint16Input(const std::string& prompt, uint16_t defaultValue) {
+	std::string input;
+	std::cout << prompt << " [" << (int)defaultValue << "]: " << std::flush;
+	std::getline(std::cin, input);
+	if (input.empty())
+		return defaultValue;
+	try {
+		int val = std::stoi(input);
+		if (val >= 0 && val <= 65535)
+			return static_cast<uint16_t>(val);
+	} catch (...) {}
+	return defaultValue;
+}
+
+void displayT1SSettings(const std::shared_ptr<icsneo::Device>& device, icsneo::Network::NetID netId) {
+	std::cout << "\t" << icsneo::Network(netId) << " T1S Settings:" << std::endl;
+	
+	std::cout << "\t  PLCA Enabled:       " << optToString(device->settings->isT1SPLCAEnabledFor(netId)) << std::endl;
+	std::cout << "\t  Local ID:           " << optToString(device->settings->getT1SLocalIDFor(netId)) << std::endl;
+	std::cout << "\t  Max Nodes:          " << optToString(device->settings->getT1SMaxNodesFor(netId)) << std::endl;
+	std::cout << "\t  TX Opp Timer:       " << optToString(device->settings->getT1STxOppTimerFor(netId)) << std::endl;
+	std::cout << "\t  Max Burst:          " << optToString(device->settings->getT1SMaxBurstFor(netId)) << std::endl;
+	std::cout << "\t  Burst Timer:        " << optToString(device->settings->getT1SBurstTimerFor(netId)) << std::endl;
+	
+	auto termEnabled = device->settings->isT1STerminationEnabledFor(netId);
+	if (termEnabled.has_value())
+		std::cout << "\t  Termination:        " << optToString(termEnabled) << std::endl;
+	
+	auto localIdAlt = device->settings->getT1SLocalIDAlternateFor(netId);
+	if (localIdAlt.has_value()) {
+		std::cout << "\t  Local ID Alternate: " << optToString(localIdAlt) << std::endl;
+		std::cout << "\t  Bus Dec Beacons:    " << optToString(device->settings->isT1SBusDecodingBeaconsEnabledFor(netId)) << std::endl;
+		std::cout << "\t  Bus Dec All:        " << optToString(device->settings->isT1SBusDecodingAllEnabledFor(netId)) << std::endl;
+		
+		auto multiIdMask = device->settings->getT1SMultiIDEnableMaskFor(netId);
+		if (multiIdMask.has_value()) {
+			std::cout << "\t  Multi-ID Mask:      0x" << std::hex << std::setw(2) << std::setfill('0') 
+			          << (int)multiIdMask.value() << std::dec << std::endl;
+			std::cout << "\t  Multi-IDs:          ";
+			for (uint8_t i = 0; i < 7; i++) {
+				if (i > 0) std::cout << ", ";
+				auto multiId = device->settings->getT1SMultiIDFor(netId, i);
+				std::cout << "[" << (int)i << "]=" << optToString(multiId);
+			}
+			std::cout << std::endl;
+		}
+	}
+	std::cout << std::endl;
+}
+
+void configureT1SNetwork(std::shared_ptr<icsneo::Device>& device, icsneo::Network::NetID netId) {
+	std::cout << "\n" << std::string(70, '=') << std::endl;
+	std::cout << "Configuring T1S Network: " << icsneo::Network(netId) << std::endl;
+	std::cout << std::string(70, '=') << std::endl;
+	
+	std::cout << "\n--- Basic PLCA Settings ---" << std::endl;
+	bool plcaEnabled = getUserConfirmation("Enable PLCA");
+	device->settings->setT1SPLCAFor(netId, plcaEnabled);
+	
+	uint8_t localId = getUint8Input("Local ID (0-255)", 1);
+	device->settings->setT1SLocalIDFor(netId, localId);
+	
+	uint8_t maxNodes = getUint8Input("Max Nodes (0-255)", 8);
+	device->settings->setT1SMaxNodesFor(netId, maxNodes);
+	
+	uint8_t txOppTimer = getUint8Input("TX Opportunity Timer (0-255)", 20);
+	device->settings->setT1STxOppTimerFor(netId, txOppTimer);
+	
+	uint8_t maxBurst = getUint8Input("Max Burst (0-255)", 128);
+	device->settings->setT1SMaxBurstFor(netId, maxBurst);
+	
+	uint8_t burstTimer = getUint8Input("Burst Timer (0-255)", 64);
+	device->settings->setT1SBurstTimerFor(netId, burstTimer);
+	
+	if (device->settings->isT1STerminationEnabledFor(netId).has_value()) {
+		std::cout << "\n--- Termination Settings ---" << std::endl;
+		bool termEnabled = getUserConfirmation("Enable Termination");
+		device->settings->setT1STerminationFor(netId, termEnabled);
+	}
+	
+	if (device->settings->getT1SLocalIDAlternateFor(netId).has_value()) {
+		std::cout << "\n--- Extended Settings ---" << std::endl;
+		uint8_t localIdAlt = getUint8Input("Local ID Alternate (0-255)", 0);
+		device->settings->setT1SLocalIDAlternateFor(netId, localIdAlt);
+		
+		bool busDecBeacons = getUserConfirmation("Enable Bus Decoding (Beacons)");
+		device->settings->setT1SBusDecodingBeaconsFor(netId, busDecBeacons);
+		
+		bool busDecAll = getUserConfirmation("Enable Bus Decoding (All Symbols)");
+		device->settings->setT1SBusDecodingAllFor(netId, busDecAll);
+		
+		if (getUserConfirmation("Configure Multi-ID settings?")) {
+			uint8_t multiIdMask = getUint8Input("Multi-ID Enable Mask (0x00-0xFF, hex)", 0x00);
+			device->settings->setT1SMultiIDEnableMaskFor(netId, multiIdMask);
+			
+			std::cout << "Configure Multi-IDs (7 slots):" << std::endl;
+			for (uint8_t i = 0; i < 7; i++) {
+				uint8_t multiId = getUint8Input("  Multi-ID [" + std::to_string(i) + "]", 0);
+				device->settings->setT1SMultiIDFor(netId, i, multiId);
+			}
+		}
+	}
+	
+	std::cout << "\n✓ Configuration complete for " << icsneo::Network(netId) << std::endl;
+}
+
+int main() {
+	std::cout << "\n" << std::string(70, '=') << std::endl;
+	std::cout << "10BASE-T1S SETTINGS CONFIGURATION EXAMPLE" << std::endl;
+	std::cout << std::string(70, '=') << std::endl;
+	std::cout << "libicsneo " << icsneo::GetVersion() << std::endl;
+	std::cout << std::string(70, '=') << std::endl;
+	
+	std::cout << "\nFinding devices... " << std::flush;
+	auto devices = icsneo::FindAllDevices();
+	std::cout << "OK, " << devices.size() << " device" << (devices.size() == 1 ? "" : "s") << " found" << std::endl;
+	
+	if (devices.empty()) {
+		std::cout << "No devices found!" << std::endl;
+		return 1;
+	}
+	
+	for(auto& device : devices)
+		std::cout << "  " << device->describe() << std::endl;
+	
+	std::shared_ptr<icsneo::Device> selectedDevice;
+	for(auto& device : devices) {
+		if (device->getType() == icsneo::DeviceType::RADComet3) {
+			selectedDevice = device;
+			break;
+		}
+	}
+	
+	if (!selectedDevice && !devices.empty())
+		selectedDevice = devices[0];
+	
+	if (!selectedDevice) {
+		std::cout << "No suitable device found!" << std::endl;
+		return 1;
+	}
+	
+	std::cout << "\nSelected device: " << selectedDevice->describe() << std::endl;
+	std::cout << "Serial: " << selectedDevice->getSerial() << std::endl;
+	
+	std::cout << "\nOpening device... " << std::flush;
+	if (!selectedDevice->open()) {
+		std::cout << "✗ Failed" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		return 1;
+	}
+	std::cout << "✓" << std::endl;
+	
+	std::vector<icsneo::Network::NetID> candidateNetworks = {
+		icsneo::Network::NetID::AE_01, icsneo::Network::NetID::AE_02,
+		icsneo::Network::NetID::AE_03, icsneo::Network::NetID::AE_04,
+		icsneo::Network::NetID::AE_05, icsneo::Network::NetID::AE_06,
+		icsneo::Network::NetID::AE_07, icsneo::Network::NetID::AE_08,
+		icsneo::Network::NetID::AE_09, icsneo::Network::NetID::AE_10
+	};
+	
+	std::vector<icsneo::Network::NetID> t1sNetworks;
+	for (auto netId : candidateNetworks) {
+		auto localId = selectedDevice->settings->getT1SLocalIDFor(netId);
+		if (localId.has_value())
+			t1sNetworks.push_back(netId);
+	}
+	
+	if (t1sNetworks.empty()) {
+		std::cout << "No T1S networks found on this device" << std::endl;
+		selectedDevice->close();
+		return 1;
+	}
+	
+	std::cout << "\nFound " << t1sNetworks.size() << " T1S network" 
+	          << (t1sNetworks.size() == 1 ? "" : "s") << ":" << std::endl;
+	for (size_t i = 0; i < t1sNetworks.size(); i++)
+		std::cout << "  [" << (i + 1) << "] " << icsneo::Network(t1sNetworks[i]) << std::endl;
+	
+	std::cout << "\n" << std::string(70, '-') << std::endl;
+	std::cout << "Current T1S Settings:" << std::endl;
+	std::cout << std::string(70, '-') << std::endl;
+	for (auto netId : t1sNetworks)
+		displayT1SSettings(selectedDevice, netId);
+	
+	auto networksToConfig = selectNetworks(t1sNetworks);
+	
+	if (networksToConfig.empty()) {
+		std::cout << "\nNo networks selected for configuration." << std::endl;
+		std::cout << "Closing device... " << std::flush;
+		selectedDevice->close();
+		std::cout << "✓" << std::endl;
+		return 0;
+	}
+	
+	std::cout << "\nConfiguring " << networksToConfig.size() << " network"
+	          << (networksToConfig.size() == 1 ? "" : "s") << "..." << std::endl;
+	
+	for (auto netId : networksToConfig)
+		configureT1SNetwork(selectedDevice, netId);
+	
+	std::cout << "\n" << std::string(70, '=') << std::endl;
+	bool saveToEEPROM = getUserConfirmation("Save settings to EEPROM (permanent)?");
+	std::cout << std::string(70, '=') << std::endl;
+	
+	std::cout << "\nApplying settings" << (saveToEEPROM ? " to EEPROM" : " temporarily") << "... " << std::flush;
+	bool success = selectedDevice->settings->apply(!saveToEEPROM);
+	if (!success) {
+		std::cout << "✗ Failed" << std::endl;
+		std::cout << icsneo::GetLastError() << std::endl;
+		selectedDevice->close();
+		return 1;
+	}
+	std::cout << "✓" << std::endl;
+	
+	std::cout << "\n" << std::string(70, '-') << std::endl;
+	std::cout << "Updated T1S Settings:" << std::endl;
+	std::cout << std::string(70, '-') << std::endl;
+	for (auto netId : t1sNetworks)
+		displayT1SSettings(selectedDevice, netId);
+	
+	std::cout << "Closing device... " << std::flush;
+	selectedDevice->close();
+	std::cout << "✓" << std::endl;
+
+	return 0;
+}

examples/cpp/t1s/src/T1SSymbolDecodingExample.cpp

@@ -0,0 +1,357 @@
+// 10BASE-T1S Symbol Decoding Example
+// Demonstrates T1S bus symbol decoding and analysis
+
+#include <iostream>
+#include <iomanip>
+#include <thread>
+#include <chrono>
+#include <map>
+#include <string>
+#include <atomic>
+
+#include "icsneo/icsneocpp.h"
+
+enum class T1SSymbol : uint8_t {
+	SSD = 0x04,
+	ESDOK = 0x07,
+	BEACON = 0x08,
+	ESD = 0x0D,
+	ESDERR = 0x11,
+	SYNC = 0x18,
+	ESDJAB = 0x19,
+	SILENCE = 0x1F
+};
+
+std::string getSymbolName(uint8_t value) {
+	switch(static_cast<T1SSymbol>(value)) {
+		case T1SSymbol::SSD:      return "SSD";
+		case T1SSymbol::ESDOK:    return "ESDOK";
+		case T1SSymbol::BEACON:   return "BEACON";
+		case T1SSymbol::ESD:      return "ESD";
+		case T1SSymbol::ESDERR:   return "ESDERR";
+		case T1SSymbol::SYNC:     return "SYNC";
+		case T1SSymbol::ESDJAB:   return "ESDJAB";
+		case T1SSymbol::SILENCE:  return "SILENCE";
+		default:
+			if (value <= 0x0F) {
+				std::stringstream ss;
+				ss << "DATA(0x" << std::hex << std::uppercase << (int)value << ")";
+				return ss.str();
+			}
+			std::stringstream ss;
+			ss << "UNKNOWN(0x" << std::hex << std::uppercase << std::setw(2) 
+			   << std::setfill('0') << (int)value << std::setfill(' ') << ")";
+			return ss.str();
+	}
+}
+
+struct T1SStatistics {
+	std::atomic<uint64_t> symbolCount{0};
+	std::atomic<uint64_t> beaconCount{0};
+	std::atomic<uint64_t> wakeCount{0};
+	std::atomic<uint64_t> burstCount{0};
+	std::atomic<uint64_t> dataFrameCount{0};
+	std::map<std::string, uint64_t> symbolStats;
+	
+	void reset() {
+		symbolCount = 0;
+		beaconCount = 0;
+		wakeCount = 0;
+		burstCount = 0;
+		dataFrameCount = 0;
+		symbolStats.clear();
+	}
+	
+	void print() const {
+		std::cout << std::setfill(' ');
+		
+		std::cout << "\n" << std::string(70, '=') << std::endl;
+		std::cout << "T1S SYMBOL DECODING STATISTICS" << std::endl;
+		std::cout << std::string(70, '=') << std::endl;
+		
+		std::cout << "Total Symbols:              " << symbolCount << std::endl;
+		std::cout << "Total Beacons:              " << beaconCount << std::endl;
+		std::cout << "Total Wake Signals:         " << wakeCount << std::endl;
+		std::cout << "Total Bursts:               " << burstCount << std::endl;
+		std::cout << "Total Data Frames:          " << dataFrameCount << std::endl;
+		
+		if (!symbolStats.empty()) {
+			std::cout << "\n" << std::string(70, '-') << std::endl;
+			std::cout << "Symbol Type Breakdown:" << std::endl;
+			std::cout << std::string(70, '-') << std::endl;
+			std::vector<std::pair<std::string, uint64_t>> sortedStats(
+				symbolStats.begin(), symbolStats.end());
+			std::sort(sortedStats.begin(), sortedStats.end(),
+				[](const auto& a, const auto& b) { return a.second > b.second; });
+			
+			for (const auto& [name, count] : sortedStats) {
+				std::cout << "  " << std::left << std::setw(20) << name 
+				          << std::right << std::setw(10) << count << std::endl;
+			}
+		}
+		std::cout << std::string(70, '=') << std::endl;
+	}
+};
+
+bool getUserConfirmation(const std::string& prompt) {
+	std::string input;
+	std::cout << prompt << " (y/n): " << std::flush;
+	std::getline(std::cin, input);
+	if (!input.empty()) {
+		char c = static_cast<char>(std::tolower(input[0]));
+		return (c == 'y');
+	}
+	return false;
+}
+
+bool configureT1SDecoding(std::shared_ptr<icsneo::Device>& device, icsneo::Network::NetID network, 
+                          bool enableSymbols, bool enableBeacons) {
+	std::cout << "\nConfiguring T1S decoding on network " << icsneo::Network(network) << "..." << std::endl;
+	if (!device->settings->setT1SBusDecodingAllFor(network, enableSymbols)) {
+		std::cerr << "  ✗ Failed to set T1S symbol decoding" << std::endl;
+		return false;
+	}
+	if (enableSymbols) {
+		std::cout << "  ✓ Enabled decoding of all T1S symbols" << std::endl;
+	} else {
+		std::cout << "  • T1S symbol decoding disabled" << std::endl;
+	}
+	
+	if (!device->settings->setT1SBusDecodingBeaconsFor(network, enableBeacons)) {
+		std::cerr << "  ✗ Failed to set T1S beacon decoding" << std::endl;
+		return false;
+	}
+	if (enableBeacons) {
+		std::cout << "  ✓ Enabled T1S beacon decoding" << std::endl;
+	} else {
+		std::cout << "  • T1S beacon decoding disabled" << std::endl;
+	}
+	
+	if (!device->settings->apply(true)) {
+		std::cerr << "  ✗ Failed to apply settings to device" << std::endl;
+		std::cerr << "  " << icsneo::GetLastError() << std::endl;
+		return false;
+	}
+	std::cout << "  ✓ Settings applied successfully" << std::endl;
+	
+	return true;
+}
+
+void setupSymbolMonitoring(std::shared_ptr<icsneo::Device>& device, 
+                          icsneo::Network::NetID network,
+                          T1SStatistics& stats) {
+	
+	auto callback = std::make_shared<icsneo::MessageCallback>(
+		icsneo::MessageFilter(network),
+		[&stats](std::shared_ptr<icsneo::Message> message) {
+			if (message->type != icsneo::Message::Type::Frame)
+				return;
+			
+			auto frame = std::static_pointer_cast<icsneo::Frame>(message);
+			auto netType = frame->network.getType();
+			if (netType != icsneo::Network::Type::Ethernet && netType != icsneo::Network::Type::AutomotiveEthernet)
+				return;
+			
+			auto ethMsg = std::static_pointer_cast<icsneo::EthernetMessage>(frame);
+			
+			if (!ethMsg->t1s)
+				return;
+			
+			double timestamp_ms = ethMsg->timestamp / 1000000.0;
+			
+			if (ethMsg->t1s->isSymbol) {
+				size_t numSymbols = ethMsg->data.size();
+				
+				std::cout << std::fixed << std::setprecision(3)
+				          << "[" << std::setw(12) << timestamp_ms << " ms] "
+				          << "T1S Symbols";
+				
+				if (numSymbols > 0) {
+					std::cout << " (" << numSymbols << " symbol" << (numSymbols > 1 ? "s" : "") << ")";
+				}
+				std::cout << " | Node ID: " << (int)ethMsg->t1s->nodeId << std::endl;
+				
+				for (size_t i = 0; i < numSymbols; i++) {
+					uint8_t symbolValue = ethMsg->data[i];
+					std::string symbolName = getSymbolName(symbolValue);
+					
+					stats.symbolCount++;
+					stats.symbolStats[symbolName]++;
+					
+					if (symbolValue == static_cast<uint8_t>(T1SSymbol::BEACON)) {
+						stats.beaconCount++;
+					}
+					
+					std::cout << "  [" << i << "] " << std::left << std::setw(10) << symbolName << std::right
+					          << " = 0x" << std::hex << std::uppercase << std::setw(2) 
+					          << std::setfill('0') << (int)symbolValue << std::setfill(' ')
+					          << std::dec << std::endl;
+				}
+				
+				if (numSymbols == 0 && ethMsg->t1s->symbolType != 0) {
+					uint8_t symbolValue = ethMsg->t1s->symbolType;
+					std::string symbolName = getSymbolName(symbolValue);
+					
+					stats.symbolCount++;
+					stats.symbolStats[symbolName]++;
+					
+					if (symbolValue == static_cast<uint8_t>(T1SSymbol::BEACON)) {
+						stats.beaconCount++;
+					}
+					
+					std::cout << "  " << std::left << std::setw(10) << symbolName << std::right
+					          << " = 0x" << std::hex << std::uppercase << std::setw(2) 
+					          << std::setfill('0') << (int)symbolValue << std::setfill(' ')
+					          << std::dec << " (from t1sSymbolType field)" << std::endl;
+				}
+			}
+			else if (ethMsg->t1s->isBurst) {
+				stats.burstCount++;
+				std::cout << std::fixed << std::setprecision(3)
+				          << "[" << std::setw(12) << timestamp_ms << " ms] "
+				          << "BURST | "
+				          << "Node ID: " << (int)ethMsg->t1s->nodeId << " | "
+				          << "Burst Count: " << (int)ethMsg->t1s->burstCount << std::endl;
+			}
+			else if (ethMsg->t1s->isWake) {
+				stats.wakeCount++;
+				std::cout << std::fixed << std::setprecision(3)
+				          << "[" << std::setw(12) << timestamp_ms << " ms] "
+				          << "WAKE signal detected | "
+				          << "Node ID: " << (int)ethMsg->t1s->nodeId << std::endl;
+			}
+			else {
+				stats.dataFrameCount++;
+				std::cout << std::fixed << std::setprecision(3)
+				          << "[" << std::setw(12) << timestamp_ms << " ms] "
+				          << "T1S Data Frame | "
+				          << "Length: " << ethMsg->data.size() << " bytes | "
+				          << "Node ID: " << (int)ethMsg->t1s->nodeId << std::endl;
+				
+				if (!ethMsg->data.empty()) {
+					std::cout << "                    Data: ";
+					size_t preview_len = std::min(ethMsg->data.size(), size_t(16));
+					for (size_t i = 0; i < preview_len; i++) {
+						std::cout << std::hex << std::uppercase << std::setw(2) 
+						          << std::setfill('0') << (int)ethMsg->data[i] << " ";
+					}
+					if (ethMsg->data.size() > 16)
+						std::cout << "...";
+					std::cout << std::setfill(' ') << std::dec << std::endl;
+				}
+			}
+		}
+	);
+	
+	device->addMessageCallback(callback);
+}
+
+int main() {
+	const icsneo::Network::NetID MONITOR_NETWORK = icsneo::Network::NetID::AE_02;
+	const int MONITOR_DURATION_SECONDS = 30;
+	
+	std::cout << "\n" << std::string(70, '=') << std::endl;
+	std::cout << "10BASE-T1S SYMBOL DECODING EXAMPLE" << std::endl;
+	std::cout << std::string(70, '=') << std::endl;
+	std::cout << "libicsneo " << icsneo::GetVersion() << std::endl;
+	std::cout << std::string(70, '=') << std::endl;
+	
+	std::cout << "\nFinding devices... " << std::flush;
+	auto devices = icsneo::FindAllDevices();
+	std::cout << "OK, " << devices.size() << " device" << (devices.size() == 1 ? "" : "s") << " found" << std::endl;
+	
+	if (devices.empty()) {
+		std::cerr << "No devices found!" << std::endl;
+		return 1;
+	}
+	
+	// List devices
+	for (const auto& device : devices) {
+		std::cout << "  " << device->describe() << std::endl;
+	}
+	
+	std::shared_ptr<icsneo::Device> device;
+	for (auto& dev : devices) {
+		if (dev->getType() == icsneo::DeviceType::RADComet3) {
+			device = dev;
+			break;
+		}
+	}
+	
+	if (!device && !devices.empty())
+		device = devices[0];
+	
+	if (!device) {
+		std::cerr << "No suitable device found!" << std::endl;
+		return 1;
+	}
+	
+	std::cout << "\nSelected device: " << device->describe() << std::endl;
+	std::cout << "Serial: " << device->getSerial() << std::endl;
+	
+	std::cout << "\n" << std::string(70, '-') << std::endl;
+	std::cout << "T1S DECODING CONFIGURATION" << std::endl;
+	std::cout << std::string(70, '-') << std::endl;
+	bool enableSymbols = getUserConfirmation("Enable T1S symbol decoding (all symbols)");
+	bool enableBeacons = getUserConfirmation("Enable T1S beacon decoding");
+	std::cout << std::string(70, '-') << std::endl;
+	
+	std::cout << "\nOpening device... " << std::flush;
+	if (!device->open()) {
+		std::cerr << "✗ Failed" << std::endl;
+		std::cerr << "  " << icsneo::GetLastError() << std::endl;
+		return 1;
+	}
+	std::cout << "✓" << std::endl;
+	
+	std::cout << "Enabling message polling... " << std::flush;
+	if (!device->enableMessagePolling()) {
+		std::cerr << "✗ Failed" << std::endl;
+		std::cerr << "  " << icsneo::GetLastError() << std::endl;
+		device->close();
+		return 1;
+	}
+	device->setPollingMessageLimit(100000);
+	std::cout << "✓" << std::endl;
+	
+	if (!configureT1SDecoding(device, MONITOR_NETWORK, enableSymbols, enableBeacons)) {
+		device->close();
+		return 1;
+	}
+	
+	std::cout << "Going online... " << std::flush;
+	if (!device->goOnline()) {
+		std::cerr << "✗ Failed" << std::endl;
+		std::cerr << "  " << icsneo::GetLastError() << std::endl;
+		device->close();
+		return 1;
+	}
+	std::cout << "✓" << std::endl;
+	
+	T1SStatistics stats;
+	setupSymbolMonitoring(device, MONITOR_NETWORK, stats);
+	
+	std::cout << "\n" << std::string(70, '-') << std::endl;
+	std::cout << "Monitoring T1S traffic for " << MONITOR_DURATION_SECONDS << " seconds..." << std::endl;
+	std::cout << std::string(70, '-') << std::endl;
+	
+	auto startTime = std::chrono::steady_clock::now();
+	std::vector<std::shared_ptr<icsneo::Message>> messages;
+	messages.reserve(10000);
+	
+	while (std::chrono::steady_clock::now() - startTime < std::chrono::seconds(MONITOR_DURATION_SECONDS)) {
+		device->getMessages(messages);
+		messages.clear();
+		std::this_thread::sleep_for(std::chrono::milliseconds(10));
+	}
+	
+	std::cout << "\n" << std::string(70, '-') << std::endl;
+	std::cout << "Closing device... " << std::flush;
+	device->close();
+	std::this_thread::sleep_for(std::chrono::milliseconds(100));
+	std::cout << "✓" << std::endl;
+	
+	stats.print();
+	
+	return 0;
+}

examples/python/ethernet/ethernet_complete_example.py

@@ -47,14 +47,23 @@ def setup_ethernet_reception(device):
 	def frame_handler(frame):
 		nonlocal frame_count
 		frame_count += 1
+		dst = frame.get_destination_mac()
+		src = frame.get_source_mac()
+		et = frame.get_ether_type()
+
+		dst_str = ":".join(f"{b:02x}" for b in dst) if dst is not None else "N/A"
+		src_str = ":".join(f"{b:02x}" for b in src) if src is not None else "N/A"
+		et_str = f"0x{et:04x}" if et is not None else "N/A"
+
 		print(f"[RX {frame_count}], "
-			  f"Data: {[hex(b) for b in frame.data]}, "
-			  f"Length: {len(frame.data)}")
-	frame_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.ETHERNET_01)
+			f"dst={dst_str}, src={src_str}, ethertype={et_str}, "
+			f"Data: {[hex(b) for b in frame.data]}, "
+			f"Length: {len(frame.data)}")
+	frame_filter = icsneopy.MessageFilter(icsneopy.Network.NetID.ETHERNET_02)
 	callback = icsneopy.MessageCallback(frame_handler, frame_filter)
 	device.add_message_callback(callback)
 
-	print("CAN frame reception configured")
+	print("Ethernet frame reception configured")
 	return 0
 
 

examples/python/t1s/t1s_settings.py

@@ -0,0 +1,315 @@
+"""
+10BASE-T1S Settings Configuration Example
+Demonstrates interactive T1S network configuration
+"""
+
+import icsneopy
+
+
+def get_user_confirmation(prompt):
+    """Get yes/no confirmation from user."""
+    response = input(f"{prompt} (y/n): ").strip().lower()
+    return response == 'y'
+
+
+def select_networks(available_networks):
+    """Let user select which networks to configure."""
+    print("\n" + "=" * 70)
+    print("Select T1S Networks to Configure")
+    print("=" * 70)
+    
+    for i, net_id in enumerate(available_networks, 1):
+        print(f"  [{i}] {net_id}")
+    
+    response = input("\nEnter network numbers to configure (e.g., '1,3' or '1-3' or 'all'): ").strip().lower()
+    
+    if not response:
+        return []
+    
+    if response == 'all':
+        return available_networks
+    
+    selected = []
+    tokens = response.split(',')
+    
+    for token in tokens:
+        token = token.strip()
+        
+        if '-' in token:
+            try:
+                parts = token.split('-')
+                start = int(parts[0])
+                end = int(parts[1])
+                for i in range(start, end + 1):
+                    if 1 <= i <= len(available_networks):
+                        selected.append(available_networks[i - 1])
+            except (ValueError, IndexError):
+                pass
+        else:
+            try:
+                num = int(token)
+                if 1 <= num <= len(available_networks):
+                    selected.append(available_networks[num - 1])
+            except ValueError:
+                pass
+    
+    return selected
+
+
+def get_uint8_input(prompt, default_value):
+    """Get uint8 input from user with default."""
+    response = input(f"{prompt} [{default_value}]: ").strip()
+    if not response:
+        return default_value
+    try:
+        val = int(response)
+        if 0 <= val <= 255:
+            return val
+    except ValueError:
+        pass
+    return default_value
+
+
+def get_uint16_input(prompt, default_value):
+    """Get uint16 input from user with default."""
+    response = input(f"{prompt} [{default_value}]: ").strip()
+    if not response:
+        return default_value
+    try:
+        val = int(response)
+        if 0 <= val <= 65535:
+            return val
+    except ValueError:
+        pass
+    return default_value
+
+
+def opt_to_string(opt):
+    """Convert optional value to string for display."""
+    if opt is None:
+        return "N/A"
+    if isinstance(opt, bool):
+        return "true" if opt else "false"
+    return str(opt)
+
+
+def display_t1s_settings(device, network):
+    """Display T1S settings for a network."""
+    print(f"\t{network} T1S Settings:")
+    
+    settings = device.settings
+    if not settings:
+        print("\t  Unable to read settings")
+        return
+    
+    print(f"\t  PLCA Enabled:       {opt_to_string(settings.is_t1s_plca_enabled(network))}")
+    print(f"\t  Local ID:           {opt_to_string(settings.get_t1s_local_id(network))}")
+    print(f"\t  Max Nodes:          {opt_to_string(settings.get_t1s_max_nodes(network))}")
+    print(f"\t  TX Opp Timer:       {opt_to_string(settings.get_t1s_tx_opp_timer(network))}")
+    print(f"\t  Max Burst:          {opt_to_string(settings.get_t1s_max_burst(network))}")
+    print(f"\t  Burst Timer:        {opt_to_string(settings.get_t1s_burst_timer(network))}")
+    
+    term_enabled = settings.is_t1s_termination_enabled(network)
+    if term_enabled is not None:
+        print(f"\t  Termination:        {opt_to_string(term_enabled)}")
+    
+    local_id_alt = settings.get_t1s_local_id_alternate(network)
+    if local_id_alt is not None:
+        print(f"\t  Local ID Alternate: {opt_to_string(local_id_alt)}")
+        print(f"\t  Bus Dec Beacons:    {opt_to_string(settings.is_t1s_bus_decoding_beacons_enabled(network))}")
+        print(f"\t  Bus Dec All:        {opt_to_string(settings.is_t1s_bus_decoding_all_enabled(network))}")
+        
+        multi_id_mask = settings.get_t1s_multi_id_enable_mask(network)
+        if multi_id_mask is not None:
+            print(f"\t  Multi-ID Mask:      0x{multi_id_mask:02X}")
+            print("\t  Multi-IDs:          ", end="")
+            multi_ids = []
+            for i in range(7):
+                multi_id = settings.get_t1s_multi_id(network, i)
+                multi_ids.append(f"[{i}]={opt_to_string(multi_id)}")
+            print(", ".join(multi_ids))
+    
+    print()
+
+
+def configure_t1s_network(device, network):
+    """Interactively configure T1S settings for a network."""
+    print("\n" + "=" * 70)
+    print(f"Configuring T1S Network: {network}")
+    print("=" * 70)
+    
+    settings = device.settings
+    if not settings:
+        print("Unable to read settings")
+        return
+    
+    print("\n--- Basic PLCA Settings ---")
+    plca_enabled = get_user_confirmation("Enable PLCA")
+    settings.set_t1s_plca(network, plca_enabled)
+    
+    local_id = get_uint8_input("Local ID (0-255)", 1)
+    settings.set_t1s_local_id(network, local_id)
+    
+    max_nodes = get_uint8_input("Max Nodes (0-255)", 8)
+    settings.set_t1s_max_nodes(network, max_nodes)
+    
+    tx_opp_timer = get_uint8_input("TX Opportunity Timer (0-255)", 20)
+    settings.set_t1s_tx_opp_timer(network, tx_opp_timer)
+    
+    max_burst = get_uint16_input("Max Burst (0-65535)", 128)
+    settings.set_t1s_max_burst(network, max_burst)
+    
+    burst_timer = get_uint16_input("Burst Timer (0-65535)", 64)
+    settings.set_t1s_burst_timer(network, burst_timer)
+    
+    if settings.is_t1s_termination_enabled(network) is not None:
+        print("\n--- Termination Settings ---")
+        term_enabled = get_user_confirmation("Enable Termination")
+        settings.set_t1s_termination(network, term_enabled)
+    
+    if settings.get_t1s_local_id_alternate(network) is not None:
+        print("\n--- Extended Settings ---")
+        local_id_alt = get_uint8_input("Local ID Alternate (0-255)", 0)
+        settings.set_t1s_local_id_alternate(network, local_id_alt)
+        
+        bus_dec_beacons = get_user_confirmation("Enable Bus Decoding (Beacons)")
+        settings.set_t1s_bus_decoding_beacons(network, bus_dec_beacons)
+        
+        bus_dec_all = get_user_confirmation("Enable Bus Decoding (All Symbols)")
+        settings.set_t1s_bus_decoding_all(network, bus_dec_all)
+        
+        if get_user_confirmation("Configure Multi-ID settings?"):
+            multi_id_mask = get_uint8_input("Multi-ID Enable Mask (0x00-0xFF, hex)", 0x00)
+            settings.set_t1s_multi_id_enable_mask(network, multi_id_mask)
+            
+            print("Configure Multi-IDs (7 slots):")
+            for i in range(7):
+                multi_id = get_uint8_input(f"  Multi-ID [{i}]", 0)
+                settings.set_t1s_multi_id(network, i, multi_id)
+    
+    print(f"\n[OK] Configuration staged for {network}")
+
+
+def main():
+    """Main T1S settings configuration example."""
+    device = None
+    
+    try:
+        print("\n" + "=" * 70)
+        print("10BASE-T1S SETTINGS CONFIGURATION EXAMPLE")
+        print("=" * 70)
+        print(f"libicsneo {icsneopy.get_version()}")
+        print("=" * 70)
+        
+        print("\nFinding devices... ", end="", flush=True)
+        devices = icsneopy.find_all_devices()
+        print(f"OK, {len(devices)} device{'s' if len(devices) != 1 else ''} found")
+        
+        if not devices:
+            print("No devices found!")
+            return 1
+        
+        for d in devices:
+            print(f"  {d}")
+        
+        device = None
+        for d in devices:
+            if d.get_type().get_device_type() == icsneopy.DeviceType.Enum.RADComet3:
+                device = d
+                break
+        
+        if not device and devices:
+            device = devices[0]
+        
+        if not device:
+            print("No suitable device found!")
+            return 1
+        
+        print(f"\nSelected device: {device}")
+        print(f"Serial: {device.get_serial()}")
+        
+        print("\nOpening device... ", end="", flush=True)
+        if not device.open():
+            print("FAIL")
+            return 1
+        print("OK")
+        
+        settings = device.settings
+        t1s_networks = []
+        for net in device.get_supported_tx_networks():
+            if net.get_type() != icsneopy.Network.Type.AutomotiveEthernet:
+                continue
+            if settings.get_t1s_local_id(net) is not None:
+                t1s_networks.append(net)
+        
+        if not t1s_networks:
+            print("No T1S networks found on this device")
+            device.close()
+            return 1
+        
+        print(f"\nFound {len(t1s_networks)} T1S network{'s' if len(t1s_networks) != 1 else ''}:")
+        for i, net_id in enumerate(t1s_networks, 1):
+            print(f"  [{i}] {net_id}")
+        
+        print("\n" + "-" * 70)
+        print("Current T1S Settings:")
+        print("-" * 70)
+        for net_id in t1s_networks:
+            display_t1s_settings(device, net_id)
+        
+        networks_to_config = select_networks(t1s_networks)
+        
+        if not networks_to_config:
+            print("\nNo networks selected for configuration.")
+            print("Closing device... ", end="", flush=True)
+            device.close()
+            print("OK")
+            return 0
+        
+        print(f"\nConfiguring {len(networks_to_config)} network{'s' if len(networks_to_config) != 1 else ''}...")
+        
+        for net_id in networks_to_config:
+            configure_t1s_network(device, net_id)
+        
+        print("\n" + "=" * 70)
+        save_to_eeprom = get_user_confirmation("Save settings to EEPROM (permanent)?")
+        print("=" * 70)
+        
+        settings = device.settings
+        print(f"\nApplying settings{' to EEPROM' if save_to_eeprom else ' temporarily'}... ", end="", flush=True)
+        success = settings.apply(not save_to_eeprom)
+        if not success:
+            print("FAIL")
+            device.close()
+            return 1
+        print("OK")
+        
+        print("\n" + "-" * 70)
+        print("Updated T1S Settings:")
+        print("-" * 70)
+        for net_id in t1s_networks:
+            display_t1s_settings(device, net_id)
+        
+        print("Closing device... ", end="", flush=True)
+        device.close()
+        print("OK")
+        
+    except KeyboardInterrupt:
+        print("\n\nInterrupted by user")
+        return 1
+    
+    except Exception as e:
+        print(f"\nError: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    finally:
+        if device and device.is_open():
+            device.close()
+    
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

examples/python/t1s/t1s_symbol_decoding.py

@@ -0,0 +1,291 @@
+"""
+10BASE-T1S Symbol Decoding Example
+Demonstrates T1S bus symbol decoding and analysis
+"""
+
+import icsneopy
+import time
+from enum import IntEnum
+
+
+class T1SSymbol(IntEnum):
+    """10BASE-T1S Symbol Types"""
+    SSD = 0x04
+    ESDOK = 0x07
+    BEACON = 0x08
+    ESD = 0x0D
+    ESDERR = 0x11
+    SYNC = 0x18
+    ESDJAB = 0x19
+    SILENCE = 0x1F
+    
+    @classmethod
+    def get_name(cls, value):
+        """Get human-readable name for symbol value."""
+        try:
+            return cls(value).name
+        except ValueError:
+            if 0x00 <= value <= 0x0F:
+                return f"DATA(0x{value:X})"
+            return f"UNKNOWN(0x{value:02X})"
+
+
+def get_user_confirmation(prompt):
+    """Get yes/no confirmation from user."""
+    response = input(f"{prompt} (y/n): ").strip().lower()
+    return response == 'y'
+
+
+def configure_t1s_decoding(device, network, enable_symbols, enable_beacons):
+    """Configure T1S bus decoding settings."""
+    settings = device.settings
+    if not settings:
+        raise RuntimeError("Failed to get device settings")
+    
+    print(f"\nConfiguring T1S decoding on network {network}...")
+    
+    if not settings.set_t1s_bus_decoding_all(network, enable_symbols):
+        raise RuntimeError("Failed to set T1S symbol decoding")
+    print(f"  [{'X' if enable_symbols else ' '}] Decoding of all T1S symbols")
+    
+    if not settings.set_t1s_bus_decoding_beacons(network, enable_beacons):
+        raise RuntimeError("Failed to set T1S beacon decoding")
+    print(f"  [{'X' if enable_beacons else ' '}] T1S beacon decoding")
+    
+    if not settings.apply(True):
+        raise RuntimeError("Failed to apply settings to device")
+    print("  [OK] Settings applied successfully")
+
+
+def setup_symbol_monitoring(device, network):
+    """Setup callback to monitor and decode T1S symbols."""
+    state = {
+        'symbol_count': 0,
+        'beacon_count': 0,
+        'wake_count': 0,
+        'burst_count': 0,
+        'symbol_stats': {},
+        'data_frame_count': 0
+    }
+    
+    def symbol_handler(msg):
+        """Handle incoming T1S messages."""
+        if not isinstance(msg, icsneopy.EthernetMessage):
+            return
+        
+        if not msg.t1s:
+            return
+        
+        timestamp_ms = msg.timestamp / 1000000.0
+        
+        if msg.t1s.isSymbol:
+            num_symbols = len(msg.data)
+            
+            print(f"[{timestamp_ms:12.3f} ms] T1S Symbols", end="")
+            if num_symbols > 0:
+                print(f" ({num_symbols} symbol{'s' if num_symbols > 1 else ''})", end="")
+            print(f" | Node ID: {msg.t1s.nodeId}")
+            
+            for i, symbol_value in enumerate(msg.data):
+                symbol_name = T1SSymbol.get_name(symbol_value)
+                
+                state['symbol_count'] += 1
+                if symbol_name not in state['symbol_stats']:
+                    state['symbol_stats'][symbol_name] = 0
+                state['symbol_stats'][symbol_name] += 1
+                
+                if symbol_value == T1SSymbol.BEACON:
+                    state['beacon_count'] += 1
+                
+                print(f"  [{i}] {symbol_name:10s} = 0x{symbol_value:02X}")
+            
+            if num_symbols == 0 and msg.t1s.symbolType != 0:
+                symbol_value = msg.t1s.symbolType
+                symbol_name = T1SSymbol.get_name(symbol_value)
+                
+                state['symbol_count'] += 1
+                if symbol_name not in state['symbol_stats']:
+                    state['symbol_stats'][symbol_name] = 0
+                state['symbol_stats'][symbol_name] += 1
+                
+                if symbol_value == T1SSymbol.BEACON:
+                    state['beacon_count'] += 1
+                
+                print(f"  {symbol_name:10s} = 0x{symbol_value:02X} (from t1sSymbolType field)")
+        
+        elif msg.t1s.isBurst:
+            state['burst_count'] += 1
+            print(f"[{timestamp_ms:12.3f} ms] BURST | "
+                  f"Node ID: {msg.t1s.nodeId} | "
+                  f"Burst Count: {msg.t1s.burstCount}")
+        
+        elif msg.t1s.isWake:
+            state['wake_count'] += 1
+            print(f"[{timestamp_ms:12.3f} ms] WAKE signal detected | "
+                  f"Node ID: {msg.t1s.nodeId}")
+        
+        else:
+            state['data_frame_count'] += 1
+            print(f"[{timestamp_ms:12.3f} ms] T1S Data Frame | "
+                  f"Length: {len(msg.data)} bytes | "
+                  f"Node ID: {msg.t1s.nodeId}")
+            
+            if msg.data and len(msg.data) > 0:
+                preview = ' '.join([f"{b:02X}" for b in msg.data[:16]])
+                if len(msg.data) > 16:
+                    preview += " ..."
+                print(f"                    Data: {preview}")
+    
+    frame_filter = icsneopy.MessageFilter(network.get_net_id())
+    callback = icsneopy.MessageCallback(symbol_handler, frame_filter)
+    device.add_message_callback(callback)
+    
+    return state
+
+
+def print_statistics(state):
+    """Print monitoring statistics."""
+    print("\n" + "=" * 70)
+    print("T1S SYMBOL DECODING STATISTICS")
+    print("=" * 70)
+    print(f"Total Symbols:              {state['symbol_count']}")
+    print(f"Total Beacons:              {state['beacon_count']}")
+    print(f"Total Wake Signals:         {state['wake_count']}")
+    print(f"Total Bursts:               {state['burst_count']}")
+    print(f"Total Data Frames:          {state['data_frame_count']}")
+    
+    if state['symbol_stats']:
+        print("\n" + "-" * 70)
+        print("Symbol Type Breakdown:")
+        print("-" * 70)
+        for symbol_name, count in sorted(state['symbol_stats'].items(), 
+                                         key=lambda x: x[1], reverse=True):
+            print(f"  {symbol_name:20s}{count:>10d}")
+    print("=" * 70)
+
+
+def main():
+    """Main T1S symbol decoding example."""
+    device = None
+    
+    try:
+        MONITOR_DURATION = 30
+        
+        print("\n" + "=" * 70)
+        print("10BASE-T1S SYMBOL DECODING EXAMPLE")
+        print("=" * 70)
+        print(f"libicsneo {icsneopy.get_version()}")
+        print("=" * 70)
+        
+        print("\nFinding devices... ", end="", flush=True)
+        devices = icsneopy.find_all_devices()
+        print(f"OK, {len(devices)} device{'s' if len(devices) != 1 else ''} found")
+        
+        if not devices:
+            print("No devices found!")
+            return 1
+        
+        for d in devices:
+            print(f"  {d}")
+        
+        device = None
+        for d in devices:
+            if d.get_type().get_device_type() == icsneopy.DeviceType.Enum.RADComet3:
+                device = d
+                break
+        
+        if not device and devices:
+            device = devices[0]
+        
+        if not device:
+            print("No suitable device found!")
+            return 1
+        
+        print(f"\nSelected device: {device}")
+        print(f"Serial: {device.get_serial()}")
+        
+        print("\n" + "-" * 70)
+        print("T1S DECODING CONFIGURATION")
+        print("-" * 70)
+        enable_symbols = get_user_confirmation("Enable T1S symbol decoding (all symbols)")
+        enable_beacons = get_user_confirmation("Enable T1S beacon decoding")
+        print("-" * 70)
+        
+        print("\nOpening device... ", end="", flush=True)
+        if not device.open():
+            print("FAIL")
+            return 1
+        print("OK")
+        
+        print("Enabling message polling... ", end="", flush=True)
+        if not device.enable_message_polling():
+            print("FAIL")
+            device.close()
+            return 1
+        device.set_polling_message_limit(100000)
+        print("OK")
+        
+        monitor_network = None
+        settings = device.settings
+        for net in device.get_supported_rx_networks():
+            if net.get_type() != icsneopy.Network.Type.AutomotiveEthernet:
+                continue
+            if settings.get_t1s_local_id(net) is not None:
+                monitor_network = net
+                break
+        
+        if monitor_network is None:
+            print("No T1S network found on this device")
+            device.close()
+            return 1
+        
+        print(f"Monitoring network: {monitor_network}")
+        
+        configure_t1s_decoding(device, monitor_network, enable_symbols, enable_beacons)
+        
+        print("Going online... ", end="", flush=True)
+        if not device.go_online():
+            print("FAIL")
+            device.close()
+            return 1
+        print("OK")
+        
+        state = setup_symbol_monitoring(device, monitor_network)
+        
+        print("\n" + "-" * 70)
+        print(f"Monitoring T1S traffic for {MONITOR_DURATION} seconds...")
+        print("-" * 70)
+        
+        start_time = time.time()
+        while time.time() - start_time < MONITOR_DURATION:
+            device.get_messages()
+            time.sleep(0.01)
+        
+        print("\n" + "-" * 70)
+        print("Closing device... ", end="", flush=True)
+        device.close()
+        time.sleep(0.1)
+        print("OK")
+        
+        print_statistics(state)
+        
+    except KeyboardInterrupt:
+        print("\n\nMonitoring interrupted by user")
+        if 'state' in locals():
+            print_statistics(state)
+    
+    except Exception as e:
+        print(f"\nError: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    finally:
+        if device and device.is_open():
+            device.close()
+    
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

include/icsneo/communication/command.h

@@ -55,6 +55,7 @@ enum class ExtendedCommand : uint16_t {
 	GetSupportedFeatures = 0x0018,
 	GetGPTPStatus = 0x0019,
 	GetComponentVersions = 0x001A,
+	SoftwareUpdate = 0x001B,
 	Reboot = 0x001C,
 	SetRootFSEntryFlags = 0x0027,
 	TransmitCoreminiMessage = 0x0028,

include/icsneo/communication/message/canerrormessage.h

@@ -4,24 +4,24 @@
 #ifdef __cplusplus
 
 #include "icsneo/communication/message/message.h"
+#include "icsneo/icsneoc2types.h"
 
 namespace icsneo {
 
-enum class CANErrorCode : uint8_t
+enum class CANErrorCode : icsneoc2_can_error_code_t
 {
-	NoError = 0,
-	StuffError = 1,
-	FormError = 2,
-	AckError = 3,
-	Bit1Error = 4,
-	Bit0Error = 5,
-	CRCError = 6,
-	NoChange = 7
+	NoError = icsneoc2_can_error_code_no_error,
+	StuffError = icsneoc2_can_error_code_stuff_error,
+	FormError = icsneoc2_can_error_code_form_error,
+	AckError = icsneoc2_can_error_code_ack_error,
+	Bit1Error = icsneoc2_can_error_code_bit1_error,
+	Bit0Error = icsneoc2_can_error_code_bit0_error,
+	CRCError = icsneoc2_can_error_code_crc_error,
+	NoChange = icsneoc2_can_error_code_no_change
 };
-class CANErrorMessage : public Message {
+class CANErrorMessage : public RawMessage {
 public:
-	CANErrorMessage() : Message(Type::CANError) {}
-	Network network;
+	CANErrorMessage() : RawMessage(Type::CANError) {}
 	uint8_t transmitErrorCount;
 	uint8_t receiveErrorCount;
 	bool busOff;

include/icsneo/communication/message/canmessage.h

@@ -16,6 +16,9 @@ public:
 	bool isCANFD = false;
 	bool baudrateSwitch = false; // CAN FD only
 	bool errorStateIndicator = false; // CAN FD only
+	bool txAborted = false;
+	bool txLostArb = false;
+	bool txError = false;
 };
 
 }

include/icsneo/communication/message/ethernetmessage.h

@@ -4,63 +4,89 @@
 #ifdef __cplusplus
 
 #include "icsneo/communication/message/message.h"
+#include <array>
 #include <string>
 #include <vector>
 #include <sstream>
 #include <iomanip>
 #include <cstring>
+#include <optional>
 
 namespace icsneo {
 
-struct MACAddress {
-	uint8_t data[6];
-
-	std::string toString() const {
-		std::stringstream ss;
-		for(size_t i = 0; i < 6; i++) {
-			ss << std::hex << std::setw(2) << std::setfill('0') << (int)data[i];
-			if(i != 5)
-				ss << ':';
-		}
-		return ss.str();
-	}
-
-	friend std::ostream& operator<<(std::ostream& os, const MACAddress& mac) {
-		os << mac.toString();
-		return os;
-	}
-};
+using MACAddress = std::array<uint8_t, 6>;
 
 class EthernetMessage : public Frame {
 public:
 	// Standard Ethernet fields
-	bool preemptionEnabled = false;
-	uint8_t preemptionFlags = 0;
+	// Frame Check Sequence
 	std::optional<uint32_t> fcs;
 	bool frameTooShort = false;
 	bool noPadding = false;
 	bool fcsVerified = false;
 	bool txAborted = false;
 	bool crcError = false;
-	bool isT1S = false;
-
 	
-	bool isT1SSymbol = false;
-	bool isT1SBurst = false;
-	bool txCollision = false;
-	bool isT1SWake = false;
-	uint8_t t1sNodeId = 0;
-	uint8_t t1sBurstCount = 0;
-	uint8_t t1sSymbolType = 0;
+	// T1S-specific fields
+	struct T1S {
+		T1S() {}
 
-	// Accessors
-	const MACAddress& getDestinationMAC() const { return *(const MACAddress*)(data.data() + 0); }
-	const MACAddress& getSourceMAC() const { return *(const MACAddress*)(data.data() + 6); }
-	uint16_t getEtherType() const { return (data[12] << 8) | data[13]; }
+		bool isSymbol = false;
+		bool isBurst = false;
+		bool txCollision = false;
+		bool isWake = false;
+		uint8_t nodeId = 0;
+		uint8_t burstCount = 0;
+		uint8_t symbolType = 0;
+	};
+	std::optional<T1S> t1s;
+
+	// TSN-specific fields
+	// If we expand TSN we should probably do something similar to what we did above with T1S.
+	// IEEE 802.1Qbu frame preemption
+	std::optional<uint8_t> preemptionFlags;
+
+	// Helper functions to extract Destination MAC from the data payload
+	// returns std::nullopt if the data payload is not large enough
+	std::optional<MACAddress> getDestinationMAC() const { 
+		if(data.size() < 6) {
+			return std::nullopt;
+		}
+		MACAddress mac;
+		std::copy(data.begin(), data.begin() + 6, mac.begin());
+		return mac;
+	}
+
+	// Helper functions to extract Source MAC from the data payload
+	// returns std::nullopt if the data payload is not large enough
+	std::optional<MACAddress> getSourceMAC() const { 
+		if(data.size() < 12) {
+			return std::nullopt;
+		}
+		MACAddress mac;
+		std::copy(data.begin() + 6, data.begin() + 12, mac.begin());
+		return mac;
+	}
+
+	// Helper function to extract EtherType from the data payload
+	//
+	// EtherType is a two-octet field in an Ethernet frame (big-endian).
+	// It is used to indicate which protocol is encapsulated in the payload of the frame 
+	// and is used at the receiving end by the data link layer to determine how the payload is processed.
+	// For example, an EtherType of 0x0800 indicates that the payload is an IPv4 packet, while 0x86DD indicates an IPv6 packet.
+	// 
+	// returns std::nullopt if the data payload is not large enough
+	std::optional<uint16_t> getEtherType() const { 
+		if(data.size() < 14) {
+			return std::nullopt;
+		}
+		// EtherType is stored in a 2-byte network byte order (big-endian)
+		return static_cast<uint16_t>((uint16_t(data[12]) << 8) | uint16_t(data[13]));
+	}
 };
 
 }
 
 #endif // __cplusplus
 
-#endif
+#endif // __ETHERNETMESSAGE_H_

include/icsneo/communication/message/extendedresponsemessage.h

@@ -10,8 +10,8 @@ namespace icsneo {
 
 class ExtendedResponseMessage : public Message {
 public:
-	ExtendedResponseMessage(ExtendedCommand cmd, ExtendedResponse resp = ExtendedResponse::OK)
-		: Message(Message::Type::ExtendedResponse), command(cmd), response(resp) {}
+	ExtendedResponseMessage(ExtendedCommand cmd, ExtendedResponse resp = ExtendedResponse::OK, const std::vector<uint8_t>& buf = {})
+		: Message(Message::Type::ExtendedResponse), command(cmd), response(resp), data(buf) {}
 
 	const ExtendedCommand command;
 	const ExtendedResponse response;

include/icsneo/communication/message/linmessage.h

@@ -1,6 +1,8 @@
 #ifndef __LINMESSAGE_H_
 #define __LINMESSAGE_H_
 
+#include "icsneo/icsneoc2messages.h"
+
 #ifdef __cplusplus
 
 #include "icsneo/communication/message/message.h"
@@ -36,14 +38,14 @@ struct LINStatusFlags {
 
 class LINMessage : public Frame {
 public:
-	enum class Type : uint8_t {
-		NOT_SET = 0,
-		LIN_COMMANDER_MSG,
-		LIN_HEADER_ONLY,
-		LIN_BREAK_ONLY,
-		LIN_SYNC_ONLY,
-		LIN_UPDATE_RESPONDER,
-		LIN_ERROR
+	enum class Type : icsneoc2_lin_msg_type_t {
+		NOT_SET = icsneoc2_lin_msg_type_not_set,
+		LIN_COMMANDER_MSG = icsneoc2_lin_msg_type_commander_msg,
+		LIN_HEADER_ONLY = icsneoc2_lin_msg_type_header_only,
+		LIN_BREAK_ONLY = icsneoc2_lin_msg_type_break_only,
+		LIN_SYNC_ONLY = icsneoc2_lin_msg_type_sync_only,
+		LIN_UPDATE_RESPONDER = icsneoc2_lin_msg_type_update_responder,
+		LIN_ERROR = icsneoc2_lin_msg_type_error
 	};
 
 	static void calcChecksum(LINMessage& message);

include/icsneo/communication/packet/ethernetpacket.h

@@ -10,6 +10,7 @@
 #include <iostream>
 #include <iomanip>
 #include <sstream>
+#include <optional>
 
 namespace icsneo {
 

include/icsneo/device/chipid.h

@@ -102,7 +102,7 @@ enum class ChipID : uint8_t {
 	neoOBD2Dev_MCHIP = 94,
 	neoOBD2Dev_SCHIP = 95,
 	neoOBD2SIMDoIP_MCHIP = 96,
-	SFPModule_MCHIP = 97,
+	SFPModule_88q2112_MCHIP = 97,
 	RADEpsilonT_MCHIP = 98,
 	RADEpsilonExpress_MCHIP = 99,
 	RADProxima_MCHIP = 100,
@@ -125,12 +125,16 @@ enum class ChipID : uint8_t {
 	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
 };

include/icsneo/device/device.h

@@ -130,14 +130,18 @@ public:
 		EtherBADGE = 38,
 		RADEpsilon = 39,
 		RADA2B = 40,
-		SFPModule = 41,
+		SFPModule_88q2112 = 41,
 		RADGalaxy2 = 47,
 		RADMoon3 = 49,
 		RADComet = 50,
 		Connect = 51,
+		SFPModule_88q2221m = 52,
+		SFPModule_88q4364 = 53,
 		RADComet3 = 54,
+		SFPModule_lan8670 = 55,
 		RADMoonT1S = 56,
 		RADGigastar2 = 57,
+		SFPModule_ent11100 = 58,
 		RADGemini = 60,
 	};
 
@@ -874,8 +878,6 @@ public:
 	bool unlockNetworks(const std::set<Network::NetID>& networks);
 	bool unlockAllNetworks();
 	std::shared_ptr<NetworkMutexMessage> getNetworkMutexStatus(Network::NetID network);
-	
-	virtual bool supportsNetworkMutex() const { return false; }
 
 protected:
 	bool online = false;
@@ -994,6 +996,8 @@ protected:
 
 	std::optional<HardwareInfo::Version> bootloaderVersion = std::nullopt;
 
+	bool supportsNetworkMutex = false;
+
 private:
 	neodevice_t data;
 	std::shared_ptr<ResetStatusMessage> latestResetStatus;

include/icsneo/device/idevicesettings.h

@@ -1194,6 +1194,77 @@ public:
 		return false;
 	}
 
+	virtual std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const {
+		(void)net;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return std::nullopt;
+	}
+
+	virtual bool setT1SLocalIDAlternateFor(Network net, uint8_t id) {
+		(void)net; (void)id;
+		return false;
+	}
+
+	virtual std::optional<bool> isT1STerminationEnabledFor(Network net) const {
+		(void)net;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return std::nullopt;
+	}
+
+	virtual bool setT1STerminationFor(Network net, bool enable) {
+		(void)net; (void)enable;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return false;
+	}
+
+	virtual std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const {
+		(void)net;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return std::nullopt;
+	}
+
+	virtual bool setT1SBusDecodingBeaconsFor(Network net, bool enable) {
+		(void)net; (void)enable;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return false;
+	}
+
+	virtual std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const {
+		(void)net;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return std::nullopt;
+	}
+
+	virtual bool setT1SBusDecodingAllFor(Network net, bool enable) {
+		(void)net; (void)enable;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return false;
+	}
+
+	virtual std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const {
+		(void)net;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return std::nullopt;
+	}
+
+	virtual bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) {
+		(void)net; (void)mask;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return false;
+	}
+
+	virtual std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const {
+		(void)net; (void)index;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return std::nullopt;
+	}
+
+	virtual bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) {
+		(void)net; (void)index; (void)id;
+		report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+		return false;
+	}
+
 	virtual bool setMiscIOAnalogOutputEnabled(uint8_t pin, bool enabled);
 	virtual bool setMiscIOAnalogOutput(uint8_t pin, MiscIOAnalogVoltage voltage);
 

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

@@ -81,6 +81,7 @@ public:
 	}
 protected:
 	NeoVIFIRE3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		supportsNetworkMutex = true;
 		initialize<NeoVIFIRE3Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}
 
@@ -123,8 +124,6 @@ protected:
 	size_t getDiskCount() const override {
 		return 2;
 	}
-
-	bool supportsNetworkMutex() const override { return true; }
 };
 
 }

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

@@ -86,6 +86,7 @@ public:
 	}
 protected:
 	NeoVIFIRE3FlexRay(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		supportsNetworkMutex = true;
 		initialize<NeoVIFIRE3FlexRaySettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}
 
@@ -150,8 +151,6 @@ protected:
 	size_t getDiskCount() const override { 
 		return 2; 
 	}
-
-	bool supportsNetworkMutex() const override { return true; }
 };
 
 }

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

@@ -89,6 +89,7 @@ public:
 	}
 protected:
 	NeoVIFIRE3T1SLIN(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		supportsNetworkMutex = true;
 		initialize<NeoVIFIRE3T1SLINSettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}
 
@@ -132,10 +133,6 @@ protected:
 		return 2;
 	}
 
-	bool supportsNetworkMutex() const override { 
-		return true; 
-	}
-
 };
 
 }

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

@@ -363,6 +363,109 @@ public:
 		return true;
 	}
 
+	std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional(t1s->local_id_alternate);
+	}
+
+	bool setT1SLocalIDAlternateFor(Network net, uint8_t id) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		t1s->local_id_alternate = id;
+		return true;
+	}
+
+	std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS) != 0);
+	}
+
+	bool setT1SBusDecodingBeaconsFor(Network net, bool enable) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		if(enable)
+			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+		else
+			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+		
+		return true;
+	}
+
+	std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL) != 0);
+	}
+
+	bool setT1SBusDecodingAllFor(Network net, bool enable) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		if(enable)
+			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+		else
+			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+		
+		return true;
+	}
+
+	std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional(t1sExt->enable_multi_id);
+	}
+
+	bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) override {
+		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return false;
+		
+		t1sExt->enable_multi_id = mask;
+		return true;
+	}
+
+	std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const override {
+		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return std::nullopt;
+		
+		if(index >= 7) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional(t1sExt->multi_id[index]);
+	}
+
+	bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) override {
+		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return false;
+		
+		if(index >= 7) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		t1sExt->multi_id[index] = id;
+		return true;
+	}
+
 private:
 	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
@@ -404,6 +507,46 @@ private:
 		}
 	}
 
+	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const {
+		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		
+		switch(net.getNetID()) {
+			case Network::NetID::AE_03: return &(cfg->t1s1Ext);
+			case Network::NetID::AE_04: return &(cfg->t1s2Ext);
+			case Network::NetID::AE_05: return &(cfg->t1s3Ext);
+			case Network::NetID::AE_06: return &(cfg->t1s4Ext);
+			case Network::NetID::AE_07: return &(cfg->t1s5Ext);
+			case Network::NetID::AE_08: return &(cfg->t1s6Ext);
+			case Network::NetID::AE_09: return &(cfg->t1s7Ext);
+			case Network::NetID::AE_10: return &(cfg->t1s8Ext);
+			default:
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return nullptr;
+		}
+	}
+
+	ETHERNET10T1S_SETTINGS_EXT* getMutableT1SSettingsExtFor(Network net) {
+		auto cfg = getMutableStructurePointer<neovifire3t1slin_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		
+		switch(net.getNetID()) {
+			case Network::NetID::AE_03: return &(cfg->t1s1Ext);
+			case Network::NetID::AE_04: return &(cfg->t1s2Ext);
+			case Network::NetID::AE_05: return &(cfg->t1s3Ext);
+			case Network::NetID::AE_06: return &(cfg->t1s4Ext);
+			case Network::NetID::AE_07: return &(cfg->t1s5Ext);
+			case Network::NetID::AE_08: return &(cfg->t1s6Ext);
+			case Network::NetID::AE_09: return &(cfg->t1s7Ext);
+			case Network::NetID::AE_10: return &(cfg->t1s8Ext);
+			default:
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return nullptr;
+		}
+	}
+
 protected:
 	ICSNEO_UNALIGNED(const uint64_t*) getTerminationEnables() const override {
 		auto cfg = getStructurePointer<neovifire3t1slin_settings_t>();

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

@@ -64,6 +64,7 @@ public:
 	}
 protected:
 	NeoVIRED2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		supportsNetworkMutex = true;
 		initialize<NeoVIRED2Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}
 
@@ -104,8 +105,6 @@ protected:
 	size_t getDiskCount() const override {
 		return 2;
 	}
-
-	bool supportsNetworkMutex() const override { return true; }
 };
 
 }

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

@@ -223,6 +223,27 @@ public:
 		return true;
 	}
 
+	std::optional<bool> isT1STerminationEnabledFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_TERMINATION) != 0);
+	}
+
+	bool setT1STerminationFor(Network net, bool enable) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		if(enable)
+			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_TERMINATION;
+		else
+			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_TERMINATION;
+		
+		return true;
+	}
+
 private:
 	const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
 		auto cfg = getStructurePointer<radcomet_settings_t>();

include/icsneo/device/tree/radcomet3/radcomet3settings.h

@@ -258,6 +258,109 @@ public:
 		return true;
 	}
 
+	std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional(t1s->local_id_alternate);
+	}
+
+	bool setT1SLocalIDAlternateFor(Network net, uint8_t id) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		t1s->local_id_alternate = id;
+		return true;
+	}
+
+	std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS) != 0);
+	}
+
+	bool setT1SBusDecodingBeaconsFor(Network net, bool enable) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		if(enable)
+			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+		else
+			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+		
+		return true;
+	}
+
+	std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL) != 0);
+	}
+
+	bool setT1SBusDecodingAllFor(Network net, bool enable) override {
+		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+		if(t1s == nullptr)
+			return false;
+		
+		if(enable)
+			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+		else
+			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+		
+		return true;
+	}
+
+	std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const override {
+		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return std::nullopt;
+		
+		return std::make_optional(t1sExt->enable_multi_id);
+	}
+
+	bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) override {
+		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return false;
+		
+		t1sExt->enable_multi_id = mask;
+		return true;
+	}
+
+	std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const override {
+		const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return std::nullopt;
+		
+		if(index >= 7) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional(t1sExt->multi_id[index]);
+	}
+
+	bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) override {
+		ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
+		if(t1sExt == nullptr)
+			return false;
+		
+		if(index >= 7) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		t1sExt->multi_id[index] = id;
+		return true;
+	}
+
 	bool setPhyRoleFor(Network net, AELinkMode mode) override {
 		if (mode != AE_LINK_AUTO && mode != AE_LINK_MASTER && mode != AE_LINK_SLAVE) {
 			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
@@ -571,6 +674,42 @@ private:
 				return nullptr;
 		}
 	}
+
+	const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const {
+		auto cfg = getStructurePointer<radcomet3_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		
+		switch(net.getNetID()) {
+			case Network::NetID::AE_02: return &(cfg->t1s1Ext);
+			case Network::NetID::AE_03: return &(cfg->t1s2Ext);
+			case Network::NetID::AE_04: return &(cfg->t1s3Ext);
+			case Network::NetID::AE_05: return &(cfg->t1s4Ext);
+			case Network::NetID::AE_06: return &(cfg->t1s5Ext);
+			case Network::NetID::AE_07: return &(cfg->t1s6Ext);
+			default:
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return nullptr;
+		}
+	}
+
+	ETHERNET10T1S_SETTINGS_EXT* getMutableT1SSettingsExtFor(Network net) {
+		auto cfg = getMutableStructurePointer<radcomet3_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		
+		switch(net.getNetID()) {
+			case Network::NetID::AE_02: return &(cfg->t1s1Ext);
+			case Network::NetID::AE_03: return &(cfg->t1s2Ext);
+			case Network::NetID::AE_04: return &(cfg->t1s3Ext);
+			case Network::NetID::AE_05: return &(cfg->t1s4Ext);
+			case Network::NetID::AE_06: return &(cfg->t1s5Ext);
+			case Network::NetID::AE_07: return &(cfg->t1s6Ext);
+			default:
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return nullptr;
+		}
+	}
 };
 
 }

include/icsneo/device/tree/radgalaxy2/radgalaxy2.h

@@ -89,10 +89,7 @@ public:
 			.add<FlashPhase>(ChipID::RAD_GALAXY_2_ZMPCHIP_ID, BootloaderCommunication::RAD)
 			.add<EnterApplicationPhase>(ChipID::RAD_GALAXY_2_ZMPCHIP_ID)
 			.add<ReconnectPhase>()
-			.add<FlashPhase>(ChipID::RADGALAXY2_SYSMON_CHIP, BootloaderCommunication::RADGalaxy2Peripheral)
-			.add<EnterApplicationPhase>(ChipID::RADGALAXY2_SYSMON_CHIP)
-			.add<ReconnectPhase>()
-			.add<WaitPhase>(std::chrono::milliseconds(3000));
+			.add<FlashPhase>(ChipID::RADGALAXY2_SYSMON_CHIP, BootloaderCommunication::RADGalaxy2Peripheral);
 	}
 
 protected:

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

@@ -35,6 +35,11 @@ public:
 			{ChipID::RADGigastar_USBZ_ZYNQ, true, "USB ZCHIP", "RADGigastar_USBz_SW_bin", 2, FirmwareType::Zip},
 			{ChipID::RADGigastar_USBZ_Z7010_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7010_SW_bin", 2, FirmwareType::Zip},
 			{ChipID::RADGigastar_USBZ_Z7007S_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7007s_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::SFPModule_88q2112_MCHIP, true, "SFP-MV2112", "sfp_mv2112_a2_mchip_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_88q2221_MCHIP, true, "SFP-MV2221M", "sfp_mv2221m_b2_mchip_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_lan8670_MCHIP, true, "SFP-MC8670", "sfp_module_lan8670_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_88q3244_MCHIP, true, "SFP-MV3244", "sfp_module_88q3244_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_ent11100_MCHIP, true, "SFP-EN11100", "sfp_module_ent11100_ief", 3, FirmwareType::IEF}
 		};
 		return chips;
 	}
@@ -80,8 +85,9 @@ public:
 				}
 
 				BootloaderPipeline pipeline;
-				for(const auto& version : chipVersions) {
-					pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip);
+				for(size_t i = 0; i < chipVersions.size(); i++) {
+					const auto& version = chipVersions[i];
+					pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip, i == 0);
 				}
 				pipeline.add<EnterApplicationPhase>(mainChipID);
 				pipeline.add<WaitPhase>(std::chrono::milliseconds(3000));

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

@@ -129,6 +129,11 @@ public:
 			{ChipID::RADGigastar_USBZ_ZYNQ, true, "USB ZCHIP", "RADGigastar_USBz_SW_bin", 2, FirmwareType::Zip},
 			{ChipID::RADGigastar_USBZ_Z7010_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7010_SW_bin", 2, FirmwareType::Zip},
 			{ChipID::RADGigastar_USBZ_Z7007S_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7007s_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::SFPModule_88q2112_MCHIP, true, "SFP-MV2112", "sfp_mv2112_a2_mchip_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_88q2221_MCHIP, true, "SFP-MV2221M", "sfp_mv2221m_b2_mchip_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_lan8670_MCHIP, true, "SFP-MC8670", "sfp_module_lan8670_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_88q3244_MCHIP, true, "SFP-MV3244", "sfp_module_88q3244_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_ent11100_MCHIP, true, "SFP-EN11100", "sfp_module_ent11100_ief", 3, FirmwareType::IEF}
 		};
 
 		static std::vector<ChipInfo> t1sChips = {
@@ -136,6 +141,11 @@ public:
 			{ChipID::RADGigastar_USBZ_ZYNQ, true, "USB ZCHIP", "RADGigastar_USBz_SW_bin", 2, FirmwareType::Zip},
 			{ChipID::RADGigastar_USBZ_Z7010_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7010_SW_bin", 2, FirmwareType::Zip},
 			{ChipID::RADGigastar_USBZ_Z7007S_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7007s_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::SFPModule_88q2112_MCHIP, true, "SFP-MV2112", "sfp_mv2112_a2_mchip_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_88q2221_MCHIP, true, "SFP-MV2221M", "sfp_mv2221m_b2_mchip_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_lan8670_MCHIP, true, "SFP-MC8670", "sfp_module_lan8670_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_88q3244_MCHIP, true, "SFP-MV3244", "sfp_module_88q3244_ief", 3, FirmwareType::IEF},
+			{ChipID::SFPModule_ent11100_MCHIP, true, "SFP-EN11100", "sfp_module_ent11100_ief", 3, FirmwareType::IEF}
 		};
 		
 		if(variantToFlash == FirmwareVariant::T1Sx8_CANx4_LINx6) {
@@ -159,8 +169,9 @@ public:
 		}
 
 		BootloaderPipeline pipeline;
-		for(const auto& version : chipVersions) {
-			pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip);
+		for(size_t i = 0; i < chipVersions.size(); i++) {
+			const auto& version = chipVersions[i];
+			pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip, i == 0);
 		}
 		pipeline.add<EnterApplicationPhase>(mainChipID);
 		pipeline.add<WaitPhase>(std::chrono::milliseconds(3000));

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

@@ -355,6 +355,130 @@ namespace icsneo
 			return true;
 		}
 
+		std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const override {
+			const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return std::nullopt;
+			
+			return std::make_optional(t1s->local_id_alternate);
+		}
+
+		bool setT1SLocalIDAlternateFor(Network net, uint8_t id) override {
+			ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return false;
+			
+			t1s->local_id_alternate = id;
+			return true;
+		}
+
+		std::optional<bool> isT1STerminationEnabledFor(Network net) const override {
+			const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return std::nullopt;
+			
+			return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_TERMINATION) != 0);
+		}
+
+		bool setT1STerminationFor(Network net, bool enable) override {
+			ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return false;
+			
+			if(enable)
+				t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_TERMINATION;
+			else
+				t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_TERMINATION;
+			
+			return true;
+		}
+
+		std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const override {
+			const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return std::nullopt;
+			
+			return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS) != 0);
+		}
+
+		bool setT1SBusDecodingBeaconsFor(Network net, bool enable) override {
+			ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return false;
+			
+			if(enable)
+				t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+			else
+				t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+			
+			return true;
+		}
+
+		std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const override {
+			const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return std::nullopt;
+			
+			return std::make_optional<bool>((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL) != 0);
+		}
+
+		bool setT1SBusDecodingAllFor(Network net, bool enable) override {
+			ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
+			if(t1s == nullptr)
+				return false;
+			
+			if(enable)
+				t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+			else
+				t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+			
+			return true;
+		}
+
+		std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const override {
+			const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
+			if(t1sExt == nullptr)
+				return std::nullopt;
+			
+			return std::make_optional(t1sExt->enable_multi_id);
+		}
+
+		bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) override {
+			ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
+			if(t1sExt == nullptr)
+				return false;
+			
+			t1sExt->enable_multi_id = mask;
+			return true;
+		}
+
+		std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const override {
+			const ETHERNET10T1S_SETTINGS_EXT* t1sExt = getT1SSettingsExtFor(net);
+			if(t1sExt == nullptr)
+				return std::nullopt;
+			
+			if(index >= 7) {
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return std::nullopt;
+			}
+			
+			return std::make_optional(t1sExt->multi_id[index]);
+		}
+
+		bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) override {
+			ETHERNET10T1S_SETTINGS_EXT* t1sExt = getMutableT1SSettingsExtFor(net);
+			if(t1sExt == nullptr)
+				return false;
+			
+			if(index >= 7) {
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return false;
+			}
+			
+			t1sExt->multi_id[index] = id;
+			return true;
+		}
+
 	private:
 		const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
 			auto cfg = getStructurePointer<radgigastar2_settings_t>();
@@ -396,6 +520,46 @@ namespace icsneo
 			}
 		}
 
+		const ETHERNET10T1S_SETTINGS_EXT* getT1SSettingsExtFor(Network net) const {
+			auto cfg = getStructurePointer<radgigastar2_settings_t>();
+			if(cfg == nullptr)
+				return nullptr;
+			
+			switch(net.getNetID()) {
+				case Network::NetID::AE_03: return &(cfg->t1s1Ext);
+				case Network::NetID::AE_04: return &(cfg->t1s2Ext);
+				case Network::NetID::AE_05: return &(cfg->t1s3Ext);
+				case Network::NetID::AE_06: return &(cfg->t1s4Ext);
+				case Network::NetID::AE_07: return &(cfg->t1s5Ext);
+				case Network::NetID::AE_08: return &(cfg->t1s6Ext);
+				case Network::NetID::AE_09: return &(cfg->t1s7Ext);
+				case Network::NetID::AE_10: return &(cfg->t1s8Ext);
+				default:
+					report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+					return nullptr;
+			}
+		}
+
+		ETHERNET10T1S_SETTINGS_EXT* getMutableT1SSettingsExtFor(Network net) {
+			auto cfg = getMutableStructurePointer<radgigastar2_settings_t>();
+			if(cfg == nullptr)
+				return nullptr;
+			
+			switch(net.getNetID()) {
+				case Network::NetID::AE_03: return &(cfg->t1s1Ext);
+				case Network::NetID::AE_04: return &(cfg->t1s2Ext);
+				case Network::NetID::AE_05: return &(cfg->t1s3Ext);
+				case Network::NetID::AE_06: return &(cfg->t1s4Ext);
+				case Network::NetID::AE_07: return &(cfg->t1s5Ext);
+				case Network::NetID::AE_08: return &(cfg->t1s6Ext);
+				case Network::NetID::AE_09: return &(cfg->t1s7Ext);
+				case Network::NetID::AE_10: return &(cfg->t1s8Ext);
+				default:
+					report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+					return nullptr;
+			}
+		}
+
 	protected:
 		ICSNEO_UNALIGNED(const uint64_t *)
 		getTerminationEnables() const override

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

@@ -210,10 +210,163 @@ private:
 				return nullptr;
 		}
 	}
+
+	std::optional<uint8_t> getT1SLocalIDAlternateFor(Network net) const override {
+		auto cfg = getStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return std::nullopt;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional(cfg->t1s.local_id_alternate);
+	}
+
+	bool setT1SLocalIDAlternateFor(Network net, uint8_t id) override {
+		auto cfg = getMutableStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return false;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		cfg->t1s.local_id_alternate = id;
+		return true;
+	}
+
+	std::optional<bool> isT1SBusDecodingBeaconsEnabledFor(Network net) const override {
+		auto cfg = getStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return std::nullopt;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional<bool>((cfg->t1s.flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS) != 0);
+	}
+
+	bool setT1SBusDecodingBeaconsFor(Network net, bool enable) override {
+		auto cfg = getMutableStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return false;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		if(enable)
+			cfg->t1s.flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+		else
+			cfg->t1s.flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS;
+		
+		return true;
+	}
+
+	std::optional<bool> isT1SBusDecodingAllEnabledFor(Network net) const override {
+		auto cfg = getStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return std::nullopt;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional<bool>((cfg->t1s.flags & ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL) != 0);
+	}
+
+	bool setT1SBusDecodingAllFor(Network net, bool enable) override {
+		auto cfg = getMutableStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return false;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		if(enable)
+			cfg->t1s.flags |= ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+		else
+			cfg->t1s.flags &= ~ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL;
+		
+		return true;
+	}
+
+	std::optional<uint8_t> getT1SMultiIDEnableMaskFor(Network net) const override {
+		auto cfg = getStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return std::nullopt;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional(cfg->t1sExt.enable_multi_id);
+	}
+
+	bool setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) override {
+		auto cfg = getMutableStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return false;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		cfg->t1sExt.enable_multi_id = mask;
+		return true;
+	}
+
+	std::optional<uint8_t> getT1SMultiIDFor(Network net, uint8_t index) const override {
+		auto cfg = getStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return std::nullopt;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		if(index >= 7) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return std::nullopt;
+		}
+		
+		return std::make_optional(cfg->t1sExt.multi_id[index]);
+	}
+
+	bool setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) override {
+		auto cfg = getMutableStructurePointer<radmoont1s_settings_t>();
+		if(cfg == nullptr)
+			return false;
+		
+		if(net.getNetID() != Network::NetID::AE_01) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		if(index >= 7) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		cfg->t1sExt.multi_id[index] = id;
+		return true;
+	}
 };
 
 }
 
 #endif // __cplusplus
 
-#endif // __RADMOONT1SSETTINGS_H_
+#endif // __RADMOONT1SSETTINGS_H_

include/icsneo/icsneoc2.h

@@ -42,6 +42,9 @@ typedef enum _icsneoc2_error_t {
 	icsneoc2_error_script_clear_failed, // Failed to clear script
 	icsneoc2_error_script_upload_failed, // Failed to upload coremini script
 	icsneoc2_error_script_load_prepare_failed, // Failed to prepare script load
+	icsneoc2_error_close_failed, // Failed to close device
+	icsneoc2_error_reconnect_failed, // Failed to reconnect to device
+	icsneoc2_error_invalid_data, // Failed to get/set data due to invalid data pointer or size
 	// NOTE: Any new values added here should be updated in icsneoc2_error_code_get
 	icsneoc2_error_maxsize
 } _icsneoc2_error_t;
@@ -166,29 +169,31 @@ icsneoc2_error_t icsneoc2_device_is_valid(const icsneoc2_device_t* device);
 icsneoc2_error_t icsneoc2_device_is_open(const icsneoc2_device_t* device, bool* is_open);
 
 /**
- * Check if a device is disconnected.
- *
- * @param[in] device The device to check.
- * @param[out] is_disconnected true if the device is disconnected, false otherwise
- *
- * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ * Create a device handle from an enumeration node without opening it. Need to call icsneoc2_device_free() to free the handle when finished.
+ * The device can then be opened with icsneoc2_device_open().
+ * 
+ * @param[in] device_info The device info node to create from.
+ * @param[out] device Pointer to receive the created device handle.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_device otherwise.
+ * 
+ * @see icsneoc2_device_open icsneoc2_device_free
  */
-icsneoc2_error_t icsneoc2_device_is_disconnected(const icsneoc2_device_t* device, bool* is_disconnected);
+icsneoc2_error_t icsneoc2_device_create(const icsneoc2_device_info_t* device_info, icsneoc2_device_t** device);
 
 /**
  * Open a device from an enumeration node.
  *
  * After a successful call, icsneoc2_device_close() must be called to close the device.
  *
- * @param[in] device_info The device info node to open.
+ * @param[in] device Pointer to the device to open.
  * @param[in] options Open options (e.g. icsneoc2_open_options_default).
- * @param[out] device Pointer to receive the opened device handle.
  *
  * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_open_failed otherwise.
  *
- * @see icsneoc2_device_close
+ * @see icsneoc2_device_close icsneoc2_device_free
  */
-icsneoc2_error_t icsneoc2_device_open(const icsneoc2_device_info_t* device_info, icsneoc2_open_options_t options, icsneoc2_device_t** device);
+icsneoc2_error_t icsneoc2_device_open(const icsneoc2_device_t* device, icsneoc2_open_options_t options);
 
 /**
  * Convenience: enumerate, find by serial, open, and free enumeration.
@@ -199,13 +204,14 @@ icsneoc2_error_t icsneoc2_device_open(const icsneoc2_device_info_t* device_info,
  *
  * @return icsneoc2_error_t icsneoc2_error_success if successful.
  *
- * @see icsneoc2_device_close
+ * @see icsneoc2_device_close icsneoc2_device_free
  */
 icsneoc2_error_t icsneoc2_device_open_serial(const char* serial, icsneoc2_open_options_t options, icsneoc2_device_t** device);
 
 /**
  * Convenience: enumerate, find first available device (optionally filtered by type), open, and free enumeration.
  * Pass 0 for device_type to match any device.
+ * 
  *
  * @param[in] device_type The device type to match, or 0 for any.
  * @param[in] options Open options (e.g. icsneoc2_open_options_default).
@@ -213,24 +219,46 @@ icsneoc2_error_t icsneoc2_device_open_serial(const char* serial, icsneoc2_open_o
  *
  * @return icsneoc2_error_t icsneoc2_error_success if successful.
  *
- * @see icsneoc2_device_close
+ * @see icsneoc2_device_close icsneoc2_device_free
  */
 icsneoc2_error_t icsneoc2_device_open_first(icsneoc2_devicetype_t device_type, icsneoc2_open_options_t options, icsneoc2_device_t** device);
 
+/**
+ * Reconnect to a device. This is useful if the device was disconnected and reconnected, or if the connection was lost for some reason.
+ * 
+ * @param[in] device The device to reconnect.
+ * @param[in] options Open options (e.g. icsneoc2_open_options_default).
+ * @param[in] timeout_ms The timeout in milliseconds to keep trying to reconnect before giving up.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_reconnect_failed if the timeout was reached without reconnecting, or icsneoc2_device_is_valid() errors otherwise.
+ */
+icsneoc2_error_t icsneoc2_device_reconnect(icsneoc2_device_t* device, icsneoc2_open_options_t options, uint32_t timeout_ms);
+
 /**
  * Close a connection to a previously opened device.
  *
  * After a successful call to icsneoc2_device_open(), this function must be called to close the device.
- * An already closed device will still succeed. All messages and events related to the device will be freed.
+ * An already closed device will still succeed. The device handle must be freed with icsneoc2_device_free() when finished.
  *
  * @param[in,out] device Pointer to the device to close.
  *
  * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_device_is_valid() errors otherwise.
  *
- * @see icsneoc2_device_open icsneoc2_device_is_valid
+ * @see icsneoc2_device_open icsneoc2_device_is_valid icsneoc2_device_free
  */
 icsneoc2_error_t icsneoc2_device_close(icsneoc2_device_t* device);
 
+/**
+ * Free a device handle created by icsneoc2_device_create(). Device should be closed before freeing.
+ * 
+ * @param[in] device The device handle to free.
+ * 
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_device_is_valid() errors otherwise.
+ * 
+ * @see icsneoc2_device_create icsneoc2_device_close
+ */
+icsneoc2_error_t icsneoc2_device_free(icsneoc2_device_t* device);
+
 /**
  * Get the description of a device
  *
@@ -263,6 +291,28 @@ icsneoc2_error_t icsneoc2_device_type_get(const icsneoc2_device_t* device, icsne
  */
 icsneoc2_error_t icsneoc2_device_serial_get(const icsneoc2_device_t* device, char* value, size_t* value_length);
 
+/**
+ * Get the PCB serial of a device.
+ *
+ * @param[in] device The device to get the PCB serial of.
+ * @param[out] value Pointer to a buffer to copy the PCB serial 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 PCB serial.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if the device does not have a PCB serial.
+ */
+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.
+ *
+ * @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.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if the device does not have a MAC address.
+ */
+icsneoc2_error_t icsneoc2_device_mac_address_get(const icsneoc2_device_t* device, uint8_t* value, size_t* value_length);
+
 /**
  * Set the online state of a device.
  *

include/icsneo/icsneoc2messages.h

@@ -41,6 +41,17 @@ icsneoc2_error_t icsneoc2_message_free(icsneoc2_message_t* message);
  */
 icsneoc2_error_t icsneoc2_message_is_transmit(icsneoc2_message_t* message, bool* value);
 
+/**
+ * Get the frame error status of a message.
+ *
+ * @param[in] message The message to check.
+ * @param[out] value Pointer to a bool to copy the frame error status into.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or
+ * icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_is_error(icsneoc2_message_t* message, bool* value);
+
 /**
  * Get the Network ID (netid) of a bus message
  *
@@ -97,11 +108,14 @@ icsneoc2_error_t icsneoc2_message_data_set(icsneoc2_message_t* message, uint8_t*
  */
 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
-#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)
-#define ICSNEOC2_MESSAGE_CAN_FLAGS_ESI 0x10 // Error State Indicator (FD only)
+#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)
+#define ICSNEOC2_MESSAGE_CAN_FLAGS_ESI 0x10         // Error State Indicator (FD only)
+#define ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED  0x20 // CAN transmit was aborted
+#define ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB 0x40 // CAN transmit lost arbitration
+#define ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR    0x80 // CAN transmit reported an error
 
 typedef uint64_t icsneoc2_message_can_flags_t;
 
@@ -122,11 +136,132 @@ icsneoc2_error_t icsneoc2_message_can_props_set(icsneoc2_message_t* message, con
  * @param[in] message The message to check.
  * @param[out] arb_id Pointer to a uint64_t to copy the arbitration ID into. If NULL, it's ignored.
  * @param[out] flags Pointer to a series of flags. If NULL, it's ignored. See icsneoc2_message_can_flags_t for details.
+ *   TX status flags are read-only and are only reported for CAN frames received back from the device.
  *
  * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
  */
 icsneoc2_error_t icsneoc2_message_can_props_get(icsneoc2_message_t* message, uint64_t* arb_id, icsneoc2_message_can_flags_t* flags);
 
+/**
+ * Create Ethernet message
+ *
+ * @param[out] message Pointer to icsneoc2_message_t to copy the message into.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_create(icsneoc2_message_t** message);
+
+// Standard Ethernet frame flags
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_FRAME_TOO_SHORT     0x001
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING          0x002
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED        0x004
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED          0x008
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_CRC_ERROR           0x010
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_IS_T1S              0x020
+#define ICSNEOC2_MESSAGE_ETH_FLAGS_PREEMPTION_ENABLED  0x040
+
+typedef uint64_t icsneoc2_message_eth_flags_t;
+
+// T1S-specific Ethernet frame flags
+#define ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL       0x002
+#define ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_BURST        0x004
+#define ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION        0x008
+#define ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_WAKE         0x010
+
+typedef uint64_t icsneoc2_message_eth_t1s_flags_t;
+
+/**
+ * Set the Ethernet specific properties of a message
+ *
+ * @param[in] message The message to modify.
+ * @param[in] flags Pointer to a icsneoc2_message_eth_flags_t containing the flags to set. If NULL, flags are not modified.
+ * @param[in] has_fcs Pointer to a bool indicating whether the FCS is present. If NULL, it's ignored.
+ * @param[in] fcs Pointer to a uint32_t containing the FCS value. If NULL, the FCS is not modified.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_props_set(icsneoc2_message_t* message, const icsneoc2_message_eth_flags_t* flags, const bool* has_fcs, const uint32_t* fcs);
+
+/**
+ * Get the Ethernet specific properties of a message
+ *
+ * @param[in] message The message to check.
+ * @param[out] flags Pointer to a icsneoc2_message_eth_flags_t to copy the flags into. If NULL, it's ignored.
+ * @param[out] has_fcs Pointer to a bool indicating whether the FCS is present. If NULL, it's ignored.
+ * @param[out] fcs Pointer to a uint32_t to copy the FCS value into. Only valid if has_fcs is true, set to 0 if FCS is not present. If NULL, it's ignored.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_props_get(icsneoc2_message_t* message, icsneoc2_message_eth_flags_t* flags, bool* has_fcs, uint32_t* fcs);
+
+/**
+ * Get the destination and/or source MAC address from an Ethernet message.
+ * The MAC addresses are extracted from the message data bytes.
+ *
+ * @param[in] message The message to check.
+ * @param[out] dst_mac Pointer to a 6-byte buffer to copy the destination MAC into. If NULL, it's ignored.
+ * @param[out] src_mac Pointer to a 6-byte buffer to copy the source MAC into. If NULL, it's ignored.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_mac_get(icsneoc2_message_t* message, uint8_t* dst_mac, uint8_t* src_mac);
+
+/**
+ * Helper function to get the EtherType field from an Ethernet message payload.
+ * 
+ * EtherType is a two-octet field in an Ethernet frame (big-endian).
+ * It is used to indicate which protocol is encapsulated in the payload of the frame 
+ * and is used at the receiving end by the data link layer to determine how the payload is processed.
+ * For example, an EtherType of 0x0800 indicates that the payload is an IPv4 packet, while 0x86DD indicates an IPv6 packet.
+ *
+ * @param[in] message The message to check.
+ * @param[out] ether_type Pointer to a uint16_t to copy the EtherType into.
+ * 
+ * @note The EtherType is extracted from the message data bytes, so the message must have the data field and it must be 
+ * large enough to contain the EtherType (at least 14 bytes). Returned value is host byte order.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters, icsneoc2_error_invalid_type, icsneoc2_error_invalid_data otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_ether_type_get(icsneoc2_message_t* message, uint16_t* ether_type);
+
+/**
+ * Set the T1S specific properties of an Ethernet message
+ *
+ * @param[in] message The message to modify.
+ * @param[in] flags Pointer to a icsneoc2_message_eth_t1s_flags_t containing the T1S flags to set. If NULL, flags are not modified.
+ * @param[in] node_id Pointer to a uint8_t containing the T1S node ID. If NULL, it's ignored.
+ * @param[in] burst_count Pointer to a uint8_t containing the T1S burst count. If NULL, it's ignored.
+ * @param[in] symbol_type Pointer to a uint8_t containing the T1S symbol type. If NULL, it's ignored.
+ * 
+ * @note If all four optional parameters are NULL, the T1S-specific state is cleared.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_t1s_props_set(icsneoc2_message_t* message, const icsneoc2_message_eth_t1s_flags_t* flags, const uint8_t* node_id, const uint8_t* burst_count, const uint8_t* symbol_type);
+
+/**
+ * Get the T1S specific properties of an Ethernet message
+ *
+ * @param[in] message The message to check.
+ * @param[out] flags Pointer to a icsneoc2_message_eth_t1s_flags_t to copy the T1S flags into. If NULL, it's ignored.
+ * @param[out] node_id Pointer to a uint8_t to copy the T1S node ID into. If NULL, it's ignored.
+ * @param[out] burst_count Pointer to a uint8_t to copy the T1S burst count into. If NULL, it's ignored.
+ * @param[out] symbol_type Pointer to a uint8_t to copy the T1S symbol type into. If NULL, it's ignored.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_eth_t1s_props_get(icsneoc2_message_t* message, icsneoc2_message_eth_t1s_flags_t* flags, uint8_t* node_id, uint8_t* burst_count, uint8_t* symbol_type);
+
+/**
+ * Check if a message is an Ethernet message
+ *
+ * @param[in] message The message to check.
+ * @param[out] is_ethernet Pointer to a bool to copy the Ethernet status of the message into.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_is_ethernet(icsneoc2_message_t* message, bool* is_ethernet);
+
 /**
  * Check if a message is valid
  *
@@ -171,6 +306,139 @@ icsneoc2_error_t icsneoc2_message_is_frame(icsneoc2_message_t* message, bool* is
  */
 icsneoc2_error_t icsneoc2_message_is_can(icsneoc2_message_t* message, bool* is_can);
 
+/**
+ * Check if a message is a LIN message
+ *
+ * @param[in] message The message to check.
+ * @param[out] is_lin Pointer to a bool to copy the LIN status of the message into.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_is_lin(icsneoc2_message_t* message, bool* is_lin);
+
+// ---- LIN Message Types ----
+
+typedef enum _icsneoc2_lin_msg_type_t {
+	icsneoc2_lin_msg_type_not_set = 0,
+	icsneoc2_lin_msg_type_commander_msg = 1,
+	icsneoc2_lin_msg_type_header_only = 2,
+	icsneoc2_lin_msg_type_break_only = 3,
+	icsneoc2_lin_msg_type_sync_only = 4,
+	icsneoc2_lin_msg_type_update_responder = 5,
+	icsneoc2_lin_msg_type_error = 6,
+} _icsneoc2_lin_msg_type_t;
+
+typedef uint8_t icsneoc2_lin_msg_type_t;
+
+// LIN error flags bitmask
+#define ICSNEOC2_LIN_ERR_RX_BREAK_ONLY          0x0001
+#define ICSNEOC2_LIN_ERR_RX_BREAK_SYNC_ONLY     0x0002
+#define ICSNEOC2_LIN_ERR_TX_RX_MISMATCH         0x0004
+#define ICSNEOC2_LIN_ERR_RX_BREAK_NOT_ZERO      0x0008
+#define ICSNEOC2_LIN_ERR_RX_BREAK_TOO_SHORT     0x0010
+#define ICSNEOC2_LIN_ERR_RX_SYNC_NOT_55         0x0020
+#define ICSNEOC2_LIN_ERR_RX_DATA_LEN_OVER_8     0x0040
+#define ICSNEOC2_LIN_ERR_FRAME_SYNC             0x0080
+#define ICSNEOC2_LIN_ERR_FRAME_MESSAGE_ID       0x0100
+#define ICSNEOC2_LIN_ERR_FRAME_RESPONDER_DATA   0x0200
+#define ICSNEOC2_LIN_ERR_CHECKSUM_MATCH         0x0400
+
+typedef uint32_t icsneoc2_lin_err_flags_t;
+
+// LIN status flags bitmask
+#define ICSNEOC2_LIN_STATUS_TX_CHECKSUM_ENHANCED      0x01
+#define ICSNEOC2_LIN_STATUS_TX_COMMANDER              0x02
+#define ICSNEOC2_LIN_STATUS_TX_RESPONDER              0x04
+#define ICSNEOC2_LIN_STATUS_TX_ABORTED                0x08
+#define ICSNEOC2_LIN_STATUS_UPDATE_RESPONDER_ONCE     0x10
+#define ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE 0x20
+#define ICSNEOC2_LIN_STATUS_BUS_RECOVERED             0x40
+#define ICSNEOC2_LIN_STATUS_BREAK_ONLY                0x80
+
+typedef uint32_t icsneoc2_lin_status_flags_t;
+
+/**
+ * Create a LIN message.
+ *
+ * @param[out] message Pointer to receive the new LIN message handle.
+ * @param[in] id The LIN frame ID (0-63). Bits above 0x3F are masked off.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful.
+ *
+ * @see icsneoc2_message_free
+ */
+icsneoc2_error_t icsneoc2_message_lin_create(icsneoc2_message_t** message, uint8_t id);
+
+/**
+ * Get the LIN-specific properties of a message.
+ *
+ * Any output pointer may be NULL to skip that field.
+ *
+ * @param[in] message The message to query (must be a LIN message).
+ * @param[out] id Pointer to receive the LIN frame ID.
+ * @param[out] protected_id Pointer to receive the protected ID (ID with parity bits).
+ * @param[out] checksum Pointer to receive the checksum byte.
+ * @param[out] msg_type Pointer to receive the LIN message type.
+ * @param[out] is_enhanced_checksum Pointer to receive whether enhanced checksum is used.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if not a LIN message.
+ */
+icsneoc2_error_t icsneoc2_message_lin_props_get(const icsneoc2_message_t* message,
+	uint8_t* id, uint8_t* protected_id, uint8_t* checksum,
+	icsneoc2_lin_msg_type_t* msg_type, bool* is_enhanced_checksum);
+
+/**
+ * Set the LIN-specific properties of a message.
+ *
+ * Any input pointer may be NULL to skip that field. Setting the ID also recalculates the protected ID.
+ *
+ * @param[in] message The message to modify (must be a LIN message).
+ * @param[in] id Pointer to the LIN frame ID to set (0-63). NULL to skip.
+ * @param[in] checksum Pointer to the checksum byte to set. NULL to skip.
+ * @param[in] msg_type Pointer to the LIN message type to set. NULL to skip.
+ * @param[in] is_enhanced_checksum Pointer to set enhanced checksum mode. NULL to skip.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if not a LIN message.
+ */
+icsneoc2_error_t icsneoc2_message_lin_props_set(icsneoc2_message_t* message,
+	const uint8_t* id, const uint8_t* checksum,
+	const icsneoc2_lin_msg_type_t* msg_type, const bool* is_enhanced_checksum);
+
+/**
+ * Get the LIN error flags of a message.
+ *
+ * @param[in] message The message to query (must be a LIN message).
+ * @param[out] err_flags Pointer to receive the error flags bitmask.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if not a LIN message.
+ *
+ * @see ICSNEOC2_LIN_ERR_*
+ */
+icsneoc2_error_t icsneoc2_message_lin_err_flags_get(const icsneoc2_message_t* message, icsneoc2_lin_err_flags_t* err_flags);
+
+/**
+ * Get the LIN status flags of a message.
+ *
+ * @param[in] message The message to query (must be a LIN message).
+ * @param[out] status_flags Pointer to receive the status flags bitmask.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if not a LIN message.
+ *
+ * @see ICSNEOC2_LIN_STATUS_*
+ */
+icsneoc2_error_t icsneoc2_message_lin_status_flags_get(const icsneoc2_message_t* message, icsneoc2_lin_status_flags_t* status_flags);
+
+/**
+ * Calculate and set the checksum on a LIN message.
+ *
+ * Uses enhanced or classic checksum based on the isEnhancedChecksum property.
+ *
+ * @param[in] message The LIN message to calculate the checksum for.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_type if not a LIN message.
+ */
+icsneoc2_error_t icsneoc2_message_lin_calc_checksum(icsneoc2_message_t* message);
+
 /**
  * Get the network type of a message
  *
@@ -183,6 +451,35 @@ icsneoc2_error_t icsneoc2_message_is_can(icsneoc2_message_t* message, bool* is_c
  */
 icsneoc2_error_t icsneoc2_message_network_type_get(icsneoc2_message_t* message, icsneoc2_network_type_t* network_type);
 
+/**
+ * Check if a message is a CAN error message
+ *
+ * @param[in] message The message to check.
+ * @param[out] is_can_error Pointer to a bool to copy the CAN error status of the message into.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_is_can_error(icsneoc2_message_t* message, bool* is_can_error);
+
+/**
+ * Get the CAN error specific properties of a message
+ *
+ * @param[in] message The message to check.
+ * @param[out] tx_err_count Pointer to a uint8_t to copy the transmit error count into. If NULL, it's ignored.
+ * @param[out] rx_err_count Pointer to a uint8_t to copy the receive error count into. If NULL, it's ignored.
+ * @param[out] error_code Pointer to a icsneoc2_can_error_code_t to copy the error code into. If NULL, it's ignored.
+ * @param[out] data_error_code Pointer to a icsneoc2_can_error_code_t to copy the data phase error code into. If NULL, it's ignored.
+ * @param[out] flags Pointer to a icsneoc2_message_can_error_flags_t to copy the error flags into. If NULL, it's ignored.
+ *   See ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_* for controller-error bits.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters or icsneoc2_error_invalid_type otherwise.
+ */
+icsneoc2_error_t icsneoc2_message_can_error_props_get(
+    icsneoc2_message_t *message, uint8_t *tx_err_count, uint8_t *rx_err_count,
+    icsneoc2_can_error_code_t *error_code,
+    icsneoc2_can_error_code_t *data_error_code,
+    icsneoc2_message_can_error_flags_t *flags);
+
 #ifdef __cplusplus
 }
 #endif

include/icsneo/icsneoc2settings.h

@@ -456,6 +456,28 @@ icsneoc2_error_t icsneoc2_settings_t1s_tx_opp_timer_get(icsneoc2_device_t* devic
  */
 icsneoc2_error_t icsneoc2_settings_t1s_tx_opp_timer_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value);
 
+/**
+ * Get the burst timer for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[out] value Pointer to store the burst timer value.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value);
+
+/**
+ * Set the burst timer for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] value The burst timer value to set.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value);
+
 /**
  * Get the Max burst timer for a network that supports 10BASE-T1S.
  *
@@ -478,6 +500,140 @@ icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t
  */
 icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value);
 
+/**
+ * Get the alternate local ID for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[out] value Pointer to store the alternate local ID.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_local_id_alternate_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value);
+
+/**
+ * Set the alternate local ID for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] value The alternate local ID to set.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_local_id_alternate_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value);
+
+/**
+ * Check if T1S termination is enabled for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[out] value Pointer to store the termination enable state.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_is_termination_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value);
+
+/**
+ * Enable or disable T1S termination for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] value True to enable termination, false to disable.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_termination_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value);
+
+/**
+ * Check if T1S bus decoding beacons are enabled for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[out] value Pointer to store the bus decoding beacons enable state.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_is_bus_decoding_beacons_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value);
+
+/**
+ * Enable or disable T1S bus decoding beacons for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] value True to enable bus decoding beacons, false to disable.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_bus_decoding_beacons_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value);
+
+/**
+ * Check if T1S bus decoding all is enabled for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[out] value Pointer to store the bus decoding all enable state.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_is_bus_decoding_all_enabled_for(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool* value);
+
+/**
+ * Enable or disable T1S bus decoding all for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] value True to enable bus decoding all, false to disable.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_bus_decoding_all_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, bool value);
+
+/**
+ * Get the multi-ID enable mask for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[out] value Pointer to store the multi-ID enable mask.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_enable_mask_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value);
+
+/**
+ * Set the multi-ID enable mask for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] value The multi-ID enable mask to set.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_enable_mask_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value);
+
+/**
+ * Get a multi-ID entry for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to check.
+ * @param[in] netid The network ID to check.
+ * @param[in] index The multi-ID index to get (0-6).
+ * @param[out] value Pointer to store the multi-ID value.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t index, uint8_t* value);
+
+/**
+ * Set a multi-ID entry for a network that supports 10BASE-T1S.
+ *
+ * @param[in] device The device to configure.
+ * @param[in] netid The network ID to configure.
+ * @param[in] index The multi-ID index to set (0-6).
+ * @param[in] value The multi-ID value to set.
+ *
+ * @return icsneoc2_error_t icsneoc2_error_success if successful, icsneoc2_error_invalid_parameters otherwise.
+ */
+icsneoc2_error_t icsneoc2_settings_t1s_multi_id_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t index, uint8_t value);
+
 /**
  * Set the analog output enabled.
  *

include/icsneo/icsneoc2types.h

@@ -400,6 +400,28 @@ typedef enum _icsneoc2_memory_type_t {
 
 typedef uint8_t icsneoc2_memory_type_t;
 
+typedef enum _icsneoc2_can_error_code_t {
+	icsneoc2_can_error_code_no_error = 0, // No error
+	icsneoc2_can_error_code_stuff_error,  // Stuff error
+	icsneoc2_can_error_code_form_error,   // Form error
+	icsneoc2_can_error_code_ack_error,    // Ack error
+	icsneoc2_can_error_code_bit1_error,   // Bit1 error
+	icsneoc2_can_error_code_bit0_error,   // Bit0 error
+	icsneoc2_can_error_code_crc_error,    // CRC error
+	icsneoc2_can_error_code_no_change,    // No change
+
+	// Must be last entry. Don't use as a CAN error code.
+	icsneoc2_can_error_code_maxsize
+} _icsneoc2_can_error_code_t;
+
+typedef uint8_t icsneoc2_can_error_code_t;
+
+#define ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF       0x01 // Bus off state
+#define ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE 0x02 // Error passive state
+#define ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN    0x04 // Error warning state
+
+typedef uint64_t icsneoc2_message_can_error_flags_t;
+
 #ifdef __cplusplus
 }
 #endif

test/unit/icsneoc2.cpp

@@ -2,7 +2,11 @@
 #include <icsneo/icsneoc2.h>
 #include <icsneo/icsneoc2settings.h>
 #include <icsneo/icsneoc2messages.h>
+#include "../../api/icsneoc2/icsneoc2_internal.h"
 #include <icsneo/device/devicetype.h>
+#include <icsneo/communication/message/linmessage.h>
+#include <icsneo/communication/message/canmessage.h>
+#include <icsneo/communication/message/canerrormessage.h>
 
 
 #include <vector>
@@ -129,7 +133,19 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_network_type_get(NULL, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_transmit(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_error(NULL, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_valid(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_can_error(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_can_error_props_get(NULL, NULL, NULL, NULL, NULL, NULL));
+
+	// LIN message NULL parameter checks
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_lin(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_create(NULL, 0));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_props_get(NULL, NULL, NULL, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_props_set(NULL, NULL, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_err_flags_get(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_status_flags_get(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_lin_calc_checksum(NULL));
 
 	// Test utility functions with NULL parameters
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_version_get(NULL, NULL));
@@ -143,7 +159,10 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_info_description_get(NULL, placeholderStr, &placeholderSizeT));
 
 	// Test open/close with NULL parameters
-	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open(NULL, 0, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_create(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_free(NULL));
+	
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open(NULL, 0));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open_serial(NULL, 0, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_open_first(0, 0, NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_close(NULL));
@@ -154,11 +173,12 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_online_supported(NULL, &placeholderBool));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_valid(NULL));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_open(NULL, &placeholderBool));
-	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_is_disconnected(NULL, &placeholderBool));
 
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_rtc_get(NULL, (int64_t *)&placeholderUnsignedInteger64));
 	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_supports_tc10(NULL, &placeholderBool));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_device_timestamp_resolution_get(NULL, &placeholderInteger32));
 
@@ -212,6 +232,20 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_tx_opp_timer_set(NULL, 0, placeholderInteger8));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_max_burst_timer_for_get(NULL, 0, &placeholderInteger8));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_max_burst_timer_for_set(NULL, 0, placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_burst_timer_get(NULL, 0, &placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_burst_timer_set(NULL, 0, placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_local_id_alternate_get(NULL, 0, &placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_local_id_alternate_set(NULL, 0, placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_termination_enabled_for(NULL, 0, &placeholderBool));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_termination_for_set(NULL, 0, false));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_bus_decoding_beacons_enabled_for(NULL, 0, &placeholderBool));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_bus_decoding_beacons_for_set(NULL, 0, false));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_is_bus_decoding_all_enabled_for(NULL, 0, &placeholderBool));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_bus_decoding_all_for_set(NULL, 0, false));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_enable_mask_get(NULL, 0, &placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_enable_mask_set(NULL, 0, placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_get(NULL, 0, 0, &placeholderInteger8));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_t1s_multi_id_set(NULL, 0, 0, placeholderInteger8));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_misc_io_analog_output_enabled_set(NULL, 0, placeholderInteger8));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_misc_io_analog_output_set(NULL, 0, placeholderMiscIoAnalogVoltage));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_settings_disabled_get(NULL, &placeholderBool));
@@ -283,6 +317,16 @@ TEST(icsneoc2, test_icsneoc2_error_invalid_parameters_and_invalid_device)
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_diagnostic_error_code_get(NULL, &placeholderInteger8));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_diagnostic_error_code_count_get(NULL, &placeholderInteger8));
 	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_script_status_max_coremini_size_kb_get(NULL, &placeholderInteger16));
+
+	// Ethernet message functions
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_create(NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_props_set(NULL, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_props_get(NULL, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_mac_get(NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_ether_type_get(NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_t1s_props_set(NULL, NULL, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_t1s_props_get(NULL, NULL, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_is_ethernet(NULL, NULL));
 }
 
 TEST(icsneoc2, test_icsneoc2_devicetype_t)
@@ -612,6 +656,66 @@ TEST(icsneoc2, test_icsneoc2_open_options_default)
 	ASSERT_EQ(icsneoc2_open_options_default, expected);
 }
 
+TEST(icsneoc2, test_icsneoc2_message_is_error)
+{
+	icsneoc2_message_t message;
+	message.message = std::make_shared<CANMessage>();
+
+	bool value = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_error(&message, &value));
+	ASSERT_FALSE(value);
+
+	auto frame = std::dynamic_pointer_cast<Frame>(message.message);
+	ASSERT_NE(frame, nullptr);
+	frame->error = true;
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_error(&message, &value));
+	ASSERT_TRUE(value);
+
+	icsneoc2_message_t raw_message;
+	raw_message.message = std::make_shared<CANErrorMessage>();
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_is_error(&raw_message, &value));
+}
+
+TEST(icsneoc2, test_icsneoc2_message_can_props_get_can_tx_flags)
+{
+	icsneoc2_message_t message;
+	auto can_message = std::make_shared<CANMessage>();
+	message.message = can_message;
+
+	uint64_t arb_id = 0;
+	icsneoc2_message_can_flags_t flags = 0;
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_props_get(&message, &arb_id, &flags));
+	ASSERT_EQ(arb_id, 0u);
+	ASSERT_EQ(flags, 0u);
+
+	can_message->txAborted = true;
+	can_message->txLostArb = true;
+	can_message->txError = true;
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_props_get(&message, &arb_id, &flags));
+	ASSERT_EQ(flags,
+		ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED |
+		ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB |
+		ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR);
+}
+
+TEST(icsneoc2, test_icsneoc2_message_can_error_props_get_invalid_type_for_can_message)
+{
+	icsneoc2_message_t message;
+	message.message = std::make_shared<CANMessage>();
+
+	uint8_t tx_err_count = 0;
+	uint8_t rx_err_count = 0;
+	icsneoc2_can_error_code_t error_code = icsneoc2_can_error_code_no_error;
+	icsneoc2_can_error_code_t data_error_code = icsneoc2_can_error_code_no_error;
+	icsneoc2_message_can_error_flags_t flags = 0;
+
+	ASSERT_EQ(icsneoc2_error_invalid_type,
+		icsneoc2_message_can_error_props_get(&message, &tx_err_count, &rx_err_count, &error_code, &data_error_code, &flags));
+}
+
 TEST(icsneoc2, test_icsneoc2_disk_format_enums)
 {
 	// Disk layout enum values
@@ -657,6 +761,53 @@ TEST(icsneoc2, test_icsneoc2_memory_type_enums)
 	ASSERT_EQ(1, icsneoc2_memory_type_sd);
 }
 
+TEST(icsneoc2, test_icsneoc2_can_error_code_t)
+{
+	// CAN error code enum values
+	ASSERT_EQ(icsneoc2_can_error_code_no_error, 0);
+	ASSERT_EQ(icsneoc2_can_error_code_stuff_error, 1);
+	ASSERT_EQ(icsneoc2_can_error_code_form_error, 2);
+	ASSERT_EQ(icsneoc2_can_error_code_ack_error, 3);
+	ASSERT_EQ(icsneoc2_can_error_code_bit1_error, 4);
+	ASSERT_EQ(icsneoc2_can_error_code_bit0_error, 5);
+	ASSERT_EQ(icsneoc2_can_error_code_crc_error, 6);
+	ASSERT_EQ(icsneoc2_can_error_code_no_change, 7);
+	ASSERT_EQ(icsneoc2_can_error_code_maxsize, 8);
+
+	using _T = icsneo::CANErrorCode;
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::NoError), icsneoc2_can_error_code_no_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::StuffError), icsneoc2_can_error_code_stuff_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::FormError), icsneoc2_can_error_code_form_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::AckError), icsneoc2_can_error_code_ack_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::Bit1Error), icsneoc2_can_error_code_bit1_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::Bit0Error), icsneoc2_can_error_code_bit0_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::CRCError), icsneoc2_can_error_code_crc_error);
+	ASSERT_EQ(static_cast<icsneoc2_can_error_code_t>(_T::NoChange), icsneoc2_can_error_code_no_change);
+
+	ASSERT_EQ(sizeof(icsneoc2_can_error_code_t), sizeof(uint8_t));
+
+	// CAN error flag bitmask values
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_BUS_OFF, 0x01);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_PASSIVE, 0x02);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_ERROR_FLAGS_ERROR_WARN, 0x04);
+
+	ASSERT_EQ(sizeof(icsneoc2_message_can_error_flags_t), sizeof(uint64_t));
+}
+
+TEST(icsneoc2, test_icsneoc2_message_can_flags_t)
+{
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_RTR, 0x01);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_IDE, 0x02);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_FDF, 0x04);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_BRS, 0x08);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_ESI, 0x10);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ABORTED, 0x20);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_TX_LOST_ARB, 0x40);
+	ASSERT_EQ(ICSNEOC2_MESSAGE_CAN_FLAGS_TX_ERROR, 0x80);
+
+	ASSERT_EQ(sizeof(icsneoc2_message_can_flags_t), sizeof(uint64_t));
+}
+
 TEST(icsneoc2, test_icsneoc2_script_error_codes)
 {
 	// Verify script error codes exist and have distinct string representations
@@ -684,4 +835,453 @@ TEST(icsneoc2, test_icsneoc2_script_error_codes)
 	ASSERT_GT(len, 0u);
 }
 
+TEST(icsneoc2, test_lin_message_create_and_props)
+{
+	// Create a LIN message with ID 0x15
+	icsneoc2_message_t* msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x15));
+	ASSERT_NE(msg, nullptr);
+
+	// Verify it reports as LIN
+	bool is_lin = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_lin(msg, &is_lin));
+	ASSERT_TRUE(is_lin);
+
+	// Verify it does NOT report as CAN
+	bool is_can = true;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_can(msg, &is_can));
+	ASSERT_FALSE(is_can);
+
+	// CAN props should fail on a LIN message
+	uint64_t arb_id = 0;
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_can_props_get(msg, &arb_id, NULL));
+
+	// Read back default props
+	uint8_t id = 0xFF, protected_id = 0, checksum = 0xFF;
+	icsneoc2_lin_msg_type_t msg_type = 0xFF;
+	bool enhanced = true;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, &id, &protected_id, &checksum, &msg_type, &enhanced));
+	ASSERT_EQ(id, 0x15);
+	ASSERT_NE(protected_id, 0); // Should have parity bits
+	ASSERT_EQ(checksum, 0);
+	ASSERT_EQ(msg_type, icsneoc2_lin_msg_type_not_set);
+	ASSERT_FALSE(enhanced);
+
+	// ID should be masked to 6 bits
+	icsneoc2_message_t* msg_masked = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg_masked, 0xFF));
+	uint8_t masked_id = 0xFF;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg_masked, &masked_id, NULL, NULL, NULL, NULL));
+	ASSERT_EQ(masked_id, 0x3F); // 0xFF & 0x3F
+	icsneoc2_message_free(msg_masked);
+
+	icsneoc2_message_free(msg);
+}
+
+TEST(icsneoc2, test_lin_message_props_set)
+{
+	icsneoc2_message_t* msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x00));
+
+	// Set individual properties using NULL to skip others
+	uint8_t new_id = 0x2A;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, &new_id, NULL, NULL, NULL));
+
+	uint8_t read_id = 0, read_pid = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, &read_id, &read_pid, NULL, NULL, NULL));
+	ASSERT_EQ(read_id, 0x2A);
+	ASSERT_NE(read_pid, 0x2A); // Protected ID should differ (has parity bits)
+
+	// Set checksum
+	uint8_t new_checksum = 0xAB;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, &new_checksum, NULL, NULL));
+	uint8_t read_checksum = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, &read_checksum, NULL, NULL));
+	ASSERT_EQ(read_checksum, 0xAB);
+
+	// Set msg type
+	icsneoc2_lin_msg_type_t new_type = icsneoc2_lin_msg_type_commander_msg;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, NULL, &new_type, NULL));
+	icsneoc2_lin_msg_type_t read_type = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, NULL, &read_type, NULL));
+	ASSERT_EQ(read_type, icsneoc2_lin_msg_type_commander_msg);
+
+	// Set enhanced checksum
+	bool new_enhanced = true;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, NULL, NULL, &new_enhanced));
+	bool read_enhanced = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, NULL, NULL, &read_enhanced));
+	ASSERT_TRUE(read_enhanced);
+
+	// LIN props set on a CAN message should fail
+	icsneoc2_message_t* can_msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_props_set(can_msg, &new_id, NULL, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_props_get(can_msg, &read_id, NULL, NULL, NULL, NULL));
+	icsneoc2_message_free(can_msg);
+
+	icsneoc2_message_free(msg);
+}
+
+TEST(icsneoc2, test_lin_message_data_and_netid)
+{
+	icsneoc2_message_t* msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x10));
+
+	// Set data
+	uint8_t data[] = {0x01, 0x02, 0x03, 0x04};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(msg, data, sizeof(data)));
+
+	// Read data back
+	uint8_t read_data[8] = {0};
+	size_t read_len = sizeof(read_data);
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_get(msg, read_data, &read_len));
+	ASSERT_EQ(read_len, sizeof(data));
+	ASSERT_EQ(memcmp(data, read_data, sizeof(data)), 0);
+
+	// Set and verify netid
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_netid_set(msg, icsneoc2_netid_lin_01));
+	icsneoc2_netid_t netid = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_netid_get(msg, &netid));
+	ASSERT_EQ(netid, icsneoc2_netid_lin_01);
+
+	// Verify is_frame and is_raw
+	bool is_frame = false, is_raw = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_frame(msg, &is_frame));
+	ASSERT_TRUE(is_frame);
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_raw(msg, &is_raw));
+	ASSERT_TRUE(is_raw);
+
+	icsneoc2_message_free(msg);
+}
+
+TEST(icsneoc2, test_lin_message_flags)
+{
+	// Create a LIN message and verify default flags are clear
+	icsneoc2_message_t* msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x01));
+
+	icsneoc2_lin_err_flags_t err_flags = 0xFFFFFFFF;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_err_flags_get(msg, &err_flags));
+	ASSERT_EQ(err_flags, 0u);
+
+	icsneoc2_lin_status_flags_t status_flags = 0xFFFFFFFF;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_status_flags_get(msg, &status_flags));
+	ASSERT_EQ(status_flags, 0u);
+
+	// Error/status flags on CAN message should fail
+	icsneoc2_message_t* can_msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_err_flags_get(can_msg, &err_flags));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_status_flags_get(can_msg, &status_flags));
+	icsneoc2_message_free(can_msg);
+
+	icsneoc2_message_free(msg);
+}
+
+TEST(icsneoc2, test_lin_message_calc_checksum)
+{
+	icsneoc2_message_t* msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_create(&msg, 0x01));
+
+	// Set some data and calculate checksum (classic)
+	uint8_t data[] = {0x01, 0x02, 0x03};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(msg, data, sizeof(data)));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_calc_checksum(msg));
+
+	uint8_t checksum = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, &checksum, NULL, NULL));
+	ASSERT_NE(checksum, 0); // Checksum should be non-zero for this data
+
+	// Now set enhanced checksum and recalculate — should give a different value
+	uint8_t classic_checksum = checksum;
+	bool enhanced = true;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_set(msg, NULL, NULL, NULL, &enhanced));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_calc_checksum(msg));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_lin_props_get(msg, NULL, NULL, &checksum, NULL, NULL));
+	ASSERT_NE(checksum, classic_checksum); // Enhanced and classic should differ
+
+	// calc_checksum on a CAN message should fail
+	icsneoc2_message_t* can_msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_lin_calc_checksum(can_msg));
+	icsneoc2_message_free(can_msg);
+
+	icsneoc2_message_free(msg);
+}
+
+TEST(icsneoc2, test_lin_msg_type_enum_values)
+{
+	ASSERT_EQ(icsneoc2_lin_msg_type_not_set, 0);
+	ASSERT_EQ(icsneoc2_lin_msg_type_commander_msg, 1);
+	ASSERT_EQ(icsneoc2_lin_msg_type_header_only, 2);
+	ASSERT_EQ(icsneoc2_lin_msg_type_break_only, 3);
+	ASSERT_EQ(icsneoc2_lin_msg_type_sync_only, 4);
+	ASSERT_EQ(icsneoc2_lin_msg_type_update_responder, 5);
+	ASSERT_EQ(icsneoc2_lin_msg_type_error, 6);
+	ASSERT_EQ(sizeof(icsneoc2_lin_msg_type_t), sizeof(uint8_t));
+}
+
+TEST(icsneoc2, test_lin_msg_type_cpp_enum_sync)
+{
+	using T = icsneo::LINMessage::Type;
+	ASSERT_EQ(static_cast<uint8_t>(T::NOT_SET), icsneoc2_lin_msg_type_not_set);
+	ASSERT_EQ(static_cast<uint8_t>(T::LIN_COMMANDER_MSG), icsneoc2_lin_msg_type_commander_msg);
+	ASSERT_EQ(static_cast<uint8_t>(T::LIN_HEADER_ONLY), icsneoc2_lin_msg_type_header_only);
+	ASSERT_EQ(static_cast<uint8_t>(T::LIN_BREAK_ONLY), icsneoc2_lin_msg_type_break_only);
+	ASSERT_EQ(static_cast<uint8_t>(T::LIN_SYNC_ONLY), icsneoc2_lin_msg_type_sync_only);
+	ASSERT_EQ(static_cast<uint8_t>(T::LIN_UPDATE_RESPONDER), icsneoc2_lin_msg_type_update_responder);
+	ASSERT_EQ(static_cast<uint8_t>(T::LIN_ERROR), icsneoc2_lin_msg_type_error);
+}
+
+TEST(icsneoc2, test_lin_flag_bitmask_values)
+{
+	// Error flags should be distinct bits
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_ONLY, 0x0001);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_SYNC_ONLY, 0x0002);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_TX_RX_MISMATCH, 0x0004);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_NOT_ZERO, 0x0008);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_BREAK_TOO_SHORT, 0x0010);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_SYNC_NOT_55, 0x0020);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_RX_DATA_LEN_OVER_8, 0x0040);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_FRAME_SYNC, 0x0080);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_FRAME_MESSAGE_ID, 0x0100);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_FRAME_RESPONDER_DATA, 0x0200);
+	ASSERT_EQ(ICSNEOC2_LIN_ERR_CHECKSUM_MATCH, 0x0400);
+
+	// Status flags should be distinct bits
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_CHECKSUM_ENHANCED, 0x01);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_COMMANDER, 0x02);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_RESPONDER, 0x04);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_TX_ABORTED, 0x08);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_UPDATE_RESPONDER_ONCE, 0x10);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE, 0x20);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_BUS_RECOVERED, 0x40);
+	ASSERT_EQ(ICSNEOC2_LIN_STATUS_BREAK_ONLY, 0x80);
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_create)
+{
+	// NULL parameter should fail
+	ASSERT_EQ(icsneoc2_error_invalid_parameters, icsneoc2_message_eth_create(NULL));
+
+	// Create an Ethernet message
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
+	ASSERT_NE(message, nullptr);
+
+	// Verify it is an Ethernet message
+	bool is_ethernet = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_ethernet(message, &is_ethernet));
+	ASSERT_TRUE(is_ethernet);
+
+	// Verify it is NOT a CAN message
+	bool is_can = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_can(message, &is_can));
+	ASSERT_FALSE(is_can);
+
+	// Verify it is a frame and raw message
+	bool is_frame = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_frame(message, &is_frame));
+	ASSERT_TRUE(is_frame);
+
+	bool is_raw = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_raw(message, &is_raw));
+	ASSERT_TRUE(is_raw);
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_props_roundtrip)
+{
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
+
+	// Set several flags
+	icsneoc2_message_eth_flags_t flags_in =
+		ICSNEOC2_MESSAGE_ETH_FLAGS_NO_PADDING |
+		ICSNEOC2_MESSAGE_ETH_FLAGS_FCS_VERIFIED |
+		ICSNEOC2_MESSAGE_ETH_FLAGS_TX_ABORTED;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, &flags_in, NULL, NULL));
+
+	// Get them back
+	icsneoc2_message_eth_flags_t flags_out = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, &flags_out, NULL, NULL));
+	ASSERT_EQ(flags_in, flags_out);
+
+	// Clear all flags
+	icsneoc2_message_eth_flags_t flags_zero = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, &flags_zero, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, &flags_out, NULL, NULL));
+	ASSERT_EQ(0u, flags_out);
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_mac_and_ethertype)
+{
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
+
+	// Set frame data: dst MAC + src MAC + EtherType
+	uint8_t frame_data[] = {
+		0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, /* Destination MAC */
+		0x11, 0x22, 0x33, 0x44, 0x55, 0x66, /* Source MAC */
+		0x08, 0x00,                           /* EtherType (IPv4) */
+		0x01, 0x02, 0x03, 0x04               /* Payload */
+	};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(message, frame_data, sizeof(frame_data)));
+
+	// Get MAC addresses
+	uint8_t dst_mac[6] = {0};
+	uint8_t src_mac[6] = {0};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_mac_get(message, dst_mac, src_mac));
+	ASSERT_EQ(0, memcmp(dst_mac, frame_data, 6));
+	ASSERT_EQ(0, memcmp(src_mac, frame_data + 6, 6));
+
+	// Get just one MAC at a time (NULL-safe)
+	uint8_t dst_only[6] = {0};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_mac_get(message, dst_only, NULL));
+	ASSERT_EQ(0, memcmp(dst_only, frame_data, 6));
+
+	uint8_t src_only[6] = {0};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_mac_get(message, NULL, src_only));
+	ASSERT_EQ(0, memcmp(src_only, frame_data + 6, 6));
+
+	// Get EtherType
+	uint16_t ether_type = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_ether_type_get(message, &ether_type));
+	ASSERT_EQ(0x0800, ether_type);
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_mac_too_short)
+{
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
+
+	// Set data too short for MAC extraction (< 14 bytes)
+	uint8_t short_data[] = {0x01, 0x02, 0x03};
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_data_set(message, short_data, sizeof(short_data)));
+
+	uint8_t dst_mac[6] = {0};
+	ASSERT_EQ(icsneoc2_error_invalid_data, icsneoc2_message_eth_mac_get(message, dst_mac, NULL));
+
+	uint8_t src_mac[6] = {0};
+	ASSERT_EQ(icsneoc2_error_invalid_data, icsneoc2_message_eth_mac_get(message, NULL, src_mac));
+
+	uint16_t ether_type = 0;
+	ASSERT_EQ(icsneoc2_error_invalid_data, icsneoc2_message_eth_ether_type_get(message, &ether_type));
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_t1s_props_roundtrip)
+{
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
+
+	// Set T1S properties
+	icsneoc2_message_eth_t1s_flags_t flags_in =
+		ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_IS_T1S_SYMBOL |
+		ICSNEOC2_MESSAGE_ETH_T1S_FLAGS_TX_COLLISION;
+	uint8_t node_id = 42;
+	uint8_t burst_count = 7;
+	uint8_t symbol_type = 3;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_set(message, &flags_in, &node_id, &burst_count, &symbol_type));
+
+	// Get them back
+	icsneoc2_message_eth_t1s_flags_t flags_out = 0;
+	uint8_t node_id_out = 0, burst_count_out = 0, symbol_type_out = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_get(message, &flags_out, &node_id_out, &burst_count_out, &symbol_type_out));
+	ASSERT_EQ(flags_in, flags_out);
+	ASSERT_EQ(42, node_id_out);
+	ASSERT_EQ(7, burst_count_out);
+	ASSERT_EQ(3, symbol_type_out);
+
+	// Set just one at a time (NULL-safe)
+	uint8_t new_node_id = 99;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_set(message, NULL, &new_node_id, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_get(message, &flags_out, &node_id_out, &burst_count_out, &symbol_type_out));
+	ASSERT_EQ(flags_in, flags_out);
+	ASSERT_EQ(99, node_id_out);
+	ASSERT_EQ(7, burst_count_out); // Unchanged
+	ASSERT_EQ(3, symbol_type_out); // Unchanged
+
+	// Passing all NULL parameters clears the optional T1S state.
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_set(message, NULL, NULL, NULL, NULL));
+	flags_out = 0xFF;
+	node_id_out = 0xFF;
+	burst_count_out = 0xFF;
+	symbol_type_out = 0xFF;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_t1s_props_get(message, &flags_out, &node_id_out, &burst_count_out, &symbol_type_out));
+	ASSERT_EQ(0, flags_out);
+	ASSERT_EQ(0, node_id_out);
+	ASSERT_EQ(0, burst_count_out);
+	ASSERT_EQ(0, symbol_type_out);
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_fcs_roundtrip)
+{
+	icsneoc2_message_t* message = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_create(&message));
+
+	// Initially, FCS should not be set
+	bool has_fcs = true;
+	uint32_t fcs = 0;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, NULL, &has_fcs, &fcs));
+	ASSERT_FALSE(has_fcs);
+
+	// Set an FCS value via eth_props_set
+	uint32_t fcs_value = 0xDEADBEEF;
+	has_fcs = true;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, NULL, &has_fcs, &fcs_value));
+
+	// Get it back
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, NULL, &has_fcs, &fcs));
+	ASSERT_TRUE(has_fcs);
+	ASSERT_EQ(0xDEADBEEF, fcs);
+
+	// Clear FCS
+	has_fcs = false;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_set(message, NULL, &has_fcs, NULL));
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_eth_props_get(message, NULL, &has_fcs, &fcs));
+	ASSERT_FALSE(has_fcs);
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(message));
+}
+
+TEST(icsneoc2, test_icsneoc2_eth_invalid_type)
+{
+	// Create a CAN message and try to use Ethernet functions on it
+	icsneoc2_message_t* can_msg = nullptr;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_can_create(&can_msg));
+
+	bool is_ethernet = true;
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_is_ethernet(can_msg, &is_ethernet));
+	ASSERT_FALSE(is_ethernet);
+
+	icsneoc2_message_eth_flags_t flags = 0;
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_props_get(can_msg, &flags, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_props_set(can_msg, &flags, NULL, NULL));
+
+	uint8_t mac[6] = {0};
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_mac_get(can_msg, mac, NULL));
+
+	uint16_t ether_type = 0;
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_ether_type_get(can_msg, &ether_type));
+
+	uint8_t val = 0;
+	icsneoc2_message_eth_t1s_flags_t t1s_flags = 0;
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_t1s_props_get(can_msg, &t1s_flags, &val, NULL, NULL));
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_t1s_props_set(can_msg, &t1s_flags, &val, NULL, NULL));
+
+	ASSERT_EQ(icsneoc2_error_invalid_type, icsneoc2_message_eth_props_set(can_msg, NULL, NULL, NULL));
+
+	ASSERT_EQ(icsneoc2_error_success, icsneoc2_message_free(can_msg));
+}
+