Refactor for a central include directory

include/icsneo/communication/message/callback/canmessagecallback.h

@@ -0,0 +1,23 @@
+#ifndef __CANMESSAGECALLBACK_H_
+#define __CANMESSAGECALLBACK_H_
+
+#include "icsneo/communication/message/callback/messagecallback.h"
+#include "icsneo/communication/message/canmessage.h"
+#include "icsneo/communication/message/filter/canmessagefilter.h"
+#include <memory>
+
+namespace icsneo {
+
+class CANMessageCallback : public MessageCallback {
+public:
+	CANMessageCallback(fn_messageCallback cb, std::shared_ptr<CANMessageFilter> f) : MessageCallback(cb, f) {}
+	CANMessageCallback(fn_messageCallback cb, CANMessageFilter f = CANMessageFilter()) : MessageCallback(cb, std::make_shared<CANMessageFilter>(f)) {}
+
+	// Allow the filter to be placed first if the user wants (maybe in the case of a lambda)
+	CANMessageCallback(std::shared_ptr<CANMessageFilter> f, fn_messageCallback cb) : MessageCallback(cb, f) {}
+	CANMessageCallback(CANMessageFilter f, fn_messageCallback cb) : MessageCallback(cb, std::make_shared<CANMessageFilter>(f)) {}
+};
+
+};
+
+#endif

include/icsneo/communication/message/callback/main51messagecallback.h

@@ -0,0 +1,23 @@
+#ifndef __MAIN51MESSAGECALLBACK_H_
+#define __MAIN51MESSAGECALLBACK_H_
+
+#include "icsneo/communication/message/callback/messagecallback.h"
+#include "icsneo/communication/message/main51message.h"
+#include "icsneo/communication/message/filter/main51messagefilter.h"
+#include <memory>
+
+namespace icsneo {
+
+class Main51MessageCallback : public MessageCallback {
+public:
+	Main51MessageCallback(fn_messageCallback cb, std::shared_ptr<Main51MessageFilter> f) : MessageCallback(cb, f) {}
+	Main51MessageCallback(fn_messageCallback cb, Main51MessageFilter f = Main51MessageFilter()) : MessageCallback(cb, std::make_shared<Main51MessageFilter>(f)) {}
+
+	// Allow the filter to be placed first if the user wants (maybe in the case of a lambda)
+	Main51MessageCallback(std::shared_ptr<Main51MessageFilter> f, fn_messageCallback cb) : MessageCallback(cb, f) {}
+	Main51MessageCallback(Main51MessageFilter f, fn_messageCallback cb) : MessageCallback(cb, std::make_shared<Main51MessageFilter>(f)) {}
+};
+
+};
+
+#endif

include/icsneo/communication/message/callback/messagecallback.h

@@ -0,0 +1,38 @@
+#ifndef __MESSAGECALLBACK_H_
+#define __MESSAGECALLBACK_H_
+
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/message/filter/messagefilter.h"
+#include <memory>
+#include <functional>
+
+namespace icsneo {
+
+class MessageCallback {
+public:
+	typedef std::function< void( std::shared_ptr<Message> ) > fn_messageCallback;
+
+	MessageCallback(fn_messageCallback cb, std::shared_ptr<MessageFilter> f) : callback(cb), filter(f) {}
+	MessageCallback(fn_messageCallback cb, MessageFilter f = MessageFilter()) : callback(cb), filter(std::make_shared<MessageFilter>(f)) {}
+	
+	// Allow the filter to be placed first if the user wants (maybe in the case of a lambda)
+	MessageCallback(std::shared_ptr<MessageFilter> f, fn_messageCallback cb) : callback(cb), filter(f) {}
+	MessageCallback(MessageFilter f, fn_messageCallback cb) : callback(cb), filter(std::make_shared<MessageFilter>(f)) {}
+	
+	virtual bool callIfMatch(const std::shared_ptr<Message>& message) const {
+		bool ret = filter->match(message);
+		if(ret)
+			callback(message);
+		return ret;
+	}
+	const MessageFilter& getFilter() const { return *filter; }
+	const fn_messageCallback& getCallback() const { return callback; }
+
+protected:
+	fn_messageCallback callback;
+	std::shared_ptr<MessageFilter> filter;
+};
+
+}
+
+#endif

include/icsneo/communication/message/canmessage.h

@@ -0,0 +1,20 @@
+#ifndef __CANMESSAGE_H_
+#define __CANMESSAGE_H_
+
+#include "icsneo/communication/message/message.h"
+
+namespace icsneo {
+
+class CANMessage : public Message {
+public:
+	uint32_t arbid;
+	uint8_t dlcOnWire;
+	bool isRemote = false;
+	bool isExtended = false;
+	bool isCANFD = false;
+	bool baudrateSwitch = false; // CAN FD only
+};
+
+}
+
+#endif

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

@@ -0,0 +1,38 @@
+#ifndef __CANMESSAGEFILTER_H_
+#define __CANMESSAGEFILTER_H_
+
+#include "icsneo/communication/message/filter/messagefilter.h"
+#include "icsneo/communication/network.h"
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/message/canmessage.h"
+#include <memory>
+
+namespace icsneo {
+
+class CANMessageFilter : public MessageFilter {
+public:
+	CANMessageFilter() : MessageFilter(Network::Type::CAN), arbid(INVALID_ARBID) {}
+	CANMessageFilter(uint32_t arbid) : MessageFilter(Network::Type::CAN), arbid(arbid) {}
+
+	bool match(const std::shared_ptr<Message>& message) const {
+		if(!MessageFilter::match(message))
+			return false;
+		const auto canMessage = std::dynamic_pointer_cast<CANMessage>(message);
+		if(canMessage == nullptr || !matchArbID(canMessage->arbid))
+			return false;
+		return true;
+	}
+
+private:
+	static constexpr uint32_t INVALID_ARBID = 0xffffffff;
+	uint32_t arbid;
+	bool matchArbID(uint32_t marbid) const {
+		if(arbid == INVALID_ARBID)
+			return true;
+		return arbid == marbid;
+	}
+};
+
+};
+
+#endif

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

@@ -0,0 +1,46 @@
+#ifndef __MAIN51MESSAGEFILTER_H_
+#define __MAIN51MESSAGEFILTER_H_
+
+#include "icsneo/communication/message/filter/messagefilter.h"
+#include "icsneo/communication/network.h"
+#include "icsneo/communication/communication.h"
+#include "icsneo/communication/message/main51message.h"
+#include <memory>
+#include <iostream>
+
+namespace icsneo {
+
+class Main51MessageFilter : public MessageFilter {
+public:
+	Main51MessageFilter() : MessageFilter(Network::NetID::Main51), command(INVALID_COMMAND) {}
+	Main51MessageFilter(Command command) : MessageFilter(Network::NetID::Main51), command(command) {}
+
+	bool match(const std::shared_ptr<Message>& message) const {
+		if(!MessageFilter::match(message)) {
+			//std::cout << "message filter did not match base for " << message->network << std::endl;
+			return false;
+		}
+		const auto main51Message = std::dynamic_pointer_cast<Main51Message>(message);
+		if(!main51Message)
+			std::cout << "could not upcast " << message->network << std::endl;
+		if(main51Message == nullptr || !matchCommand(main51Message->command)) {
+			if(main51Message)
+				std::cout << "Could not match command " << (int)(command) << " to " << (int)(main51Message->command) << std::endl;
+			return false;
+		}
+		return true;
+	}
+
+private:
+	static constexpr Command INVALID_COMMAND = (Command)0xff;
+	Command command;
+	bool matchCommand(Command mcommand) const {
+		if(command == INVALID_COMMAND)
+			return true;
+		return command == mcommand;
+	}
+};
+
+}
+
+#endif

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

@@ -0,0 +1,45 @@
+#ifndef __MESSAGEFILTER_H_
+#define __MESSAGEFILTER_H_
+
+#include "icsneo/communication/network.h"
+#include "icsneo/communication/message/message.h"
+#include <memory>
+
+namespace icsneo {
+
+class MessageFilter {
+public:
+	MessageFilter() {}
+	MessageFilter(Network::Type type) : type(type) {}
+	MessageFilter(Network::NetID netid) : netid(netid) {}
+	virtual ~MessageFilter() {}
+	// When getting "all" types of messages, include the ones marked as "internal only"
+	bool includeInternalInAny = false;
+
+	virtual bool match(const std::shared_ptr<Message>& message) const {
+		if(!matchType(message->network.getType()))
+			return false;
+		if(!matchNetID(message->network.getNetID()))
+			return false;
+		return true;
+	}
+
+private:
+	Network::Type type = Network::Type::Any;
+	bool matchType(Network::Type mtype) const {
+		if(type == Network::Type::Any && (mtype != Network::Type::Internal || includeInternalInAny))
+			return true;
+		return type == mtype;
+	}
+
+	Network::NetID netid = Network::NetID::Any;
+	bool matchNetID(Network::NetID mnetid) const {
+		if(netid == Network::NetID::Any)
+			return true;
+		return netid == mnetid;
+	}
+};
+
+}
+
+#endif

include/icsneo/communication/message/main51message.h

@@ -0,0 +1,17 @@
+#ifndef __MAIN51MESSAGE_H_
+#define __MAIN51MESSAGE_H_
+
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/communication.h"
+
+namespace icsneo {
+
+class Main51Message : public Message {
+public:
+	virtual ~Main51Message() = default;
+	Command command;
+};
+
+}
+
+#endif

include/icsneo/communication/message/message.h

@@ -0,0 +1,19 @@
+#ifndef __MESSAGE_H_
+#define __MESSAGE_H_
+
+#include "icsneo/communication/network.h"
+#include <vector>
+
+namespace icsneo {
+
+class Message {
+public:
+	virtual ~Message() = default;
+	Network network;
+	std::vector<uint8_t> data;
+	uint64_t timestamp;
+};
+
+}
+
+#endif

include/icsneo/communication/message/neomessage.h

@@ -0,0 +1,135 @@
+#ifndef __NEOMESSAGE_H_
+#define __NEOMESSAGE_H_
+
+#include <stdint.h>
+#include <stddef.h>
+
+#pragma pack(push, 1)
+
+typedef union {
+	struct {
+		uint32_t globalError : 1;
+		uint32_t transmitMessage : 1;
+		uint32_t extendedFrame : 1;
+		uint32_t remoteFrame : 1;
+		uint32_t crcError : 1;
+		uint32_t canErrorPassive : 1;
+		uint32_t incompleteFrame : 1;
+		uint32_t lostArbitration : 1;
+		uint32_t undefinedError : 1;
+		uint32_t canBusOff : 1;
+		uint32_t canErrorWarning : 1;
+		uint32_t canBusShortedPlus : 1;
+		uint32_t canBusShortedGround : 1;
+		uint32_t checksumError : 1;
+		uint32_t badMessageBitTimeError : 1;
+		uint32_t ifrData : 1;
+		uint32_t hardwareCommError : 1;
+		uint32_t expectedLengthError : 1;
+		uint32_t incomingNoMatch : 1;
+		uint32_t statusBreak : 1;
+		uint32_t avsiRecOverflow : 1;
+		uint32_t testTrigger : 1;
+		uint32_t audioComment : 1;
+		uint32_t gpsData : 1;
+		uint32_t analogDigitalInput : 1;
+		uint32_t textComment : 1;
+		uint32_t networkMessageType : 1;
+		uint32_t vsiTXUnderrun : 1;
+		uint32_t vsiIFRCRCBit : 1;
+		uint32_t initMessage : 1;
+		//uint32_t highSpeedMessage : 1; // Occupies the same space as flexraySecondStartupFrame
+		uint32_t flexraySecondStartupFrame : 1;
+		uint32_t extended : 1;
+		// ~~~ End of bitfield 1 ~~~
+		uint32_t hasValue : 1;
+		uint32_t valueIsBoolean : 1;
+		uint32_t highVoltage : 1;
+		uint32_t longMessage : 1;
+		uint32_t : 12;
+		uint32_t globalChange : 1;
+		uint32_t errorFrame : 1;
+		uint32_t : 2;
+		uint32_t endOfLongMessage : 1;
+		uint32_t linErrorRXBreakNotZero : 1;
+		uint32_t linErrorRXBreakTooShort : 1;
+		uint32_t linErrorRXSyncNot55 : 1;
+		uint32_t linErrorRXDataGreaterEight : 1;
+		uint32_t linErrorTXRXMismatch : 1;
+		uint32_t linErrorMessageIDParity : 1;
+		//isoFrameError
+		uint32_t linSyncFrameError : 1;
+		//isoOverflowError
+		uint32_t linIDFrameError : 1;
+		//isoParityError
+		uint32_t linSlaveByteError : 1;
+		uint32_t rxTimeoutError : 1;
+		uint32_t linNoSlaveData : 1;
+		// mostPacketData
+		// mostStatus
+		// mostLowLevel
+		// mostControlData
+		// mostMHPUserData
+		// mostMHPControlData
+		// mostI2SDump
+		// mostTooShort
+		// most50
+		// most150
+		// mostChangedParameter
+		// ethernetCRCError
+		// ethernetFrameTooShort
+		// ethernetFCSAvailable
+		// ~~~ End of bitfield 2 ~~~
+		//uint32_t linJustBreakSync : 1;
+		//uint32_t linSlaveDataTooShort : 1;
+		//uint32_t linOnlyUpdateSlaveTableOnce : 1;
+		uint32_t canfdESI : 1;
+		uint32_t canfdIDE : 1;
+		uint32_t canfdRTR : 1;
+		uint32_t canfdFDF : 1;
+		uint32_t canfdBRS : 1;
+	};
+	uint32_t statusBitfield[4];
+} neomessage_statusbitfield_t;
+
+typedef struct {
+	neomessage_statusbitfield_t status;
+	uint64_t timestamp;
+	const uint8_t* data;
+	size_t length;
+	uint8_t header[4];
+	uint16_t netid;
+	uint8_t type;
+	uint8_t reserved[9];
+} neomessage_t;
+// Any time you add another neomessage_*_t type, make sure to add it to the static_asserts below!
+
+typedef struct {
+	neomessage_statusbitfield_t status;
+	uint64_t timestamp;
+	const uint8_t* data;
+	size_t length;
+	uint32_t arbid;
+	uint16_t netid;
+	uint8_t type;
+	uint8_t dlcOnWire;
+	char reserved[8];
+} neomessage_can_t;
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+#include "icsneo/communication/message/message.h"
+#include <memory>
+
+static_assert(sizeof(neomessage_can_t) == sizeof(neomessage_t), "All types of neomessage_t must be the same size!");
+
+namespace icsneo {
+
+neomessage_t CreateNeoMessage(const std::shared_ptr<Message> message);
+std::shared_ptr<Message> CreateMessageFromNeoMessage(const neomessage_t* neomessage);
+
+}
+#endif
+
+#endif

