updated example to use msg type and bus type functions

api/icsneo/icsneo.cpp

@@ -327,6 +327,7 @@ ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_me
     if (!device || !messages || !messages_count) {
         return icsneo_error_invalid_parameters;
     }
+    // TODO: Check if device is valid
     auto dev = device->device;
     // Wait for messages
     auto start_time = std::chrono::steady_clock::now();
@@ -366,9 +367,10 @@ ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_me
 }
 
 ICSNEO_API icsneo_error_t icsneo_is_message_valid(icsneo_device_t* device, icsneo_message_t* message, bool* is_valid) {
-    if (!message || !is_valid) {
+    if (!device || !message || !is_valid) {
         return icsneo_error_invalid_parameters;
     }
+    // TODO: Check if device is valid
     *is_valid = std::find_if(device->messages.begin(), device->messages.end(), [&](const auto& msg) {
         return msg->message == message->message;
     }) == device->messages.end();
@@ -376,20 +378,31 @@ ICSNEO_API icsneo_error_t icsneo_is_message_valid(icsneo_device_t* device, icsne
     return icsneo_error_success;
 }
 
-ICSNEO_API icsneo_error_t icsneo_message_get_type(icsneo_device_t* device, icsneo_message_t* message, uint32_t* type) {
-    if (!message || !type) {
+ICSNEO_API icsneo_error_t icsneo_message_get_type(icsneo_device_t* device, icsneo_message_t* message, icsneo_msg_type_t* msg_type) {
+    if (!device || !message || !msg_type) {
         return icsneo_error_invalid_parameters;
     }
-    // TODO: Fix this in the core so we actually get the message type from the message
-    if (dynamic_cast<CANMessage*>(message->message.get())) {
-        return 100;
-    } else if (dynamic_cast<LINMessage*>(message->message.get())) {
-        return 200;
-    } else if (dynamic_cast<EthernetMessage*>(message->message.get())) {
-        return 300;
-    } else {
-        return 999;
+    // TODO: Check if message is valid
+    
+    // Assign the message type
+    *msg_type = message->message->getMsgType();
+
+    return icsneo_error_success;
+}
+
+ICSNEO_API icsneo_error_t icsneo_message_get_bus_type(icsneo_device_t* device, icsneo_message_t* message, icsneo_msg_bus_type_t* bus_type) {
+    if (!device || !message || !bus_type) {
+        return icsneo_error_invalid_parameters;
     }
+    // TODO: Check if message is valid
+
+    // Make sure the message is a bus message
+    if (message->message->getMsgType() != icsneo_msg_type_bus) {
+        return icsneo_error_invalid_type;
+    }
+    // We can static cast here because we are relying on the type being correct at this point
+    auto bus_message = static_cast<BusMessage*>(message->message.get());
+    *bus_type = bus_message->getBusType();
     
     return icsneo_error_success;
 }

api/icsneoc/icsneoc.cpp

@@ -274,10 +274,10 @@ bool icsneo_removeMessageCallback(const neodevice_t* device, int id) {
 	return device->device->removeMessageCallback(id);
 }
 
-neonetid_t icsneo_getNetworkByNumber(const neodevice_t* device, neonettype_t type, unsigned int number) {
+neonetid_t icsneo_getNetworkByNumber(const neodevice_t* device, icsneo_msg_bus_type_t type, unsigned int number) {
 	if(!icsneo_isValidNeoDevice(device))
 		return false;
-	return neonetid_t(device->device->getNetworkByNumber(icsneo::Network::Type(type), size_t(number)).getNetID());
+	return neonetid_t(device->device->getNetworkByNumber(icsneo::icsneo_msg_bus_type_t(type), size_t(number)).getNetID());
 }
 
 bool icsneo_getProductName(const neodevice_t* device, char* str, size_t* maxLength) {
@@ -462,7 +462,7 @@ bool icsneo_transmit(const neodevice_t* device, const neomessage_t* message) {
 	if(!icsneo_isValidNeoDevice(device))
 		return false;
 
-	if(auto frame = std::dynamic_pointer_cast<icsneo::Frame>(CreateMessageFromNeoMessage(message)))
+	if(auto frame = std::dynamic_pointer_cast<icsneo::BusMessage>(CreateMessageFromNeoMessage(message)))
 		return device->device->transmit(frame);
 
 	return false;
@@ -738,7 +738,7 @@ int icsneo_getDeviceStatus(const neodevice_t* device, void* status, size_t* size
 	if(!msg) // Did not receive a message
 		return false;
 	
-	auto rawMessage = std::static_pointer_cast<RawMessage>(msg);
+	auto rawMessage = std::static_pointer_cast<InternalMessage>(msg);
 	if(!rawMessage || (rawMessage->network.getNetID() != Network::NetID::DeviceStatus))
 		return false;
 

communication/decoder.cpp

@@ -54,7 +54,7 @@ uint64_t Decoder::GetUInt64FromLEBytes(const uint8_t* bytes) {
 
 bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Packet>& packet) {
 	switch(packet->network.getType()) {
-		case Network::Type::Ethernet: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
 			result = HardwareEthernetPacket::DecodeToMessage(packet->data, report);
 			if(!result) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
@@ -68,9 +68,9 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			eth.network = packet->network;
 			return true;
 		}
-		case Network::Type::CAN:
-		case Network::Type::SWCAN:
-		case Network::Type::LSFTCAN: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
 			if(packet->data.size() < 24) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -105,7 +105,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 			return true;
 		}
-		case Network::Type::FlexRay: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_flexray: {
 			if(packet->data.size() < 24) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -124,7 +124,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			fr.network = packet->network;
 			return true;
 		}
-		case Network::Type::ISO9141: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
 			if(packet->data.size() < sizeof(HardwareISO9141Packet)) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -141,7 +141,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			iso.network = packet->network;
 			return true;
 		}
-		case Network::Type::I2C: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: {
 			if(packet->data.size() < sizeof(HardwareI2CPacket)) {
 				report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 				return false;
@@ -155,7 +155,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 			return true;
 		}
-		case Network::Type::A2B: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
 			result = HardwareA2BPacket::DecodeToMessage(packet->data);
 
 			if(!result) {
@@ -168,7 +168,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.timestamp *= timestampResolution;
 			return true;
 		}
-		case Network::Type::LIN: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
 			result = HardwareLINPacket::DecodeToMessage(packet->data);
 
 			if(!result) {
@@ -180,7 +180,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.network = packet->network;
 			return true;
 		}
-		case Network::Type::MDIO: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
 			result = HardwareMDIOPacket::DecodeToMessage(packet->data);
 
 			if(!result) {
@@ -192,7 +192,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 			msg.network = packet->network;
 			return true;
 		}
-		case Network::Type::Internal: {
+		case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal: {
 			switch(packet->network.getNetID()) {
 				case Network::NetID::Reset_Status: {
 					// We can deal with not having the last two fields (voltage and temperature)
@@ -230,7 +230,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 					// They come in as CAN but we will handle them in the device rather than
 					// passing them onto the user.
 					if(packet->data.size() < 24) {
-						auto rawmsg = std::make_shared<RawMessage>(Network::NetID::Device);
+						auto rawmsg = std::make_shared<InternalMessage>(Network::NetID::Device);
 						result = rawmsg;
 						rawmsg->data = packet->data;
 						return true;
@@ -244,7 +244,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 
 					// Timestamps are in (resolution) ns increments since 1/1/2007 GMT 00:00:00.0000
 					// The resolution depends on the device
-					auto* raw = dynamic_cast<RawMessage*>(result.get());
+					auto* raw = dynamic_cast<InternalMessage*>(result.get());
 					if(raw == nullptr) {
 						report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
 						return false; // A nullptr was returned, the packet was malformed
@@ -255,7 +255,7 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 				}
 				case Network::NetID::DeviceStatus: {
 					// Just pass along the data, the device needs to handle this itself
-					result = std::make_shared<RawMessage>(packet->network, packet->data);
+					result = std::make_shared<InternalMessage>(packet->network, packet->data);
 					return true;
 				}
 				case Network::NetID::RED_INT_MEMORYREAD: {
@@ -483,6 +483,6 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 	}
 
 	// For the moment other types of messages will automatically be decoded as raw messages
-	result = std::make_shared<RawMessage>(packet->network, packet->data);
+	result = std::make_shared<InternalMessage>(packet->network, packet->data);
 	return true;
 }

communication/encoder.cpp

@@ -24,14 +24,14 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 
 	switch(message->type) {
 		case Message::Type::Frame: {
-			auto frame = std::dynamic_pointer_cast<Frame>(message);
+			auto frame = std::dynamic_pointer_cast<BusMessage>(message);
 
 			// Frame uses frame->data as the buffer unless directed otherwise
 			buffer = &frame->data;
 			netid = uint16_t(frame->network.getNetID());
 
 			switch(frame->network.getType()) {
-				case Network::Type::Ethernet: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
 					auto ethmsg = std::dynamic_pointer_cast<EthernetMessage>(message);
 					if(!ethmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -44,9 +44,9 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 
 					break;
 				} // End of Network::Type::Ethernet
-				case Network::Type::CAN:
-				case Network::Type::SWCAN:
-				case Network::Type::LSFTCAN: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
 					auto canmsg = std::dynamic_pointer_cast<CANMessage>(message);
 					if(!canmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -64,7 +64,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 
 					break;
 				} // End of Network::Type::CAN
-				case Network::Type::ISO9141: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
 					auto isomsg = std::dynamic_pointer_cast<ISO9141Message>(message);
 					if(!isomsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -75,7 +75,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					// packets to the device. This function just encodes them back to back into `result`
 					return HardwareISO9141Packet::EncodeFromMessage(*isomsg, result, report, packetizer);
 				} // End of Network::Type::ISO9141
-				case Network::Type::A2B: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b: {
 					auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message);
 					if(!a2bmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -87,7 +87,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::A2B
-				case Network::Type::I2C: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_i2c: {
 					auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message);
 					if(!i2cmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -99,7 +99,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::I2C
-				case Network::Type::LIN: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
 					auto linmsg = std::dynamic_pointer_cast<LINMessage>(message);
 					if(!linmsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -111,7 +111,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					}
 					break;
 				} // End of Network::Type::LIN
-				case Network::Type::MDIO: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio: {
 					auto mdiomsg = std::dynamic_pointer_cast<MDIOMessage>(message);
 					if(!mdiomsg) {
 						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
@@ -131,7 +131,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 			break;
 		}
 		case Message::Type::RawMessage: {
-			auto raw = std::dynamic_pointer_cast<RawMessage>(message);
+			auto raw = std::dynamic_pointer_cast<InternalMessage>(message);
 
 			// Raw message uses raw->data as the buffer unless directed otherwise
 			buffer = &raw->data;
@@ -243,7 +243,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 		 * In this case, command 0x06 is SetLEDState.
 		 * This old command type is not really used anywhere else.
 		 */
-		auto canmsg = std::make_shared<RawMessage>(Network::NetID::Device);
+		auto canmsg = std::make_shared<InternalMessage>(Network::NetID::Device);
 		msg = canmsg;
 		if(arguments.empty()) {
 			report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);

communication/message/callback/streamoutput/a2bwavoutput.cpp

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

communication/message/neomessage.cpp

@@ -16,11 +16,11 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 	{
 	case Message::Type::Frame: {
 		neomessage_frame_t& frame = *(neomessage_frame_t*)&neomsg;
-		auto framemsg = std::static_pointer_cast<Frame>(message);
+		auto framemsg = std::static_pointer_cast<BusMessage>(message);
 		const auto netType = framemsg->network.getType();
 
 		frame.netid = (neonetid_t)framemsg->network.getNetID();
-		frame.type = (neonettype_t)netType;
+		frame.type = (icsneo_msg_bus_type_t)netType;
 		frame.description = framemsg->description;
 		frame.length = framemsg->data.size();
 		frame.data = framemsg->data.data();
@@ -29,9 +29,9 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 		frame.status.transmitMessage = framemsg->transmitted;
 
 		switch(netType) {
-			case Network::Type::CAN:
-			case Network::Type::SWCAN:
-			case Network::Type::LSFTCAN: {
+			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
+			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
+			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
 				neomessage_can_t& can = *(neomessage_can_t*)&neomsg;
 				auto canmsg = std::static_pointer_cast<CANMessage>(message);
 				can.arbid = canmsg->arbid;
@@ -44,7 +44,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				can.status.canfdESI = canmsg->errorStateIndicator;
 				break;
 			}
-			case Network::Type::Ethernet: {
+			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
 				neomessage_eth_t& eth = *(neomessage_eth_t*)&neomsg;
 				auto ethmsg = std::static_pointer_cast<EthernetMessage>(message);
 				eth.preemptionFlags = ethmsg->preemptionFlags;
@@ -55,7 +55,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 				//eth.status.xyz = ethmsg->noPadding;
 				break;
 			}
-			case Network::Type::LIN: {
+			case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
 				neomessage_lin_t& lin = *(neomessage_lin_t*)&neomsg;
 				auto linmsg = std::static_pointer_cast<LINMessage>(message);
 				if(!linmsg) { break; }
@@ -109,7 +109,7 @@ neomessage_t icsneo::CreateNeoMessage(const std::shared_ptr<Message> message) {
 		canerror.receiveErrorCount = canerrormsg->receiveErrorCount;
 		canerror.status.canBusOff = canerrormsg->busOff;
 		canerror.netid = (neonetid_t)canerrormsg->network.getNetID();
-		canerror.type = (neonettype_t)canerrormsg->network.getType();
+		canerror.type = (icsneo_msg_bus_type_t)canerrormsg->network.getType();
 		break;
 	}
 	default:
@@ -123,9 +123,9 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 		case Message::Type::Frame: {
 			const Network network = ((neomessage_frame_t*)neomessage)->netid;
 			switch(network.getType()) {
-				case Network::Type::CAN:
-				case Network::Type::SWCAN:
-				case Network::Type::LSFTCAN: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can:
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_swcan:
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lsftcan: {
 					neomessage_can_t& can = *(neomessage_can_t*)neomessage;
 					auto canmsg = std::make_shared<CANMessage>();
 					canmsg->network = network;
@@ -140,7 +140,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 					canmsg->errorStateIndicator = can.status.canfdESI;
 					return canmsg;
 				}
-				case Network::Type::Ethernet: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
 					neomessage_eth_t& eth = *(neomessage_eth_t*)neomessage;
 					auto ethmsg = std::make_shared<EthernetMessage>();
 					ethmsg->network = network;
@@ -148,7 +148,7 @@ std::shared_ptr<Message> icsneo::CreateMessageFromNeoMessage(const neomessage_t*
 					ethmsg->data.insert(ethmsg->data.end(), eth.data, eth.data + eth.length);
 					return ethmsg;
 				}
-				case Network::Type::LIN: {
+				case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_lin: {
 					neomessage_lin_t& lin = *(neomessage_lin_t*)neomessage;
 					auto linmsg = std::make_shared<LINMessage>();
 					linmsg->network = network;

device/device.cpp

@@ -472,7 +472,7 @@ int8_t Device::prepareScriptLoad() {
 			return false;
 		}
 
-		const auto resp = std::static_pointer_cast<RawMessage>(generic);
+		const auto resp = std::static_pointer_cast<InternalMessage>(generic);
 		retVal = (int8_t)resp->data[0];
 	}
 
@@ -735,7 +735,7 @@ std::optional<CoreminiHeader> Device::readCoreminiHeader(Disk::MemoryType memTyp
 	return ret;
 }
 
-bool Device::transmit(std::shared_ptr<Frame> frame) {
+bool Device::transmit(std::shared_ptr<BusMessage> frame) {
 	if(!isOpen()) {
 		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
 		return false;
@@ -768,7 +768,7 @@ bool Device::transmit(std::shared_ptr<Frame> frame) {
 	return com->sendPacket(packet);
 }
 
-bool Device::transmit(std::vector<std::shared_ptr<Frame>> frames) {
+bool Device::transmit(std::vector<std::shared_ptr<BusMessage>> frames) {
 	for(auto& frame : frames) {
 		if(!transmit(frame))
 			return false;
@@ -780,7 +780,7 @@ void Device::setWriteBlocks(bool blocks) {
 	com->setWriteBlocks(blocks);
 }
 
-size_t Device::getNetworkCountByType(Network::Type type) const {
+size_t Device::getNetworkCountByType(icsneo_msg_bus_type_t type) const {
 	size_t count = 0;
 	for(const auto& net : getSupportedRXNetworks())
 		if(net.getType() == type)
@@ -789,7 +789,7 @@ size_t Device::getNetworkCountByType(Network::Type type) const {
 }
 
 // Indexed starting at one
-Network Device::getNetworkByNumber(Network::Type type, size_t index) const {
+Network Device::getNetworkByNumber(icsneo_msg_bus_type_t type, size_t index) const {
 	size_t count = 0;
 	for(const auto& net : getSupportedRXNetworks()) {
 		if(net.getType() == type) {
@@ -1719,7 +1719,7 @@ void Device::handleInternalMessage(std::shared_ptr<Message> message) {
 			latestResetStatus = std::static_pointer_cast<ResetStatusMessage>(message);
 			break;
 		case Message::Type::RawMessage: {
-			auto rawMessage = std::static_pointer_cast<RawMessage>(message);
+			auto rawMessage = std::static_pointer_cast<InternalMessage>(message);
 			switch(rawMessage->network.getNetID()) {
 				case Network::NetID::Device: {
 					// Device is not guaranteed to be a CANMessage, it might be a RawMessage
@@ -1895,7 +1895,7 @@ std::optional<std::chrono::time_point<std::chrono::system_clock>> Device::getRTC
 	if(!generic) // Did not receive a message
 		return std::nullopt;
 
-	auto rawMes = std::dynamic_pointer_cast<RawMessage>(generic);
+	auto rawMes = std::dynamic_pointer_cast<InternalMessage>(generic);
 	if(!rawMes)
 		return std::nullopt;
 

device/extensions/flexray/extension.cpp

@@ -48,8 +48,8 @@ void FlexRay::Extension::handleMessage(const std::shared_ptr<Message>& message)
 	}
 }
 
-bool FlexRay::Extension::transmitHook(const std::shared_ptr<Frame>& frame, bool& success) {
-	if(!frame || frame->network.getType() != Network::Type::FlexRay)
+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)
 		return true; // Don't hook non-FlexRay messages
 
 	success = false;

device/idevicesettings.cpp

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

disk/vsa/vsa.cpp

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

examples/c/simple/src/main.c

@@ -46,6 +46,21 @@ int print_error_code(const char* message, icsneo_error_t error) {
     return (int)error;
 }
 
+/**
+ * @brief Processes a list of messages from a device.
+ *
+ * This function iterates over a given array of messages received from a specified device. 
+ * For each message in the array, it retrieves and prints the message type and bus type.
+ * If an error occurs while retrieving these details, an error message is printed.
+ *
+ * @param device A pointer to the icsneo_device_t structure representing the device.
+ * @param messages An array of pointers to icsneo_message_t structures containing the messages to process.
+ * @param messages_count The number of messages in the messages array.
+ *
+ * @return An icsneo_error_t value indicating success or failure of the message processing.
+ */
+int process_messages(icsneo_device_t* device, icsneo_message_t** messages, uint32_t messages_count);
+
 int main(int argc, char* argv[]) {
     (void)argc;
     (void)argv;
@@ -95,9 +110,10 @@ int main(int argc, char* argv[]) {
             return print_error_code("Failed to open device", res);
         };
 
+        // Wait for the bus to collect some messages, requires an active bus to get messages
         printf("Waiting 1 second for messages...\n");
         sleep_ms(1000);
-
+        // Get the messages
         icsneo_message_t* messages[20000] = {0};
         uint32_t message_count = 20000;
         printf("Getting messages from device with timeout of 3000ms on %s...\n", description);
@@ -105,17 +121,12 @@ int main(int argc, char* argv[]) {
         if (res != icsneo_error_success) {
             return print_error_code("Failed to get messages from device", res);
         };
-        printf("Received %u messages\n", message_count);
-
-        for (uint32_t i = 0; i < message_count; i++) {
-            icsneo_message_t* message = messages[i];
-            uint32_t type = 0;
-            res = icsneo_message_get_type(device, message, &type);
-            if (res != icsneo_error_success) {
-                return print_error_code("Failed to get message type", res);
-            }
-            printf("%d Message type: %u\n", i, type);
+        // Process the messages
+        res = process_messages(device, messages, message_count);
+        if (res != icsneo_error_success) {
+            return print_error_code("Failed to process messages", res);
         }
+
         printf("Closing device: %s...\n", description);
         res = icsneo_close(device);
         if (res != icsneo_error_success) {
@@ -125,3 +136,23 @@ int main(int argc, char* argv[]) {
     
     return 0;
 }
+int process_messages(icsneo_device_t* device, icsneo_message_t** messages, uint32_t messages_count) {
+    printf("Received %u messages\n", messages_count);
+    // Print the type and bus type of each message
+    for (uint32_t i = 0; i < messages_count; i++) {
+        icsneo_message_t* message = messages[i];
+        icsneo_msg_type_t msg_type = 0;
+        icsneo_error_t res = icsneo_message_get_type(device, message, &msg_type);
+        if (res != icsneo_error_success) {
+            return print_error_code("Failed to get message type", res);
+        }
+        icsneo_msg_bus_type_t bus_type = 0;
+        res = icsneo_message_get_bus_type(device, message, &bus_type);
+        if (res != icsneo_error_success) {
+            return print_error_code("Failed to get message bus type", res);
+        }
+        printf("%d Message type: %u bus type: %u\n", i, msg_type, bus_type);
+    }
+
+    return icsneo_error_success;
+}

examples/cpp/a2b/src/a2b.cpp

@@ -260,7 +260,7 @@ void example4(const std::shared_ptr<icsneo::Device>& rada2b) {
 		[] (std::shared_ptr<icsneo::Message> newMsg) {
 
 			if(newMsg->type == icsneo::Message::Type::Frame) {
-				const auto& frame = std::dynamic_pointer_cast<icsneo::Frame>(newMsg);
+				const auto& frame = std::dynamic_pointer_cast<icsneo::BusMessage>(newMsg);
 				if(frame && frame->network.getNetID() == icsneo::Network::NetID::I2C2) {
 					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& rxNetworks = dev->getSupportedRXNetworks();
 
-			if(std::none_of(txNetworks.begin(), txNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo::Network::Type::A2B; })) {
+			if(std::none_of(txNetworks.begin(), txNetworks.end(), [](const icsneo::Network& net) { return net.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; })) {
 				return false;
 			}
 
-			if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == icsneo::Network::Type::A2B; })) {
+			if(std::none_of(rxNetworks.begin(), rxNetworks.end(), [](const icsneo::Network& net) { return net.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_a2b; })) {
 				return false;
 			}
 

examples/cpp/interactive/src/InteractiveExample.cpp

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

examples/cpp/lin/src/LINExample.cpp

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

examples/cpp/mdio/src/MDIOExample.cpp

@@ -93,8 +93,8 @@ int main()
 		auto handler = device->addMessageCallback(std::make_shared<icsneo::MessageCallback>([&](std::shared_ptr<icsneo::Message> message)
 																							{
 			if(icsneo::Message::Type::Frame == message->type) {
-				auto frame = std::static_pointer_cast<icsneo::Frame>(message);
-				if(icsneo::Network::Type::MDIO == frame->network.getType()) {
+				auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
+				if(_icsneo_msg_bus_type_t::icsneo_msg_bus_type_mdio == frame->network.getType()) {
 					auto msg = std::static_pointer_cast<icsneo::MDIOMessage>(message);
 					std::cout << msg->network << " " << ((msg->isTXMsg)? "TX" : "RX") << " frame\n";
 					std::cout << "Clause: " << ((msg->clause ==  icsneo::MDIOMessage::Clause::Clause22) ? "22" : "45") << "\n";

examples/cpp/simple/src/SimpleExample.cpp

@@ -171,9 +171,9 @@ int main() {
 			switch(message->type) {
 				case icsneo::Message::Type::Frame: {
 					// A message of type Frame is guaranteed to be a Frame, so we can static cast safely
-					auto frame = std::static_pointer_cast<icsneo::Frame>(message);
+					auto frame = std::static_pointer_cast<icsneo::BusMessage>(message);
 					switch(frame->network.getType()) {
-						case icsneo::Network::Type::CAN: {
+						case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can: {
 							// A message of type CAN is guaranteed to be a CANMessage, so we can static cast safely
 							auto canMessage = std::static_pointer_cast<icsneo::CANMessage>(message);
 
@@ -199,7 +199,7 @@ int main() {
 							std::cout << std::dec << '(' << canMessage->timestamp << " ns since 1/1/2007)\n";
 							break;
 						}
-						case icsneo::Network::Type::Ethernet: {
+						case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet: {
 							auto ethMessage = std::static_pointer_cast<icsneo::EthernetMessage>(message);
 
 							std::cout << "\t\t" << ethMessage->network << " Frame - " << std::dec
@@ -220,7 +220,7 @@ int main() {
 							std::cout << std::dec << std::endl;
 							break;
 						}
-						case icsneo::Network::Type::ISO9141: {
+						case _icsneo_msg_bus_type_t::icsneo_msg_bus_type_iso9141: {
 							// Note that the default settings on some devices have ISO9141 disabled by default in favor of LIN
 							// 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

examples/cpp/vsa/src/VSAExample.cpp

@@ -16,13 +16,13 @@ void onEvent(std::shared_ptr<icsneo::APIEvent> event) {
 	std::cout << event->describe() << std::endl;
 }
 
-std::vector<std::shared_ptr<icsneo::Frame>> constructRandomFrames(size_t frameCount, MessageType frameType) {
+std::vector<std::shared_ptr<icsneo::BusMessage>> constructRandomFrames(size_t frameCount, MessageType frameType) {
 	static constexpr size_t ClassicCANSize = 8;
 	static constexpr size_t CANFDSize = 64;
 	static constexpr size_t ShortEthSize = 500;
 	static constexpr size_t LongEthSize = 1500;
 
-	std::vector<std::shared_ptr<icsneo::Frame>> frames;
+	std::vector<std::shared_ptr<icsneo::BusMessage>> frames;
 	std::random_device randDev;
 	std::mt19937 randEngine(randDev());
 	std::uniform_int_distribution randByteDist(0,255);
@@ -169,10 +169,10 @@ int main(int argc, char* argv[]) {
 		if(msg->type != icsneo::Message::Type::Frame) {
 			return;
 		}
-		const auto frame = std::static_pointer_cast<icsneo::Frame>(msg);
-		if(frame->network.getType() == icsneo::Network::Type::CAN) {
+		const auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg);
+		if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_can) {
 			++canFrameCount;
-		} else if(frame->network.getType() == icsneo::Network::Type::Ethernet) {
+		} else if(frame->network.getType() == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_ethernet) {
 			++ethFrameCount;
 		}
 	}));
@@ -200,7 +200,7 @@ int main(int argc, char* argv[]) {
 
 	const uint8_t NumFrameTypes = 4;
 	const size_t FrameCountPerType = 2500;
-	std::vector<std::shared_ptr<icsneo::Frame>> frames;
+	std::vector<std::shared_ptr<icsneo::BusMessage>> frames;
 	for(uint8_t i = 0; i < NumFrameTypes; i++) {
 		std::cout << "info: transmitting " << FrameCountPerType << " random " << MessageTypeLabels[i] << " frames" << std::endl;
 		auto tempFrames = constructRandomFrames(FrameCountPerType, static_cast<MessageType>(i));
@@ -219,7 +219,7 @@ int main(int argc, char* argv[]) {
 		if(msg->type != icsneo::Message::Type::Frame) {
 			return;
 		}
-		auto frame = std::static_pointer_cast<icsneo::Frame>(msg);
+		auto frame = std::static_pointer_cast<icsneo::BusMessage>(msg);
 		if(frames[currentMessage]->data == frame->data) {
 			currentMessage++;
 		}

include/icsneo/communication/message/a2bmessage.h

@@ -20,8 +20,10 @@ enum class PCMType : uint8_t {
 
 using ChannelMap = std::unordered_map<uint8_t, uint8_t>;
 
-class A2BMessage : public Frame {
+class A2BMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_a2b; }
+
 	static constexpr size_t maxAudioBufferSize = 2048;
 
 	enum class TDMMode : uint8_t {

include/icsneo/communication/message/apperrormessage.h

@@ -64,9 +64,9 @@ enum class AppErrorType : uint16_t {
 	AppNoError = 255
 };
 
-class AppErrorMessage : public RawMessage {
+class AppErrorMessage : public InternalMessage {
 public:
-	AppErrorMessage() : RawMessage(Message::Type::AppError, Network::NetID::RED_App_Error) {}
+	AppErrorMessage() : InternalMessage(Message::Type::AppError, Network::NetID::RED_App_Error) {}
 	uint16_t errorType;
 	Network::NetID errorNetID;
 	uint32_t timestamp10us;

include/icsneo/communication/message/canmessage.h

@@ -7,8 +7,10 @@
 
 namespace icsneo {
 
-class CANMessage : public Frame {
+class CANMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_can; }
+
 	uint32_t arbid;
 	uint8_t dlcOnWire;
 	bool isRemote = false; // Not allowed if CAN FD

include/icsneo/communication/message/diskdatamessage.h

@@ -7,9 +7,9 @@
 
 namespace icsneo {
 
-class DiskDataMessage : public RawMessage {
+class DiskDataMessage : public InternalMessage {
 public:
-	DiskDataMessage(std::vector<uint8_t>&& d) : RawMessage(Network::NetID::DiskData) {
+	DiskDataMessage(std::vector<uint8_t>&& d) : InternalMessage(Network::NetID::DiskData) {
 		data = std::move(d);
 	}
 };

include/icsneo/communication/message/ethernetmessage.h

@@ -31,8 +31,10 @@ struct MACAddress {
 	}
 };
 
-class EthernetMessage : public Frame {
+class EthernetMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_ethernet; }
+
 	bool preemptionEnabled = false;
 	uint8_t preemptionFlags = 0;
 	bool fcsAvailable = false;

include/icsneo/communication/message/extendeddatamessage.h

@@ -9,7 +9,7 @@
 
 namespace icsneo {
 
-class ExtendedDataMessage : public Frame {
+class ExtendedDataMessage : public InternalMessage {
 public:
 	#pragma pack(push, 2)
 	struct ExtendedDataHeader {

include/icsneo/communication/message/filter/canmessagefilter.h

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

include/icsneo/communication/message/filter/messagefilter.h

@@ -14,10 +14,10 @@ public:
 	MessageFilter() {}
 	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::Type type, Network::NetID net = Network::NetID::Any) : networkType(type), netid(net) {
+	MessageFilter(icsneo_msg_bus_type_t type, Network::NetID net = Network::NetID::Any) : networkType(type), netid(net) {
 		// If a Network::Type::Internal is used, we want to also get internal Message::Types
 		// The NetID we want may be in there
-		includeInternalInAny = (networkType == Network::Type::Internal);
+		includeInternalInAny = (networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal);
 	}
 	virtual ~MessageFilter() = default;
 	// When getting "all" types of messages, include the ones marked as "internal only"
@@ -29,12 +29,12 @@ public:
 
 		if(message->type == Message::Type::Frame || message->type == Message::Type::Main51 || 
 			message->type == Message::Type::RawMessage || message->type == Message::Type::ReadSettings) {
-			const auto frame = std::static_pointer_cast<RawMessage>(message);
+			const auto frame = std::static_pointer_cast<InternalMessage>(message);
 			if(!matchNetworkType(frame->network.getType()))
 				return false;
 			if(!matchNetID(frame->network.getNetID()))
 				return false;
-		} else if (netid != Network::NetID::Any || networkType != Network::Type::Any) {
+		} else if (netid != Network::NetID::Any || networkType != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any) {
 			return false; // Filtering on a NetID or Type, but this message doesn't have one
 		}
 		return true;
@@ -48,9 +48,9 @@ protected:
 		return messageType == mtype;
 	}
 
-	Network::Type networkType = Network::Type::Any;
-	bool matchNetworkType(Network::Type mtype) const {
-		if(networkType == Network::Type::Any && (mtype != Network::Type::Internal || includeInternalInAny))
+	icsneo_msg_bus_type_t networkType = _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any;
+	bool matchNetworkType(icsneo_msg_bus_type_t mtype) const {
+		if(networkType == _icsneo_msg_bus_type_t::icsneo_msg_bus_type_any && (mtype != _icsneo_msg_bus_type_t::icsneo_msg_bus_type_internal || includeInternalInAny))
 			return true;
 		return networkType == mtype;
 	}

include/icsneo/communication/message/flashmemorymessage.h

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

include/icsneo/communication/message/flexray/flexraymessage.h

@@ -10,8 +10,9 @@
 
 namespace icsneo {
 
-class FlexRayMessage : public Frame {
+class FlexRayMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_flexray; }
 	uint16_t slotid = 0;
 	double tsslen = 0;
 	double framelen = 0;

include/icsneo/communication/message/i2cmessage.h

@@ -8,8 +8,10 @@
 
 namespace icsneo {
 
-class I2CMessage : public Frame {
+class I2CMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_i2c; }
+
 	enum class DeviceMode : uint8_t {
 		Target = 0,
 		Controller = 1

include/icsneo/communication/message/iso9141message.h

@@ -8,8 +8,9 @@
 
 namespace icsneo {
 
-class ISO9141Message : public Frame {
+class ISO9141Message : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_iso9141; }
 	std::array<uint8_t, 3> header;
 	bool isInit = false;
 	bool isBreak = false;

include/icsneo/communication/message/linmessage.h

@@ -34,8 +34,10 @@ struct LINStatusFlags {
 	bool BreakOnly = false;
 };
 
-class LINMessage : public Frame {
+class LINMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_lin; }
+	
 	enum class Type : uint8_t {
 		NOT_SET = 0,
 		LIN_COMMANDER_MSG,

include/icsneo/communication/message/livedatamessage.h

@@ -8,9 +8,9 @@
 #include "icsneo/communication/livedata.h"
 
 namespace icsneo {
-class LiveDataMessage : public RawMessage {
+class LiveDataMessage : public InternalMessage {
 public:
-	LiveDataMessage() : RawMessage(Message::Type::LiveData, Network::NetID::ExtendedCommand) {}
+	LiveDataMessage() : InternalMessage(Message::Type::LiveData, Network::NetID::ExtendedCommand) {}
 	LiveDataHandle handle;
 	LiveDataCommand cmd;
 };

include/icsneo/communication/message/main51message.h

@@ -8,9 +8,9 @@
 
 namespace icsneo {
 
-class Main51Message : public RawMessage {
+class Main51Message : public InternalMessage {
 public:
-	Main51Message() : RawMessage(Message::Type::Main51, Network::NetID::Main51) {}
+	Main51Message() : InternalMessage(Message::Type::Main51, Network::NetID::Main51) {}
 	Command command = Command(0);
 	bool forceShortFormat = false; // Necessary for EnableNetworkCom and EnableNetworkComEx
 };

include/icsneo/communication/message/mdiomessage.h

@@ -7,8 +7,10 @@
 
 namespace icsneo {
 
-class MDIOMessage : public Frame {
+class MDIOMessage : public BusMessage {
 public:
+	const icsneo_msg_bus_type_t getBusType() const final { return icsneo_msg_bus_type_mdio; }
+	
 	enum class Clause : uint8_t {
 		Clause45 = 0,
 		Clause22 = 1

include/icsneo/communication/message/message.h

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

include/icsneo/communication/message/neomessage.h

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

include/icsneo/communication/message/neoreadmemorysdmessage.h

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

include/icsneo/communication/message/readsettingsmessage.h

@@ -8,9 +8,9 @@
 
 namespace icsneo {
 
-class ReadSettingsMessage : public RawMessage {
+class ReadSettingsMessage : public InternalMessage {
 public:
-	ReadSettingsMessage() : RawMessage(Message::Type::ReadSettings, Network::NetID::ReadSettings) {}
+	ReadSettingsMessage() : InternalMessage(Message::Type::ReadSettings, Network::NetID::ReadSettings) {}
 	
 	enum class Response : uint8_t {
 		OK = 0,

include/icsneo/communication/network.h

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

include/icsneo/device/device.h

@@ -212,8 +212,8 @@ public:
 	int addMessageCallback(const std::shared_ptr<MessageCallback>& cb) { return com->addMessageCallback(cb); }
 	bool removeMessageCallback(int id) { return com->removeMessageCallback(id); }
 
-	bool transmit(std::shared_ptr<Frame> frame);
-	bool transmit(std::vector<std::shared_ptr<Frame>> frames);
+	bool transmit(std::shared_ptr<BusMessage> frame);
+	bool transmit(std::vector<std::shared_ptr<BusMessage>> frames);
 
 	void setWriteBlocks(bool blocks);
 
@@ -226,8 +226,8 @@ public:
 		return std::find(supportedTXNetworks.begin(), supportedTXNetworks.end(), net) != supportedTXNetworks.end();
 	}
 
-	virtual size_t getNetworkCountByType(Network::Type) const;
-	virtual Network getNetworkByNumber(Network::Type, size_t) const;
+	virtual size_t getNetworkCountByType(icsneo_msg_bus_type_t) const;
+	virtual Network getNetworkByNumber(icsneo_msg_bus_type_t, size_t) const;
 
 	std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
 
@@ -835,7 +835,7 @@ protected:
 
 	void handleInternalMessage(std::shared_ptr<Message> message);
 
-	virtual void handleDeviceStatus(const std::shared_ptr<RawMessage>&) {}
+	virtual void handleDeviceStatus(const std::shared_ptr<InternalMessage>&) {}
 
 	neodevice_t& getWritableNeoDevice() { return data; }
 

include/icsneo/device/extensions/deviceextension.h

@@ -33,7 +33,7 @@ public:
 	virtual void handleMessage(const std::shared_ptr<Message>&) {}
 
 	// Return true to continue transmitting, success should be written to if false is returned
-	virtual bool transmitHook(const std::shared_ptr<Frame>& frame, bool& success) { (void)frame; (void)success; return true; }
+	virtual bool transmitHook(const std::shared_ptr<BusMessage>& frame, bool& success) { (void)frame; (void)success; return true; }
 
 protected:
 	Device& device;

include/icsneo/device/extensions/flexray/extension.h

@@ -25,7 +25,7 @@ public:
 	void onGoOffline() override;
 
 	void handleMessage(const std::shared_ptr<Message>& message) override;
-	bool transmitHook(const std::shared_ptr<Frame>& frame, bool& success) override;
+	bool transmitHook(const std::shared_ptr<BusMessage>& frame, bool& success) override;
 
 	std::shared_ptr<Controller> getController(uint8_t index) const {
 		if(index >= controllers.size())

include/icsneo/device/tree/neovifire2/neovifire2.h

@@ -121,7 +121,7 @@ protected:
 	// The supported TX networks are the same as the supported RX networks for this device
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
-	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+	void handleDeviceStatus(const std::shared_ptr<InternalMessage>& message) override {
 		if(message->data.size() < sizeof(neovifire2_status_t))
 			return;
 		std::lock_guard<std::mutex> lk(ioMutex);

include/icsneo/device/tree/plasion/plasion.h

@@ -81,7 +81,7 @@ protected:
 		return ret;
 	}
 
-	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+	void handleDeviceStatus(const std::shared_ptr<InternalMessage>& message) override {
 		if(message->data.size() < sizeof(fire2vnet_status_t))
 			return;
 		std::lock_guard<std::mutex> lk(ioMutex);

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

@@ -91,7 +91,7 @@ protected:
 	// The supported TX networks are the same as the supported RX networks for this device
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
-	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+	void handleDeviceStatus(const std::shared_ptr<InternalMessage>& message) override {
 		if(message->data.size() < sizeof(radgalaxy_status_t))
 			return;
 		std::lock_guard<std::mutex> lk(ioMutex);

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

@@ -104,7 +104,7 @@ protected:
 		txNetworks.insert(txNetworks.end(), supportedTxNetworks.begin(), supportedTxNetworks.end());
 	}
 
-	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+	void handleDeviceStatus(const std::shared_ptr<InternalMessage>& message) override {
 		if(message->data.size() < sizeof(radgigastar_status_t))
 			return;
 		std::lock_guard<std::mutex> lk(ioMutex);

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

@@ -112,7 +112,7 @@ namespace icsneo
 		// The supported TX networks are the same as the supported RX networks for this device
 		void setupSupportedTXNetworks(std::vector<Network> &txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
-		void handleDeviceStatus(const std::shared_ptr<RawMessage> &message) override
+		void handleDeviceStatus(const std::shared_ptr<InternalMessage> &message) override
 		{
 			if (message->data.size() < sizeof(radgigastar2_status_t))
 				return;

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

@@ -96,7 +96,7 @@ protected:
 		txNetworks.insert(txNetworks.end(), supportedTxNetworks.begin(), supportedTxNetworks.end());
 	}
 
-	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+	void handleDeviceStatus(const std::shared_ptr<InternalMessage>& message) override {
 		if(message->data.size() < sizeof(radmars_status_t))
 			return;
 		std::lock_guard<std::mutex> lk(ioMutex);

include/icsneo/device/tree/valuecan4/valuecan4-2el.h

@@ -75,7 +75,7 @@ protected:
 
 	size_t getEthernetActivationLineCount() const override { return 1; }
 
-	void handleDeviceStatus(const std::shared_ptr<RawMessage>& message) override {
+	void handleDeviceStatus(const std::shared_ptr<InternalMessage>& message) override {
 		if(message->data.size() < sizeof(valuecan4_2el_status_t))
 			return;
 		std::lock_guard<std::mutex> lk(ioMutex);

include/icsneo/icsneo.h

@@ -65,6 +65,8 @@ typedef enum _icsneo_error_t {
     icsneo_error_sync_rtc_failed,
     // Error getting messages.
     icsneo_error_get_messages_failed,
+    // Generic invalid type error
+    icsneo_error_invalid_type,
 } _icsneo_error_t;
 
 /** @brief Integer representation of _icsneo_error_t enum. 
@@ -286,7 +288,29 @@ ICSNEO_API icsneo_error_t icsneo_get_messages(icsneo_device_t* device, icsneo_me
  */
 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_get_type(icsneo_device_t* device, icsneo_message_t* message, uint32_t* type);
+/** @brief Get the type of a message
+ * 
+ * @param[in] icsneo_device_t* device The device to check against.
+ * @param[in] icsneo_message_t* message The message to check.
+ * @param[out] icsneo_msg_type_t* msg_type Pointer to a icsneo_msg_type_t to copy the type of the value into.
+ * 
+ * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters otherwise.
+ * 
+ * @see icsneo_msg_type_t
+ */
+ICSNEO_API icsneo_error_t icsneo_message_get_type(icsneo_device_t* device, icsneo_message_t* message, icsneo_msg_type_t* msg_type);
+
+/** @brief Get the type of a bus message
+ * 
+ * @param[in] icsneo_device_t* device The device to check against.
+ * @param[in] icsneo_message_t* message The message to check.
+ * @param[out] icsneo_msg_type_t* msg_type Pointer to a icsneo_msg_type_t to copy the type of the value into.
+ * 
+ * @return icsneo_error_t icsneo_error_success if successful, icsneo_error_invalid_parameters or icsneo_error_invalid_type otherwise.
+ * 
+ * @see icsneo_msg_bus_type_t
+ */
+ICSNEO_API icsneo_error_t icsneo_message_get_bus_type(icsneo_device_t* device, icsneo_message_t* message, icsneo_msg_bus_type_t* bus_type);
 
 #ifdef __cplusplus
 }

include/icsneo/icsneoc.h

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

include/icsneo/icsneocpp.h

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

include/icsneo/icsneotypes.h

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