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

Compare commits

base: sven:875bf454214aeb6dcde5f61272979d9cd9273c39
Branches Tags
sven:master
sven:liveDataSetValue
sven:icsneo_api
sven:ks-refactor-docs
sven:136-add-android-support
sven:add-device-sharing
sven:v0.3.0-dev
sven:checksum-failure-logging
sven:pcap
sven:1.2.2
sven:1.2.1
sven:1.2.0
sven:1.1.0
sven:1.0.0
sven:v0.2.0
sven:v0.1.2
...
compare: sven:7e4c0cdc43d6b3a4bae5fc5e54118b33db7cf1ca
Branches Tags
sven:master
sven:liveDataSetValue
sven:icsneo_api
sven:ks-refactor-docs
sven:136-add-android-support
sven:add-device-sharing
sven:v0.3.0-dev
sven:checksum-failure-logging
sven:pcap
sven:1.2.2
sven:1.2.1
sven:1.2.0
sven:1.1.0
sven:1.0.0
sven:v0.2.0
sven:v0.1.2

11 Commits
875bf45421 ... 7e4c0cdc43

Author SHA1 Message Date
David Rebbe 7e4c0cdc43 commonize the naming of the functions 2024-12-05 16:19:32 -05:00
David Rebbe a2feff5dbd rename icsneo_error_code 2024-12-05 16:11:53 -05:00
David Rebbe 9acd669feb add icsneo_is_online_supported 2024-12-05 16:10:32 -05:00
David Rebbe 82502db319 fixed naming 2024-12-05 15:14:32 -05:00
David Rebbe 36065fab05 python bindings build now. 2024-12-05 14:59:05 -05:00
David Rebbe 721c8b22d3 removed static_assert for now 2024-12-05 14:44:25 -05:00
David Rebbe dafcbac251 icsneopy fixes 2024-12-05 13:59:28 -05:00
David Rebbe 86992b2612 revert c++20 feature 2024-12-05 13:59:10 -05:00
David Rebbe 4308958f66 more renaming 2024-12-05 13:07:42 -05:00
David Rebbe d3c7a92f57 fixed some naming issues. 2024-12-05 12:01:39 -05:00
David Rebbe 3cdf9a341f memory optimizations 2024-12-05 11:42:55 -05:00
33 changed files with 312 additions and 305 deletions
Show Stats Expand all files Collapse all files

69
api/icsneo/icsneo.cpp
View File

