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))
{
case Network::Type::CAN:
case Network::Type::SWCAN:
case Network::Type::LSFTCAN:
case icsneo_msg_bus_type_can:
case icsneo_msg_bus_type_swcan:
case icsneo_msg_bus_type_lsftcan:
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.NumberBytesHeader = 4;
copyFrameData();
break;
case Network::Type::Ethernet:
case icsneo_msg_bus_type_ethernet:
oldmsg.Protocol = SPY_PROTOCOL_ETHERNET;
oldmsg.NumberBytesData = static_cast<uint8_t>(frame.length & 0xFF);
oldmsg.NumberBytesHeader = static_cast<uint8_t>(frame.length >> 8);
copyFrameData();
break;
case Network::Type::LIN:
case icsneo_msg_bus_type_lin:
{
const neomessage_lin_t& linFrame = *reinterpret_cast<const neomessage_lin_t*>(&frame);
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) {
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);
if(!result) {
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;
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
case icsneo_msg_bus_type_can:
case icsneo_msg_bus_type_swcan:
case icsneo_msg_bus_type_lsftcan: {
if(packet->data.size() < 24) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false;
@ -105,7 +105,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray: {
case icsneo_msg_bus_type_flexray: {
if(packet->data.size() < 24) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false;
@ -124,7 +124,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
fr.network = packet->network;
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)) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false;
@ -141,7 +141,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
iso.network = packet->network;
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)) {
report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
return false;
@ -155,7 +155,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
case icsneo_msg_bus_type_a2b: {
result = HardwareA2BPacket::DecodeToMessage(packet->data);
if(!result) {
@ -168,7 +168,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
msg.timestamp *= timestampResolution;
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
case icsneo_msg_bus_type_lin: {
result = HardwareLINPacket::DecodeToMessage(packet->data);
if(!result) {
@ -180,7 +180,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
msg.network = packet->network;
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
case icsneo_msg_bus_type_mdio: {
result = HardwareMDIOPacket::DecodeToMessage(packet->data);
if(!result) {
@ -192,7 +192,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
msg.network = packet->network;
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal: {
case icsneo_msg_bus_type_internal: {
switch(packet->network.getNetID()) {
case Network::NetID::Reset_Status: {
// 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());
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);
if(!ethmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -43,10 +43,10 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false;
break;
} // End of Network::Type::Ethernet
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
} // End of icsneo_msg_bus_type_ethernet
case icsneo_msg_bus_type_can:
case icsneo_msg_bus_type_swcan:
case icsneo_msg_bus_type_lsftcan: {
auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
if(!canmsg) {
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
break;
} // End of Network::Type::CAN
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
} // End of icsneo_msg_bus_type_can
case icsneo_msg_bus_type_iso9141: {
auto isomsg = std::dynamic_pointer_cast<ISO9141Message>(message);
if(!isomsg) {
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
// packets to the device. This function just encodes them back to back into `result`
return HardwareISO9141Packet::EncodeFromMessage(*isomsg, result, report, packetizer);
} // End of Network::Type::ISO9141
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
} // End of icsneo_msg_bus_type_iso9141
case icsneo_msg_bus_type_a2b: {
auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message);
if(!a2bmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -86,8 +86,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false;
}
break;
} // End of Network::Type::A2B
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: {
} // End of icsneo_msg_bus_type_a2b
case icsneo_msg_bus_type_i2c: {
auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message);
if(!i2cmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -98,8 +98,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false;
}
break;
} // End of Network::Type::I2C
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
} // End of icsneo_msg_bus_type_i2c
case icsneo_msg_bus_type_lin: {
auto linmsg = std::dynamic_pointer_cast<LINMessage>(message);
if(!linmsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -110,8 +110,8 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false;
}
break;
} // End of Network::Type::LIN
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
} // End of icsneo_msg_bus_type_lin
case icsneo_msg_bus_type_mdio: {
auto mdiomsg = std::dynamic_pointer_cast<MDIOMessage>(message);
if(!mdiomsg) {
report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@ -122,7 +122,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
return false;
}
break;
} // End of Network::Type::MDIO
} // End of icsneo_msg_bus_type_mdio
default:
report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
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;
}
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;
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;
switch(netType) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
case icsneo_msg_bus_type_can:
case icsneo_msg_bus_type_swcan:
case icsneo_msg_bus_type_lsftcan: {
neomessage_can_t& can = *(neomessage_can_t*)&neomsg;
auto canmsg = std::static_pointer_cast<CANMessage>(message);
can.arbid = canmsg->arbid;
@ -44,7 +44,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
can.status.canfdESI = canmsg->errorStateIndicator;
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;
auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
eth.preemptionFlags = ethmsg->preemptionFlags;
@ -55,7 +55,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
//eth.status.xyz = ethmsg->noPadding;
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;
auto linmsg = std::static_pointer_cast<LINMessage>(message);
if(!linmsg) { break; }
@ -123,9 +123,9 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
case Message::Type::Frame: {
const Network network = ((neomessage_frame_t*)neomessage)->netid;
switch(network.getType()) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
case icsneo_msg_bus_type_can:
case icsneo_msg_bus_type_swcan:
case icsneo_msg_bus_type_lsftcan: {
neomessage_can_t& can = *(neomessage_can_t*)neomessage;
auto canmsg = std::make_shared<CANMessage>();
canmsg->network = network;
@ -140,7 +140,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
canmsg->errorStateIndicator = can.status.canfdESI;
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;
auto ethmsg = std::make_shared<EthernetMessage>();
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);
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;
auto linmsg = std::make_shared<LINMessage>();
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) {
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
success = false;

32
device/idevicesettings.cpp
View File

@ -403,7 +403,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::CANSettingsNotAvailable, APIEvent::Severity::Error);
@ -417,7 +417,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error);
@ -431,7 +431,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LSFTCANSettingsNotAvailable, APIEvent::Severity::Error);
@ -445,7 +445,7 @@ int64_t IDeviceSettings::getBaudrateFor(Network net) const {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -477,7 +477,7 @@ bool IDeviceSettings::setBaudrateFor(Network net, int64_t baudrate) {
}
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.
report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
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
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
case icsneo_msg_bus_type_lsftcan: {
CAN_SETTINGS* cfg = getMutableLSFTCANSettingsFor(net);
if(cfg == nullptr) {
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
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan: {
case icsneo_msg_bus_type_swcan: {
SWCAN_SETTINGS* cfg = getMutableSWCANSettingsFor(net);
if(cfg == nullptr) {
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
return true;
}
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
case icsneo_msg_bus_type_lin: {
LIN_SETTINGS* cfg = getMutableLINSettingsFor(net);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -566,7 +566,7 @@ int64_t IDeviceSettings::getFDBaudrateFor(Network net) const {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
@ -604,7 +604,7 @@ bool IDeviceSettings::setFDBaudrateFor(Network net, int64_t baudrate) {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::Error);
@ -771,7 +771,7 @@ std::optional<bool> IDeviceSettings::isCommanderResistorEnabledFor(Network net)
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -803,7 +803,7 @@ bool IDeviceSettings::setCommanderResistorFor(Network net, bool resistor_on) {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -831,7 +831,7 @@ std::optional<LINMode> IDeviceSettings::getLINModeFor(Network net) const {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -863,7 +863,7 @@ bool IDeviceSettings::setLINModeFor(Network net, LINMode mode) {
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -891,7 +891,7 @@ std::optional<uint8_t> IDeviceSettings::getLINCommanderResponseTimeFor(Network n
}
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);
if(cfg == nullptr) {
report(APIEvent::Type::LINSettingsNotAvailable, APIEvent::Severity::Error);
@ -923,7 +923,7 @@ bool IDeviceSettings::setLINCommanderResponseTimeFor(Network net, uint8_t bits)
}
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);
if(cfg == nullptr) {
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;
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 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;
for(auto& msg : messages) {
switch(msg->network.getType()) {
case icsneo::Network::Type::CAN:
case icsneo::Network::Type::SWCAN:
case icsneo::Network::Type::LSFTCAN: {
case icsneo::icsneo_msg_bus_type_can:
case icsneo::icsneo_msg_bus_type_swcan:
case icsneo::icsneo_msg_bus_type_lsftcan: {
// 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);
// 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& 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;
}
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;
}

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
auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
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
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";
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);
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;
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
// 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

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) {
if(icsneo::Message::Type::Frame == message->type) {
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);
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: ";

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

@ -94,7 +94,7 @@ int main()
{
if(icsneo::Message::Type::Frame == message->type) {
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);
std::cout << msg->network << " " << ((msg->isTXMsg)? "TX" : "RX") << " frame\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
auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
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
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";
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);
std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec
@ -220,7 +220,7 @@ int main() {
std::cout << std::dec << std::endl;
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
// 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

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

@ -170,9 +170,9 @@ int main(int argc, char* argv[]) {
return;
}
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;
} 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;
}
}));

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

@ -13,8 +13,8 @@ namespace icsneo {
class CANMessageFilter : public MessageFilter {
public:
CANMessageFilter() : MessageFilter(_icsneo_msg_bus_type_t::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() : MessageFilter(icsneo_msg_bus_type_can), arbid(INVALID_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 {
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(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) {
// 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
includeInternalInAny = (networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal);
includeInternalInAny = (networkType == icsneo_msg_bus_type_internal);
}
virtual ~MessageFilter() = default;
// When getting "all" types of messages, include the ones marked as "internal only"
@ -34,7 +34,7 @@ public:
return false;
if(!matchNetID(frame->network.getNetID()))
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 true;
@ -48,9 +48,9 @@ protected:
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 {
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 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) {
switch(type) {
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
case icsneo_msg_bus_type_can:
return "CAN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin:
case icsneo_msg_bus_type_lin:
return "LIN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray:
case icsneo_msg_bus_type_flexray:
return "FlexRay";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_most:
case icsneo_msg_bus_type_most:
return "MOST";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_other:
case icsneo_msg_bus_type_other:
return "Other";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal:
case icsneo_msg_bus_type_internal:
return "Internal";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141:
case icsneo_msg_bus_type_iso9141:
return "ISO 9141-2";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet:
case icsneo_msg_bus_type_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";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
case icsneo_msg_bus_type_swcan:
return "Single Wire CAN";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c:
case icsneo_msg_bus_type_i2c:
return "I²C";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b:
case icsneo_msg_bus_type_a2b:
return "A2B";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_spi:
case icsneo_msg_bus_type_spi:
return "SPI";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio:
case icsneo_msg_bus_type_mdio:
return "MDIO";
case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid:
case icsneo_msg_bus_type_invalid:
default:
return "Invalid Type";
}
@ -515,7 +515,7 @@ public:
case NetID::DWCAN14:
case NetID::DWCAN15:
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::LIN2:
case NetID::LIN3:
@ -532,18 +532,18 @@ public:
case NetID::LIN14:
case NetID::LIN15:
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::FlexRay1a:
case NetID::FlexRay1b:
case NetID::FlexRay2:
case NetID::FlexRay2a:
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::MOST50:
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_OLDFORMAT:
case NetID::Device:
@ -565,10 +565,10 @@ public:
case NetID::RED_GET_RTC:
case NetID::DiskData:
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::Any:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_invalid;
return icsneo_msg_bus_type_invalid;
case NetID::Ethernet:
case NetID::Ethernet_DAQ:
case NetID::Ethernet2:
@ -589,26 +589,26 @@ public:
case NetID::OP_Ethernet14:
case NetID::OP_Ethernet15:
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::LSFTCAN2:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan;
return icsneo_msg_bus_type_lsftcan;
case NetID::SWCAN:
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_2:
case NetID::ISO9141_3:
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::I2C2:
case NetID::I2C3:
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::A2B2:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b;
return icsneo_msg_bus_type_a2b;
case NetID::SPI1:
case NetID::SPI2:
case NetID::SPI3:
@ -617,7 +617,7 @@ public:
case NetID::SPI6:
case NetID::SPI7:
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::MDIO2:
case NetID::MDIO3:
@ -626,9 +626,9 @@ public:
case NetID::MDIO6:
case NetID::MDIO7:
case NetID::MDIO8:
return _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio;
return icsneo_msg_bus_type_mdio;
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) {