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

moved and renamed network type to icsneo_msg_bus_type_t

David Rebbe 2024-12-03 23:56:17 -05:00
parent 63fd8c2f3a
commit e3ff239da7
24 changed files with 179 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
api/icsneoc/icsneoc.cpp
View File

@ -274,10 +274,10 @@ bool icsneo_removeMessageCallback(const neodevice_t* device, int id) {
return device->device->removeMessageCallback(id); return device->device->removeMessageCallback(id);
} }
neonetid_t icsneo_getNetworkByNumber(const neodevice_t* device, neonettype_t type, unsigned int number) { neonetid_t icsneo_getNetworkByNumber(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number) {
if(!icsneo_isValidNeoDevice(device)) if(!icsneo_isValidNeoDevice(device))
return false; return false;
return neonetid_t(device->device->getNetworkByNumber(icsneo::Network::Type(type), size_t(number)).getNetID()); return neonetid_t(device->device->getNetworkByNumber(icsneo::icsneo_msg_bus_type_t(type), size_t(number)).getNetID());
} }
bool icsneo_getProductName(const neodevice_t* device, char* str, size_t* maxLength) { bool icsneo_getProductName(const neodevice_t* device, char* str, size_t* maxLength) {

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 Network::Type::Ethernet: { case _icsneo_msg_bus_type_t::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 Network::Type::CAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case Network::Type::SWCAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case Network::Type::LSFTCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::FlexRay: { case _icsneo_msg_bus_type_t::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 Network::Type::ISO9141: { case _icsneo_msg_bus_type_t::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 Network::Type::I2C: { case _icsneo_msg_bus_type_t::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 Network::Type::A2B: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::MDIO: { case _icsneo_msg_bus_type_t::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 Network::Type::Internal: { case _icsneo_msg_bus_type_t::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)

18
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 Network::Type::Ethernet: { case _icsneo_msg_bus_type_t::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);
@ -44,9 +44,9 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
break; break;
} // End of Network::Type::Ethernet } // End of Network::Type::Ethernet
case Network::Type::CAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case Network::Type::SWCAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case Network::Type::LSFTCAN: { case _icsneo_msg_bus_type_t::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);
@ -64,7 +64,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
break; break;
} // End of Network::Type::CAN } // End of Network::Type::CAN
case Network::Type::ISO9141: { case _icsneo_msg_bus_type_t::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);
@ -75,7 +75,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
// 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 Network::Type::ISO9141
case Network::Type::A2B: { case _icsneo_msg_bus_type_t::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);
@ -87,7 +87,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
} }
break; break;
} // End of Network::Type::A2B } // End of Network::Type::A2B
case Network::Type::I2C: { case _icsneo_msg_bus_type_t::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);
@ -99,7 +99,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
} }
break; break;
} // End of Network::Type::I2C } // End of Network::Type::I2C
case Network::Type::LIN: { case _icsneo_msg_bus_type_t::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);
@ -111,7 +111,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
} }
break; break;
} // End of Network::Type::LIN } // End of Network::Type::LIN
case Network::Type::MDIO: { case _icsneo_msg_bus_type_t::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);

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() != Network::Type::A2B) if(frameMsg->network.getType() != _icsneo_msg_bus_type_t::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);

24
communication/message/neomessage.cpp
View File

@ -20,7 +20,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
const auto netType = framemsg->network.getType(); const auto netType = framemsg->network.getType();
frame.netid = (neonetid_t)framemsg->network.getNetID(); frame.netid = (neonetid_t)framemsg->network.getNetID();
frame.type = (neonettype_t)netType; frame.type = (icsneo_msg_bus_type_t)netType;
frame.description = framemsg->description; frame.description = framemsg->description;
frame.length = framemsg->data.size(); frame.length = framemsg->data.size();
frame.data = framemsg->data.data(); frame.data = framemsg->data.data();
@ -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 Network::Type::CAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case Network::Type::SWCAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case Network::Type::LSFTCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::Ethernet: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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; }
@ -109,7 +109,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
canerror.receiveErrorCount = canerrormsg->receiveErrorCount; canerror.receiveErrorCount = canerrormsg->receiveErrorCount;
canerror.status.canBusOff = canerrormsg->busOff; canerror.status.canBusOff = canerrormsg->busOff;
canerror.netid = (neonetid_t)canerrormsg->network.getNetID(); canerror.netid = (neonetid_t)canerrormsg->network.getNetID();
canerror.type = (neonettype_t)canerrormsg->network.getType(); canerror.type = (icsneo_msg_bus_type_t)canerrormsg->network.getType();
break; break;
} }
default: default:
@ -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 Network::Type::CAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case Network::Type::SWCAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case Network::Type::LSFTCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::Ethernet: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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;

