Bindings: Python: Add Message::Type MessageFilter

Fixes
- HardwareEthernetPacket packing
- EthernetMessage::fcs

.gitlab-ci.yml

@@ -437,7 +437,7 @@ build python/linux/amd64:
     CIBW_BEFORE_ALL: yum install -y flex && sh ci/bootstrap-libpcap.sh && sh ci/bootstrap-libusb.sh
     CIBW_BUILD: "*manylinux*" # no musl
     CIBW_ARCHS: x86_64
-    DOCKER_HOST: tcp://docker:2375/
+    DOCKER_HOST: unix:///var/run/docker.sock
     DOCKER_DRIVER: overlay2
     DOCKER_TLS_CERTDIR: ""
     CIBW_ENVIRONMENT: CMAKE_PREFIX_PATH=/project/libpcap/install:/project/libusb/install
@@ -514,3 +514,18 @@ deploy python/pypi:
     - build python/linux/arm64
     - build python/macos
     - build python/windows
+
+push github:
+  stage: deploy
+  tags:
+    - linux-build
+  image: alpine:latest
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  dependencies:
+    - deploy python/pypi
+  needs:
+    - deploy python/pypi
+  script:
+    - apk add git
+    - git push https://$LIBICSNEO_GITHUB_USERNAME:$LIBICSNEO_GITHUB_TOKEN@github.com/intrepidcs/libicsneo.git HEAD:master

.readthedocs.yaml

@@ -9,7 +9,7 @@ build:
 
 python:
   install:
-    - requirements: docs/icsneopy/requirements.txt
+    - requirements: docs/requirements.txt
 
 sphinx:
   configuration: docs/conf.py

CMakeLists.txt

@@ -246,6 +246,7 @@ set(SRC_FILES
 	communication/message/linmessage.cpp
 	communication/message/livedatamessage.cpp
 	communication/message/tc10statusmessage.cpp
+	communication/message/gptpstatusmessage.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp

README.md

@@ -24,6 +24,7 @@ each of the respective APIs.
 - RAD-Comet 2
 - RAD-Comet 3
 - RAD-Galaxy
+- RAD-Galaxy 2
 - RAD-Gigastar
 - RAD-Gigastar 2
 - RAD-Moon 2

api/icsneocpp/event.cpp

@@ -120,6 +120,7 @@ static constexpr const char* DISK_NOT_CONNECTED = "The program tried to access a
 static constexpr const char* UNEXPECTED_RESPONSE = "Received an unexpected or invalid response from the device.";
 static constexpr const char* LIN_SETTINGS_NOT_AVAILABLE = "LIN settings are not available for this device.";
 static constexpr const char* MODE_NOT_FOUND = "The mode was not found.";
+static constexpr const char* GPTP_NOT_SUPPORTED = "GPTP clock synchronization is not supported on this device.";
 
 // Transport Errors
 static constexpr const char* FAILED_TO_READ = "A read operation failed.";
@@ -185,6 +186,7 @@ static constexpr const char* VSA_OTHER_ERROR = "Unknown error in VSA read API.";
 static constexpr const char* TOO_MANY_EVENTS = "Too many events have occurred. The list has been truncated.";
 static constexpr const char* UNKNOWN = "An unknown internal error occurred.";
 static constexpr const char* INVALID = "An invalid internal error occurred.";
+
 const char* APIEvent::DescriptionForType(Type type) {
 	switch(type) {
 		// API Errors
@@ -345,6 +347,8 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return GETIFADDRS_ERROR;
 		case Type::SendToError:
 			return SEND_TO_ERROR;
+		case Type::GPTPNotSupported:
+			return GPTP_NOT_SUPPORTED;
 	
 		// FTD3XX
 		case Type::FTOK:

bindings/python/CMakeLists.txt

@@ -13,7 +13,10 @@ pybind11_add_module(icsneopy
     icsneopy/communication/message/message.cpp
     icsneopy/communication/message/canmessage.cpp
     icsneopy/communication/message/ethernetmessage.cpp
+    icsneopy/communication/message/linmessage.cpp
     icsneopy/communication/message/tc10statusmessage.cpp
+    icsneopy/communication/message/mdiomessage.cpp
+    icsneopy/communication/message/gptpstatusmessage.cpp
     icsneopy/communication/message/callback/messagecallback.cpp
     icsneopy/communication/message/filter/messagefilter.cpp
     icsneopy/device/device.cpp

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

@@ -15,7 +15,7 @@ void init_ethernetmessage(pybind11::module_& m) {
 		.def(pybind11::init())
 		.def_readwrite("preemptionEnabled", &EthernetMessage::preemptionEnabled)
 		.def_readwrite("preemptionFlags", &EthernetMessage::preemptionFlags)
-		.def_readwrite("fcsAvailable", &EthernetMessage::fcsAvailable)
+		.def_readwrite("fcs", &EthernetMessage::fcs)
 		.def_readwrite("frameTooShort", &EthernetMessage::frameTooShort)
 		.def_readwrite("noPadding", &EthernetMessage::noPadding)
 		.def("get_destination_mac", &EthernetMessage::getDestinationMAC, pybind11::return_value_policy::reference)

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

@@ -8,6 +8,8 @@ namespace icsneo {
 
 void init_messagefilter(pybind11::module_& m) {
 	pybind11::class_<MessageFilter, std::shared_ptr<MessageFilter>>(m, "MessageFilter")
+		.def(pybind11::init())
+		.def(pybind11::init<Message::Type>())
 		.def(pybind11::init<Network::NetID>());
 }
 

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

@@ -0,0 +1,79 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/gptpstatusmessage.h"
+
+namespace icsneo {
+
+void init_gptpstatusmessage(pybind11::module_& m) {
+	pybind11::class_<GPTPStatus, std::shared_ptr<GPTPStatus>, Message> gptpStatus(m, "GPTPStatus");
+	
+	pybind11::class_<GPTPStatus::Timestamp>(gptpStatus, "Timestamp")
+		.def_readonly("seconds", &GPTPStatus::Timestamp::seconds)
+		.def_readonly("nanoseconds", &GPTPStatus::Timestamp::nanoseconds)
+		.def("to_seconds", &GPTPStatus::Timestamp::toSeconds, pybind11::call_guard<pybind11::gil_scoped_release>());
+	
+	pybind11::class_<GPTPStatus::ScaledNanoSeconds>(gptpStatus, "ScaledNanoSeconds")
+		.def_readonly("nanosecondsMSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsMSB)
+		.def_readonly("nanosecondsLSB", &GPTPStatus::ScaledNanoSeconds::nanosecondsLSB)
+		.def_readonly("fractionalNanoseconds", &GPTPStatus::ScaledNanoSeconds::fractionalNanoseconds);
+	
+	pybind11::class_<GPTPStatus::PortID>(gptpStatus, "PortID")
+		.def_readonly("clockIdentity", &GPTPStatus::PortID::clockIdentity)
+		.def_readonly("portNumber", &GPTPStatus::PortID::portNumber);
+	
+	pybind11::class_<GPTPStatus::ClockQuality>(gptpStatus, "ClockQuality")
+		.def_readonly("clockClass", &GPTPStatus::ClockQuality::clockClass)
+		.def_readonly("clockAccuracy", &GPTPStatus::ClockQuality::clockAccuracy)
+		.def_readonly("offsetScaledLogVariance", &GPTPStatus::ClockQuality::offsetScaledLogVariance);
+	
+	pybind11::class_<GPTPStatus::SystemID>(gptpStatus, "SystemID")
+		.def_readonly("priority1", &GPTPStatus::SystemID::priority1)
+		.def_readonly("clockQuality", &GPTPStatus::SystemID::clockQuality)
+		.def_readonly("priority2", &GPTPStatus::SystemID::priority2)
+		.def_readonly("clockID", &GPTPStatus::SystemID::clockID);
+	
+	pybind11::class_<GPTPStatus::PriorityVector>(gptpStatus, "PriorityVector")
+		.def_readonly("sysID", &GPTPStatus::PriorityVector::sysID)
+		.def_readonly("stepsRemoved", &GPTPStatus::PriorityVector::stepsRemoved)
+		.def_readonly("portID", &GPTPStatus::PriorityVector::portID)
+		.def_readonly("portNumber", &GPTPStatus::PriorityVector::portNumber);
+	
+	pybind11::class_<GPTPStatus::ParentDS>(gptpStatus, "ParentDS")
+		.def_readonly("parentPortIdentity", &GPTPStatus::ParentDS::parentPortIdentity)
+		.def_readonly("cumulativeRateRatio", &GPTPStatus::ParentDS::cumulativeRateRatio)
+		.def_readonly("grandmasterIdentity", &GPTPStatus::ParentDS::grandmasterIdentity)
+		.def_readonly("gmClockQualityClockClass", &GPTPStatus::ParentDS::gmClockQualityClockClass)
+		.def_readonly("gmClockQualityClockAccuracy", &GPTPStatus::ParentDS::gmClockQualityClockAccuracy)
+		.def_readonly("gmClockQualityOffsetScaledLogVariance", &GPTPStatus::ParentDS::gmClockQualityOffsetScaledLogVariance)
+		.def_readonly("gmPriority1", &GPTPStatus::ParentDS::gmPriority1)
+		.def_readonly("gmPriority2", &GPTPStatus::ParentDS::gmPriority2);
+
+	pybind11::class_<GPTPStatus::CurrentDS>(gptpStatus, "CurrentDS")
+		.def_readonly("stepsRemoved", &GPTPStatus::CurrentDS::stepsRemoved)
+		.def_readonly("offsetFromMaster", &GPTPStatus::CurrentDS::offsetFromMaster)
+		.def_readonly("lastgmPhaseChange", &GPTPStatus::CurrentDS::lastgmPhaseChange)
+		.def_readonly("lastgmFreqChange", &GPTPStatus::CurrentDS::lastgmFreqChange)
+		.def_readonly("gmTimeBaseIndicator", &GPTPStatus::CurrentDS::gmTimeBaseIndicator)
+		.def_readonly("gmChangeCount", &GPTPStatus::CurrentDS::gmChangeCount)
+		.def_readonly("timeOfLastgmChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmChangeEvent)
+		.def_readonly("timeOfLastgmPhaseChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmPhaseChangeEvent)
+		.def_readonly("timeOfLastgmFreqChangeEvent", &GPTPStatus::CurrentDS::timeOfLastgmFreqChangeEvent);
+
+	gptpStatus.def_readonly("currentTime", &GPTPStatus::currentTime)
+		.def_readonly("gmPriority", &GPTPStatus::gmPriority)
+		.def_readonly("msOffsetNs", &GPTPStatus::msOffsetNs)
+		.def_readonly("isSync", &GPTPStatus::isSync)
+		.def_readonly("linkStatus", &GPTPStatus::linkStatus)
+		.def_readonly("linkDelayNS", &GPTPStatus::linkDelayNS)
+		.def_readonly("selectedRole", &GPTPStatus::selectedRole)
+		.def_readonly("asCapable", &GPTPStatus::asCapable)
+		.def_readonly("isSyntonized", &GPTPStatus::isSyntonized)
+		.def_readonly("lastRXSyncTS", &GPTPStatus::lastRXSyncTS)
+		.def_readonly("currentDS", &GPTPStatus::currentDS)
+		.def_readonly("parentDS", &GPTPStatus::parentDS);
+
+}
+
+} // namespace icsneo

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

@@ -0,0 +1,59 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/linmessage.h"
+
+namespace icsneo {
+
+void init_linmessage(pybind11::module_& m) {
+	pybind11::class_<LINErrorFlags>(m, "LINErrorFlags")
+		.def_readwrite("ErrRxBreakOnly", &LINErrorFlags::ErrRxBreakOnly)
+		.def_readwrite("ErrRxBreakSyncOnly", &LINErrorFlags::ErrRxBreakSyncOnly)
+		.def_readwrite("ErrTxRxMismatch", &LINErrorFlags::ErrTxRxMismatch)
+		.def_readwrite("ErrRxBreakNotZero", &LINErrorFlags::ErrRxBreakNotZero)
+		.def_readwrite("ErrRxBreakTooShort", &LINErrorFlags::ErrRxBreakTooShort)
+		.def_readwrite("ErrRxSyncNot55", &LINErrorFlags::ErrRxSyncNot55)
+		.def_readwrite("ErrRxDataLenOver8", &LINErrorFlags::ErrRxDataLenOver8)
+		.def_readwrite("ErrFrameSync", &LINErrorFlags::ErrFrameSync)
+		.def_readwrite("ErrFrameMessageID", &LINErrorFlags::ErrFrameMessageID)
+		.def_readwrite("ErrFrameResponderData", &LINErrorFlags::ErrFrameResponderData)
+		.def_readwrite("ErrChecksumMatch", &LINErrorFlags::ErrChecksumMatch);
+
+	pybind11::class_<LINStatusFlags>(m, "LINStatusFlags")
+		.def_readwrite("TxChecksumEnhanced", &LINStatusFlags::TxChecksumEnhanced)
+		.def_readwrite("TxCommander", &LINStatusFlags::TxCommander)
+		.def_readwrite("TxResponder", &LINStatusFlags::TxResponder)
+		.def_readwrite("TxAborted", &LINStatusFlags::TxAborted)
+		.def_readwrite("UpdateResponderOnce", &LINStatusFlags::UpdateResponderOnce)
+		.def_readwrite("HasUpdatedResponderOnce", &LINStatusFlags::HasUpdatedResponderOnce)
+		.def_readwrite("BusRecovered", &LINStatusFlags::BusRecovered)
+		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly);
+
+	pybind11::class_<LINMessage, std::shared_ptr<LINMessage>, Frame> linMessage(m, "LINMessage");
+
+	pybind11::enum_<LINMessage::Type>(linMessage, "Type")
+		.value("NOT_SET", LINMessage::Type::NOT_SET)
+		.value("LIN_COMMANDER_MSG", LINMessage::Type::LIN_COMMANDER_MSG)
+		.value("LIN_HEADER_ONLY", LINMessage::Type::LIN_HEADER_ONLY)
+		.value("LIN_BREAK_ONLY", LINMessage::Type::LIN_BREAK_ONLY)
+		.value("LIN_SYNC_ONLY", LINMessage::Type::LIN_SYNC_ONLY)
+		.value("LIN_UPDATE_RESPONDER", LINMessage::Type::LIN_UPDATE_RESPONDER)
+		.value("LIN_ERROR", LINMessage::Type::LIN_ERROR);
+
+	linMessage
+		.def(pybind11::init<>())
+		.def(pybind11::init<uint8_t>())
+		.def_static("calc_checksum", &LINMessage::calcChecksum)
+		.def("calc_protected_id", &LINMessage::calcProtectedID)
+		.def_readwrite("ID", &LINMessage::ID)
+		.def_readwrite("protectedID", &LINMessage::protectedID)
+		.def_readwrite("checksum", &LINMessage::checksum)
+		.def_readwrite("linMsgType", &LINMessage::linMsgType)
+		.def_readwrite("isEnhancedChecksum", &LINMessage::isEnhancedChecksum)
+		.def_readwrite("errFlags", &LINMessage::errFlags)
+		.def_readwrite("statusFlags", &LINMessage::statusFlags);
+}
+
+} // namespace icsneo
+

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

@@ -0,0 +1,35 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/communication/message/mdiomessage.h"
+
+namespace icsneo {
+
+void init_mdiomessage(pybind11::module_& m) {
+	pybind11::class_<MDIOMessage, std::shared_ptr<MDIOMessage>, Frame> mdioMessage(m, "MDIOMessage");
+	pybind11::enum_<MDIOMessage::Clause>(mdioMessage, "Clause")
+		.value("Clause45", MDIOMessage::Clause::Clause45)
+		.value("Clause22", MDIOMessage::Clause::Clause22);
+	pybind11::enum_<MDIOMessage::Direction>(mdioMessage, "Direction")
+		.value("Write", MDIOMessage::Direction::Write)
+		.value("Read", MDIOMessage::Direction::Read);
+	mdioMessage
+		.def(pybind11::init())
+		.def_readwrite("isTXMsg", &MDIOMessage::isTXMsg)
+		.def_readwrite("txTimeout", &MDIOMessage::txTimeout)
+		.def_readwrite("txAborted", &MDIOMessage::txAborted)
+		.def_readwrite("txInvalidBus", &MDIOMessage::txInvalidBus)
+		.def_readwrite("txInvalidPhyAddr", &MDIOMessage::txInvalidPhyAddr)
+		.def_readwrite("txInvalidRegAddr", &MDIOMessage::txInvalidRegAddr)
+		.def_readwrite("txInvalidClause", &MDIOMessage::txInvalidClause)
+		.def_readwrite("txInvalidOpcode", &MDIOMessage::txInvalidOpcode)
+		.def_readwrite("phyAddress", &MDIOMessage::phyAddress)
+		.def_readwrite("devAddress", &MDIOMessage::devAddress)
+		.def_readwrite("regAddress", &MDIOMessage::regAddress)
+		.def_readwrite("direction", &MDIOMessage::direction)
+		.def_readwrite("clause", &MDIOMessage::clause);
+}
+
+} // namespace icsneo 
+

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

@@ -31,7 +31,8 @@ void init_message(pybind11::module_& m) {
 		.value("LiveData", Message::Type::LiveData)
 		.value("HardwareInfo", Message::Type::HardwareInfo)
 		.value("TC10Status", Message::Type::TC10Status)
-		.value("AppError", Message::Type::AppError);
+		.value("AppError", Message::Type::AppError)
+		.value("GPTPStatus", Message::Type::GPTPStatus);
 
 	message.def(pybind11::init<Message::Type>());
 	message.def_readonly("type", &Message::type);

bindings/python/icsneopy/communication/network.cpp

@@ -167,7 +167,30 @@ void init_network(pybind11::module_& m) {
 		.value("Any", Network::NetID::Any)
 		.value("Invalid", Network::NetID::Invalid);
 	
-    network.def(pybind11::init<Network::NetID>());
+	pybind11::enum_<Network::Type>(network, "Type")
+		.value("Invalid", Network::Type::Invalid)
+		.value("Internal", Network::Type::Internal)
+		.value("CAN", Network::Type::CAN)
+		.value("LIN", Network::Type::LIN)
+		.value("FlexRay", Network::Type::FlexRay)
+		.value("MOST", Network::Type::MOST)
+		.value("Ethernet", Network::Type::Ethernet)
+		.value("LSFTCAN", Network::Type::LSFTCAN)
+		.value("SWCAN", Network::Type::SWCAN)
+		.value("ISO9141", Network::Type::ISO9141)
+		.value("I2C", Network::Type::I2C)
+		.value("A2B", Network::Type::A2B)
+		.value("SPI", Network::Type::SPI)
+		.value("MDIO", Network::Type::MDIO)
+		.value("Any", Network::Type::Any)
+		.value("Other", Network::Type::Other);
+
+    network
+		.def(pybind11::init<Network::NetID>())
+		.def("__repr__", [](Network& self) { return Network::GetNetIDString(self.getNetID()); })
+		.def_static("get_net_id_string", &Network::GetNetIDString, pybind11::arg("netid"), pybind11::arg("expand") = true)
+		.def("get_net_id", &Network::getNetID)
+		.def("get_type", &Network::getType);
 }
 
 } // namespace icsneo 

bindings/python/icsneopy/device/device.cpp

@@ -1,6 +1,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
+#include <pybind11/chrono.h>
 
 #include "icsneo/device/device.h"
 
@@ -12,30 +13,33 @@ void init_device(pybind11::module_& m) {
 		.def("get_serial", &Device::getSerial)
 		.def("get_serial_number", &Device::getSerialNumber)
 		.def("get_product_name", &Device::getProductName)
-		.def("open", [](Device& device) { return device.open(); })
-		.def("close", &Device::close)
+		.def("open", [](Device& device) { return device.open(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("close", &Device::close, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("is_open", &Device::isOpen)
-		.def("go_online", &Device::goOnline)
-		.def("go_offline", &Device::goOffline)
-		.def("is_online", &Device::isOnline).def("enable_message_polling", &Device::enableMessagePolling)
-		.def("disable_message_polling", &Device::disableMessagePolling)
+		.def("go_online", &Device::goOnline, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("go_offline", &Device::goOffline, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("is_online", &Device::isOnline)
+		.def("enable_message_polling", &Device::enableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("disable_message_polling", &Device::disableMessagePolling, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("is_message_polling_enabled", &Device::isMessagePollingEnabled)
-		.def("get_messages", [](Device& device) { return device.getMessages(); })
+		.def("get_messages", [](Device& device) { return device.getMessages(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_current_message_count", &Device::getCurrentMessageCount)
 		.def("get_polling_message_limit", &Device::getPollingMessageLimit)
 		.def("set_polling_message_limit", &Device::setPollingMessageLimit)
-		.def("add_message_callback", &Device::addMessageCallback)
-		.def("remove_message_callback", &Device::removeMessageCallback)
-		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit))
+		.def("add_message_callback", &Device::addMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("remove_message_callback", &Device::removeMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
 		.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
-		.def("get_rtc", &Device::getRTC)
-		.def("set_rtc", &Device::setRTC)
+		.def("get_rtc", &Device::getRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("set_rtc", &Device::setRTC, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("describe", &Device::describe)
 		.def("is_online_supported", &Device::isOnlineSupported)
 		.def("supports_tc10", &Device::supportsTC10)
-		.def("request_tc10_wake", &Device::requestTC10Wake)
-		.def("request_tc10_sleep", &Device::requestTC10Sleep)
+		.def("request_tc10_wake", &Device::requestTC10Wake, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("request_tc10_sleep", &Device::requestTC10Sleep, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_gptp_status", &Device::getGPTPStatus, pybind11::arg("timeout") = std::chrono::milliseconds(100), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("__repr__", &Device::describe);
 }
 

bindings/python/icsneopy/device/devicetype.cpp

@@ -33,6 +33,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("EtherBADGE", DeviceType::Enum::EtherBADGE)
 		.value("RAD_A2B", DeviceType::Enum::RAD_A2B)
 		.value("RADEpsilon", DeviceType::Enum::RADEpsilon)
+		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
 		.value("RADComet", DeviceType::Enum::RADComet)
 		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)

bindings/python/icsneopy/icsneocpp.cpp

@@ -14,7 +14,10 @@ void init_devicetype(pybind11::module_&);
 void init_message(pybind11::module_&);
 void init_canmessage(pybind11::module_&);
 void init_ethernetmessage(pybind11::module_&);
+void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
+void init_gptpstatusmessage(pybind11::module_&);
+void init_mdiomessage(pybind11::module_&);
 void init_device(pybind11::module_&);
 void init_messagefilter(pybind11::module_&);
 void init_messagecallback(pybind11::module_&);
@@ -32,7 +35,10 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_message(m);
 	init_canmessage(m);
 	init_ethernetmessage(m);
+	init_linmessage(m);
 	init_tc10statusmessage(m);
+	init_gptpstatusmessage(m);
+	init_mdiomessage(m);
 	init_messagefilter(m);
 	init_messagecallback(m);
 	init_device(m);

communication/decoder.cpp

@@ -19,6 +19,7 @@
 #include "icsneo/communication/message/diskdatamessage.h"
 #include "icsneo/communication/message/hardwareinfo.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
+#include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/apperrormessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
@@ -178,6 +179,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 			LINMessage& msg = *static_cast<LINMessage*>(result.get());
 			msg.network = packet->network;
+			msg.timestamp *= timestampResolution;
 			return true;
 		}
 		case Network::Type::MDIO: {
@@ -284,11 +286,11 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 				}
 				case Network::NetID::ExtendedCommand: {
 
-					if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
+					if(packet->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
 						break; // Handle as a raw message, might not be a generic response
 
-					const auto& resp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
-					switch(resp.header.command) {
+					const auto& resp = *reinterpret_cast<ExtendedResponseMessage::ResponseHeader*>(packet->data.data());
+					switch(resp.command) {
 						case ExtendedCommand::GetComponentVersions:
 							result = ComponentVersionPacket::DecodeToMessage(packet->data);
 							return true;
@@ -298,15 +300,23 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::GenericBinaryInfo:
 							result = GenericBinaryStatusPacket::DecodeToMessage(packet->data);
 							return true;
-						case ExtendedCommand::GenericReturn:
-							result = std::make_shared<ExtendedResponseMessage>(resp.command, resp.returnCode);
+						case ExtendedCommand::GenericReturn: {
+							if(packet->data.size() < sizeof(ExtendedResponseMessage::PackedGenericResponse))
+								break;
+							const auto& packedResp = *reinterpret_cast<ExtendedResponseMessage::PackedGenericResponse*>(packet->data.data());
+							result = std::make_shared<ExtendedResponseMessage>(packedResp.command, packedResp.returnCode);
 							return true;
+						}
 						case ExtendedCommand::LiveData:
 							result = HardwareLiveDataPacket::DecodeToMessage(packet->data, report);
 							return true;
 						case ExtendedCommand::GetTC10Status:
 							result = TC10StatusMessage::DecodeToMessage(packet->data);
 							return true;
+						case ExtendedCommand::GetGPTPStatus: {
+							result = GPTPStatus::DecodeToMessage(packet->data, report);
+							return true;
+						}
 						default:
 							// No defined handler, treat this as a RawMessage
 							break;

communication/message/gptpstatusmessage.cpp

@@ -0,0 +1,219 @@
+#include <icsneo/communication/message/gptpstatusmessage.h>
+#include <icsneo/communication/message/extendedresponsemessage.h>
+#include <cstring>
+
+namespace icsneo {
+typedef double float64;
+typedef int64_t time_interval;
+typedef uint64_t _clock_identity;
+
+
+#pragma pack(push, 1)
+
+struct port_identity {
+	_clock_identity clock_identity;
+	uint16_t port_number;
+};
+
+struct _scaled_ns {
+	int16_t nanoseconds_msb;
+	int64_t nanoseconds_lsb;
+	int16_t fractional_nanoseconds;
+};
+
+struct _clock_quality {
+	uint8_t clock_class;
+	uint8_t clock_accuracy;
+	uint16_t offset_scaled_log_variance;
+};
+
+struct system_identity {
+	uint8_t priority_1;
+	struct _clock_quality clock_quality;
+	uint8_t priority_2;
+	_clock_identity clock_identity;
+};
+
+struct _timestamp {
+	uint16_t seconds_msb;
+	uint32_t seconds_lsb;
+	uint32_t nanoseconds;
+};
+
+struct priority_vector {
+	struct system_identity sysid;
+	uint16_t steps_removed;
+	struct port_identity portid;
+	uint16_t port_number;
+};
+
+
+// IEEE 802.1AS-2020 14.3
+// This is a read-only data structure
+struct _current_ds {
+	uint16_t steps_removed;
+	time_interval offset_from_master;
+	struct _scaled_ns last_gm_phase_change;
+	float64 last_gm_freq_change;
+	uint16_t gm_time_base_indicator;
+	uint32_t gm_change_count;
+	uint32_t time_of_last_gm_change_event;
+	uint32_t time_of_last_gm_phase_change_event;
+	uint32_t time_of_last_gm_freq_change_event;
+};
+
+// IEEE 802.1AS-2020 14.4
+// This is a read-only data structure
+struct _parent_ds {
+	struct port_identity parent_port_identity;
+	int32_t cumulative_rate_ratio;
+	_clock_identity grandmaster_identity;
+	uint8_t gm_clock_quality_clock_class;
+	uint8_t gm_clock_quality_clock_accuracy;
+	uint16_t gm_clock_quality_offset_scaled_log_variance;
+	uint8_t gm_priority1;
+	uint8_t gm_priority2;
+};
+
+struct _GPTPStatus
+{
+	struct _timestamp current_time;
+	struct priority_vector gm_priority;
+	int64_t ms_offset_ns;
+	uint8_t is_sync;
+	uint8_t link_status;
+	int64_t link_delay_ns;
+	uint8_t selected_role;
+	uint8_t as_capable;
+	uint8_t is_syntonized;
+	struct _timestamp last_rx_sync_ts; // t2 in IEEE 1588-2019 Figure-16
+	struct _current_ds current_ds;
+	struct _parent_ds parent_ds;
+};
+
+#pragma pack(pop)
+
+static void SetField(GPTPStatus::Timestamp& output, const _timestamp& input) {
+	output.seconds = ((uint64_t)(input.seconds_msb) << 32) | ((uint64_t)input.seconds_lsb);
+	output.nanoseconds = input.nanoseconds;
+}
+
+static void SetField(GPTPStatus::PortID& output, const port_identity& input) {
+	output.clockIdentity = input.clock_identity;
+	output.portNumber = input.port_number;	
+}
+static void SetField(GPTPStatus::ClockQuality& output, const _clock_quality& input) {
+	output.clockClass = input.clock_class;
+	output.clockAccuracy = input.clock_accuracy;
+	output.offsetScaledLogVariance = input.offset_scaled_log_variance;
+}
+
+static void SetField(GPTPStatus::SystemID& output, const system_identity& input) {
+	output.priority1 = input.priority_1;
+	SetField(output.clockQuality, input.clock_quality);
+	output.priority2 = input.priority_2;
+	output.clockID = input.clock_identity;
+}
+
+static void SetField(GPTPStatus::ScaledNanoSeconds& output, const _scaled_ns& input) {
+	output.nanosecondsMSB = input.nanoseconds_msb;
+	output.nanosecondsLSB = input.nanoseconds_lsb;
+	output.fractionalNanoseconds = input.fractional_nanoseconds;
+}
+
+static void SetField(GPTPStatus::PriorityVector& output, const priority_vector& input) {
+	SetField(output.sysID, input.sysid);
+	output.stepsRemoved = input.steps_removed;
+	SetField(output.portID, input.portid);
+	output.portNumber = input.port_number;
+}
+
+static void SetField(GPTPStatus::CurrentDS& output, const _current_ds& input) {
+	output.stepsRemoved = input.steps_removed;
+	output.offsetFromMaster = input.offset_from_master;
+	SetField(output.lastgmPhaseChange, input.last_gm_phase_change);
+	output.lastgmFreqChange = input.last_gm_freq_change;	
+	output.gmTimeBaseIndicator = input.gm_time_base_indicator;
+	output.gmChangeCount = input.gm_change_count;
+	output.timeOfLastgmChangeEvent = input.time_of_last_gm_change_event;
+	output.timeOfLastgmPhaseChangeEvent = input.time_of_last_gm_phase_change_event;
+	output.timeOfLastgmFreqChangeEvent = input.time_of_last_gm_freq_change_event;
+}
+
+static void SetField(GPTPStatus::ParentDS& output, const _parent_ds& input) {
+	SetField(output.parentPortIdentity, input.parent_port_identity);
+	output.cumulativeRateRatio = input.cumulative_rate_ratio;
+	output.grandmasterIdentity = input.grandmaster_identity;
+	output.gmClockQualityClockClass = input.gm_clock_quality_clock_class;
+	output.gmClockQualityClockAccuracy = input.gm_clock_quality_clock_accuracy;
+	output.gmClockQualityOffsetScaledLogVariance = input.gm_clock_quality_offset_scaled_log_variance;
+	output.gmPriority1 = input.gm_priority1;
+	output.gmPriority2 = input.gm_priority2;
+}
+
+[[maybe_unused]] static void SetField(uint8_t& output, const uint8_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint16_t& output, const uint16_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint32_t& output, const uint32_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(uint64_t& output, const uint64_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int8_t& output, const int8_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int16_t& output, const int16_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int32_t& output, const int32_t& input) {
+	output = input;
+}
+
+[[maybe_unused]] static void SetField(int64_t& output, const int64_t& input) {
+	output = input;
+}
+
+std::shared_ptr<GPTPStatus> GPTPStatus::DecodeToMessage(std::vector<uint8_t>& bytes, const device_eventhandler_t&) {
+
+	// The following does not lead to overflow since we only call this function if it has at least ResponseHeader length bytes
+	std::shared_ptr<GPTPStatus> res = std::make_shared<GPTPStatus>();
+	auto* header = reinterpret_cast<ExtendedResponseMessage::ResponseHeader*>(bytes.data());
+	uint16_t length = header->length;
+	_GPTPStatus* input = reinterpret_cast<_GPTPStatus*>(bytes.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
+
+#define CheckLengthAndSet(output, input) if(length >= sizeof(decltype(input))) { \
+		SetField(output, input); \
+		length -= sizeof(decltype(input)); \
+	} else {\
+		memset(&output, 0, sizeof(decltype(output))); \
+		length = 0; \
+		res->shortFormat = true; \
+	}
+
+	CheckLengthAndSet(res->currentTime, input->current_time);
+	CheckLengthAndSet(res->gmPriority, input->gm_priority);
+	CheckLengthAndSet(res->msOffsetNs, input->ms_offset_ns);
+	CheckLengthAndSet(res->isSync, input->is_sync);
+	CheckLengthAndSet(res->linkStatus, input->link_status);
+	CheckLengthAndSet(res->linkDelayNS, input->link_delay_ns);
+	CheckLengthAndSet(res->selectedRole, input->selected_role);
+	CheckLengthAndSet(res->asCapable, input->as_capable);
+	CheckLengthAndSet(res->isSyntonized, input->is_syntonized);
+	CheckLengthAndSet(res->lastRXSyncTS, input->last_rx_sync_ts);
+	CheckLengthAndSet(res->currentDS, input->current_ds);
+	CheckLengthAndSet(res->parentDS, input->parent_ds);
+
+	return res;
+}
+
+}

communication/message/neomessage.cpp

@@ -51,7 +51,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				eth.status.incompleteFrame = ethmsg->frameTooShort;
 				// TODO Fill in extra status bits
 				//eth.status.xyz = ethmsg->preemptionEnabled;
-				//eth.status.xyz = ethmsg->fcsAvailable;
+				//eth.status.xyz = ethmsg->fcs;
 				//eth.status.xyz = ethmsg->noPadding;
 				break;
 			}

communication/packet/ethernetpacket.cpp

@@ -16,8 +16,8 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	if(packet->Length < 4)
 		return nullptr;
 	
-	const size_t ethernetFrameSize = packet->Length - (sizeof(uint16_t) * 2);
-	const size_t bytestreamExpectedSize = sizeof(HardwareEthernetPacket) + ethernetFrameSize;
+	const size_t fcsSize = packet->header.FCS_AVAIL ? 4 : 0;
+	const size_t bytestreamExpectedSize = sizeof(HardwareEthernetPacket) + packet->Length;
 	const size_t bytestreamActualSize = bytestream.size();
 	if(bytestreamActualSize < bytestreamExpectedSize)
 		return nullptr;
@@ -36,8 +36,6 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	message.preemptionEnabled = packet->header.PREEMPTION_ENABLED;
 	if(message.preemptionEnabled)
 		message.preemptionFlags = (uint8_t)((rawWords[0] & 0x03F8) >> 4);
-	
-	message.fcsAvailable = packet->header.FCS_AVAIL;
 
 	message.frameTooShort = packet->header.RUNT_FRAME;
 	if(message.frameTooShort)
@@ -47,11 +45,14 @@ std::shared_ptr<EthernetMessage> HardwareEthernetPacket::DecodeToMessage(const s
 	// Decoder will fix as it has information about the timestampResolution increments
 	message.timestamp = packet->timestamp.TS;
 
-	// Network ID is also not set, this will be fixed in the Decoder as well
-
-	const std::vector<uint8_t>::const_iterator databegin = bytestream.begin() + (sizeof(HardwareEthernetPacket) - (sizeof(uint16_t) * 2));
-	const std::vector<uint8_t>::const_iterator dataend = databegin + ethernetFrameSize;
+	const std::vector<uint8_t>::const_iterator databegin = bytestream.begin() + sizeof(HardwareEthernetPacket);
+	const std::vector<uint8_t>::const_iterator dataend = databegin + packet->Length - fcsSize;
 	message.data.insert(message.data.begin(), databegin, dataend);
+	
+	if(fcsSize) {
+		uint32_t& fcs = message.fcs.emplace();
+		std::copy(dataend, dataend + fcsSize, (uint8_t*)&fcs);
+	}
 
 	return messagePtr;
 }

device/device.cpp

@@ -1951,7 +1951,7 @@ bool Device::setRTC(const std::chrono::time_point<std::chrono::system_clock>& ti
 	}
 
 	auto m51msg = std::dynamic_pointer_cast<Main51Message>(generic);
-	if(!m51msg || m51msg->data.size() != 1) {
+	if(!m51msg || m51msg->data.empty() || m51msg->data.size() > 2) {
 		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
 		return false;
 	}
@@ -3335,3 +3335,34 @@ std::optional<TC10StatusMessage> Device::getTC10Status(Network::NetID network) {
 
 	return *typed;
 }
+
+std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeout) {
+	if(!supportsGPTP()) {
+		report(APIEvent::Type::GPTPNotSupported, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	if(!isOpen()) {
+		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+
+	std::shared_ptr<Message> response = com->waitForMessageSync(
+		[this](){ 
+			return com->sendCommand(ExtendedCommand::GetGPTPStatus, {}); 
+		},
+		std::make_shared<MessageFilter>(Message::Type::GPTPStatus),
+		timeout
+	);
+
+	if(!response) {
+		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	auto retMsg = std::static_pointer_cast<GPTPStatus>(response);
+	if(!retMsg) {
+		return std::nullopt;
+	}
+
+	return *retMsg;
+}

device/devicefinder.cpp

@@ -197,6 +197,10 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADGalaxy>(dev, newFoundDevices);
 		#endif
 
+		#ifdef __RADGALAXY2_H_
+		makeIfSerialMatches<RADGalaxy2>(dev, newFoundDevices);
+		#endif
+
 		#ifdef __RADMARS_H_
 		makeIfSerialMatches<RADMars>(dev, newFoundDevices);
 		#endif
@@ -352,6 +356,10 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADGalaxy::DEVICE_TYPE,
 		#endif
 
+		#ifdef __RADGALAXY2_H_
+		RADGalaxy2::DEVICE_TYPE,
+		#endif
+
 		#ifdef __RADMARS_H_
 		RADMars::DEVICE_TYPE,
 		#endif

docs/index.rst

@@ -1,9 +1,14 @@
+=========
 libicsneo
 =========
 
+libicsneo is the `Intrepid Control Systems <https://intrepidcs.com/>`_ device
+communication library. The source code for libicsneo can be found on GitHub: 
+`https://github.com/intrepidcs/libicsneo <https://github.com/intrepidcs/libicsneo>`_
+
 .. toctree::
    :maxdepth: 1
-   :caption: API Documentation
+   :caption: Documentation
 
    icsneocpp/index
    icsneopy/index

include/icsneo/api/event.h

@@ -109,6 +109,7 @@ public:
 		LINSettingsNotAvailable = 0x2053,
 		ModeNotFound = 0x2054,
 		AppErrorParsingFailed = 0x2055,
+		GPTPNotSupported = 0x2056,
 
 		// Transport Events
 		FailedToRead = 0x3000,

include/icsneo/communication/command.h

@@ -51,6 +51,7 @@ enum class ExtendedCommand : uint16_t {
 	StartDHCPServer = 0x0016,
 	StopDHCPServer = 0x0017,
 	GetSupportedFeatures = 0x0018,
+	GetGPTPStatus = 0x0019,
 	GetComponentVersions = 0x001A,
 	Reboot = 0x001C,
 	SetRootFSEntryFlags = 0x0027,

include/icsneo/communication/message/ethernetmessage.h

@@ -35,7 +35,7 @@ class EthernetMessage : public Frame {
 public:
 	bool preemptionEnabled = false;
 	uint8_t preemptionFlags = 0;
-	bool fcsAvailable = false;
+	std::optional<uint32_t> fcs;
 	bool frameTooShort = false;
 	bool noPadding = false;
 

include/icsneo/communication/message/gptpstatusmessage.h

@@ -0,0 +1,103 @@
+#ifndef __GPTPSTATUSMESSAGE_H_
+#define __GPTPSTATUSMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/command.h"
+#include "icsneo/api/eventmanager.h"
+
+
+namespace icsneo {
+
+class GPTPStatus : public Message {
+public:
+	typedef uint64_t TimeInterval;
+	typedef uint64_t ClockID;
+
+	struct Timestamp {
+		uint64_t seconds;
+		uint32_t nanoseconds;
+
+		double toSeconds() const {
+			static constexpr double billion = 1e9;
+			return (double)seconds + ((double)nanoseconds) / billion;
+		}
+	};
+
+	struct ScaledNanoSeconds {
+		int16_t nanosecondsMSB; // The most significant bits
+		int64_t nanosecondsLSB; // The least significant bits
+		int16_t fractionalNanoseconds; // Fractional part
+	};
+
+	struct PortID {
+		ClockID clockIdentity;
+		uint16_t portNumber;
+	};
+	struct ClockQuality {
+		uint8_t clockClass;
+		uint8_t clockAccuracy;
+		uint16_t offsetScaledLogVariance;
+	};
+
+	struct SystemID {
+		uint8_t priority1;
+		ClockQuality clockQuality;
+		uint8_t priority2;
+		ClockID clockID;
+	};
+
+	struct PriorityVector {
+		SystemID sysID;
+		uint16_t stepsRemoved;
+		PortID portID;
+		uint16_t portNumber;
+	};
+
+	struct ParentDS {
+		PortID parentPortIdentity;
+		int32_t cumulativeRateRatio;
+		ClockID grandmasterIdentity;
+		uint8_t gmClockQualityClockClass;
+		uint8_t gmClockQualityClockAccuracy;
+		uint16_t gmClockQualityOffsetScaledLogVariance;
+		uint8_t gmPriority1;
+		uint8_t gmPriority2;
+	};
+
+	struct CurrentDS {
+		uint16_t stepsRemoved;
+		TimeInterval offsetFromMaster;
+		ScaledNanoSeconds lastgmPhaseChange;
+		double lastgmFreqChange;
+		uint16_t gmTimeBaseIndicator;
+		uint32_t gmChangeCount;
+		uint32_t timeOfLastgmChangeEvent;
+		uint32_t timeOfLastgmPhaseChangeEvent;
+		uint32_t timeOfLastgmFreqChangeEvent;
+	};
+
+	GPTPStatus() : Message(Message::Type::GPTPStatus) {}
+	static std::shared_ptr<GPTPStatus> DecodeToMessage(std::vector<uint8_t>& bytes, const device_eventhandler_t& report);
+
+	Timestamp currentTime;
+	PriorityVector gmPriority;
+	int64_t msOffsetNs;
+	uint8_t isSync;
+	uint8_t linkStatus;
+	int64_t linkDelayNS;
+	uint8_t selectedRole;
+	uint8_t asCapable;
+	uint8_t isSyntonized;
+	Timestamp lastRXSyncTS; // t2 in IEEE 1588-2019 Figure-16
+	CurrentDS currentDS;
+	ParentDS parentDS;
+	
+	bool shortFormat = false; // Set to true if the above variables weren't set (some firmware versions do not contain all the above variables)
+};
+
+}
+
+#endif
+#endif

include/icsneo/communication/message/message.h

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

include/icsneo/communication/packet/ethernetpacket.h

@@ -10,6 +10,8 @@
 
 namespace icsneo {
 
+#pragma pack(push, 2)
+
 typedef uint16_t icscm_bitfield;
 
 struct HardwareEthernetPacket {
@@ -42,6 +44,8 @@ struct HardwareEthernetPacket {
 	uint16_t Length;
 };
 
+#pragma pack(pop)
+
 }
 
 #endif // __cplusplus

include/icsneo/device/device.h

@@ -50,6 +50,7 @@
 #include "icsneo/disk/vsa/vsa.h"
 #include "icsneo/disk/vsa/vsaparser.h"
 #include "icsneo/communication/message/versionmessage.h"
+#include "icsneo/communication/message/gptpstatusmessage.h"
 
 
 #define ICSNEO_FINDABLE_DEVICE_BASE(className, type) \
@@ -727,12 +728,15 @@ public:
 	virtual bool supportsComponentVersions() const { return false; }
 
 	virtual bool supportsTC10() const { return false; }
+	
+	virtual bool supportsGPTP() const { return false; }
 
 	bool requestTC10Wake(Network::NetID network);
 
 	bool requestTC10Sleep(Network::NetID network);
 
 	std::optional<TC10StatusMessage> getTC10Status(Network::NetID network);
+	std::optional<GPTPStatus> getGPTPStatus(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
 
 protected:
 	bool online = false;

include/icsneo/device/devicetype.h

@@ -47,6 +47,7 @@ public:
 		EtherBADGE = (0x00000016),
 		RAD_A2B = (0x00000017),
 		RADEpsilon = (0x00000018),
+		RADGalaxy2 = (0x00000021),
 		RADMoon3 = (0x00000023),
 		RADComet = (0x00000024),
 		FIRE3_FlexRay = (0x00000025),
@@ -182,6 +183,8 @@ public:
 				return "neoVI Flex";
 			case RADGalaxy:
 				return "RAD-Galaxy";
+			case RADGalaxy2:
+				return "RAD-Galaxy 2";
 			case RADStar2:
 				return "RAD-Star 2";
 			case VividCAN:
@@ -248,6 +251,7 @@ private:
 #define ICSNEO_DEVICETYPE_ETHERBADGE ((devicetype_t)0x00000016)
 #define ICSNEO_DEVICETYPE_RAD_A2B ((devicetype_t)0x00000017)
 #define ICSNEO_DEVICETYPE_RADEPSILON ((devicetype_t)0x00000018)
+#define ICSNEO_DEVICETYPE_RADGALAXY2 ((devicetype_t)0x00000021)
 #define ICSNEO_DEVICETYPE_RADMoon3 ((devicetype_t)0x00000023)
 #define ICSNEO_DEVICETYPE_RADCOMET ((devicetype_t)0x00000024)
 #define ICSNEO_DEVICETYPE_FIRE3FLEXRAY ((devicetype_t)0x00000025)

include/icsneo/device/idevicesettings.h

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

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

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

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

@@ -36,6 +36,7 @@ public:
 	}
 
 	bool supportsComponentVersions() const override { return true; }
+	bool supportsGPTP() const override { return true; }
 
 protected:
 	NeoVIRED2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {

include/icsneo/device/tree/rada2b/rada2b.h

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

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

@@ -31,6 +31,7 @@ public:
 	}
 
 	bool getEthPhyRegControlSupported() const override { return true; }
+	bool supportsGPTP() const override { return true; }
 
 protected:
 	using Device::Device;

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

@@ -45,6 +45,7 @@ public:
 	bool getEthPhyRegControlSupported() const override { return true; }
 
 	bool supportsTC10() const override { return true; }
+	bool supportsGPTP() const override { return true; }
 
 protected:
 	RADComet3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {

include/icsneo/device/tree/radgalaxy/radgalaxy.h

@@ -61,6 +61,7 @@ public:
 	}
 
 	size_t getEthernetActivationLineCount() const override { return 1; }
+	bool supportsGPTP() const override { return true; }
 
 protected:
 	RADGalaxy(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {

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

@@ -0,0 +1,121 @@
+#ifndef __RADGALAXY2_H_
+#define __RADGALAXY2_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/device.h"
+#include "icsneo/device/devicetype.h"
+#include "icsneo/communication/packetizer.h"
+#include "icsneo/communication/decoder.h"
+#include "icsneo/disk/extextractordiskreaddriver.h"
+#include "icsneo/disk/neomemorydiskdriver.h"
+#include "icsneo/device/tree/radgalaxy2/radgalaxy2settings.h"
+
+namespace icsneo {
+
+class RADGalaxy2 : public Device {
+public:
+	// Serial numbers start with G2
+	// Ethernet MAC allocation is 0x17, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE(RADGalaxy2, DeviceType::RADGalaxy2, "G2");
+
+	static const std::vector<Network>& GetSupportedNetworks() {
+		static std::vector<Network> supportedNetworks = {
+			Network::NetID::HSCAN,
+			Network::NetID::MSCAN,
+			Network::NetID::HSCAN2,
+			Network::NetID::HSCAN3,
+			Network::NetID::HSCAN4,
+			Network::NetID::HSCAN5,
+			Network::NetID::HSCAN6,
+			Network::NetID::HSCAN7,
+
+			Network::NetID::LIN,
+			Network::NetID::LIN2,
+
+			Network::NetID::Ethernet,
+			Network::NetID::Ethernet2,
+			Network::NetID::Ethernet3,
+
+			Network::NetID::OP_Ethernet1,
+			Network::NetID::OP_Ethernet2,
+			Network::NetID::OP_Ethernet3,
+			Network::NetID::OP_Ethernet4,
+			Network::NetID::OP_Ethernet5,
+			Network::NetID::OP_Ethernet6,
+			Network::NetID::OP_Ethernet7,
+			Network::NetID::OP_Ethernet8,
+			Network::NetID::OP_Ethernet9,
+			Network::NetID::OP_Ethernet10,
+			Network::NetID::OP_Ethernet11,
+			Network::NetID::OP_Ethernet12,
+
+			Network::NetID::ISO9141,
+			Network::NetID::ISO9141_2,
+
+			Network::NetID::MDIO1,
+			Network::NetID::MDIO2,
+			Network::NetID::MDIO3,
+			Network::NetID::MDIO4,
+			Network::NetID::MDIO5,
+		};
+		return supportedNetworks;
+	}
+
+	size_t getEthernetActivationLineCount() const override { return 1; }
+
+	bool supportsTC10() const override { return true; }
+	bool supportsGPTP() const override { return true; }
+
+protected:
+	RADGalaxy2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
+		initialize<RADGalaxy2Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
+	}
+
+	void setupPacketizer(Packetizer& packetizer) override {
+		Device::setupPacketizer(packetizer);
+		packetizer.disableChecksum = true;
+		packetizer.align16bit = false;
+	}
+
+	void setupEncoder(Encoder& encoder) override {
+		Device::setupEncoder(encoder);
+		encoder.supportCANFD = true;
+		encoder.supportEthPhy = true;
+	}
+
+	void setupDecoder(Decoder& decoder) override {
+		Device::setupDecoder(decoder);
+		decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns
+	}
+
+	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
+		for(auto& netid : GetSupportedNetworks())
+			rxNetworks.emplace_back(netid);
+	}
+
+	// The supported TX networks are the same as the supported RX networks for this device
+	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
+
+	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+		if(message->data.size() < sizeof(radgalaxy2_status_t))
+			return;
+		std::lock_guard<std::mutex> lk(ioMutex);
+		const radgalaxy2_status_t* status = reinterpret_cast<const radgalaxy2_status_t*>(message->data.data());
+		ethActivationStatus = status->ethernetActivationLineEnabled;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
+};
+
+}
+
+#endif // __cplusplus
+
+#endif

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

@@ -0,0 +1,192 @@
+#ifndef __RADGALAXY2SETTINGS_H_
+#define __RADGALAXY2SETTINGS_H_
+
+#include "icsneo/device/idevicesettings.h"
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+namespace icsneo {
+
+#endif
+
+#pragma pack(push, 2)
+
+typedef struct {
+	uint32_t ecu_id;
+	uint16_t perf_en;
+
+	/* CAN */
+	CAN_SETTINGS can1;
+	CANFD_SETTINGS canfd1;
+	CAN_SETTINGS can2;
+	CANFD_SETTINGS canfd2;
+	CAN_SETTINGS can3;
+	CANFD_SETTINGS canfd3;
+	CAN_SETTINGS can4;
+	CANFD_SETTINGS canfd4;
+	CAN_SETTINGS can5;
+	CANFD_SETTINGS canfd5;
+	CAN_SETTINGS can6;
+	CANFD_SETTINGS canfd6;
+	CAN_SETTINGS can7;
+	CANFD_SETTINGS canfd7;
+	CAN_SETTINGS can8;
+	CANFD_SETTINGS canfd8;
+
+	// SWCAN_SETTINGS swcan1;	G2 does not have SWCAN.
+	uint16_t network_enables;
+	// SWCAN_SETTINGS swcan2;	G2 does not have SWCAN.
+	uint16_t network_enables_2;
+
+	uint32_t pwr_man_timeout;
+	uint16_t pwr_man_enable;
+
+	uint16_t network_enabled_on_boot;
+
+	/* ISO15765-2 Transport Layer */
+	uint16_t iso15765_separation_time_offset;
+
+	/* ISO9141 - Keyword */
+	uint16_t iso_9141_kwp_enable_reserved;
+	ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_1;
+	uint16_t iso_parity_1;
+
+	uint16_t iso_msg_termination_1;
+
+	uint16_t idle_wakeup_network_enables_1;
+	uint16_t idle_wakeup_network_enables_2;
+
+	/* reserved for T1 networks such as BR1, BR2, etc.. */
+	uint16_t network_enables_3;
+	uint16_t idle_wakeup_network_enables_3;
+
+	STextAPISettings text_api;
+
+	uint64_t termination_enables; // New feature unlike Galaxy.
+
+	TIMESYNC_ICSHARDWARE_SETTINGS timeSyncSettings;
+	struct
+	{
+		uint16_t hwComLatencyTestEn : 1;
+		uint16_t reserved : 15;
+	} flags;
+
+	LIN_SETTINGS lin1;
+
+	OP_ETH_GENERAL_SETTINGS opEthGen;
+	OP_ETH_SETTINGS opEth1;
+	OP_ETH_SETTINGS opEth2;
+	OP_ETH_SETTINGS opEth3;
+	OP_ETH_SETTINGS opEth4;
+	OP_ETH_SETTINGS opEth5;
+	OP_ETH_SETTINGS opEth6;
+	OP_ETH_SETTINGS opEth7;
+	OP_ETH_SETTINGS opEth8;
+	OP_ETH_SETTINGS opEth9;
+	OP_ETH_SETTINGS opEth10;
+	OP_ETH_SETTINGS opEth11;
+	OP_ETH_SETTINGS opEth12;
+	OP_ETH_SETTINGS opEth13;
+	OP_ETH_SETTINGS opEth14;
+	OP_ETH_SETTINGS opEth15;
+	OP_ETH_SETTINGS opEth16;
+
+	ETHERNET10G_SETTINGS ethernet10g;
+	ETHERNET10G_SETTINGS ethernet10g_2;
+	ETHERNET10G_SETTINGS ethernet10g_3;
+
+	uint16_t network_enables_4;
+	RAD_REPORTING_SETTINGS reporting;
+	RAD_GPTP_SETTINGS gPTP;
+
+	uint64_t network_enables_5;
+
+	LIN_SETTINGS lin2;
+} radgalaxy2_settings_t;
+
+typedef struct {
+	uint8_t unused[3];
+	uint8_t ethernetActivationLineEnabled;
+} radgalaxy2_status_t;
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+
+#include <iostream>
+
+class RADGalaxy2Settings : public IDeviceSettings {
+public:
+	RADGalaxy2Settings(std::shared_ptr<Communication> com) : IDeviceSettings(com, sizeof(radgalaxy2_settings_t)) {}
+	const CAN_SETTINGS* getCANSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radgalaxy2_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::HSCAN:
+				return &(cfg->can1);
+			case Network::NetID::MSCAN:
+				return &(cfg->can2);
+			case Network::NetID::HSCAN2:
+				return &(cfg->can3);
+			case Network::NetID::HSCAN3:
+				return &(cfg->can4);
+			case Network::NetID::HSCAN4:
+				return &(cfg->can5);
+			case Network::NetID::HSCAN5:
+				return &(cfg->can6);
+			case Network::NetID::HSCAN6:
+				return &(cfg->can7);
+			case Network::NetID::HSCAN7:
+				return &(cfg->can8);
+			default:
+				return nullptr;
+		}
+	}
+	const CANFD_SETTINGS* getCANFDSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radgalaxy2_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::HSCAN:
+				return &(cfg->canfd1);
+			case Network::NetID::MSCAN:
+				return &(cfg->canfd2);
+			case Network::NetID::HSCAN2:
+				return &(cfg->canfd3);
+			case Network::NetID::HSCAN3:
+				return &(cfg->canfd4);
+			case Network::NetID::HSCAN4:
+				return &(cfg->canfd5);
+			case Network::NetID::HSCAN5:
+				return &(cfg->canfd6);
+			case Network::NetID::HSCAN6:
+				return &(cfg->canfd7);
+			case Network::NetID::HSCAN7:
+				return &(cfg->canfd8);
+			default:
+				return nullptr;
+		}
+	}
+
+	const LIN_SETTINGS* getLINSettingsFor(Network net) const override {
+		auto cfg = getStructurePointer<radgalaxy2_settings_t>();
+		if(cfg == nullptr)
+			return nullptr;
+		switch(net.getNetID()) {
+			case Network::NetID::LIN:
+				return &(cfg->lin1);
+			case Network::NetID::LIN2:
+				return &(cfg->lin2);
+			default:
+				return nullptr;
+		}
+	}
+};
+
+}
+
+#endif // __cplusplus
+
+#endif

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

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

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

@@ -76,7 +76,8 @@ namespace icsneo
 		bool getEthPhyRegControlSupported() const override { return true; }
 
 		bool supportsTC10() const override { return true; }
-
+		bool supportsGPTP() const override { return true; }
+	
 	protected:
 		RADGigastar2(neodevice_t neodevice, const driver_factory_t &makeDriver) : Device(neodevice)
 		{

include/icsneo/device/tree/radmars/radmars.h

@@ -19,6 +19,7 @@ public:
 	ICSNEO_FINDABLE_DEVICE(RADMars, DeviceType::RADMars, "GL");
 
 	size_t getEthernetActivationLineCount() const override { return 1; }
+	bool supportsGPTP() const override { return true; }
 
 protected:
 	RADMars(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {

include/icsneo/icsnVC40.h

@@ -220,7 +220,7 @@ typedef unsigned __int64 uint64_t;
 #define NEODEVICE_RADEPSILON_EXPRESS (0x0000001d)
 #define NEODEVICE_RADPROXIMA (0x0000001e)
 #define NEODEVICE_NEW_DEVICE_58 (0x0000001f)
-#define NEODEVICE_NEW_DEVICE_59 (0x00000021)
+#define NEODEVICE_RAD_GALAXY_2 (0x00000021)
 #define NEODEVICE_RAD_BMS (0x00000022)
 #define NEODEVICE_RADMOON3 (0x00000023)
 #define NEODEVICE_RADCOMET (0x00000024)
@@ -2999,6 +2999,100 @@ typedef struct _SRADGigastarSettings
 
 #define SRADGigastarSettings_SIZE 710
 
+typedef struct _SRADGalaxy2Settings
+{
+	uint32_t ecu_id;
+	uint16_t perf_en;
+
+	/* CAN */
+	CAN_SETTINGS can1;
+	CANFD_SETTINGS canfd1;
+	CAN_SETTINGS can2;
+	CANFD_SETTINGS canfd2;
+	CAN_SETTINGS can3;
+	CANFD_SETTINGS canfd3;
+	CAN_SETTINGS can4;
+	CANFD_SETTINGS canfd4;
+	CAN_SETTINGS can5;
+	CANFD_SETTINGS canfd5;
+	CAN_SETTINGS can6;
+	CANFD_SETTINGS canfd6;
+	CAN_SETTINGS can7;
+	CANFD_SETTINGS canfd7;
+	CAN_SETTINGS can8;
+	CANFD_SETTINGS canfd8;
+
+	// SWCAN_SETTINGS swcan1;	G2 does not have SWCAN.
+	uint16_t network_enables;
+	// SWCAN_SETTINGS swcan2;	G2 does not have SWCAN.
+	uint16_t network_enables_2;
+
+	uint32_t pwr_man_timeout;
+	uint16_t pwr_man_enable;
+
+	uint16_t network_enabled_on_boot;
+
+	/* ISO15765-2 Transport Layer */
+	uint16_t iso15765_separation_time_offset;
+
+	/* ISO9141 - Keyword */
+	uint16_t iso_9141_kwp_enable_reserved;
+	ISO9141_KEYWORD2000_SETTINGS iso9141_kwp_settings_1;
+	uint16_t iso_parity_1;
+
+	uint16_t iso_msg_termination_1;
+
+	uint16_t idle_wakeup_network_enables_1;
+	uint16_t idle_wakeup_network_enables_2;
+
+	/* reserved for T1 networks such as BR1, BR2, etc.. */
+	uint16_t network_enables_3;
+	uint16_t idle_wakeup_network_enables_3;
+
+	STextAPISettings text_api;
+
+	uint64_t termination_enables; // New feature unlike Galaxy.
+
+	TIMESYNC_ICSHARDWARE_SETTINGS timeSyncSettings;
+	struct
+	{
+		uint16_t hwComLatencyTestEn : 1;
+		uint16_t reserved : 15;
+	} flags;
+
+	LIN_SETTINGS lin1;
+
+	OP_ETH_GENERAL_SETTINGS opEthGen;
+	OP_ETH_SETTINGS opEth1;
+	OP_ETH_SETTINGS opEth2;
+	OP_ETH_SETTINGS opEth3;
+	OP_ETH_SETTINGS opEth4;
+	OP_ETH_SETTINGS opEth5;
+	OP_ETH_SETTINGS opEth6;
+	OP_ETH_SETTINGS opEth7;
+	OP_ETH_SETTINGS opEth8;
+	OP_ETH_SETTINGS opEth9;
+	OP_ETH_SETTINGS opEth10;
+	OP_ETH_SETTINGS opEth11;
+	OP_ETH_SETTINGS opEth12;
+	OP_ETH_SETTINGS opEth13;
+	OP_ETH_SETTINGS opEth14;
+	OP_ETH_SETTINGS opEth15;
+	OP_ETH_SETTINGS opEth16;
+
+	ETHERNET10G_SETTINGS ethernet10g;
+	ETHERNET10G_SETTINGS ethernet10g_2;
+	ETHERNET10G_SETTINGS ethernet10g_3;
+
+	uint16_t network_enables_4;
+	RAD_REPORTING_SETTINGS reporting;
+	RAD_GPTP_SETTINGS gPTP;
+
+	uint64_t network_enables_5;
+	LIN_SETTINGS lin2;
+} SRADGalaxy2Settings;
+#define SRADGalaxy2Settings_SIZE 840
+
 typedef struct _SVividCANSettings
 {
 	uint32_t ecu_id;
@@ -5425,6 +5519,7 @@ CHECK_STRUCT_SIZE(SPendantSettings);
 CHECK_STRUCT_SIZE(SIEVBSettings);
 CHECK_STRUCT_SIZE(SEEVBSettings);
 CHECK_STRUCT_SIZE(SRADGalaxySettings);
+CHECK_STRUCT_SIZE(SRADGalaxy2Settings);
 CHECK_STRUCT_SIZE(SRADStar2Settings);
 CHECK_STRUCT_SIZE(SOBD2SimSettings)
 CHECK_STRUCT_SIZE(CmProbeSettings);

include/icsneo/platform/posix/devices.h

@@ -19,6 +19,7 @@
 #include "icsneo/device/tree/radmoont1s/radmoont1s.h"
 #include "icsneo/device/tree/radepsilon/radepsilon.h"
 #include "icsneo/device/tree/radgalaxy/radgalaxy.h"
+#include "icsneo/device/tree/radgalaxy2/radgalaxy2.h"
 #include "icsneo/device/tree/radgigastar/radgigastar.h"
 #include "icsneo/device/tree/radgigastar2/radgigastar2.h"
 #include "icsneo/device/tree/radjupiter/radjupiter.h"

include/icsneo/platform/windows/devices.h

@@ -19,6 +19,7 @@
 #include "icsneo/device/tree/radmoont1s/radmoont1s.h"
 #include "icsneo/device/tree/radepsilon/radepsilon.h"
 #include "icsneo/device/tree/radgalaxy/radgalaxy.h"
+#include "icsneo/device/tree/radgalaxy2/radgalaxy2.h"
 #include "icsneo/device/tree/radgigastar/radgigastar.h"
 #include "icsneo/device/tree/radgigastar2/radgigastar2.h"
 #include "icsneo/device/tree/radjupiter/radjupiter.h"

platform/tcp.cpp

@@ -88,6 +88,21 @@ void TCP::Socket::poll(uint16_t event, uint32_t msTimeout) {
 }
 
 void TCP::Find(std::vector<FoundDevice>& found) {
+	static const auto tcpDisabled = []() -> bool {
+		#ifdef _MSC_VER
+		#pragma warning(push)
+		#pragma warning(disable : 4996)
+		#endif
+		const auto disabled = std::getenv("LIBICSNEO_DISABLE_TCP");
+		return disabled ? std::stoi(disabled) : false;
+		#ifdef _MSC_VER
+		#pragma warning(pop)
+		#endif
+	};
+	if(tcpDisabled()) {
+		return;
+	}
+
 	static const auto MDNS_PORT = htons((unsigned short)5353);
 	static const auto MDNS_IP = htonl((((uint32_t)224U) << 24U) | ((uint32_t)251U));