sven
/
libicsneo
mirror of https://github.com/intrepidcs/libicsneo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fixed some naming issues.

David Rebbe 2024-12-05 12:01:39 -05:00
parent 3cdf9a341f
commit d3c7a92f57
18 changed files with 113 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
api/icsneolegacy/icsneolegacy.cpp
View File

@ -83,21 +83,21 @@ static bool NeoMessageToSpyMessage(const neodevice_t* device, const neomessage_t
switch (Network::Type(frame.type)) switch (Network::Type(frame.type))
{ {
case Network::Type::CAN: case icsneo_msg_bus_type_can:
case Network::Type::SWCAN: case icsneo_msg_bus_type_swcan:
case Network::Type::LSFTCAN: case icsneo_msg_bus_type_lsftcan:
oldmsg.Protocol = frame.status.canfdFDF ? SPY_PROTOCOL_CANFD : SPY_PROTOCOL_CAN; oldmsg.Protocol = frame.status.canfdFDF ? SPY_PROTOCOL_CANFD : SPY_PROTOCOL_CAN;
oldmsg.NumberBytesData = static_cast<uint8_t>(std::min(frame.length, (size_t)255)); oldmsg.NumberBytesData = static_cast<uint8_t>(std::min(frame.length, (size_t)255));
oldmsg.NumberBytesHeader = 4; oldmsg.NumberBytesHeader = 4;
copyFrameData(); copyFrameData();
break; break;
case Network::Type::Ethernet: case icsneo_msg_bus_type_ethernet:
oldmsg.Protocol = SPY_PROTOCOL_ETHERNET; oldmsg.Protocol = SPY_PROTOCOL_ETHERNET;
oldmsg.NumberBytesData = static_cast<uint8_t>(frame.length & 0xFF); oldmsg.NumberBytesData = static_cast<uint8_t>(frame.length & 0xFF);
oldmsg.NumberBytesHeader = static_cast<uint8_t>(frame.length >> 8); oldmsg.NumberBytesHeader = static_cast<uint8_t>(frame.length >> 8);
copyFrameData(); copyFrameData();
break; break;
case Network::Type::LIN: case icsneo_msg_bus_type_lin:
{ {
const neomessage_lin_t& linFrame = *reinterpret_cast<const neomessage_lin_t*>(&frame); const neomessage_lin_t& linFrame = *reinterpret_cast<const neomessage_lin_t*>(&frame);
icsSpyMessageJ1850& linSpyMsg = *reinterpret_cast<icsSpyMessageJ1850*>(&oldmsg); icsSpyMessageJ1850& linSpyMsg = *reinterpret_cast<icsSpyMessageJ1850*>(&oldmsg);

22
communication/decoder.cpp
View File

@ -54,7 +54,7 @@ uint64_t Decoder::GetUInt64FromLEBytes(const uint8_t* bytes) {
bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Packet>& packet) { bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Packet>& packet) {
switch(packet->network.getType()) { switch(packet->network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: { case icsneo_msg_bus_type_ethernet: {
result = HardwareEthernetPacket::DecodeToMessage(packet->data, report); result = HardwareEthernetPacket::DecodeToMessage(packet->data, report);
if(!result) { if(!result) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error); report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
@ -68,9 +68,9 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
eth.network = packet->network; eth.network = packet->network;
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: case icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: case icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: { case icsneo_msg_bus_type_lsftcan: {
if(packet->data.size() < 24) { if(packet->data.size() < 24) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error); report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false; return false;
@ -105,7 +105,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray: { case icsneo_msg_bus_type_flexray: {
if(packet->data.size() < 24) { if(packet->data.size() < 24) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error); report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false; return false;
@ -124,7 +124,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
fr.network = packet->network; fr.network = packet->network;
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: { case icsneo_msg_bus_type_iso9141: {
if(packet->data.size() < sizeof(HardwareISO9141Packet)) { if(packet->data.size() < sizeof(HardwareISO9141Packet)) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error); report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false; return false;
@ -141,7 +141,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
iso.network = packet->network; iso.network = packet->network;
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: { case icsneo_msg_bus_type_i2c: {
if(packet->data.size() < sizeof(HardwareI2CPacket)) { if(packet->data.size() < sizeof(HardwareI2CPacket)) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error); report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false; return false;
@ -155,7 +155,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: { case icsneo_msg_bus_type_a2b: {
result = HardwareA2BPacket::DecodeToMessage(packet->data); result = HardwareA2BPacket::DecodeToMessage(packet->data);
if(!result) { if(!result) {
@ -168,7 +168,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
msg.timestamp *= timestampResolution; msg.timestamp *= timestampResolution;
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
result = HardwareLINPacket::DecodeToMessage(packet->data); result = HardwareLINPacket::DecodeToMessage(packet->data);
if(!result) { if(!result) {
@ -180,7 +180,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
msg.network = packet->network; msg.network = packet->network;
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: { case icsneo_msg_bus_type_mdio: {
result = HardwareMDIOPacket::DecodeToMessage(packet->data); result = HardwareMDIOPacket::DecodeToMessage(packet->data);
if(!result) { if(!result) {
@ -192,7 +192,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
msg.network = packet->network; msg.network = packet->network;
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal: { case icsneo_msg_bus_type_internal: {
switch(packet->network.getNetID()) { switch(packet->network.getNetID()) {
case Network::NetID::Reset_Status: { case Network::NetID::Reset_Status: {
// We can deal with not having the last two fields (voltage and temperature) // We can deal with not having the last two fields (voltage and temperature)

32
communication/encoder.cpp
View File

@ -31,7 +31,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
netid = uint16_t(frame->network.getNetID()); netid = uint16_t(frame->network.getNetID());
switch(frame->network.getType()) { switch(frame->network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: { case icsneo_msg_bus_type_ethernet: {
auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message); auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
if(!ethmsg) { if(!ethmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -43,10 +43,10 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false; return false;
break; break;
} // End of Network::Type::Ethernet } // End of icsneo_msg_bus_type_ethernet
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: case icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: case icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: { case icsneo_msg_bus_type_lsftcan: {
auto canmsg = std::dynamic_pointer_cast<CANMessage>(message); auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
if(!canmsg) { if(!canmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -63,8 +63,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false; // The CANMessage was malformed return false; // The CANMessage was malformed
break; break;
} // End of Network::Type::CAN } // End of icsneo_msg_bus_type_can
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: { case icsneo_msg_bus_type_iso9141: {
auto isomsg = std::dynamic_pointer_cast<ISO9141Message>(message); auto isomsg = std::dynamic_pointer_cast<ISO9141Message>(message);
if(!isomsg) { if(!isomsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -74,8 +74,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
// Skip the normal message wrapping at the bottom since we need to send multiple // Skip the normal message wrapping at the bottom since we need to send multiple
// packets to the device. This function just encodes them back to back into `result` // packets to the device. This function just encodes them back to back into `result`
return HardwareISO9141Packet::EncodeFromMessage(*isomsg, result, report, packetizer); return HardwareISO9141Packet::EncodeFromMessage(*isomsg, result, report, packetizer);
} // End of Network::Type::ISO9141 } // End of icsneo_msg_bus_type_iso9141
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: { case icsneo_msg_bus_type_a2b: {
auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message); auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message);
if(!a2bmsg) { if(!a2bmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -86,8 +86,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false; return false;
} }
break; break;
} // End of Network::Type::A2B } // End of icsneo_msg_bus_type_a2b
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: { case icsneo_msg_bus_type_i2c: {
auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message); auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message);
if(!i2cmsg) { if(!i2cmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -98,8 +98,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false; return false;
} }
break; break;
} // End of Network::Type::I2C } // End of icsneo_msg_bus_type_i2c
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
auto linmsg = std::dynamic_pointer_cast<LINMessage>(message); auto linmsg = std::dynamic_pointer_cast<LINMessage>(message);
if(!linmsg) { if(!linmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -110,8 +110,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false; return false;
} }
break; break;
} // End of Network::Type::LIN } // End of icsneo_msg_bus_type_lin
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: { case icsneo_msg_bus_type_mdio: {
auto mdiomsg = std::dynamic_pointer_cast<MDIOMessage>(message); auto mdiomsg = std::dynamic_pointer_cast<MDIOMessage>(message);
if(!mdiomsg) { if(!mdiomsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error); report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -122,7 +122,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false; return false;
} }
break; break;
} // End of Network::Type::MDIO } // End of icsneo_msg_bus_type_mdio
default: default:
report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error); report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
return false; return false;

2
communication/message/callback/streamoutput/a2bwavoutput.cpp
View File

@ -112,7 +112,7 @@ bool A2BWAVOutput::callIfMatch(const std::shared_ptr<Message>& message) const {
return false; return false;
} }
if(frameMsg->network.getType() != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b) if(frameMsg->network.getType() != icsneo_msg_bus_type_a2b)
return false; return false;
const auto& a2bMsg = std::dynamic_pointer_cast<A2BMessage>(frameMsg); const auto& a2bMsg = std::dynamic_pointer_cast<A2BMessage>(frameMsg);

20
communication/message/neomessage.cpp
View File

@ -29,9 +29,9 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
frame.status.transmitMessage = framemsg->transmitted; frame.status.transmitMessage = framemsg->transmitted;
switch(netType) { switch(netType) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: case icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: case icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: { case icsneo_msg_bus_type_lsftcan: {
neomessage_can_t& can = *(neomessage_can_t*)&neomsg; neomessage_can_t& can = *(neomessage_can_t*)&neomsg;
auto canmsg = std::static_pointer_cast<CANMessage>(message); auto canmsg = std::static_pointer_cast<CANMessage>(message);
can.arbid = canmsg->arbid; can.arbid = canmsg->arbid;
@ -44,7 +44,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
can.status.canfdESI = canmsg->errorStateIndicator; can.status.canfdESI = canmsg->errorStateIndicator;
break; break;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: { case icsneo_msg_bus_type_ethernet: {
neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg; neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg;
auto ethmsg = std::static_pointer_cast<EthernetMessage>(message); auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
eth.preemptionFlags = ethmsg->preemptionFlags; eth.preemptionFlags = ethmsg->preemptionFlags;
@ -55,7 +55,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
//eth.status.xyz = ethmsg->noPadding; //eth.status.xyz = ethmsg->noPadding;
break; break;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
neomessage_lin_t& lin = *(neomessage_lin_t*)&neomsg; neomessage_lin_t& lin = *(neomessage_lin_t*)&neomsg;
auto linmsg = std::static_pointer_cast<LINMessage>(message); auto linmsg = std::static_pointer_cast<LINMessage>(message);
if(!linmsg) { break; } if(!linmsg) { break; }
@ -123,9 +123,9 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
case Message::Type::Frame: { case Message::Type::Frame: {
const Network network = ((neomessage_frame_t*)neomessage)->netid; const Network network = ((neomessage_frame_t*)neomessage)->netid;
switch(network.getType()) { switch(network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: case icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: case icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: { case icsneo_msg_bus_type_lsftcan: {
neomessage_can_t& can = *(neomessage_can_t*)neomessage; neomessage_can_t& can = *(neomessage_can_t*)neomessage;
auto canmsg = std::make_shared<CANMessage>(); auto canmsg = std::make_shared<CANMessage>();
canmsg->network = network; canmsg->network = network;
@ -140,7 +140,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
canmsg->errorStateIndicator = can.status.canfdESI; canmsg->errorStateIndicator = can.status.canfdESI;
return canmsg; return canmsg;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: { case icsneo_msg_bus_type_ethernet: {
neomessage_eth_t& eth = *(neomessage_eth_t*)neomessage; neomessage_eth_t& eth = *(neomessage_eth_t*)neomessage;
auto ethmsg = std::make_shared<EthernetMessage>(); auto ethmsg = std::make_shared<EthernetMessage>();
ethmsg->network = network; ethmsg->network = network;
@ -148,7 +148,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
ethmsg->data.insert(ethmsg->data.end(), eth.data, eth.data + eth.length); ethmsg->data.insert(ethmsg->data.end(), eth.data, eth.data + eth.length);
return ethmsg; return ethmsg;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
neomessage_lin_t& lin = *(neomessage_lin_t*)neomessage; neomessage_lin_t& lin = *(neomessage_lin_t*)neomessage;
auto linmsg = std::make_shared<LINMessage>(); auto linmsg = std::make_shared<LINMessage>();
linmsg->network = network; linmsg->network = network;

2
device/extensions/flexray/extension.cpp
View File

@ -49,7 +49,7 @@ void FlexRay::Extension::handleMessage(const std::shared_ptr<Message>& message)
} }
bool FlexRay::Extension::transmitHook(const std::shared_ptr<BusMessage>& frame, bool& success) { bool FlexRay::Extension::transmitHook(const std::shared_ptr<BusMessage>& frame, bool& success) {
if(!frame || frame->network.getType() != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray) if(!frame || frame->network.getType() != icsneo_msg_bus_type_flexray)
return true; // Don't hook non-FlexRay messages return true; // Don't hook non-FlexRay messages
success = false; success = false;

32
device/idevicesettings.cpp
View File

@ -403,7 +403,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: { case icsneo_msg_bus_type_can: {
const CAN_SETTINGS* cfg = getCANSettingsFor(net); const CAN_SETTINGS* cfg = getCANSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::CANSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::CANSettingsNotAvailable, APIEvent::Severity::Error);
@ -417,7 +417,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
} }
return baudrate; return baudrate;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: { case icsneo_msg_bus_type_swcan: {
const SWCAN_SETTINGS* cfg = getSWCANSettingsFor(net); const SWCAN_SETTINGS* cfg = getSWCANSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error);
@ -431,7 +431,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
} }
return baudrate; return baudrate;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: { case icsneo_msg_bus_type_lsftcan: {
const CAN_SETTINGS* cfg = getLSFTCANSettingsFor(net); const CAN_SETTINGS* cfg = getLSFTCANSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error);
@ -445,7 +445,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
} }
return baudrate; return baudrate;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
const LIN_SETTINGS* cfg = getLINSettingsFor(net); const LIN_SETTINGS* cfg = getLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -477,7 +477,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: { case icsneo_msg_bus_type_can: {
if(baudrate > 1000000) { // This is an FD baudrate. Use setFDBaudrateFor instead. if(baudrate > 1000000) { // This is an FD baudrate. Use setFDBaudrateFor instead.
report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
return false; return false;
@ -499,7 +499,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: { case icsneo_msg_bus_type_lsftcan: {
CAN_SETTINGS* cfg = getMutableLSFTCANSettingsFor(net); CAN_SETTINGS* cfg = getMutableLSFTCANSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error);
@ -516,7 +516,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: { case icsneo_msg_bus_type_swcan: {
SWCAN_SETTINGS* cfg = getMutableSWCANSettingsFor(net); SWCAN_SETTINGS* cfg = getMutableSWCANSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error);
@ -533,7 +533,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values cfg->SetBaudrate = AUTO; // Device will use the baudrate value to set the TQ values
return true; return true;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
LIN_SETTINGS* cfg = getMutableLINSettingsFor(net); LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -566,7 +566,7 @@ int64_t IDeviceSettings::getFDBaudrateFor(Network net) const {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: { case icsneo_msg_bus_type_can: {
const CANFD_SETTINGS* cfg = getCANFDSettingsFor(net); const CANFD_SETTINGS* cfg = getCANFDSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
@ -604,7 +604,7 @@ bool IDeviceSettings::setFDBaudrateFor(Network net, int64_t baudrate) {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: { case icsneo_msg_bus_type_can: {
CANFD_SETTINGS* cfg = getMutableCANFDSettingsFor(net); CANFD_SETTINGS* cfg = getMutableCANFDSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
@ -771,7 +771,7 @@ std::optional<bool> IDeviceSettings::isCommanderResistorEnabledFor(Network net)
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
const LIN_SETTINGS* cfg = getLINSettingsFor(net); const LIN_SETTINGS* cfg = getLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -803,7 +803,7 @@ bool IDeviceSettings::setCommanderResistorFor(Network net, bool resistor_on) {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
LIN_SETTINGS* cfg = getMutableLINSettingsFor(net); LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -831,7 +831,7 @@ std::optional<LINMode> IDeviceSettings::getLINModeFor(Network net) const {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
const LIN_SETTINGS* cfg = getLINSettingsFor(net); const LIN_SETTINGS* cfg = getLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -863,7 +863,7 @@ bool IDeviceSettings::setLINModeFor(Network net, LINMode mode) {
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
LIN_SETTINGS* cfg = getMutableLINSettingsFor(net); LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -891,7 +891,7 @@ std::optional<uint8_t> IDeviceSettings::getLINCommanderResponseTimeFor(Network n
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
const LIN_SETTINGS* cfg = getLINSettingsFor(net); const LIN_SETTINGS* cfg = getLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -923,7 +923,7 @@ bool IDeviceSettings::setLINCommanderResponseTimeFor(Network net, uint8_t bits)
} }
switch(net.getType()) { switch(net.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: { case icsneo_msg_bus_type_lin: {
LIN_SETTINGS* cfg = getMutableLINSettingsFor(net); LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
if(cfg == nullptr) { if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error); report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);

2
disk/vsa/vsa.cpp
View File

@ -31,7 +31,7 @@ void VSAExtendedMessage::truncatePacket(std::shared_ptr<Packet> packet)
{ {
static constexpr auto EthernetLengthOffset = 26u; static constexpr auto EthernetLengthOffset = 26u;
switch(packet->network.getType()) { switch(packet->network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: case icsneo_msg_bus_type_ethernet:
{ {
const auto& packetLength = *reinterpret_cast<uint16_t*>(packet->data.data() + EthernetLengthOffset); const auto& packetLength = *reinterpret_cast<uint16_t*>(packet->data.data() + EthernetLengthOffset);
const size_t ethernetFrameSize = packetLength - (sizeof(uint16_t) * 2); const size_t ethernetFrameSize = packetLength - (sizeof(uint16_t) * 2);

6
docs/icsneocpp/examples.rst
View File

@ -36,9 +36,9 @@ the arbitration ID.
std::cout << "We got " << messages.size() << " messages!" << std::endl; std::cout << "We got " << messages.size() << " messages!" << std::endl;
for(auto& msg : messages) { for(auto& msg : messages) {
switch(msg->network.getType()) { switch(msg->network.getType()) {
case icsneo::Network::Type::CAN: case icsneo::icsneo_msg_bus_type_can:
case icsneo::Network::Type::SWCAN: case icsneo::icsneo_msg_bus_type_swcan:
case icsneo::Network::Type::LSFTCAN: { case icsneo::icsneo_msg_bus_type_lsftcan: {
// A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely // A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
auto canmsg = std::static_pointer_cast<icsneo::CANMessage>(msg); auto canmsg = std::static_pointer_cast<icsneo::CANMessage>(msg);
// canmsg->arbid is valid here // canmsg->arbid is valid here

4
examples/cpp/a2b/src/a2b.cpp
View File

@ -392,11 +392,11 @@ int main(int argc, char** argv) {
const auto& txNetworks = dev->getSupportedTXNetworks(); const auto& txNetworks = dev->getSupportedTXNetworks();
const auto& rxNetworks = dev->getSupportedRXNetworks(); const auto& rxNetworks = dev->getSupportedRXNetworks();
if(std::none_of(txNetworks.begin(), txNetworks.end(), [](const icsneo::Network& net) { return net.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; })) { if(std::none_of(txNetworks.begin(), txNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo_msg_bus_type_a2b; })) {
return false; return false;
} }
if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; })) { if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo_msg_bus_type_a2b; })) {
return false; return false;
} }

6
examples/cpp/interactive/src/InteractiveExample.cpp
View File

@ -188,7 +188,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
// A message of type Frame is guaranteed to be a Frame, so we can static cast safely // A message of type Frame is guaranteed to be a Frame, so we can static cast safely
auto frame = std::static_pointer_cast<icsneo::BusMessage>(message); auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
switch(frame->network.getType()) { switch(frame->network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: { case icsneo_msg_bus_type_can: {
// A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely // A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message); auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message);
@ -214,7 +214,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n"; std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
break; break;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: { case icsneo_msg_bus_type_ethernet: {
auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message); auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec
@ -235,7 +235,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
std::cout << std::dec << std::endl; std::cout << std::dec << std::endl;
break; break;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: { case icsneo_msg_bus_type_iso9141: {
// Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN // Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN
// and that this example loads the device defaults at the very end. // and that this example loads the device defaults at the very end.
// A message of type ISO9414 is guaranteed to be an ISO9141Message, so we can static cast safely // A message of type ISO9414 is guaranteed to be an ISO9141Message, so we can static cast safely

2
examples/cpp/lin/src/LINExample.cpp
View File

@ -98,7 +98,7 @@ int main() {
auto handler = device->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> message) { auto handler = device->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> message) {
if(icsneo::Message::Type::Frame == message->type) { if(icsneo::Message::Type::Frame == message->type) {
auto frame = std::static_pointer_cast<icsneo::BusMessage>(message); auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
if(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin == frame->network.getType()) { if(icsneo_msg_bus_type_lin == frame->network.getType()) {
auto msg = std::static_pointer_cast<icsneo::LINMessage>(message); auto msg = std::static_pointer_cast<icsneo::LINMessage>(message);
std::cout << msg->network << " RX frame | ID: 0x" << std::hex << static_cast<int>(msg->ID) << " | "; std::cout << msg->network << " RX frame | ID: 0x" << std::hex << static_cast<int>(msg->ID) << " | ";
std::cout << "Protected ID: 0x" << static_cast<int>(msg->protectedID) << "\n" << "Data: "; std::cout << "Protected ID: 0x" << static_cast<int>(msg->protectedID) << "\n" << "Data: ";

2
examples/cpp/mdio/src/MDIOExample.cpp
View File

@ -94,7 +94,7 @@ int main()
{ {
if(icsneo::Message::Type::Frame == message->type) { if(icsneo::Message::Type::Frame == message->type) {
auto frame = std::static_pointer_cast<icsneo::BusMessage>(message); auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
if(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio == frame->network.getType()) { if(icsneo_msg_bus_type_mdio == frame->network.getType()) {
auto msg = std::static_pointer_cast<icsneo::MDIOMessage>(message); auto msg = std::static_pointer_cast<icsneo::MDIOMessage>(message);
std::cout << msg->network << " " << ((msg->isTXMsg)? "TX" : "RX") << " frame\n"; std::cout << msg->network << " " << ((msg->isTXMsg)? "TX" : "RX") << " frame\n";
std::cout << "Clause: " << ((msg->clause == icsneo::MDIOMessage::Clause::Clause22) ? "22" : "45") << "\n"; std::cout << "Clause: " << ((msg->clause == icsneo::MDIOMessage::Clause::Clause22) ? "22" : "45") << "\n";

6
examples/cpp/simple/src/SimpleExample.cpp
View File

@ -173,7 +173,7 @@ int main() {
// A message of type Frame is guaranteed to be a Frame, so we can static cast safely // A message of type Frame is guaranteed to be a Frame, so we can static cast safely
auto frame = std::static_pointer_cast<icsneo::BusMessage>(message); auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
switch(frame->network.getType()) { switch(frame->network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: { case icsneo_msg_bus_type_can: {
// A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely // A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message); auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message);
@ -199,7 +199,7 @@ int main() {
std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n"; std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
break; break;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: { case icsneo_msg_bus_type_ethernet: {
auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message); auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec
@ -220,7 +220,7 @@ int main() {
std::cout << std::dec << std::endl; std::cout << std::dec << std::endl;
break; break;
} }
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: { case icsneo_msg_bus_type_iso9141: {
// Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN // Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN
// and that this example loads the device defaults at the very end. // and that this example loads the device defaults at the very end.
// A message of type ISO9414 is guaranteed to be an ISO9141Message, so we can static cast safely // A message of type ISO9414 is guaranteed to be an ISO9141Message, so we can static cast safely

4
examples/cpp/vsa/src/VSAExample.cpp
View File

@ -170,9 +170,9 @@ int main(int argc, char* argv[]) {
return; return;
} }
const auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg); const auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg);
if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can) { if(frame->network.getType() == icsneo_msg_bus_type_can) {
++canFrameCount; ++canFrameCount;
} else if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet) { } else if(frame->network.getType() == icsneo_msg_bus_type_ethernet) {
++ethFrameCount; ++ethFrameCount;
} }
})); }));

4
include/icsneo/communication/message/filter/canmessagefilter.h
View File

@ -13,8 +13,8 @@ namespace icsneo {
class CANMessageFilter : public MessageFilter { class CANMessageFilter : public MessageFilter {
public: public:
CANMessageFilter() : MessageFilter(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_can), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; } CANMessageFilter() : MessageFilter(icsneo_msg_bus_type_can), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; }
CANMessageFilter(uint32_t arbid) : MessageFilter(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_can), arbid(arbid) { messageType = Message::Type::Frame; } CANMessageFilter(uint32_t arbid) : MessageFilter(icsneo_msg_bus_type_can), arbid(arbid) { messageType = Message::Type::Frame; }
bool match(const std::shared_ptr<Message>& message) const { bool match(const std::shared_ptr<Message>& message) const {
if(!MessageFilter::match(message)) if(!MessageFilter::match(message))

10
include/icsneo/communication/message/filter/messagefilter.h
View File

@ -15,9 +15,9 @@ public:
MessageFilter(Message::Type type) : includeInternalInAny(neomessagetype_t(type) & 0x8000), messageType(type) {} MessageFilter(Message::Type type) : includeInternalInAny(neomessagetype_t(type) & 0x8000), messageType(type) {}
MessageFilter(Network::NetID netid) : MessageFilter(Network::GetTypeOfNetID(netid, false), netid) {} // Messages on the communication layer are never encoded as VNET ID + common ID, so skip the expansion step MessageFilter(Network::NetID netid) : MessageFilter(Network::GetTypeOfNetID(netid, false), netid) {} // Messages on the communication layer are never encoded as VNET ID + common ID, so skip the expansion step
MessageFilter(icsneo_msg_bus_type_t type, Network::NetID net = Network::NetID::Any) : networkType(type), netid(net) { MessageFilter(icsneo_msg_bus_type_t type, Network::NetID net = Network::NetID::Any) : networkType(type), netid(net) {
// If a Network::Type::Internal is used, we want to also get internal Message::Types // If a icsneo_msg_bus_type_internal is used, we want to also get internal Message::Types
// The NetID we want may be in there // The NetID we want may be in there
includeInternalInAny = (networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal); includeInternalInAny = (networkType == icsneo_msg_bus_type_internal);
} }
virtual ~MessageFilter() = default; virtual ~MessageFilter() = default;
// When getting "all" types of messages, include the ones marked as "internal only" // When getting "all" types of messages, include the ones marked as "internal only"
@ -34,7 +34,7 @@ public:
return false; return false;
if(!matchNetID(frame->network.getNetID())) if(!matchNetID(frame->network.getNetID()))
return false; return false;
} else if (netid != Network::NetID::Any || networkType != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any) { } else if (netid != Network::NetID::Any || networkType != icsneo_msg_bus_type_any) {
return false; // Filtering on a NetID or Type, but this message doesn't have one return false; // Filtering on a NetID or Type, but this message doesn't have one
} }
return true; return true;
@ -48,9 +48,9 @@ protected:
return messageType == mtype; return messageType == mtype;
} }
icsneo_msg_bus_type_t networkType = _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any; icsneo_msg_bus_type_t networkType = icsneo_msg_bus_type_any;
bool matchNetworkType(icsneo_msg_bus_type_t mtype) const { bool matchNetworkType(icsneo_msg_bus_type_t mtype) const {
if(networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any && (mtype != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal || includeInternalInAny)) if(networkType == icsneo_msg_bus_type_any && (mtype != icsneo_msg_bus_type_internal || includeInternalInAny))
return true; return true;
return networkType == mtype; return networkType == mtype;
} }

60
include/icsneo/communication/network.h
View File

@ -291,35 +291,35 @@ public:
}; };
static const char* GetTypeString(icsneo_msg_bus_type_t type) { static const char* GetTypeString(icsneo_msg_bus_type_t type) {
switch(type) { switch(type) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: case icsneo_msg_bus_type_can:
return "CAN"; return "CAN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: case icsneo_msg_bus_type_lin:
return "LIN"; return "LIN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray: case icsneo_msg_bus_type_flexray:
return "FlexRay"; return "FlexRay";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most: case icsneo_msg_bus_type_most:
return "MOST"; return "MOST";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other: case icsneo_msg_bus_type_other:
return "Other"; return "Other";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal: case icsneo_msg_bus_type_internal:
return "Internal"; return "Internal";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: case icsneo_msg_bus_type_iso9141:
return "ISO 9141-2"; return "ISO 9141-2";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: case icsneo_msg_bus_type_ethernet:
return "Ethernet"; return "Ethernet";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: case icsneo_msg_bus_type_lsftcan:
return "Low Speed Fault Tolerant CAN"; return "Low Speed Fault Tolerant CAN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: case icsneo_msg_bus_type_swcan:
return "Single Wire CAN"; return "Single Wire CAN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: case icsneo_msg_bus_type_i2c:
return "I²C"; return "I²C";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: case icsneo_msg_bus_type_a2b:
return "A2B"; return "A2B";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi: case icsneo_msg_bus_type_spi:
return "SPI"; return "SPI";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: case icsneo_msg_bus_type_mdio:
return "MDIO"; return "MDIO";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid: case icsneo_msg_bus_type_invalid:
default: default:
return "Invalid Type"; return "Invalid Type";
} }
@ -515,7 +515,7 @@ public:
case NetID::DWCAN14: case NetID::DWCAN14:
case NetID::DWCAN15: case NetID::DWCAN15:
case NetID::DWCAN16: case NetID::DWCAN16:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can; return icsneo_msg_bus_type_can;
case NetID::LIN: case NetID::LIN:
case NetID::LIN2: case NetID::LIN2:
case NetID::LIN3: case NetID::LIN3:
@ -532,18 +532,18 @@ public:
case NetID::LIN14: case NetID::LIN14:
case NetID::LIN15: case NetID::LIN15:
case NetID::LIN16: case NetID::LIN16:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin; return icsneo_msg_bus_type_lin;
case NetID::FlexRay: case NetID::FlexRay:
case NetID::FlexRay1a: case NetID::FlexRay1a:
case NetID::FlexRay1b: case NetID::FlexRay1b:
case NetID::FlexRay2: case NetID::FlexRay2:
case NetID::FlexRay2a: case NetID::FlexRay2a:
case NetID::FlexRay2b: case NetID::FlexRay2b:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray; return icsneo_msg_bus_type_flexray;
case NetID::MOST25: case NetID::MOST25:
case NetID::MOST50: case NetID::MOST50:
case NetID::MOST150: case NetID::MOST150:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most; return icsneo_msg_bus_type_most;
case NetID::RED: case NetID::RED:
case NetID::RED_OLDFORMAT: case NetID::RED_OLDFORMAT:
case NetID::Device: case NetID::Device:
@ -565,10 +565,10 @@ public:
case NetID::RED_GET_RTC: case NetID::RED_GET_RTC:
case NetID::DiskData: case NetID::DiskData:
case NetID::RED_App_Error: case NetID::RED_App_Error:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal; return icsneo_msg_bus_type_internal;
case NetID::Invalid: case NetID::Invalid:
case NetID::Any: case NetID::Any:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid; return icsneo_msg_bus_type_invalid;
case NetID::Ethernet: case NetID::Ethernet:
case NetID::Ethernet_DAQ: case NetID::Ethernet_DAQ:
case NetID::Ethernet2: case NetID::Ethernet2:
@ -589,26 +589,26 @@ public:
case NetID::OP_Ethernet14: case NetID::OP_Ethernet14:
case NetID::OP_Ethernet15: case NetID::OP_Ethernet15:
case NetID::OP_Ethernet16: case NetID::OP_Ethernet16:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet; return icsneo_msg_bus_type_ethernet;
case NetID::LSFTCAN: case NetID::LSFTCAN:
case NetID::LSFTCAN2: case NetID::LSFTCAN2:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan; return icsneo_msg_bus_type_lsftcan;
case NetID::SWCAN: case NetID::SWCAN:
case NetID::SWCAN2: case NetID::SWCAN2:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan; return icsneo_msg_bus_type_swcan;
case NetID::ISO9141: case NetID::ISO9141:
case NetID::ISO9141_2: case NetID::ISO9141_2:
case NetID::ISO9141_3: case NetID::ISO9141_3:
case NetID::ISO9141_4: case NetID::ISO9141_4:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141; return icsneo_msg_bus_type_iso9141;
case NetID::I2C: case NetID::I2C:
case NetID::I2C2: case NetID::I2C2:
case NetID::I2C3: case NetID::I2C3:
case NetID::I2C4: case NetID::I2C4:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c; return icsneo_msg_bus_type_i2c;
case NetID::A2B1: case NetID::A2B1:
case NetID::A2B2: case NetID::A2B2:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; return icsneo_msg_bus_type_a2b;
case NetID::SPI1: case NetID::SPI1:
case NetID::SPI2: case NetID::SPI2:
case NetID::SPI3: case NetID::SPI3:
@ -617,7 +617,7 @@ public:
case NetID::SPI6: case NetID::SPI6:
case NetID::SPI7: case NetID::SPI7:
case NetID::SPI8: case NetID::SPI8:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi; return icsneo_msg_bus_type_spi;
case NetID::MDIO1: case NetID::MDIO1:
case NetID::MDIO2: case NetID::MDIO2:
case NetID::MDIO3: case NetID::MDIO3:
@ -626,9 +626,9 @@ public:
case NetID::MDIO6: case NetID::MDIO6:
case NetID::MDIO7: case NetID::MDIO7:
case NetID::MDIO8: case NetID::MDIO8:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio; return icsneo_msg_bus_type_mdio;
default: default:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other; return icsneo_msg_bus_type_other;
} }
} }
static const char* GetNetIDString(NetID netid, bool expand = true) { static const char* GetNetIDString(NetID netid, bool expand = true) {