include/icsneo/communication/message/resetstatusmessage.h

@@ -0,0 +1,35 @@
+#ifndef __RESETSTATUSMESSAGE_H_
+#define __RESETSTATUSMESSAGE_H_
+
+#include "icsneo/communication/message/main51message.h"
+#include "icsneo/communication/command.h"
+#include <string>
+
+namespace icsneo {
+
+class ResetStatusMessage : public Message {
+public:
+	ResetStatusMessage() : Message() {}
+	virtual ~ResetStatusMessage() = default;
+	uint16_t mainLoopTime;
+	uint16_t maxMainLoopTime;
+	bool justReset;
+	bool comEnabled;
+	bool cmRunning;
+	bool cmChecksumFailed;
+	bool cmLicenseFailed;
+	bool cmVersionMismatch;
+	bool cmBootOff;
+	bool hardwareFailure;
+	bool usbComEnabled;
+	bool linuxComEnabled;
+	bool cmTooBig;
+	bool hidUsbState;
+	bool fpgaUsbState;
+	uint16_t busVoltage;
+	uint16_t deviceTemperature;
+};
+
+}
+
+#endif

include/icsneo/communication/message/serialnumbermessage.h

@@ -0,0 +1,24 @@
+#ifndef __SERIALNUMBERMESSAGE_H_
+#define __SERIALNUMBERMESSAGE_H_
+
+#include "icsneo/communication/message/main51message.h"
+#include "icsneo/communication/command.h"
+#include <string>
+
+namespace icsneo {
+
+// The response for Command::RequestSerialNumber
+class SerialNumberMessage : public Main51Message {
+public:
+	SerialNumberMessage() : Main51Message() { command = Command::RequestSerialNumber; }
+	virtual ~SerialNumberMessage() = default;
+	std::string deviceSerial;
+	uint8_t macAddress[6]; // This might be all zeros even if `hasMacAddress` is true
+	bool hasMacAddress = false; // The message might not actually be long enough to contain a MAC address, in which case we mark this
+	uint8_t pcbSerial[16];
+	bool hasPCBSerial = false;
+};
+
+}
+
+#endif