@ -33,7 +33,7 @@ typedef struct icsneo_event_t {
static std::vector<std::shared_ptr<icsneo_device_t>> g_devices; static std::vector<std::shared_ptr<icsneo_device_t>> g_devices;
static std::vector<icsneo_event_t> g_events; static std::vector<icsneo_event_t> g_events;
ICSNEO_API icsneo_error_t icsneo_error_code(icsneo_error_t error_code, const char* value, uint32_t* value_length) { ICSNEO_API icsneo_error_t icsneo_get_error_code(icsneo_error_t error_code, const char* value, uint32_t* value_length) {
if (!value || !value_length) { if (!value || !value_length) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -90,7 +90,7 @@ ICSNEO_API icsneo_error_t icsneo_device_type_from_type(icsneo_devicetype_t devic
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_find(icsneo_device_t** devices, uint32_t* devices_count, void* reserved) { ICSNEO_API icsneo_error_t icsneo_device_find_all(icsneo_device_t** devices, uint32_t* devices_count, void* reserved) {
if (!devices || !devices_count) { if (!devices || !devices_count) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -136,7 +136,7 @@ ICSNEO_API icsneo_error_t icsneo_device_is_valid(icsneo_device_t* device) {
return !device->device ? icsneo_error_invalid_parameters : icsneo_error_success; return !device->device ? icsneo_error_invalid_parameters : icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_get_open_options(icsneo_device_t* device, icsneo_open_options_t* options) { ICSNEO_API icsneo_error_t icsneo_device_get_open_options(icsneo_device_t* device, icsneo_open_options_t* options) {
if (!device || !options) { if (!device || !options) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -145,7 +145,7 @@ ICSNEO_API icsneo_error_t icsneo_get_open_options(icsneo_device_t* device, icsne
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_set_open_options(icsneo_device_t* device, icsneo_open_options_t options) { ICSNEO_API icsneo_error_t icsneo_device_set_open_options(icsneo_device_t* device, icsneo_open_options_t options) {
if (!device) { if (!device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -155,7 +155,7 @@ ICSNEO_API icsneo_error_t icsneo_set_open_options(icsneo_device_t* device, icsne
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_open(icsneo_device_t* device) { ICSNEO_API icsneo_error_t icsneo_device_open(icsneo_device_t* device) {
if (!device || !device->device) { if (!device || !device->device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -188,7 +188,7 @@ ICSNEO_API icsneo_error_t icsneo_open(icsneo_device_t* device) {
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_close(icsneo_device_t* device) { ICSNEO_API icsneo_error_t icsneo_device_close(icsneo_device_t* device) {
if (!device || !device->device) { if (!device || !device->device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -197,12 +197,15 @@ ICSNEO_API icsneo_error_t icsneo_close(icsneo_device_t* device) {
return icsneo_error_success; return icsneo_error_success;
} }
dev->close(); dev->close();
// Clear out old messages // Clear out old messages and events
device->messages.clear(); device->messages.clear();
device->messages.shrink_to_fit();
device->events.clear();
device->events.shrink_to_fit();
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_device_describe(icsneo_device_t* device, const char* value, uint32_t* value_length) { ICSNEO_API icsneo_error_t icsneo_device_get_description(icsneo_device_t* device, const char* value, uint32_t* value_length) {
if (!device || !device->device) { if (!device || !device->device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -216,7 +219,7 @@ ICSNEO_API icsneo_error_t icsneo_device_describe(icsneo_device_t* device, const
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_device_type(icsneo_device_t* device, icsneo_devicetype_t* value) { ICSNEO_API icsneo_error_t icsneo_device_get_type(icsneo_device_t* device, icsneo_devicetype_t* value) {
if (!device || !device->device) { if (!device || !device->device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -226,7 +229,7 @@ ICSNEO_API icsneo_error_t icsneo_device_type(icsneo_device_t* device, icsneo_dev
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_device_serial(icsneo_device_t* device, const char* value, uint32_t* value_length) { ICSNEO_API icsneo_error_t icsneo_device_get_serial(icsneo_device_t* device, const char* value, uint32_t* value_length) {
if (!device || !device->device) { if (!device || !device->device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -241,7 +244,7 @@ ICSNEO_API icsneo_error_t icsneo_device_serial(icsneo_device_t* device, const ch
} }
ICSNEO_API icsneo_error_t icsneo_go_online(icsneo_device_t* device, bool go_online) { ICSNEO_API icsneo_error_t icsneo_device_go_online(icsneo_device_t* device, bool go_online) {
if (!device) { if (!device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -258,7 +261,7 @@ ICSNEO_API icsneo_error_t icsneo_go_online(icsneo_device_t* device, bool go_onli
return icsneo_error_go_online_failed; return icsneo_error_go_online_failed;
} }
ICSNEO_API icsneo_error_t icsneo_is_online(icsneo_device_t* device, bool* is_online) { ICSNEO_API icsneo_error_t icsneo_device_is_online(icsneo_device_t* device, bool* is_online) {
if (!device || !is_online) { if (!device || !is_online) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -268,7 +271,17 @@ ICSNEO_API icsneo_error_t icsneo_is_online(icsneo_device_t* device, bool* is_onl
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_set_message_polling(icsneo_device_t* device, bool enable) { ICSNEO_API icsneo_error_t icsneo_device_is_online_supported(icsneo_device_t* device, bool* is_online_supported) {
if (!device || !is_online_supported) {
return icsneo_error_invalid_parameters;
}
auto dev = device->device;
*is_online_supported = dev->isOnlineSupported();
return icsneo_error_success;
}
ICSNEO_API icsneo_error_t icsneo_device_set_message_polling(icsneo_device_t* device, bool enable) {
if (!device) { if (!device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -285,7 +298,7 @@ ICSNEO_API icsneo_error_t icsneo_set_message_polling(icsneo_device_t* device, bo
return icsneo_error_enable_message_polling_failed; return icsneo_error_enable_message_polling_failed;
} }
ICSNEO_API icsneo_error_t icsneo_get_message_polling(icsneo_device_t* device, bool* is_enabled) { ICSNEO_API icsneo_error_t icsneo_device_get_message_polling(icsneo_device_t* device, bool* is_enabled) {
if (!device || !is_enabled) { if (!device || !is_enabled) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -295,7 +308,7 @@ ICSNEO_API icsneo_error_t icsneo_get_message_polling(icsneo_device_t* device, bo
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_set_message_polling_limit(icsneo_device_t* device, uint32_t limit) { ICSNEO_API icsneo_error_t icsneo_device_set_message_polling_limit(icsneo_device_t* device, uint32_t limit) {
if (!device) { if (!device) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -305,7 +318,7 @@ ICSNEO_API icsneo_error_t icsneo_set_message_polling_limit(icsneo_device_t* devi
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_get_message_polling_limit(icsneo_device_t* device, uint32_t* limit) { ICSNEO_API icsneo_error_t icsneo_device_get_message_polling_limit(icsneo_device_t* device, uint32_t* limit) {
if (!device || !limit) { if (!device || !limit) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -315,7 +328,7 @@ ICSNEO_API icsneo_error_t icsneo_get_message_polling_limit(icsneo_device_t* devi
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_get_message_count(icsneo_device_t* device, uint32_t* count) { ICSNEO_API icsneo_error_t icsneo_device_get_message_count(icsneo_device_t* device, uint32_t* count) {
if (!device || !count) { if (!device || !count) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -325,7 +338,7 @@ ICSNEO_API icsneo_error_t icsneo_get_message_count(icsneo_device_t* device, uint
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_get_timestamp_resolution(icsneo_device_t* device, uint32_t* resolution) { ICSNEO_API icsneo_error_t icsneo_device_get_timestamp_resolution(icsneo_device_t* device, uint32_t* resolution) {
if (!device || !resolution) { if (!device || !resolution) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -335,7 +348,7 @@ ICSNEO_API icsneo_error_t icsneo_get_timestamp_resolution(icsneo_device_t* devic
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_message_t** messages, uint32_t* messages_count, uint32_t timeout_ms) { ICSNEO_API icsneo_error_t icsneo_device_get_messages(icsneo_device_t* device, icsneo_message_t** messages, uint32_t* messages_count, uint32_t timeout_ms) {
if (!device || !messages || !messages_count) { if (!device || !messages || !messages_count) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -369,7 +382,7 @@ ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_me
message_t->message = message; message_t->message = message;
device->messages.push_back(message_t); device->messages.push_back(message_t);
} }
device->messages.shrink_to_fit();
// Copy the messages into the output array // Copy the messages into the output array
for (uint32_t i = 0; i < min_size; i++) { for (uint32_t i = 0; i < min_size; i++) {
messages[i] = device->messages[i].get(); messages[i] = device->messages[i].get();
@ -378,7 +391,7 @@ ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_me
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_is_message_valid(icsneo_device_t* device, icsneo_message_t* message, bool* is_valid) { ICSNEO_API icsneo_error_t icsneo_message_is_valid(icsneo_device_t* device, icsneo_message_t* message, bool* is_valid) {
if (!device || !message || !is_valid) { if (!device || !message || !is_valid) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -441,7 +454,7 @@ ICSNEO_API icsneo_error_t icsneo_message_get_data(icsneo_device_t* device, icsne
} }
ICSNEO_API icsneo_error_t icsneo_can_message_arbid(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value) { ICSNEO_API icsneo_error_t icsneo_can_message_get_arbid(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value) {
if (!device || !message || !value) { if (!device || !message || !value) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -457,7 +470,7 @@ ICSNEO_API icsneo_error_t icsneo_can_message_arbid(icsneo_device_t* device, icsn
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_can_message_dlc_on_wire(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value) { ICSNEO_API icsneo_error_t icsneo_can_message_get_dlc_on_wire(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value) {
if (!device || !message || !value) { if (!device || !message || !value) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -521,7 +534,7 @@ ICSNEO_API icsneo_error_t icsneo_can_message_is_canfd(icsneo_device_t* device, i
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_can_message_baudrate_switch(icsneo_device_t* device, icsneo_message_t* message, bool* value) { ICSNEO_API icsneo_error_t icsneo_can_message_get_baudrate_switch(icsneo_device_t* device, icsneo_message_t* message, bool* value) {
if (!device || !message || !value) { if (!device || !message || !value) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -537,7 +550,7 @@ ICSNEO_API icsneo_error_t icsneo_can_message_baudrate_switch(icsneo_device_t* de
return icsneo_error_success; return icsneo_error_success;
} }
ICSNEO_API icsneo_error_t icsneo_can_message_error_state_indicator(icsneo_device_t* device, icsneo_message_t* message, bool* value) { ICSNEO_API icsneo_error_t icsneo_can_message_get_error_state_indicator(icsneo_device_t* device, icsneo_message_t* message, bool* value) {
if (!device || !message || !value) { if (!device || !message || !value) {
return icsneo_error_invalid_parameters; return icsneo_error_invalid_parameters;
} }
@ -567,10 +580,11 @@ ICSNEO_API icsneo_error_t icsneo_get_events(icsneo_event_t** events, uint32_t* e
// Copy the events into the global event container // Copy the events into the global event container
for (uint32_t i = 0; i < min_size; i++) { for (uint32_t i = 0; i < min_size; i++) {
auto e = icsneo_event_t { auto e = icsneo_event_t {
.event = global_events[i], global_events[i],
}; };
g_events.push_back(e); g_events.push_back(e);
} }
g_events.shrink_to_fit();
// Copy the global events references into the events array // Copy the global events references into the events array
for (uint32_t i = 0; i < min_size; i++) { for (uint32_t i = 0; i < min_size; i++) {
events[i] = &g_events[i]; events[i] = &g_events[i];
@ -599,10 +613,11 @@ ICSNEO_API icsneo_error_t icsneo_device_get_events(icsneo_device_t* device, icsn
auto device_events = icsneo::GetEvents(filter, min_size); auto device_events = icsneo::GetEvents(filter, min_size);
for (uint32_t i = 0; i < min_size; i++) { for (uint32_t i = 0; i < min_size; i++) {
auto e = icsneo_event_t { auto e = icsneo_event_t {
.event = device_events[i], device_events[i],
}; };
device->events.push_back(e); device->events.push_back(e);
} }
device->events.shrink_to_fit();
// Copy the device events references into the events array // Copy the device events references into the events array
for (uint32_t i = 0; i < min_size; i++) { for (uint32_t i = 0; i < min_size; i++) {
events[i] = &device->events[i]; events[i] = &device->events[i];

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);

2
bindings/python/icsneopy/communication/message/canmessage.cpp
View File

@ -7,7 +7,7 @@
namespace icsneo { namespace icsneo {
void init_canmessage(pybind11::module_& m) { void init_canmessage(pybind11::module_& m) {
pybind11::class_<CANMessage, std::shared_ptr<CANMessage>, Frame>(m, "CANMessage") pybind11::class_<CANMessage, std::shared_ptr<CANMessage>, BusMessage>(m, "CANMessage")
.def(pybind11::init()) .def(pybind11::init())
.def_readwrite("arbid", &CANMessage::arbid) .def_readwrite("arbid", &CANMessage::arbid)
.def_readwrite("dlcOnWire", &CANMessage::dlcOnWire) .def_readwrite("dlcOnWire", &CANMessage::dlcOnWire)

2
bindings/python/icsneopy/communication/message/ethernetmessage.cpp
View File

@ -11,7 +11,7 @@ void init_ethernetmessage(pybind11::module_& m) {
.def("to_string", &MACAddress::toString) .def("to_string", &MACAddress::toString)
.def("__repr__", &MACAddress::toString); .def("__repr__", &MACAddress::toString);
pybind11::class_<EthernetMessage, std::shared_ptr<EthernetMessage>, Frame>(m, "EthernetMessage") pybind11::class_<EthernetMessage, std::shared_ptr<EthernetMessage>, BusMessage>(m, "EthernetMessage")
.def(pybind11::init()) .def(pybind11::init())
.def_readwrite("preemptionEnabled", &EthernetMessage::preemptionEnabled) .def_readwrite("preemptionEnabled", &EthernetMessage::preemptionEnabled)
.def_readwrite("preemptionFlags", &EthernetMessage::preemptionFlags) .def_readwrite("preemptionFlags", &EthernetMessage::preemptionFlags)

2
bindings/python/icsneopy/communication/message/mdiomessage.cpp
View File

@ -7,7 +7,7 @@
namespace icsneo { namespace icsneo {
void init_mdiomessage(pybind11::module_& m) { void init_mdiomessage(pybind11::module_& m) {
pybind11::class_<MDIOMessage, std::shared_ptr<MDIOMessage>, Frame> mdioMessage(m, "MDIOMessage"); pybind11::class_<MDIOMessage, std::shared_ptr<MDIOMessage>, BusMessage> mdioMessage(m, "MDIOMessage");
pybind11::enum_<MDIOMessage::Clause>(mdioMessage, "Clause") pybind11::enum_<MDIOMessage::Clause>(mdioMessage, "Clause")
.value("Clause45", MDIOMessage::Clause::Clause45) .value("Clause45", MDIOMessage::Clause::Clause45)
.value("Clause22", MDIOMessage::Clause::Clause22); .value("Clause22", MDIOMessage::Clause::Clause22);

18
bindings/python/icsneopy/communication/message/message.cpp
View File

@ -9,12 +9,12 @@ namespace icsneo {
void init_message(pybind11::module_& m) { void init_message(pybind11::module_& m) {
pybind11::class_<Message, std::shared_ptr<Message>> message(m, "Message"); pybind11::class_<Message, std::shared_ptr<Message>> message(m, "Message");
pybind11::enum_<Message::Type>(message, "Type") pybind11::enum_<Message::Type>(message, "Type")
.value("Frame", Message::Type::Frame) .value("BusMessage", Message::Type::BusMessage)
.value("CANErrorCount", Message::Type::CANErrorCount) .value("CANErrorCount", Message::Type::CANErrorCount)
.value("LINHeaderOnly", Message::Type::LINHeaderOnly) .value("LINHeaderOnly", Message::Type::LINHeaderOnly)
.value("LINBreak", Message::Type::LINBreak) .value("LINBreak", Message::Type::LINBreak)
.value("Invalid", Message::Type::Invalid) .value("Invalid", Message::Type::Invalid)
.value("RawMessage", Message::Type::RawMessage) .value("InternalMessage", Message::Type::InternalMessage)
.value("ReadSettings", Message::Type::ReadSettings) .value("ReadSettings", Message::Type::ReadSettings)
.value("ResetStatus", Message::Type::ResetStatus) .value("ResetStatus", Message::Type::ResetStatus)
.value("DeviceVersion", Message::Type::DeviceVersion) .value("DeviceVersion", Message::Type::DeviceVersion)
@ -37,14 +37,14 @@ void init_message(pybind11::module_& m) {
message.def_readonly("type", &Message::type); message.def_readonly("type", &Message::type);
message.def_readwrite("timestamp", &Message::timestamp); message.def_readwrite("timestamp", &Message::timestamp);
pybind11::class_<RawMessage, std::shared_ptr<RawMessage>, Message>(m, "RawMessage") pybind11::class_<InternalMessage, std::shared_ptr<InternalMessage>, Message>(m, "InternalMessage")
.def_readwrite("network", &RawMessage::network) .def_readwrite("network", &InternalMessage::network)
.def_readwrite("data", &RawMessage::data); .def_readwrite("data", &InternalMessage::data);
pybind11::class_<Frame, std::shared_ptr<Frame>, RawMessage>(m, "Frame") pybind11::class_<BusMessage, std::shared_ptr<BusMessage>, InternalMessage>(m, "BusMessage")
.def_readwrite("description", &Frame::description) .def_readwrite("description", &BusMessage::description)
.def_readwrite("transmitted", &Frame::transmitted) .def_readwrite("transmitted", &BusMessage::transmitted)
.def_readwrite("error", &Frame::error); .def_readwrite("error", &BusMessage::error);
} }
} // namespace icsneo } // namespace icsneo

2
bindings/python/icsneopy/device/device.cpp
View File

@ -26,7 +26,7 @@ void init_device(pybind11::module_& m) {
.def("set_polling_message_limit", &Device::setPollingMessageLimit) .def("set_polling_message_limit", &Device::setPollingMessageLimit)
.def("add_message_callback", &Device::addMessageCallback) .def("add_message_callback", &Device::addMessageCallback)
.def("remove_message_callback", &Device::removeMessageCallback) .def("remove_message_callback", &Device::removeMessageCallback)
.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit)) .def("transmit", pybind11::overload_cast<std::shared_ptr<BusMessage>>(&Device::transmit))
.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference) .def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference) .def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
.def("get_rtc", &Device::getRTC) .def("get_rtc", &Device::getRTC)

118
bindings/python/icsneopy/device/devicetype.cpp
View File

@ -3,72 +3,68 @@
#include <pybind11/functional.h> #include <pybind11/functional.h>
#include <icsneo/device/devicetype.h> #include <icsneo/device/devicetype.h>
#include <icsneo/icsneotypes.h>
namespace icsneo { namespace icsneo {
void init_devicetype(pybind11::module_& m) { void init_devicetype(pybind11::module_& m) {
pybind11::class_<DeviceType> deviceType(m, "DeviceType"); pybind11::class_<DeviceType> deviceType(m, "DeviceType");
pybind11::enum_<icsneo_devicetype_t>(deviceType, "Enum") deviceType.def("get_device_type", &DeviceType::getDeviceType);
.value("Unknown", _icsneo_devicetype_t::Unknown) deviceType.def(
.value("BLUE", _icsneo_devicetype_t::BLUE) "get_generic_product_name", [](DeviceType &self) -> std::string {
.value("ECU_AVB", _icsneo_devicetype_t::ECU_AVB) return self.getGenericProductName(self.getDeviceType());
.value("RADSupermoon", _icsneo_devicetype_t::RADSupermoon) });
.value("DW_VCAN", _icsneo_devicetype_t::DW_VCAN)
.value("RADMoon2", _icsneo_devicetype_t::RADMoon2) pybind11::enum_<_icsneo_devicetype_t>(m, "icsneo_devicetype_t")
.value("RADMars", _icsneo_devicetype_t::RADMars) .value("unknown", icsneo_devicetype_unknown)
.value("VCAN4_1", _icsneo_devicetype_t::VCAN4_1) .value("blue", icsneo_devicetype_blue)
.value("FIRE", _icsneo_devicetype_t::FIRE) .value("ecu_avb", icsneo_devicetype_ecu_avb)
.value("RADPluto", _icsneo_devicetype_t::RADPluto) .value("rad_supermoon", icsneo_devicetype_rad_supermoon)
.value("VCAN4_2EL", _icsneo_devicetype_t::VCAN4_2EL) .value("dw_vcan", icsneo_devicetype_dw_vcan)
.value("RADIO_CANHUB", _icsneo_devicetype_t::RADIO_CANHUB) .value("rad_moon2", icsneo_devicetype_rad_moon2)
.value("NEOECU12", _icsneo_devicetype_t::NEOECU12) .value("rad_mars", icsneo_devicetype_rad_mars)
.value("OBD2_LCBADGE", _icsneo_devicetype_t::OBD2_LCBADGE) .value("vcan41", icsneo_devicetype_vcan41)
.value("RADMoonDuo", _icsneo_devicetype_t::RADMoonDuo) .value("fire", icsneo_devicetype_fire)
.value("FIRE3", _icsneo_devicetype_t::FIRE3) .value("rad_pluto", icsneo_devicetype_rad_pluto)
.value("VCAN3", _icsneo_devicetype_t::VCAN3) .value("vcan42_el", icsneo_devicetype_vcan42_el)
.value("RADJupiter", _icsneo_devicetype_t::RADJupiter) .value("radio_canhub", icsneo_devicetype_radio_canhub)
.value("VCAN4_IND", _icsneo_devicetype_t::VCAN4_IND) .value("neo_ecu12", icsneo_devicetype_neo_ecu12)
.value("RADGigastar", _icsneo_devicetype_t::RADGigastar) .value("obd2_lc_badge", icsneo_devicetype_obd2_lc_badge)
.value("RED2", _icsneo_devicetype_t::RED2) .value("rad_moon_duo", icsneo_devicetype_rad_moon_duo)
.value("EtherBADGE", _icsneo_devicetype_t::EtherBADGE) .value("fire3", icsneo_devicetype_fire3)
.value("RAD_A2B", _icsneo_devicetype_t::RAD_A2B) .value("vcan3", icsneo_devicetype_vcan3)
.value("RADEpsilon", _icsneo_devicetype_t::RADEpsilon) .value("rad_jupiter", icsneo_devicetype_rad_jupiter)
.value("RADMoon3", _icsneo_devicetype_t::RADMoon3) .value("vcan4_industrial", icsneo_devicetype_vcan4_industrial)
.value("RADComet", _icsneo_devicetype_t::RADComet) .value("rad_gigastar", icsneo_devicetype_rad_gigastar)
.value("FIRE3_FlexRay", _icsneo_devicetype_t::FIRE3_FlexRay) .value("red2", icsneo_devicetype_red2)
.value("Connect", _icsneo_devicetype_t::Connect) .value("etherbadge", icsneo_devicetype_etherbadge)
.value("RADComet3", _icsneo_devicetype_t::RADComet3) .value("rad_a2b", icsneo_devicetype_rad_a2b)
.value("RADMoonT1S", _icsneo_devicetype_t::RADMoonT1S) .value("rad_epsilon", icsneo_devicetype_rad_epsilon)
.value("RADGigastar2", _icsneo_devicetype_t::RADGigastar2) .value("rad_moon3", icsneo_devicetype_rad_moon3)
.value("RED", _icsneo_devicetype_t::RED) .value("rad_comet", icsneo_devicetype_rad_comet)
.value("ECU", _icsneo_devicetype_t::ECU) .value("fire3_flexray", icsneo_devicetype_fire3_flexray)
.value("IEVB", _icsneo_devicetype_t::IEVB) .value("connect", icsneo_devicetype_connect)
.value("Pendant", _icsneo_devicetype_t::Pendant) .value("rad_comet3", icsneo_devicetype_rad_comet3)
.value("OBD2_PRO", _icsneo_devicetype_t::OBD2_PRO) .value("rad_moon_t1s", icsneo_devicetype_rad_moon_t1s)
.value("ECUChip_UART", _icsneo_devicetype_t::ECUChip_UART) .value("rad_gigastar2", icsneo_devicetype_rad_gigastar2)
.value("PLASMA", _icsneo_devicetype_t::PLASMA) .value("red", icsneo_devicetype_red)
.value("DONT_REUSE0", _icsneo_devicetype_t::DONT_REUSE0) .value("ecu", icsneo_devicetype_ecu)
.value("NEOAnalog", _icsneo_devicetype_t::NEOAnalog) .value("ievb", icsneo_devicetype_ievb)
.value("CT_OBD", _icsneo_devicetype_t::CT_OBD) .value("pendant", icsneo_devicetype_pendant)
.value("DONT_REUSE1", _icsneo_devicetype_t::DONT_REUSE1) .value("obd2_pro", icsneo_devicetype_obd2_pro)
.value("DONT_REUSE2", _icsneo_devicetype_t::DONT_REUSE2) .value("plasma", icsneo_devicetype_plasma)
.value("ION", _icsneo_devicetype_t::ION) .value("ion", icsneo_devicetype_ion)
.value("RADStar", _icsneo_devicetype_t::RADStar) .value("rad_star", icsneo_devicetype_rad_star)
.value("DONT_REUSE3", _icsneo_devicetype_t::DONT_REUSE3) .value("vcan44", icsneo_devicetype_vcan44)
.value("VCAN4_4", _icsneo_devicetype_t::VCAN4_4) .value("vcan42", icsneo_devicetype_vcan42)
.value("VCAN4_2", _icsneo_devicetype_t::VCAN4_2) .value("cm_probe", icsneo_devicetype_cm_probe)
.value("CMProbe", _icsneo_devicetype_t::CMProbe) .value("eevb", icsneo_devicetype_eevb)
.value("EEVB", _icsneo_devicetype_t::EEVB) .value("fire2", icsneo_devicetype_fire2)
.value("VCANrf", _icsneo_devicetype_t::VCANrf) .value("flex", icsneo_devicetype_flex)
.value("FIRE2", _icsneo_devicetype_t::FIRE2) .value("rad_galaxy", icsneo_devicetype_rad_galaxy)
.value("Flex", _icsneo_devicetype_t::Flex) .value("rad_star2", icsneo_devicetype_rad_star2)
.value("RADGalaxy", _icsneo_devicetype_t::RADGalaxy) .value("vividcan", icsneo_devicetype_vividcan)
.value("RADStar2", _icsneo_devicetype_t::RADStar2) .value("obd2_sim", icsneo_devicetype_obd2_sim);
.value("VividCAN", _icsneo_devicetype_t::VividCAN)
.value("OBD2_SIM", _icsneo_devicetype_t::OBD2_SIM);
deviceType.def(pybind11::init<icsneo_devicetype_t>());
deviceType.def("get_device_type", &_icsneo_devicetype_t::getDeviceType);
deviceType.def("get_generic_product_name", &_icsneo_devicetype_t::getGenericProductName);
} }
} // namespace icsneo } // namespace icsneo

26
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;
@ -87,7 +87,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
result->timestamp *= timestampResolution; result->timestamp *= timestampResolution;
switch(result->type) { switch(result->type) {
case Message::Type::Frame: { case Message::Type::BusMessage: {
CANMessage& can = *static_cast<CANMessage*>(result.get()); CANMessage& can = *static_cast<CANMessage*>(result.get());
can.network = packet->network; can.network = packet->network;
break; break;
@ -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)
@ -308,7 +308,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
result = TC10StatusMessage::DecodeToMessage(packet->data); result = TC10StatusMessage::DecodeToMessage(packet->data);
return true; return true;
default: default:
// No defined handler, treat this as a RawMessage // No defined handler, treat this as a InternalMessage
break; break;
} }
break; break;

38
communication/encoder.cpp
View File

@ -23,15 +23,15 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
result.clear(); result.clear();
switch(message->type) { switch(message->type) {
case Message::Type::Frame: { case Message::Type::BusMessage: {
auto frame = std::dynamic_pointer_cast<BusMessage>(message); auto frame = std::dynamic_pointer_cast<BusMessage>(message);
// Frame uses frame->data as the buffer unless directed otherwise // BusMessage uses frame->data as the buffer unless directed otherwise
buffer = &frame->data; buffer = &frame->data;
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;
@ -130,7 +130,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
break; break;
} }
case Message::Type::RawMessage: { case Message::Type::InternalMessage: {
auto raw = std::dynamic_pointer_cast<InternalMessage>(message); auto raw = std::dynamic_pointer_cast<InternalMessage>(message);
// Raw message uses raw->data as the buffer unless directed otherwise // Raw message uses raw->data as the buffer unless directed otherwise

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

@ -102,7 +102,7 @@ bool A2BWAVOutput::callIfMatch(const std::shared_ptr<Message>& message) const {
return false; return false;
} }
if(message->type != Message::Type::Frame) { if(message->type != Message::Type::BusMessage) {
return false; return false;
} }
@ -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);

24
communication/message/neomessage.cpp
View File

@ -14,7 +14,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
neomsg.timestamp = message->timestamp; neomsg.timestamp = message->timestamp;
switch (message->type) switch (message->type)
{ {
case Message::Type::Frame: { case Message::Type::BusMessage: {
neomessage_frame_t& frame = *(neomessage_frame_t*)&neomsg; neomessage_frame_t& frame = *(neomessage_frame_t*)&neomsg;
auto framemsg = std::static_pointer_cast<BusMessage>(message); auto framemsg = std::static_pointer_cast<BusMessage>(message);
const auto netType = framemsg->network.getType(); const auto netType = framemsg->network.getType();
@ -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; }
@ -120,12 +120,12 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t* neomessage) { std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t* neomessage) {
switch((Message::Type)neomessage->messageType) { switch((Message::Type)neomessage->messageType) {
case Message::Type::Frame: { case Message::Type::BusMessage: {
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;

6
communication/packet/canpacket.cpp
View File

@ -69,7 +69,7 @@ std::shared_ptr<Message> HardwareCANPacket::DecodeToMessage(const std::vector<ui
return msg; return msg;
} else { // CAN Frame } else { // CAN BusMessage
auto msg = std::make_shared<CANMessage>(); auto msg = std::make_shared<CANMessage>();
// Arb ID // Arb ID
@ -104,7 +104,7 @@ std::shared_ptr<Message> HardwareCANPacket::DecodeToMessage(const std::vector<ui
// Data // Data
// The first 8 bytes are always in the standard place // The first 8 bytes are always in the standard place
if((data->dlc.RTR && data->header.IDE) || (!data->header.IDE && data->header.SRR)) { // Remote Request Frame if((data->dlc.RTR && data->header.IDE) || (!data->header.IDE && data->header.SRR)) { // Remote Request BusMessage
msg->data.resize(length); // This data will be all zeros, but the length will be set msg->data.resize(length); // This data will be all zeros, but the length will be set
msg->isRemote = true; msg->isRemote = true;
} else { } else {
@ -197,7 +197,7 @@ bool HardwareCANPacket::EncodeFromMessage(const CANMessage& message, std::vector
// Status and DLC bits // Status and DLC bits
if(message.isCANFD) { if(message.isCANFD) {
result.push_back(0x0F); // FD Frame result.push_back(0x0F); // FD BusMessage
uint8_t fdStatusByte = *dlc; uint8_t fdStatusByte = *dlc;
if(message.baudrateSwitch) if(message.baudrateSwitch)
fdStatusByte |= 0x80; // BRS status bit fdStatusByte |= 0x80; // BRS status bit

4
device/device.cpp
View File

@ -1718,11 +1718,11 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
case Message::Type::ResetStatus: case Message::Type::ResetStatus:
latestResetStatus = std::static_pointer_cast<ResetStatusMessage>(message); latestResetStatus = std::static_pointer_cast<ResetStatusMessage>(message);
break; break;
case Message::Type::RawMessage: { case Message::Type::InternalMessage: {
auto rawMessage = std::static_pointer_cast<InternalMessage>(message); auto rawMessage = std::static_pointer_cast<InternalMessage>(message);
switch(rawMessage->network.getNetID()) { switch(rawMessage->network.getNetID()) {
case Network::NetID::Device: { case Network::NetID::Device: {
// Device is not guaranteed to be a CANMessage, it might be a RawMessage // Device is not guaranteed to be a CANMessage, it might be a InternalMessage
// if it couldn't be decoded to a CANMessage. We only care about the // if it couldn't be decoded to a CANMessage. We only care about the
// CANMessage decoding right now. // CANMessage decoding right now.
auto canmsg = std::dynamic_pointer_cast<CANMessage>(message); auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);

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

23
examples/c/simple/src/main.c
View File

@ -37,7 +37,7 @@ void sleep_ms(uint32_t ms) {
int print_error_code(const char* message, icsneo_error_t error) { int print_error_code(const char* message, icsneo_error_t error) {
char error_str[256] = {0}; char error_str[256] = {0};
uint32_t error_length = 256; uint32_t error_length = 256;
icsneo_error_t res = icsneo_error_code(error, error_str, &error_length); icsneo_error_t res = icsneo_get_error_code(error, error_str, &error_length);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
printf("%s: Failed to get string for error code %d with error code %d\n", message, error, res); printf("%s: Failed to get string for error code %d with error code %d\n", message, error, res);
return res; return res;
@ -70,7 +70,7 @@ int main(int argc, char* argv[]) {
icsneo_device_t* devices[255] = {0}; icsneo_device_t* devices[255] = {0};
uint32_t devices_count = 255; uint32_t devices_count = 255;
icsneo_error_t res = icsneo_find(devices, &devices_count, NULL); icsneo_error_t res = icsneo_device_find_all(devices, &devices_count, NULL);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
return print_error_code("Failed to find devices", res); return print_error_code("Failed to find devices", res);
}; };
@ -82,14 +82,14 @@ int main(int argc, char* argv[]) {
// Get description of the device // Get description of the device
const char description[255] = {0}; const char description[255] = {0};
uint32_t description_length = 255; uint32_t description_length = 255;
res = icsneo_device_describe(device, description, &description_length); res = icsneo_device_get_description(device, description, &description_length);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to get device description", res); return print_error_code("Failed to get device description", res);
}; };
// Get timestamp resolution of the device // Get timestamp resolution of the device
uint32_t timestamp_resolution = 0; uint32_t timestamp_resolution = 0;
res = icsneo_get_timestamp_resolution(device, &timestamp_resolution); res = icsneo_device_get_timestamp_resolution(device, &timestamp_resolution);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to get timestamp resolution", res); return print_error_code("Failed to get timestamp resolution", res);
@ -97,21 +97,21 @@ int main(int argc, char* argv[]) {
printf("%s timestamp resolution: %uns\n", description, timestamp_resolution); printf("%s timestamp resolution: %uns\n", description, timestamp_resolution);
// Get/Set open options // Get/Set open options
icsneo_open_options_t options = icsneo_open_options_none; icsneo_open_options_t options = icsneo_open_options_none;
res = icsneo_get_open_options(device, &options); res = icsneo_device_get_open_options(device, &options);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to get open options", res); return print_error_code("Failed to get open options", res);
} }
// Disable Syncing RTC // Disable Syncing RTC
options &= ~icsneo_open_options_sync_rtc; options &= ~icsneo_open_options_sync_rtc;
res = icsneo_set_open_options(device, options); res = icsneo_device_set_open_options(device, options);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to set open options", res); return print_error_code("Failed to set open options", res);
} }
// Open the device // Open the device
printf("Opening device: %s...\n", description); printf("Opening device: %s...\n", description);
res = icsneo_open(device); res = icsneo_device_open(device);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to open device", res); return print_error_code("Failed to open device", res);
@ -123,7 +123,7 @@ int main(int argc, char* argv[]) {
icsneo_message_t* messages[20000] = {0}; icsneo_message_t* messages[20000] = {0};
uint32_t message_count = 20000; uint32_t message_count = 20000;
printf("Getting messages from device with timeout of 3000ms on %s...\n", description); printf("Getting messages from device with timeout of 3000ms on %s...\n", description);
res = icsneo_get_messages(device, messages, &message_count, 3000); res = icsneo_device_get_messages(device, messages, &message_count, 3000);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to get messages from device", res); return print_error_code("Failed to get messages from device", res);
@ -136,7 +136,7 @@ int main(int argc, char* argv[]) {
} }
// Finally, close the device. // Finally, close the device.
printf("Closing device: %s...\n", description); printf("Closing device: %s...\n", description);
res = icsneo_close(device); res = icsneo_device_close(device);
if (res != icsneo_error_success) { if (res != icsneo_error_success) {
print_device_events(device, description); print_device_events(device, description);
return print_error_code("Failed to close device", res); return print_error_code("Failed to close device", res);
@ -215,8 +215,8 @@ int process_messages(icsneo_device_t* device, icsneo_message_t** messages, uint3
bool is_extended = false; bool is_extended = false;
uint8_t data[64] = {0}; uint8_t data[64] = {0};
uint32_t data_length = 64; uint32_t data_length = 64;
uint32_t result = icsneo_can_message_arbid(device, message, &arbid); uint32_t result = icsneo_can_message_get_arbid(device, message, &arbid);
result += icsneo_can_message_dlc_on_wire(device, message, &dlc); result += icsneo_can_message_get_dlc_on_wire(device, message, &dlc);
result += icsneo_can_message_is_remote(device, message, &is_remote); result += icsneo_can_message_is_remote(device, message, &is_remote);
result += icsneo_can_message_is_canfd(device, message, &is_canfd); result += icsneo_can_message_is_canfd(device, message, &is_canfd);
result += icsneo_can_message_is_extended(device, message, &is_extended); result += icsneo_can_message_is_extended(device, message, &is_extended);
@ -233,7 +233,6 @@ int process_messages(icsneo_device_t* device, icsneo_message_t** messages, uint3
printf(" ]\n"); printf(" ]\n");
continue; continue;
} }
} }
return icsneo_error_success; return icsneo_error_success;

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

@ -259,7 +259,7 @@ void example4(const std::shared_ptr<icsneo::Device>& rada2b) {
auto handler = rada2b->addMessageCallback(std::make_shared<icsneo::MessageCallback>( auto handler = rada2b->addMessageCallback(std::make_shared<icsneo::MessageCallback>(
[] (std::shared_ptr<icsneo::Message> newMsg) { [] (std::shared_ptr<icsneo::Message> newMsg) {
if(newMsg->type == icsneo::Message::Type::Frame) { if(newMsg->type == icsneo::Message::Type::BusMessage) {
const auto& frame = std::dynamic_pointer_cast<icsneo::BusMessage>(newMsg); const auto& frame = std::dynamic_pointer_cast<icsneo::BusMessage>(newMsg);
if(frame && frame->network.getNetID() == icsneo::Network::NetID::I2C2) { if(frame && frame->network.getNetID() == icsneo::Network::NetID::I2C2) {
const auto& i2cMessage = std::dynamic_pointer_cast<icsneo::I2CMessage>(frame); const auto& i2cMessage = std::dynamic_pointer_cast<icsneo::I2CMessage>(frame);
@ -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;
} }

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

@ -184,11 +184,11 @@ std::shared_ptr<icsneo::Device> selectDevice(const std::vector<std::shared_ptr<i
void printMessage(const std::shared_ptr<icsneo::Message>& message) { void printMessage(const std::shared_ptr<icsneo::Message>& message) {
switch(message->type) { switch(message->type) {
case icsneo::Message::Type::Frame: { case icsneo::Message::Type::BusMessage: {
// A message of type Frame is guaranteed to be a Frame, so we can static cast safely // A message of type BusMessage is guaranteed to be a BusMessage, 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,10 +214,10 @@ 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 << " BusMessage - " << std::dec
<< ethMessage->data.size() << " bytes on wire\n"; << ethMessage->data.size() << " bytes on wire\n";
std::cout << "\t\t Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n"; std::cout << "\t\t Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n";
@ -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
@ -264,7 +264,7 @@ void printMessage(const std::shared_ptr<icsneo::Message>& message) {
break; break;
} }
break; break;
} // end of icsneo::Message::Type::Frame } // end of icsneo::Message::Type::BusMessage
case icsneo::Message::Type::CANErrorCount: { case icsneo::Message::Type::CANErrorCount: {
// A message of type CANErrorCount is guaranteed to be a CANErrorCount, so we can static cast safely // A message of type CANErrorCount is guaranteed to be a CANErrorCount, so we can static cast safely
auto cec = std::static_pointer_cast<icsneo::CANErrorCountMessage>(message); auto cec = std::static_pointer_cast<icsneo::CANErrorCountMessage>(message);

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

@ -96,9 +96,9 @@ int main() {
std::cout << "OK" << std::endl << std::endl; std::cout << "OK" << std::endl << std::endl;
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::BusMessage == 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: ";

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

@ -92,9 +92,9 @@ 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::BusMessage == 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";

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

@ -169,11 +169,11 @@ int main() {
// MessageCallbacks are powerful, and can filter on things like ArbID for you. See the documentation // MessageCallbacks are powerful, and can filter on things like ArbID for you. See the documentation
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) {
switch(message->type) { switch(message->type) {
case icsneo::Message::Type::Frame: { case icsneo::Message::Type::BusMessage: {
// A message of type Frame is guaranteed to be a Frame, so we can static cast safely // A message of type BusMessage is guaranteed to be a BusMessage, 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,10 +199,10 @@ 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 << " BusMessage - " << std::dec
<< ethMessage->data.size() << " bytes on wire\n"; << ethMessage->data.size() << " bytes on wire\n";
std::cout << "\t\t Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n"; std::cout << "\t\t Timestamped:\t"<< ethMessage->timestamp << " ns since 1/1/2007\n";
@ -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
@ -249,7 +249,7 @@ int main() {
break; break;
} }
break; break;
} // end of icsneo::Message::Type::Frame } // end of icsneo::Message::Type::BusMessage
case icsneo::Message::Type::CANErrorCount: { case icsneo::Message::Type::CANErrorCount: {
// A message of type CANErrorCount is guaranteed to be a CANErrorCount, so we can static cast safely // A message of type CANErrorCount is guaranteed to be a CANErrorCount, so we can static cast safely
auto cec = std::static_pointer_cast<icsneo::CANErrorCountMessage>(message); auto cec = std::static_pointer_cast<icsneo::CANErrorCountMessage>(message);

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

@ -166,13 +166,13 @@ int main(int argc, char* argv[]) {
uint64_t canFrameCount = 0; uint64_t canFrameCount = 0;
uint64_t ethFrameCount = 0; uint64_t ethFrameCount = 0;
rxDevice->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> msg) { rxDevice->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> msg) {
if(msg->type != icsneo::Message::Type::Frame) { if(msg->type != icsneo::Message::Type::BusMessage) {
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;
} }
})); }));
@ -216,7 +216,7 @@ int main(int argc, char* argv[]) {
size_t currentMessage = 0; size_t currentMessage = 0;
rxDevice->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> msg) { rxDevice->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> msg) {
if(msg->type != icsneo::Message::Type::Frame) { if(msg->type != icsneo::Message::Type::BusMessage) {
return; return;
} }
auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg); auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg);

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::BusMessage; }
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::BusMessage; }
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))

14
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"
@ -27,14 +27,14 @@ public:
if(!matchMessageType(message->type)) if(!matchMessageType(message->type))
return false; return false;
if(message->type == Message::Type::Frame || message->type == Message::Type::Main51 || if(message->type == Message::Type::BusMessage || message->type == Message::Type::Main51 ||
message->type == Message::Type::RawMessage || message->type == Message::Type::ReadSettings) { message->type == Message::Type::InternalMessage || message->type == Message::Type::ReadSettings) {
const auto frame = std::static_pointer_cast<InternalMessage>(message); const auto frame = std::static_pointer_cast<InternalMessage>(message);
if(!matchNetworkType(frame->network.getType())) if(!matchNetworkType(frame->network.getType()))
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;
} }

2
include/icsneo/communication/message/flashmemorymessage.h
View File

@ -9,7 +9,7 @@ namespace icsneo {
class FlashMemoryMessage : public InternalMessage { class FlashMemoryMessage : public InternalMessage {
public: public:
FlashMemoryMessage() : InternalMessage(Message::Type::RawMessage, Network::NetID::RED_INT_MEMORYREAD) {} FlashMemoryMessage() : InternalMessage(Message::Type::InternalMessage, Network::NetID::RED_INT_MEMORYREAD) {}
uint16_t startAddress = 0; uint16_t startAddress = 0;
}; };

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

@ -22,7 +22,7 @@ public:
virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_device; } 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, BusMessage = 0,
CANErrorCount = 0x100, CANErrorCount = 0x100,
@ -31,7 +31,7 @@ public:
// Past 0x8000 are all for internal use only // Past 0x8000 are all for internal use only
Invalid = 0x8000, Invalid = 0x8000,
RawMessage = 0x8001, InternalMessage = 0x8001,
ReadSettings = 0x8002, ReadSettings = 0x8002,
ResetStatus = 0x8003, ResetStatus = 0x8003,
DeviceVersion = 0x8004, DeviceVersion = 0x8004,
@ -59,10 +59,10 @@ public:
class InternalMessage : public Message { class InternalMessage : public Message {
public: public:
InternalMessage(Message::Type type = Message::Type::RawMessage) : Message(type) {} InternalMessage(Message::Type type = Message::Type::InternalMessage) : Message(type) {}
InternalMessage(Message::Type type, Network net) : Message(type), network(net) {} InternalMessage(Message::Type type, Network net) : Message(type), network(net) {}
InternalMessage(Network net) : Message(Message::Type::RawMessage), network(net) {} InternalMessage(Network net) : Message(Message::Type::InternalMessage), network(net) {}
InternalMessage(Network net, std::vector<uint8_t> d) : Message(Message::Type::RawMessage), network(net), data(d) {} InternalMessage(Network net, std::vector<uint8_t> d) : Message(Message::Type::InternalMessage), network(net), data(d) {}
virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_internal; } virtual const icsneo_msg_type_t getMsgType() const { return icsneo_msg_type_internal; }
@ -72,7 +72,7 @@ public:
class BusMessage : public InternalMessage { class BusMessage : public InternalMessage {
public: public:
BusMessage() : InternalMessage(Message::Type::Frame) {} BusMessage() : InternalMessage(Message::Type::BusMessage) {}
const icsneo_msg_type_t getMsgType() const final { return icsneo_msg_type_bus; } const icsneo_msg_type_t getMsgType() const final { return icsneo_msg_type_bus; }

2
include/icsneo/communication/message/neoreadmemorysdmessage.h
View File

@ -9,7 +9,7 @@ namespace icsneo {
class NeoReadMemorySDMessage : public InternalMessage { class NeoReadMemorySDMessage : public InternalMessage {
public: public:
NeoReadMemorySDMessage() : InternalMessage(Message::Type::RawMessage, Network::NetID::NeoMemorySDRead) {} NeoReadMemorySDMessage() : InternalMessage(Message::Type::InternalMessage, Network::NetID::NeoMemorySDRead) {}
uint32_t startAddress = 0; uint32_t startAddress = 0;
}; };

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) {

69
include/icsneo/icsneo.h
View File

@ -103,7 +103,7 @@ typedef uint32_t icsneo_error_t;
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_error_code(icsneo_error_t error_code, const char* value, uint32_t* value_length); ICSNEO_API icsneo_error_t icsneo_get_error_code(icsneo_error_t error_code, const char* value, uint32_t* value_length);
/** @brief Get the device type string for a icsneo_devicetype_t. /** @brief Get the device type string for a icsneo_devicetype_t.
* *
@ -124,7 +124,7 @@ ICSNEO_API icsneo_error_t icsneo_device_type_from_type(icsneo_devicetype_t devic
* *
* @return icsneo_error_t icsneo_error_success if successful. * @return icsneo_error_t icsneo_error_success if successful.
*/ */
ICSNEO_API icsneo_error_t icsneo_find(icsneo_device_t** devices, uint32_t* devices_count, void* reserved); ICSNEO_API icsneo_error_t icsneo_device_find_all(icsneo_device_t** devices, uint32_t* devices_count, void* reserved);
/** @brief Check to make sure a device is valid. /** @brief Check to make sure a device is valid.
* *
@ -141,7 +141,7 @@ ICSNEO_API icsneo_error_t icsneo_device_is_valid(icsneo_device_t* device);
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_get_open_options(icsneo_device_t* device, icsneo_open_options_t* options); ICSNEO_API icsneo_error_t icsneo_device_get_open_options(icsneo_device_t* device, icsneo_open_options_t* options);
/** @brief Set the open options for a device /** @brief Set the open options for a device
* *
@ -150,31 +150,31 @@ ICSNEO_API icsneo_error_t icsneo_get_open_options(icsneo_device_t* device, icsne
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_set_open_options(icsneo_device_t* device, icsneo_open_options_t options); ICSNEO_API icsneo_error_t icsneo_device_set_open_options(icsneo_device_t* device, icsneo_open_options_t options);
/** @brief Open a connection to a device. /** @brief Open a connection to a device.
* *
* After a successful call to this function, icsneo_close() must be called to close the device. * After a successful call to this function, icsneo_device_close() must be called to close the device.
* *
* @param[in] icsneo_device_t device The device to open. * @param[in] icsneo_device_t device The device to open.
* @param[out] icsneo_handle_t* handle Pointer to a handle to the opened device. Will be NULL on failure. * @param[out] icsneo_handle_t* handle Pointer to a handle to the opened device. Will be NULL on failure.
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_failure otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_failure otherwise.
* *
* @see icsneo_close * @see icsneo_device_close
*/ */
ICSNEO_API icsneo_error_t icsneo_open(icsneo_device_t* device); ICSNEO_API icsneo_error_t icsneo_device_open(icsneo_device_t* device);
/** @brief Close a connection to a previously opened device. /** @brief Close a connection to a previously opened device.
* *
* After a successful call to icsneo_open(), this function must be called to close the device. * After a successful call to icsneo_device_open(), this function must be called to close the device.
* An already closed device will still succeed. * An already closed device will still succeed.
* *
* @param[in] icsneo_device_t device The device to close. * @param[in] icsneo_device_t device The device to close.
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_failure otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_failure otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_close(icsneo_device_t* device); ICSNEO_API icsneo_error_t icsneo_device_close(icsneo_device_t* device);
/** @brief Get the description of a device /** @brief Get the description of a device
* *
@ -184,16 +184,16 @@ ICSNEO_API icsneo_error_t icsneo_close(icsneo_device_t* device);
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_device_describe(icsneo_device_t* device, const char* value, uint32_t* value_length); ICSNEO_API icsneo_error_t icsneo_device_get_description(icsneo_device_t* device, const char* value, uint32_t* value_length);
/** @brief Get the description type a device /** @brief Get the type of a device
* *
* @param[in] icsneo_device_t device The device to get the description of. * @param[in] icsneo_device_t device The device to get the type of.
* @param[out] icsneo_devicetype_t* value Pointer to an icsneo_devicetype_t to copy the type into. * @param[out] icsneo_devicetype_t* value Pointer to an icsneo_devicetype_t to copy the type into.
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_device_type(icsneo_device_t* device, icsneo_devicetype_t* value); ICSNEO_API icsneo_error_t icsneo_device_get_type(icsneo_device_t* device, icsneo_devicetype_t* value);
/** @brief Get the serial of a device /** @brief Get the serial of a device
* *
@ -203,7 +203,7 @@ ICSNEO_API icsneo_error_t icsneo_device_type(icsneo_device_t* device, icsneo_dev
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_device_serial(icsneo_device_t* device, const char* value, uint32_t* value_length); ICSNEO_API icsneo_error_t icsneo_device_get_serial(icsneo_device_t* device, const char* value, uint32_t* value_length);
/** @brief Set the online state of a device. /** @brief Set the online state of a device.
* *
@ -212,16 +212,25 @@ ICSNEO_API icsneo_error_t icsneo_device_serial(icsneo_device_t* device, const ch
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_go_online(icsneo_device_t* device, bool go_online); ICSNEO_API icsneo_error_t icsneo_device_go_online(icsneo_device_t* device, bool go_online);
/** @brief Get the online state of a device. /** @brief Get the online state of a device.
* *
* @param[in] icsneo_device_t device The device to set the online state of. * @param[in] icsneo_device_t device The device to get the online state of.
* @param[out] bool true if online, false if offline. * @param[out] bool true if online, false if offline.
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_is_online(icsneo_device_t* device, bool* is_online); ICSNEO_API icsneo_error_t icsneo_device_is_online(icsneo_device_t* device, bool* is_online);
/** @brief Get the online supported state of a device.
*
* @param[in] icsneo_device_t device The device to get the online supported state of.
* @param[out] bool true if online, false if offline.
*
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/
ICSNEO_API icsneo_error_t icsneo_device_is_online_supported(icsneo_device_t* device, bool* is_online_supported);
/** @brief Set the message polling state of a device. /** @brief Set the message polling state of a device.
@ -231,7 +240,7 @@ ICSNEO_API icsneo_error_t icsneo_is_online(icsneo_device_t* device, bool* is_onl
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_set_message_polling(icsneo_device_t* device, bool enable); ICSNEO_API icsneo_error_t icsneo_device_set_message_polling(icsneo_device_t* device, bool enable);
/** @brief Get the message polling state of a device. /** @brief Get the message polling state of a device.
* *
@ -240,7 +249,7 @@ ICSNEO_API icsneo_error_t icsneo_set_message_polling(icsneo_device_t* device, bo
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_get_message_polling(icsneo_device_t* device, bool* is_enabled); ICSNEO_API icsneo_error_t icsneo_device_get_message_polling(icsneo_device_t* device, bool* is_enabled);
/** @brief Set the message polling limit of a device. /** @brief Set the message polling limit of a device.
* *
@ -251,18 +260,18 @@ ICSNEO_API icsneo_error_t icsneo_get_message_polling(icsneo_device_t* device, bo
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_set_message_polling_limit(icsneo_device_t* device, uint32_t limit); ICSNEO_API icsneo_error_t icsneo_device_set_message_polling_limit(icsneo_device_t* device, uint32_t limit);
/** @brief Get the message polling limit of a device. /** @brief Get the message polling limit of a device.
* *
* @see icsneo_set_message_polling_limit * @see icsneo_device_set_message_polling_limit
* *
* @param[in] icsneo_device_t device The device to enforce the message polling limit. * @param[in] icsneo_device_t device The device to enforce the message polling limit.
* @param[out] uint32_t limit The limit to get. * @param[out] uint32_t limit The limit to get.
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_get_message_polling_limit(icsneo_device_t* device, uint32_t* limit); ICSNEO_API icsneo_error_t icsneo_device_get_message_polling_limit(icsneo_device_t* device, uint32_t* limit);
/** @brief Get the message count of a device /** @brief Get the message count of a device
* *
@ -271,7 +280,7 @@ ICSNEO_API icsneo_error_t icsneo_get_message_polling_limit(icsneo_device_t* devi
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_get_message_count(icsneo_device_t* device, uint32_t* count); ICSNEO_API icsneo_error_t icsneo_device_get_message_count(icsneo_device_t* device, uint32_t* count);
/** @brief Get the timestamp resolution (nanoseconds) of a device /** @brief Get the timestamp resolution (nanoseconds) of a device
@ -281,7 +290,7 @@ ICSNEO_API icsneo_error_t icsneo_get_message_count(icsneo_device_t* device, uint
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_get_timestamp_resolution(icsneo_device_t* device, uint32_t* resolution); ICSNEO_API icsneo_error_t icsneo_device_get_timestamp_resolution(icsneo_device_t* device, uint32_t* resolution);
/** @brief Get the messages of a device /** @brief Get the messages of a device
* *
@ -295,7 +304,7 @@ ICSNEO_API icsneo_error_t icsneo_get_timestamp_resolution(icsneo_device_t* devic
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_message_t** messages, uint32_t* messages_count, uint32_t timeout_ms); ICSNEO_API icsneo_error_t icsneo_device_get_messages(icsneo_device_t* device, icsneo_message_t** messages, uint32_t* messages_count, uint32_t timeout_ms);
/** @brief Check if a message is valid /** @brief Check if a message is valid
* *
@ -305,7 +314,7 @@ ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_me
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_is_message_valid(icsneo_device_t* device, icsneo_message_t* message, bool* is_valid); ICSNEO_API icsneo_error_t icsneo_message_is_valid(icsneo_device_t* device, icsneo_message_t* message, bool* is_valid);
/** @brief Get the type of a message /** @brief Get the type of a message
* *
@ -350,7 +359,7 @@ ICSNEO_API icsneo_error_t icsneo_message_get_data(icsneo_device_t* device, icsne
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_can_message_arbid(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value); ICSNEO_API icsneo_error_t icsneo_can_message_get_arbid(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value);
/** @brief Get the DLC on wire of a CAN message /** @brief Get the DLC on wire of a CAN message
* *
@ -360,7 +369,7 @@ ICSNEO_API icsneo_error_t icsneo_can_message_arbid(icsneo_device_t* device, icsn
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_can_message_dlc_on_wire(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value); ICSNEO_API icsneo_error_t icsneo_can_message_get_dlc_on_wire(icsneo_device_t* device, icsneo_message_t* message, uint32_t* value);
/** @brief Get the remote status of a CAN message /** @brief Get the remote status of a CAN message
* *
@ -400,7 +409,7 @@ ICSNEO_API icsneo_error_t icsneo_can_message_is_canfd(icsneo_device_t* device, i
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_can_message_baudrate_switch(icsneo_device_t* device, icsneo_message_t* message, bool* value); ICSNEO_API icsneo_error_t icsneo_can_message_get_baudrate_switch(icsneo_device_t* device, icsneo_message_t* message, bool* value);
/** @brief Get the error state indicator status of a CAN message /** @brief Get the error state indicator status of a CAN message
* *
@ -410,7 +419,7 @@ ICSNEO_API icsneo_error_t icsneo_can_message_baudrate_switch(icsneo_device_t* de
* *
* @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise. * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
*/ */
ICSNEO_API icsneo_error_t icsneo_can_message_error_state_indicator(icsneo_device_t* device, icsneo_message_t* message, bool* value); ICSNEO_API icsneo_error_t icsneo_can_message_get_error_state_indicator(icsneo_device_t* device, icsneo_message_t* message, bool* value);
/** @brief Get the global events not specifically related to a device. /** @brief Get the global events not specifically related to a device.
* *

14
include/icsneo/icsneotypes.h
View File

@ -1,10 +1,5 @@
#pragma once #pragma once
// _Static_assert support, this can be removed once C23 is the "standard"
#if __STDC_VERSION__ < 202311L && !defined(__cplusplus)
#include <assert.h>
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@ -12,7 +7,7 @@ extern "C" {
#include <stdint.h> #include <stdint.h>
/** @brief /** @brief
* Options for opening a device. See icsneo_open() for more info. * Options for opening a device. See icsneo_device_open() for more info.
*/ */
typedef enum _icsneo_open_options_t { typedef enum _icsneo_open_options_t {
// No options // No options
@ -158,13 +153,6 @@ typedef enum _icsneo_devicetype_t {
*/ */
typedef uint32_t icsneo_devicetype_t; typedef uint32_t icsneo_devicetype_t;
// Make sure icsneo_devicetype_t is never smaller than the actual enum
#if __STDC_VERSION__ < 202311L && !defined(__cplusplus)
_Static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t), "icsneo_devicetype_t is too small");
#else // C++ or C23
static_assert(sizeof(_icsneo_devicetype_t) <= sizeof(icsneo_devicetype_t));
#endif
typedef enum _icsneo_msg_type_t { typedef enum _icsneo_msg_type_t {
icsneo_msg_type_device, icsneo_msg_type_device,
icsneo_msg_type_internal, icsneo_msg_type_internal,