4
device/device.cpp
View File

@ -780,7 +780,7 @@ void Device::setWriteBlocks(bool blocks) {
com->setWriteBlocks(blocks); com->setWriteBlocks(blocks);
} }
size_t Device::getNetworkCountByType(Network::Type type) const { size_t Device::getNetworkCountByType(icsneo_msg_bus_type_t type) const {
size_t count = 0; size_t count = 0;
for(const auto& net : getSupportedRXNetworks()) for(const auto& net : getSupportedRXNetworks())
if(net.getType() == type) if(net.getType() == type)
@ -789,7 +789,7 @@ size_t Device::getNetworkCountByType(Network::Type type) const {
} }
// Indexed starting at one // Indexed starting at one
Network Device::getNetworkByNumber(Network::Type type, size_t index) const { Network Device::getNetworkByNumber(icsneo_msg_bus_type_t type, size_t index) const {
size_t count = 0; size_t count = 0;
for(const auto& net : getSupportedRXNetworks()) { for(const auto& net : getSupportedRXNetworks()) {
if(net.getType() == type) { if(net.getType() == type) {

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<Frame>& frame, bool& success) { bool FlexRay::Extension::transmitHook(const std::shared_ptr<Frame>& frame, bool& success) {
if(!frame || frame->network.getType() != Network::Type::FlexRay) if(!frame || frame->network.getType() != _icsneo_msg_bus_type_t::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 Network::Type::CAN: { case _icsneo_msg_bus_type_t::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 Network::Type::SWCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::LSFTCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::CAN: { case _icsneo_msg_bus_type_t::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 Network::Type::LSFTCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::SWCAN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::CAN: { case _icsneo_msg_bus_type_t::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 Network::Type::CAN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::LIN: { case _icsneo_msg_bus_type_t::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 Network::Type::Ethernet: case _icsneo_msg_bus_type_t::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);

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::Network::Type::A2B; })) { 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; })) {
return false; return false;
} }
if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo::Network::Type::A2B; })) { 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; })) {
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::Frame>(message); auto frame = std::static_pointer_cast<icsneo::Frame>(message);
switch(frame->network.getType()) { switch(frame->network.getType()) {
case icsneo::Network::Type::CAN: { case _icsneo_msg_bus_type_t::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::Network::Type::Ethernet: { case _icsneo_msg_bus_type_t::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::Network::Type::ISO9141: { case _icsneo_msg_bus_type_t::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::Frame>(message); auto frame = std::static_pointer_cast<icsneo::Frame>(message);
if(icsneo::Network::Type::LIN == frame->network.getType()) { if(_icsneo_msg_bus_type_t::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::Frame>(message); auto frame = std::static_pointer_cast<icsneo::Frame>(message);
if(icsneo::Network::Type::MDIO == frame->network.getType()) { if(_icsneo_msg_bus_type_t::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::Frame>(message); auto frame = std::static_pointer_cast<icsneo::Frame>(message);
switch(frame->network.getType()) { switch(frame->network.getType()) {
case icsneo::Network::Type::CAN: { case _icsneo_msg_bus_type_t::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::Network::Type::Ethernet: { case _icsneo_msg_bus_type_t::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::Network::Type::ISO9141: { case _icsneo_msg_bus_type_t::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::Frame>(msg); const auto frame = std::static_pointer_cast<icsneo::Frame>(msg);
if(frame->network.getType() == icsneo::Network::Type::CAN) { if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can) {
++canFrameCount; ++canFrameCount;
} else if(frame->network.getType() == icsneo::Network::Type::Ethernet) { } else if(frame->network.getType() == _icsneo_msg_bus_type_t::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(Network::Type::CAN), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; } CANMessageFilter() : MessageFilter(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_can), arbid(INVALID_ARBID) { messageType = Message::Type::Frame; }
CANMessageFilter(uint32_t arbid) : MessageFilter(Network::Type::CAN), arbid(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; }
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))

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

@ -14,10 +14,10 @@ public:
MessageFilter() {} MessageFilter() {}
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(Network::Type 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 Network::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 == Network::Type::Internal); includeInternalInAny = (networkType == _icsneo_msg_bus_type_t::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 != Network::Type::Any) { } else if (netid != Network::NetID::Any || networkType != _icsneo_msg_bus_type_t::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;
} }
Network::Type networkType = Network::Type::Any; icsneo_msg_bus_type_t networkType = _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any;
bool matchNetworkType(Network::Type mtype) const { bool matchNetworkType(icsneo_msg_bus_type_t mtype) const {
if(networkType == Network::Type::Any && (mtype != Network::Type::Internal || includeInternalInAny)) if(networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any && (mtype != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal || includeInternalInAny))
return true; return true;
return networkType == mtype; return networkType == mtype;
} }

16
include/icsneo/communication/message/message.h
View File

@ -7,12 +7,20 @@ typedef uint16_t neomessagetype_t;
#ifdef __cplusplus #ifdef __cplusplus
#include "icsneo/communication/network.h" #include "icsneo/communication/network.h"
#include "icsneo/icsneotypes.h"
#include <vector> #include <vector>
namespace icsneo { namespace icsneo {
class Message { class AbstractMessage {
public: public:
virtual const icsneo_msg_type_t getMsgType() const = 0;
};
class Message : public AbstractMessage {
public:
virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_device; }
enum class Type : neomessagetype_t { enum class Type : neomessagetype_t {
Frame = 0, Frame = 0,
@ -56,6 +64,8 @@ public:
RawMessage(Network net) : Message(Message::Type::RawMessage), network(net) {} RawMessage(Network net) : Message(Message::Type::RawMessage), network(net) {}
RawMessage(Network net, std::vector<uint8_t> d) : Message(Message::Type::RawMessage), network(net), data(d) {} RawMessage(Network net, std::vector<uint8_t> d) : Message(Message::Type::RawMessage), network(net), data(d) {}
virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_internal; }
Network network; Network network;
std::vector<uint8_t> data; std::vector<uint8_t> data;
}; };
@ -64,6 +74,10 @@ class Frame : public RawMessage {
public: public:
Frame() : RawMessage(Message::Type::Frame) {} Frame() : RawMessage(Message::Type::Frame) {}
const icsneo_msg_type_t getMsgType() const final { return icsneo_msg_type_bus; }
//virtual const icsneo_msg_bus_type_t getBusType() const = 0;
uint16_t description = 0; uint16_t description = 0;
bool transmitted = false; bool transmitted = false;
bool error = false; bool error = false;

12
include/icsneo/communication/message/neomessage.h
View File

@ -115,7 +115,7 @@ typedef struct {
uint8_t _reserved1[16]; uint8_t _reserved1[16];
uint64_t timestamp; uint64_t timestamp;
uint64_t _reservedTimestamp; uint64_t _reservedTimestamp;
uint8_t _reserved2[sizeof(size_t) * 2 + 7 + sizeof(neonetid_t) + sizeof(neonettype_t)]; uint8_t _reserved2[sizeof(size_t) * 2 + 7 + sizeof(neonetid_t) + sizeof(icsneo_msg_bus_type_t)];
neomessagetype_t messageType; neomessagetype_t messageType;
uint8_t _reserved3[12]; uint8_t _reserved3[12];
} neomessage_t; // 72 bytes total } neomessage_t; // 72 bytes total
@ -129,7 +129,7 @@ typedef struct {
size_t length; size_t length;
uint8_t header[4]; uint8_t header[4];
neonetid_t netid; neonetid_t netid;
neonettype_t type; icsneo_msg_bus_type_t type;
uint8_t _reserved0; uint8_t _reserved0;
uint16_t description; uint16_t description;
neomessagetype_t messageType; neomessagetype_t messageType;
@ -144,7 +144,7 @@ typedef struct {
size_t length; size_t length;
uint32_t arbid; uint32_t arbid;
neonetid_t netid; neonetid_t netid;
neonettype_t type; icsneo_msg_bus_type_t type;
uint8_t dlcOnWire; uint8_t dlcOnWire;
uint16_t description; uint16_t description;
neomessagetype_t messageType; neomessagetype_t messageType;
@ -160,7 +160,7 @@ typedef struct {
uint8_t receiveErrorCount; uint8_t receiveErrorCount;
uint8_t _reserved3[5]; uint8_t _reserved3[5];
neonetid_t netid; neonetid_t netid;
neonettype_t type; icsneo_msg_bus_type_t type;
neomessagetype_t messageType; neomessagetype_t messageType;
uint8_t _reserved4[12]; uint8_t _reserved4[12];
} neomessage_can_error_t; } neomessage_can_error_t;
@ -174,7 +174,7 @@ typedef struct {
uint8_t preemptionFlags; uint8_t preemptionFlags;
uint8_t _reservedHeader[3]; uint8_t _reservedHeader[3];
neonetid_t netid; neonetid_t netid;
neonettype_t type; icsneo_msg_bus_type_t type;
uint8_t _reserved0; uint8_t _reserved0;
uint16_t description; uint16_t description;
neomessagetype_t messageType; neomessagetype_t messageType;
@ -200,7 +200,7 @@ typedef struct {
size_t length; size_t length;
uint8_t header[4]; uint8_t header[4];
neonetid_t netid; neonetid_t netid;
neonettype_t type; icsneo_msg_bus_type_t type;
neomessage_linstatus_t linStatus; neomessage_linstatus_t linStatus;
uint16_t description; uint16_t description;
neomessagetype_t messageType; neomessagetype_t messageType;

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

@ -2,9 +2,9 @@
#define __NETWORKID_H_ #define __NETWORKID_H_
#include <stdint.h> #include <stdint.h>
#include <icsneo/icsneotypes.h>
typedef uint16_t neonetid_t; typedef uint16_t neonetid_t;
typedef uint8_t neonettype_t;
#ifdef __cplusplus #ifdef __cplusplus
@ -187,24 +187,6 @@ public:
Any = 0xfffe, // Never actually set as type, but used as flag for filtering Any = 0xfffe, // Never actually set as type, but used as flag for filtering
Invalid = 0xffff Invalid = 0xffff
}; };
enum class Type : neonettype_t {
Invalid = 0,
Internal = 1, // Used for statuses that don't actually need to be transferred to the client application
CAN = 2,
LIN = 3,
FlexRay = 4,
MOST = 5,
Ethernet = 6,
LSFTCAN = 7,
SWCAN = 8,
ISO9141 = 9,
I2C = 10,
A2B = 11,
SPI = 12,
MDIO = 13,
Any = 0xFE, // Never actually set as type, but used as flag for filtering
Other = 0xFF
};
enum class CoreMini : uint8_t { enum class CoreMini : uint8_t {
HSCAN = 0, HSCAN = 0,
MSCAN = 1, MSCAN = 1,
@ -307,37 +289,37 @@ public:
LIN15 = 99, LIN15 = 99,
LIN16 = 100, LIN16 = 100,
}; };
static const char* GetTypeString(Type type) { static const char* GetTypeString(icsneo_msg_bus_type_t type) {
switch(type) { switch(type) {
case Type::CAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
return "CAN"; return "CAN";
case Type::LIN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin:
return "LIN"; return "LIN";
case Type::FlexRay: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray:
return "FlexRay"; return "FlexRay";
case Type::MOST: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most:
return "MOST"; return "MOST";
case Type::Other: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other:
return "Other"; return "Other";
case Type::Internal: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal:
return "Internal"; return "Internal";
case Type::ISO9141: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141:
return "ISO 9141-2"; return "ISO 9141-2";
case Type::Ethernet: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet:
return "Ethernet"; return "Ethernet";
case Type::LSFTCAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan:
return "Low Speed Fault Tolerant CAN"; return "Low Speed Fault Tolerant CAN";
case Type::SWCAN: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
return "Single Wire CAN"; return "Single Wire CAN";
case Type::I2C: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c:
return "I²C"; return "I²C";
case Type::A2B: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b:
return "A2B"; return "A2B";
case Type::SPI: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi:
return "SPI"; return "SPI";
case Type::MDIO: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio:
return "MDIO"; return "MDIO";
case Type::Invalid: case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid:
default: default:
return "Invalid Type"; return "Invalid Type";
} }
@ -511,7 +493,7 @@ public:
} }
return "Invalid VNET ID"; return "Invalid VNET ID";
} }
static Type GetTypeOfNetID(NetID netid, bool expand = true) { static icsneo_msg_bus_type_t GetTypeOfNetID(NetID netid, bool expand = true) {
if(expand) { if(expand) {
netid = GetVnetAgnosticNetid((neonetid_t)netid).second; netid = GetVnetAgnosticNetid((neonetid_t)netid).second;
} }
@ -533,7 +515,7 @@ public:
case NetID::DWCAN14: case NetID::DWCAN14:
case NetID::DWCAN15: case NetID::DWCAN15:
case NetID::DWCAN16: case NetID::DWCAN16:
return Type::CAN; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can;
case NetID::LIN: case NetID::LIN:
case NetID::LIN2: case NetID::LIN2:
case NetID::LIN3: case NetID::LIN3:
@ -550,18 +532,18 @@ public:
case NetID::LIN14: case NetID::LIN14:
case NetID::LIN15: case NetID::LIN15:
case NetID::LIN16: case NetID::LIN16:
return Type::LIN; return _icsneo_msg_bus_type_t::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 Type::FlexRay; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray;
case NetID::MOST25: case NetID::MOST25:
case NetID::MOST50: case NetID::MOST50:
case NetID::MOST150: case NetID::MOST150:
return Type::MOST; return _icsneo_msg_bus_type_t::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:
@ -583,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 Type::Internal; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal;
case NetID::Invalid: case NetID::Invalid:
case NetID::Any: case NetID::Any:
return Type::Invalid; return _icsneo_msg_bus_type_t::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:
@ -607,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 Type::Ethernet; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet;
case NetID::LSFTCAN: case NetID::LSFTCAN:
case NetID::LSFTCAN2: case NetID::LSFTCAN2:
return Type::LSFTCAN; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan;
case NetID::SWCAN: case NetID::SWCAN:
case NetID::SWCAN2: case NetID::SWCAN2:
return Type::SWCAN; return _icsneo_msg_bus_type_t::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 Type::ISO9141; return _icsneo_msg_bus_type_t::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 Type::I2C; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c;
case NetID::A2B1: case NetID::A2B1:
case NetID::A2B2: case NetID::A2B2:
return Type::A2B; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b;
case NetID::SPI1: case NetID::SPI1:
case NetID::SPI2: case NetID::SPI2:
case NetID::SPI3: case NetID::SPI3:
@ -635,7 +617,7 @@ public:
case NetID::SPI6: case NetID::SPI6:
case NetID::SPI7: case NetID::SPI7:
case NetID::SPI8: case NetID::SPI8:
return Type::SPI; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi;
case NetID::MDIO1: case NetID::MDIO1:
case NetID::MDIO2: case NetID::MDIO2:
case NetID::MDIO3: case NetID::MDIO3:
@ -644,9 +626,9 @@ public:
case NetID::MDIO6: case NetID::MDIO6:
case NetID::MDIO7: case NetID::MDIO7:
case NetID::MDIO8: case NetID::MDIO8:
return Type::MDIO; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio;
default: default:
return Type::Other; return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other;
} }
} }
static const char* GetNetIDString(NetID netid, bool expand = true) { static const char* GetNetIDString(NetID netid, bool expand = true) {
@ -1386,7 +1368,7 @@ public:
Network(NetID netid) { setValue(netid); } Network(NetID netid) { setValue(netid); }
Network(CoreMini cm) { setValue(GetNetIDFromCoreMiniNetwork(cm)); } Network(CoreMini cm) { setValue(GetNetIDFromCoreMiniNetwork(cm)); }
NetID getNetID() const { return value; } NetID getNetID() const { return value; }
Type getType() const { return type; } icsneo_msg_bus_type_t getType() const { return type; }
VnetId getVnetId() const { return vnetId; } VnetId getVnetId() const { return vnetId; }
std::optional<CoreMini> getCoreMini() const { return GetCoreMiniNetworkFromNetID(getNetID()); } std::optional<CoreMini> getCoreMini() const { return GetCoreMiniNetworkFromNetID(getNetID()); }
friend std::ostream& operator<<(std::ostream& os, const Network& network) { friend std::ostream& operator<<(std::ostream& os, const Network& network) {
@ -1398,7 +1380,7 @@ public:
private: private:
NetID value; // Always use setValue so that value and type stay in sync NetID value; // Always use setValue so that value and type stay in sync
Type type; icsneo_msg_bus_type_t type;
NetID commonNetId; NetID commonNetId;
VnetId vnetId; VnetId vnetId;
void setValue(NetID id, bool expand = true) { void setValue(NetID id, bool expand = true) {

4
include/icsneo/device/device.h
View File

@ -226,8 +226,8 @@ public:
return std::find(supportedTXNetworks.begin(), supportedTXNetworks.end(), net) != supportedTXNetworks.end(); return std::find(supportedTXNetworks.begin(), supportedTXNetworks.end(), net) != supportedTXNetworks.end();
} }
virtual size_t getNetworkCountByType(Network::Type) const; virtual size_t getNetworkCountByType(icsneo_msg_bus_type_t) const;
virtual Network getNetworkByNumber(Network::Type, size_t) const; virtual Network getNetworkByNumber(icsneo_msg_bus_type_t, size_t) const;
std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100)); std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));

4
include/icsneo/icsneoc.h
View File

@ -313,7 +313,7 @@ extern bool DLLExport icsneo_removeMessageCallback(const neodevice_t* device, in
* device. For instance, on a ValueCAN 4-2, the second CAN network is ICSNEO_NETID_HSCAN2, while * device. For instance, on a ValueCAN 4-2, the second CAN network is ICSNEO_NETID_HSCAN2, while
* on a neoVI FIRE the second CAN network is ICSNEO_NETID_MSCAN. * on a neoVI FIRE the second CAN network is ICSNEO_NETID_MSCAN.
*/ */
extern neonetid_t DLLExport icsneo_getNetworkByNumber(const neodevice_t* device, neonettype_t type, unsigned int number); extern neonetid_t DLLExport icsneo_getNetworkByNumber(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number);
/** /**
* \brief Get the friendly product name for a specified device. * \brief Get the friendly product name for a specified device.
@ -908,7 +908,7 @@ fn_icsneo_addMessageCallback icsneo_addMessageCallback;
typedef bool(*fn_icsneo_removeMessageCallback)(const neodevice_t* device, int id); typedef bool(*fn_icsneo_removeMessageCallback)(const neodevice_t* device, int id);
fn_icsneo_removeMessageCallback icsneo_removeMessageCallback; fn_icsneo_removeMessageCallback icsneo_removeMessageCallback;
typedef neonetid_t (*fn_icsneo_getNetworkByNumber)(const neodevice_t* device, neonettype_t type, unsigned int number); typedef neonetid_t (*fn_icsneo_getNetworkByNumber)(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number);
fn_icsneo_getNetworkByNumber icsneo_getNetworkByNumber; fn_icsneo_getNetworkByNumber icsneo_getNetworkByNumber;
typedef bool(*fn_icsneo_getProductName)(const neodevice_t* device, char* str, size_t* maxLength); typedef bool(*fn_icsneo_getProductName)(const neodevice_t* device, char* str, size_t* maxLength);

1
include/icsneo/icsneocpp.h
View File

@ -6,6 +6,7 @@
#include <vector> #include <vector>
#include <memory> #include <memory>
#include "icsneo/icsneotypes.h"
#include "icsneo/device/device.h" #include "icsneo/device/device.h"
#include "icsneo/api/version.h" #include "icsneo/api/version.h"
#include "icsneo/api/eventmanager.h" #include "icsneo/api/eventmanager.h"

43
include/icsneo/icsneotypes.h
View File

@ -165,6 +165,49 @@ _Static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t), "ics
static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t)); static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t));
#endif #endif
typedef enum _icsneo_msg_type_t {
icsneo_msg_type_device,
icsneo_msg_type_internal,
icsneo_msg_type_bus,
icsneo_msg_type_maxsize,
} _icsneo_msg_type_t;
/** @brief Integer representation of _icsneo_msg_type_t enum.
*
* This is used for easier ABI compatibility, especially between other languages.
*/
typedef uint32_t icsneo_msg_type_t;
/** @brief
* Bus message types, useful for filtering out or identifying Bus Messages.
*/
typedef enum _icsneo_msg_bus_type_t {
icsneo_msg_bus_type_invalid = 0,
icsneo_msg_bus_type_internal = 1, // Used for statuses that don't actually need to be transferred to the client application
icsneo_msg_bus_type_can = 2,
icsneo_msg_bus_type_lin = 3,
icsneo_msg_bus_type_flexray = 4,
icsneo_msg_bus_type_most = 5,
icsneo_msg_bus_type_ethernet = 6,
icsneo_msg_bus_type_lsftcan = 7,
icsneo_msg_bus_type_swcan = 8,
icsneo_msg_bus_type_iso9141 = 9,
icsneo_msg_bus_type_i2c = 10,
icsneo_msg_bus_type_a2b = 11,
icsneo_msg_bus_type_spi = 12,
icsneo_msg_bus_type_mdio = 13,
icsneo_msg_bus_type_any = 0xFE, // Never actually set as type, but used as flag for filtering
icsneo_msg_bus_type_other = 0xFF
} _icsneo_msg_bus_type_t;
/** @brief Integer representation of _icsneo_msg_bus_type_t enum.
*
* This is used for easier ABI compatibility, especially between other languages.
*/
typedef uint8_t icsneo_msg_bus_type_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif