Drivers: Decouple from devices

This allows us to better implement alternative drivers
for devices, such as for device sharing servers or
talking to CoreMini processors within the same device.

include/icsneo/device/tree/valuecan4/valuecan4-1.h

@@ -5,27 +5,14 @@
 
 #include "icsneo/device/tree/valuecan4/valuecan4.h"
 #include "icsneo/device/tree/valuecan4/settings/valuecan4-1settings.h"
-#include "icsneo/platform/cdcacm.h"
-#include <string>
 
 namespace icsneo {
 
 class ValueCAN4_1 : public ValueCAN4 {
 public:
 	// Serial numbers start with V1 for 4-1
-	static constexpr DeviceType::Enum DEVICE_TYPE = DeviceType::VCAN4_1;
-	static constexpr const char* SERIAL_START = "V1";
-
-	static std::vector<std::shared_ptr<Device>> Find() {
-		std::vector<std::shared_ptr<Device>> found;
-
-		for(auto neodevice : CDCACM::FindByProduct(USB_PRODUCT_ID)) {
-			if(std::string(neodevice.serial).substr(0, 2) == SERIAL_START)
-				found.emplace_back(new ValueCAN4_1(neodevice));
-		}
-
-		return found;
-	}
+	// USB PID is 0x1101 (shared by all ValueCAN 4s), standard driver is CDCACM
+	ICSNEO_FINDABLE_DEVICE(ValueCAN4_1, DeviceType::VCAN4_1, "V1");
 
 	static const std::vector<Network>& GetSupportedNetworks() {
 		static std::vector<Network> supportedNetworks = {
@@ -35,25 +22,22 @@ public:
 	}
 
 protected:
+	ValueCAN4_1(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
+		initialize<ValueCAN4_1Settings>(makeDriver);
+	}
+
 	void setupEncoder(Encoder& encoder) override {
 		ValueCAN4::setupEncoder(encoder);
 		encoder.supportCANFD = false; // VCAN 4-1 does not support CAN FD
 	}
 
-	virtual void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
+	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
 		for(auto& netid : GetSupportedNetworks())
 			rxNetworks.emplace_back(netid);
 	}
 
 	// The supported TX networks are the same as the supported RX networks for this device
-	virtual void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
-
-private:
-	ValueCAN4_1(neodevice_t neodevice) : ValueCAN4(neodevice) {
-		initialize<CDCACM, ValueCAN4_1Settings>();
-		getWritableNeoDevice().type = DEVICE_TYPE;
-		productId = USB_PRODUCT_ID;
-	}
+	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 };
 
 }

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

@@ -5,33 +5,20 @@
 
 #include "icsneo/device/tree/valuecan4/valuecan4.h"
 #include "icsneo/device/tree/valuecan4/settings/valuecan4-2settings.h"
-#include "icsneo/platform/cdcacm.h"
-#include <string>
 
 namespace icsneo {
 
 class ValueCAN4_2 : public ValueCAN4 {
 public:
 	// Serial numbers start with V2 for 4-2
-	static constexpr DeviceType::Enum DEVICE_TYPE = DeviceType::VCAN4_2;
-	static constexpr const char* SERIAL_START = "V2";
+	// USB PID is 0x1101 (shared by all ValueCAN 4s), standard driver is CDCACM
+	ICSNEO_FINDABLE_DEVICE(ValueCAN4_2, DeviceType::VCAN4_2, "V2");
 
 	enum class SKU {
 		Standard,
 		AP0200A, // USB A and Keysight Branding
 	};
 
-	static std::vector<std::shared_ptr<Device>> Find() {
-		std::vector<std::shared_ptr<Device>> found;
-
-		for(auto neodevice : CDCACM::FindByProduct(USB_PRODUCT_ID)) {
-			if(std::string(neodevice.serial).substr(0, 2) == SERIAL_START)
-				found.emplace_back(new ValueCAN4_2(neodevice));
-		}
-
-		return found;
-	}
-
 	static const std::vector<Network>& GetSupportedNetworks() {
 		static std::vector<Network> supportedNetworks = {
 			Network::NetID::HSCAN,
@@ -60,20 +47,17 @@ public:
 	}
 
 protected:
-	virtual void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
+	ValueCAN4_2(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
+		initialize<ValueCAN4_2Settings>(makeDriver);
+	}
+
+	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
 		for(auto& netid : GetSupportedNetworks())
 			rxNetworks.emplace_back(netid);
 	}
 
 	// The supported TX networks are the same as the supported RX networks for this device
-	virtual void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
-
-private:
-	ValueCAN4_2(neodevice_t neodevice) : ValueCAN4(neodevice) {
-		initialize<CDCACM, ValueCAN4_2Settings>();
-		getWritableNeoDevice().type = DEVICE_TYPE;
-		productId = USB_PRODUCT_ID;
-	}
+	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 };
 
 }

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

@@ -5,15 +5,15 @@
 
 #include "icsneo/device/tree/valuecan4/valuecan4.h"
 #include "icsneo/device/tree/valuecan4/settings/valuecan4-2elsettings.h"
-#include <string>
 
 namespace icsneo {
 
 class ValueCAN4_2EL : public ValueCAN4 {
 public:
 	// Serial numbers start with VE for 4-2EL
-	static constexpr DeviceType::Enum DEVICE_TYPE = DeviceType::VCAN4_2EL;
-	static constexpr const char* SERIAL_START = "VE";
+	// USB PID is 0x1101 (shared by all ValueCAN 4s), standard driver is CDCACM
+	// Ethernet MAC allocation is 0x0B, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE(ValueCAN4_2EL, DeviceType::VCAN4_2EL, "VE");
 
 	enum class SKU {
 		Standard,
@@ -53,14 +53,16 @@ public:
 			Network::NetID::HSCAN,
 			Network::NetID::HSCAN2,
 
-			Network::NetID::Ethernet
+			Network::NetID::Ethernet,
+
+			Network::NetID::LIN
 		};
 		return supportedNetworks;
 	}
 
 protected:
-	ValueCAN4_2EL(neodevice_t neodevice) : ValueCAN4(neodevice) {
-		getWritableNeoDevice().type = DEVICE_TYPE;
+	ValueCAN4_2EL(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
+		initialize<ValueCAN4_2ELSettings>(makeDriver);
 	}
 
 	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
@@ -80,6 +82,13 @@ protected:
 		const valuecan4_2el_status_t* status = reinterpret_cast<const valuecan4_2el_status_t*>(message->data.data());
 		ethActivationStatus = status->ethernetActivationLineEnabled;
 	}
+
+	bool currentDriverSupportsDFU() const override { return com->driver->isEthernet(); }
+
+	void setupPacketizer(Packetizer& packetizer) override {
+		ValueCAN4::setupPacketizer(packetizer);
+		packetizer.align16bit = !com->driver->isEthernet();
+	}
 };
 
 }

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

@@ -1,68 +0,0 @@
-#ifndef __VALUECAN4_2EL_ETH_H_
-#define __VALUECAN4_2EL_ETH_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/device/tree/valuecan4/valuecan4-2el.h"
-#include "icsneo/platform/pcap.h"
-#include <string>
-
-namespace icsneo {
-
-class ValueCAN4_2EL_ETH : public ValueCAN4_2EL {
-public:
-	static constexpr const uint16_t ETH_PRODUCT_ID = 0x000B;
-
-	static std::vector<std::shared_ptr<Device>> Find(const std::vector<PCAP::PCAPFoundDevice>& pcapDevices) {
-		std::vector<std::shared_ptr<Device>> found;
-		
-		for(auto& foundDev : pcapDevices) {
-			auto fakedev = std::shared_ptr<ValueCAN4_2EL_ETH>(new ValueCAN4_2EL_ETH({}));
-			for (auto& payload : foundDev.discoveryPackets)
-				fakedev->com->packetizer->input(payload);
-			for (auto& packet : fakedev->com->packetizer->output()) {
-				std::shared_ptr<Message> msg;
-				if (!fakedev->com->decoder->decode(msg, packet))
-					continue; // We failed to decode this packet
-
-				if(!msg || msg->type != Message::Type::Main51)
-					continue; // Not a message we care about
-				auto sn = std::dynamic_pointer_cast<SerialNumberMessage>(msg);
-				if(!sn)
-					continue; // Not a serial number message
-				
-				if(sn->deviceSerial.length() < 2)
-					continue;
-				if(sn->deviceSerial.substr(0, 2) != SERIAL_START)
-					continue; // Not a ValueCAN4-2EL
-				
-				auto device = foundDev.device;
-				device.serial[sn->deviceSerial.copy(device.serial, sizeof(device.serial))] = '\0';
-				found.push_back(std::shared_ptr<ValueCAN4_2EL_ETH>(new ValueCAN4_2EL_ETH(std::move(device))));
-				break;
-			}
-		}
-
-		return found;
-	}
-
-	bool currentDriverSupportsDFU() const override { return false; }
-
-protected:
-	void setupPacketizer(Packetizer& packetizer) override {
-		ValueCAN4_2EL::setupPacketizer(packetizer);
-		packetizer.align16bit = false;
-	}
-
-private:
-	ValueCAN4_2EL_ETH(neodevice_t neodevice) : ValueCAN4_2EL(neodevice) {
-		initialize<PCAP, ValueCAN4_2ELSettings>();
-		productId = ETH_PRODUCT_ID;
-	}
-};
-
-}
-
-#endif // __cplusplus
-
-#endif

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

@@ -1,36 +0,0 @@
-#ifndef __VALUECAN4_2EL_USB_H_
-#define __VALUECAN4_2EL_USB_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/device/tree/valuecan4/valuecan4-2el.h"
-#include "icsneo/platform/cdcacm.h"
-#include <string>
-
-namespace icsneo {
-
-class ValueCAN4_2EL_USB : public ValueCAN4_2EL {
-public:
-	static std::vector<std::shared_ptr<Device>> Find() {
-		std::vector<std::shared_ptr<Device>> found;
-
-		for(auto neodevice : CDCACM::FindByProduct(USB_PRODUCT_ID)) {
-			if(std::string(neodevice.serial).substr(0, 2) == SERIAL_START)
-				found.emplace_back(new ValueCAN4_2EL_USB(neodevice));
-		}
-
-		return found;
-	}
-
-private:
-	ValueCAN4_2EL_USB(neodevice_t neodevice) : ValueCAN4_2EL(neodevice) {
-		initialize<CDCACM, ValueCAN4_2ELSettings>();
-		productId = USB_PRODUCT_ID;
-	}
-};
-
-}
-
-#endif // __cplusplus
-
-#endif

include/icsneo/device/tree/valuecan4/valuecan4-4.h

@@ -5,16 +5,14 @@
 
 #include "icsneo/device/tree/valuecan4/valuecan4.h"
 #include "icsneo/device/tree/valuecan4/settings/valuecan4-4settings.h"
-#include "icsneo/platform/cdcacm.h"
-#include <string>
 
 namespace icsneo {
 
 class ValueCAN4_4 : public ValueCAN4 {
 public:
 	// Serial numbers start with V4 for 4-4
-	static constexpr DeviceType::Enum DEVICE_TYPE = DeviceType::VCAN4_4;
-	static constexpr const char* SERIAL_START = "V4";
+	// USB PID is 0x1101 (shared by all ValueCAN 4s), standard driver is CDCACM
+	ICSNEO_FINDABLE_DEVICE(ValueCAN4_4, DeviceType::VCAN4_4, "V4");
 
 	enum class SKU {
 		Standard,
@@ -23,17 +21,6 @@ public:
 		AP0400A_OBD, // OBD, USB A, and Keysight Branding
 	};
 
-	static std::vector<std::shared_ptr<Device>> Find() {
-		std::vector<std::shared_ptr<Device>> found;
-
-		for(auto neodevice : CDCACM::FindByProduct(USB_PRODUCT_ID)) {
-			if(std::string(neodevice.serial).substr(0, 2) == SERIAL_START)
-				found.emplace_back(new ValueCAN4_4(neodevice));
-		}
-
-		return found;
-	}
-
 	static const std::vector<Network>& GetSupportedNetworks() {
 		static std::vector<Network> supportedNetworks = {
 			Network::NetID::HSCAN,
@@ -71,20 +58,17 @@ public:
 	}
 
 protected:
-	virtual void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
+	ValueCAN4_4(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
+		initialize<ValueCAN4_4Settings>(makeDriver);
+	}
+
+	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
 		for(auto& netid : GetSupportedNetworks())
 			rxNetworks.emplace_back(netid);
 	}
 
 	// The supported TX networks are the same as the supported RX networks for this device
-	virtual void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
-
-private:
-	ValueCAN4_4(neodevice_t neodevice) : ValueCAN4(neodevice) {
-		initialize<CDCACM, ValueCAN4_4Settings>();
-		getWritableNeoDevice().type = DEVICE_TYPE;
-		productId = USB_PRODUCT_ID;
-	}
+	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 };
 
 }

include/icsneo/device/tree/valuecan4/valuecan4.h

@@ -10,17 +10,16 @@ namespace icsneo {
 
 class ValueCAN4 : public Device {
 public:
-	// All ValueCAN 4 devices share a USB PID
-	static constexpr const uint16_t USB_PRODUCT_ID = 0x1101;
+	// All ValueCAN 4 devices share a USB PID of 0x1101
 
 protected:
+	using Device::Device;
+
 	virtual void setupEncoder(Encoder& encoder) override {
 		Device::setupEncoder(encoder);
 		encoder.supportCANFD = true;
 	}
 
-	ValueCAN4(neodevice_t neodevice) : Device(neodevice) {}
-
 	bool requiresVehiclePower() const override { return false; }
 };
 

include/icsneo/device/tree/valuecan4/valuecan4industrial.h

@@ -11,12 +11,40 @@ namespace icsneo {
 class ValueCAN4Industrial : public ValueCAN4 {
 public:
 	// Serial numbers start with IV for Industrial
-	static constexpr DeviceType::Enum DEVICE_TYPE = DeviceType::VCAN4_IND;
-	static constexpr const char* SERIAL_START = "IV";
+	// USB PID is 0x1101 (shared by all ValueCAN 4s), standard driver is CDCACM
+	// Ethernet MAC allocation is 0x12, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE(ValueCAN4Industrial, DeviceType::VCAN4_IND, "IV");
+
+	static const std::vector<Network>& GetSupportedNetworks() {
+		static std::vector<Network> supportedNetworks = {
+			Network::NetID::HSCAN,
+			Network::NetID::HSCAN2,
+
+			Network::NetID::Ethernet,
+
+			Network::NetID::LIN
+		};
+		return supportedNetworks;
+	}
 
 protected:
-	ValueCAN4Industrial(neodevice_t neodevice) : ValueCAN4(neodevice) {
-		getWritableNeoDevice().type = DEVICE_TYPE;
+	ValueCAN4Industrial(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
+		initialize<ValueCAN4IndustrialSettings>(makeDriver);
+	}
+
+	void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
+		for(auto& netid : GetSupportedNetworks())
+			rxNetworks.emplace_back(netid);
+	}
+
+	// The supported TX networks are the same as the supported RX networks for this device
+	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
+
+	bool currentDriverSupportsDFU() const override { return com->driver->isEthernet(); }
+
+	void setupPacketizer(Packetizer& packetizer) override {
+		ValueCAN4::setupPacketizer(packetizer);
+		packetizer.align16bit = !com->driver->isEthernet();
 	}
 };
 

include/icsneo/device/tree/valuecan4/valuecan4industrialeth.h

@@ -1,85 +0,0 @@
-#ifndef __VALUECAN4INDUSTRIAL_ETH_H_
-#define __VALUECAN4INDUSTRIAL_ETH_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/device/tree/valuecan4/valuecan4industrial.h"
-#include "icsneo/platform/pcap.h"
-#include <string>
-
-namespace icsneo {
-
-class ValueCAN4IndustrialETH : public ValueCAN4Industrial {
-public:
-	static constexpr const uint16_t ETH_PRODUCT_ID = 0x0012;
-
-	static std::vector<std::shared_ptr<Device>> Find(const std::vector<PCAP::PCAPFoundDevice>& pcapDevices) {
-		std::vector<std::shared_ptr<Device>> found;
-		
-		for(auto& foundDev : pcapDevices) {
-			auto fakedev = std::shared_ptr<ValueCAN4IndustrialETH>(new ValueCAN4IndustrialETH({}));
-			for (auto& payload : foundDev.discoveryPackets)
-				fakedev->com->packetizer->input(payload);
-			for (auto& packet : fakedev->com->packetizer->output()) {
-				std::shared_ptr<Message> msg;
-				if (!fakedev->com->decoder->decode(msg, packet))
-					continue; // We failed to decode this packet
-
-				if(!msg || msg->type != Message::Type::Main51)
-					continue; // Not a message we care about
-				auto sn = std::dynamic_pointer_cast<SerialNumberMessage>(msg);
-				if(!sn)
-					continue; // Not a serial number message
-				
-				if(sn->deviceSerial.length() < 2)
-					continue;
-				if(sn->deviceSerial.substr(0, 2) != SERIAL_START)
-					continue; // Not a ValueCAN 4 Industrial
-				
-				auto device = foundDev.device;
-				device.serial[sn->deviceSerial.copy(device.serial, sizeof(device.serial))] = '\0';
-				found.push_back(std::shared_ptr<ValueCAN4IndustrialETH>(new ValueCAN4IndustrialETH(std::move(device))));
-				break;
-			}
-		}
-
-		return found;
-	}
-
-	static const std::vector<Network>& GetSupportedNetworks() {
-		static std::vector<Network> supportedNetworks = {
-			Network::NetID::HSCAN,
-			Network::NetID::HSCAN2,
-
-			// No Network::NetID::Ethernet, since we're communicating over it instead
-		};
-		return supportedNetworks;
-	}
-
-	bool currentDriverSupportsDFU() const override { return false; }
-
-protected:
-	void setupPacketizer(Packetizer& packetizer) override {
-		ValueCAN4Industrial::setupPacketizer(packetizer);
-		packetizer.align16bit = false;
-	}
-
-	virtual void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
-		for(auto& netid : GetSupportedNetworks())
-			rxNetworks.emplace_back(netid);
-	}
-
-	// The supported TX networks are the same as the supported RX networks for this device
-	virtual void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
-
-private:
-	ValueCAN4IndustrialETH(neodevice_t neodevice) : ValueCAN4Industrial(neodevice) {
-		initialize<PCAP, ValueCAN4IndustrialSettings>();
-	}
-};
-
-}
-
-#endif // __cplusplus
-
-#endif

include/icsneo/device/tree/valuecan4/valuecan4industrialusb.h

@@ -1,54 +0,0 @@
-#ifndef __VALUECAN4INDUSTRIAL_USB_H_
-#define __VALUECAN4INDUSTRIAL_USB_H_
-
-#ifdef __cplusplus
-
-#include "icsneo/device/tree/valuecan4/valuecan4industrial.h"
-#include "icsneo/platform/cdcacm.h"
-#include <string>
-
-namespace icsneo {
-
-class ValueCAN4IndustrialUSB : public ValueCAN4Industrial {
-public:
-	static std::vector<std::shared_ptr<Device>> Find() {
-		std::vector<std::shared_ptr<Device>> found;
-
-		for(auto neodevice : CDCACM::FindByProduct(USB_PRODUCT_ID)) {
-			if(std::string(neodevice.serial).substr(0, 2) == SERIAL_START)
-				found.emplace_back(new ValueCAN4IndustrialUSB(neodevice));
-		}
-
-		return found;
-	}
-
-	static const std::vector<Network>& GetSupportedNetworks() {
-		static std::vector<Network> supportedNetworks = {
-			Network::NetID::HSCAN,
-			Network::NetID::HSCAN2,
-
-			Network::NetID::Ethernet
-		};
-		return supportedNetworks;
-	}
-
-protected:
-	virtual void setupSupportedRXNetworks(std::vector<Network>& rxNetworks) override {
-		for(auto& netid : GetSupportedNetworks())
-			rxNetworks.emplace_back(netid);
-	}
-
-	// The supported TX networks are the same as the supported RX networks for this device
-	virtual void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
-
-private:
-	ValueCAN4IndustrialUSB(neodevice_t neodevice) : ValueCAN4Industrial(neodevice) {
-		initialize<CDCACM, ValueCAN4IndustrialSettings>();
-	}
-};
-
-}
-
-#endif // __cplusplus
-
-#endif