Device: Add Coremini script upload function

include/icsneo/api/event.h

@@ -91,6 +91,8 @@ public:
 		WiVIUploadStackOverflow = 0x2037,
 		I2CMessageExceedsMaxLength = 0x2038,
 		A2BMessageIncompleteFrame = 0x2039,
+		CoreminiUploadVersionMismatch = 0x2040,
+		DiskNotConnected = 0x2041,
 
 		// Transport Events
 		FailedToRead = 0x3000,

include/icsneo/device/device.h

@@ -55,6 +55,8 @@ namespace icsneo {
 
 class DeviceExtension;
 
+typedef uint64_t MemoryAddress;
+
 class Device {
 public:
 	virtual ~Device();
@@ -135,10 +137,34 @@ public:
 		NoScript,
 	};
 
+
+
 	int8_t prepareScriptLoad();
-	bool startScript();
+	bool startScript(Disk::MemoryType memType = Disk::MemoryType::SD);
 	bool stopScript();
 	bool clearScript();
+	bool uploadCoremini(std::unique_ptr<std::istream>&& stream, Disk::MemoryType memType = Disk::MemoryType::SD);
+
+	virtual std::optional<MemoryAddress> getCoreminiStartAddressFlash() const {
+		return std::nullopt;
+	}
+
+	virtual std::optional<MemoryAddress> getCoreminiStartAddressSD() const {
+		return std::nullopt;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddress(Disk::MemoryType memType) const {
+		switch(memType) {
+			case Disk::MemoryType::Flash:
+				return getCoreminiStartAddressFlash();
+			case Disk::MemoryType::SD:
+				return getCoreminiStartAddressSD();
+			default:
+				break;
+		}
+		return std::nullopt;
+	}
+
 
 	// Message polling related functions
 	bool enableMessagePolling();
@@ -173,6 +199,8 @@ public:
 	virtual size_t getNetworkCountByType(Network::Type) const;
 	virtual Network getNetworkByNumber(Network::Type, size_t) const;
 
+
+
 	/**
 	 * Read from the logical disk in this device, starting from byte `pos`
 	 * and reading up to `amount` bytes.
@@ -188,7 +216,7 @@ public:
 	 * set in icsneo::GetLastError().
 	 */
 	std::optional<uint64_t> readLogicalDisk(uint64_t pos, uint8_t* into, uint64_t amount,
-		std::chrono::milliseconds timeout = Disk::DefaultTimeout);
+		std::chrono::milliseconds timeout = Disk::DefaultTimeout, Disk::MemoryType memType = Disk::MemoryType::SD);
 
 	/**
 	 * Write to the logical disk in this device, starting from byte `pos`
@@ -205,7 +233,7 @@ public:
 	 * set in icsneo::GetLastError().
 	 */
 	std::optional<uint64_t> writeLogicalDisk(uint64_t pos, const uint8_t* from, uint64_t amount,
-		std::chrono::milliseconds timeout = Disk::DefaultTimeout);
+		std::chrono::milliseconds timeout = Disk::DefaultTimeout, Disk::MemoryType memType = Disk::MemoryType::SD);
 
 	/**
 	 * Check if the logical disk is connected. This means the disk is inserted,

include/icsneo/device/tree/etherbadge/etherbadge.h

@@ -45,6 +45,15 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 2048 * 512;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
+
 };
 
 }

include/icsneo/device/tree/neoobd2pro/neoobd2pro.h

@@ -36,6 +36,14 @@ private:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 2048 * 512;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/neoobd2sim/neoobd2sim.h

@@ -36,6 +36,14 @@ private:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 2048 * 512;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/neovifire/neovifire.h

@@ -69,6 +69,14 @@ private:
 
 	// The supported TX networks are the same as the supported RX networks for this device
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 4 * 512;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -129,6 +129,14 @@ protected:
 		ethActivationStatus = status->ethernetActivationLineEnabled;
 		usbHostPowerStatus = status->usbHostPowerEnabled;
 	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 4608 * 512;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/neovifire3/neovifire3.h

@@ -74,6 +74,14 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool supportsWiVI() const override { return true; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 33*1024*1024;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/neovifire3flexray/neovifire3flexray.h

@@ -76,6 +76,14 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool supportsWiVI() const override { return true; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/neovired2/neovired2.h

@@ -59,6 +59,14 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool supportsWiVI() const override { return true; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 33*1024*1024;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -35,6 +35,10 @@ private:
 			1 // 2
 		);
 	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -33,6 +33,10 @@ private:
 			1 // 3
 		);
 	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/rada2b/rada2b.h

@@ -7,6 +7,7 @@
 #include "icsneo/device/devicetype.h"
 #include "icsneo/communication/packetizer.h"
 #include "icsneo/communication/decoder.h"
+#include "icsneo/disk/neomemorydiskdriver.h"
 #include "icsneo/device/tree/rada2b/rada2bsettings.h"
 
 namespace icsneo {
@@ -40,7 +41,7 @@ public:
 
 protected:
 	RADA2B(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
-		initialize<RADA2BSettings>(makeDriver);
+		initialize<RADA2BSettings, Disk::NeoMemoryDiskDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}
 
 	void setupPacketizer(Packetizer& packetizer) override {
@@ -66,6 +67,14 @@ 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); }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 15*1024*1024;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radepsilon/radepsilon.h

@@ -41,6 +41,14 @@ 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); }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 14*1024*1024;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -89,6 +89,14 @@ protected:
 		const radgalaxy_status_t* status = reinterpret_cast<const radgalaxy_status_t*>(message->data.data());
 		ethActivationStatus = status->ethernetActivationLineEnabled;
 	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -98,6 +98,14 @@ protected:
 		const radgigastar_status_t* status = reinterpret_cast<const radgigastar_status_t*>(message->data.data());
 		ethActivationStatus = status->ethernetActivationLineEnabled;
 	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radjupiter/radjupiter.h

@@ -49,6 +49,14 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*2048;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -86,6 +86,14 @@ protected:
 		const radmars_status_t* status = reinterpret_cast<const radmars_status_t*>(message->data.data());
 		ethActivationStatus = status->ethernetActivationLineEnabled;
 	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radmoon2/radmoon2.h

@@ -81,6 +81,14 @@ protected:
 	}
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radmoonduo/radmoonduo.h

@@ -45,6 +45,13 @@ protected:
 
 	bool requiresVehiclePower() const override { return false; }
 
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*2048;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radpluto/radpluto.h

@@ -54,6 +54,14 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*2048;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radstar2/radstar2.h

@@ -57,6 +57,14 @@ 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); }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/radsupermoon/radsupermoon.h

@@ -79,6 +79,14 @@ protected:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/valuecan3/valuecan3.h

@@ -36,6 +36,14 @@ private:
 	void setupSupportedTXNetworks(std::vector<Network>& txNetworks) override { setupSupportedRXNetworks(txNetworks); }
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*2048;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

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

@@ -21,6 +21,14 @@ protected:
 	}
 
 	bool requiresVehiclePower() const override { return false; }
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*2048;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/device/tree/vividcan/vividcan.h

@@ -33,6 +33,14 @@ protected:
 	}
 
 	bool requiresVehiclePower() const override { return false; }
+	
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override {
+		return 512*128;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override {
+		return 0;
+	}
 };
 
 }

include/icsneo/disk/diskdriver.h

@@ -19,6 +19,12 @@ enum class Access {
 	VSA
 };
 
+enum class MemoryType : uint8_t
+{
+	Flash = 0,
+	SD = 1
+};
+
 /**
  * Interface for drivers which work with block data on devices
  */

include/icsneo/disk/diskreaddriver.h

@@ -20,10 +20,10 @@ namespace Disk {
 class ReadDriver : public virtual Driver {
 public:
 	virtual std::optional<uint64_t> readLogicalDisk(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout);
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout, MemoryType memType = MemoryType::SD);
 
 	void invalidateCache(uint64_t pos = 0,
-		uint64_t amount = std::numeric_limits<uint32_t>::max() /* large value, but avoid overflow */);
+		uint64_t amount = std::numeric_limits<uint32_t>::max() /* large value, but avoid overflow */, MemoryType memType = MemoryType::SD);
 
 protected:
 	/**
@@ -33,16 +33,19 @@ protected:
 	 * within the block size bounds provided by the driver.
 	 */
 	virtual std::optional<uint64_t> readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout) = 0;
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) = 0;
 
 private:
-	std::vector<uint8_t> cache;
-	uint64_t cachePos = 0;
+	std::vector<uint8_t> cacheSD;
+	std::vector<uint8_t> cacheEEPROM;
+
+	uint64_t cachePosSD = 0;
+	uint64_t cachePosEEPROM = 0;
 	std::chrono::time_point<std::chrono::steady_clock> cachedAt;
 
 	static constexpr const std::chrono::milliseconds CacheTime = std::chrono::milliseconds(1000);
 
-	std::optional<uint64_t> readFromCache(uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds staleAfter = CacheTime);
+	std::optional<uint64_t> readFromCache(uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds staleAfter = CacheTime, MemoryType memType = MemoryType::SD);
 };
 
 } // namespace Disk

include/icsneo/disk/diskwritedriver.h

@@ -20,7 +20,7 @@ namespace Disk {
 class WriteDriver : public virtual Driver {
 public:
 	virtual std::optional<uint64_t> writeLogicalDisk(Communication& com, device_eventhandler_t report, ReadDriver& readDriver,
-		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout);
+		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout, MemoryType memType = MemoryType::SD);
 
 protected:
 	/**
@@ -30,7 +30,7 @@ protected:
 	 * within the block size bounds provided by the driver.
 	 */
 	virtual std::optional<uint64_t> writeLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout) = 0;
+		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) = 0;
 };
 
 } // namespace Disk

include/icsneo/disk/extextractordiskreaddriver.h

@@ -29,10 +29,10 @@ private:
 	Access getPossibleAccess() const override { return Access::EntireCard; }
 
 	std::optional<uint64_t> readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout) override;
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) override;
 
 	std::optional<uint64_t> attemptReadLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout);
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD);
 };
 
 } // namespace Disk

include/icsneo/disk/neomemorydiskdriver.h

@@ -31,10 +31,10 @@ private:
 	Access getPossibleAccess() const override { return Access::VSA; }
 
 	std::optional<uint64_t> readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout) override;
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) override;
 	
 	std::optional<uint64_t> writeLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout) override;
+		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) override;
 };
 
 } // namespace Disk

include/icsneo/disk/nulldiskdriver.h

@@ -19,9 +19,9 @@ namespace Disk {
 class NullDriver : public ReadDriver, public WriteDriver {
 public:
 	std::optional<uint64_t> readLogicalDisk(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout) override;
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout, MemoryType memType = MemoryType::SD) override;
 	std::optional<uint64_t> writeLogicalDisk(Communication& com, device_eventhandler_t report, ReadDriver& readDriver,
-		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout) override;
+		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout = DefaultTimeout, MemoryType memType = MemoryType::SD) override;
 	std::pair<uint32_t, uint32_t> getBlockSizeBounds() const override {
 		static_assert(SectorSize <= std::numeric_limits<uint32_t>::max(), "Incorrect sector size");
 		static_assert(SectorSize >= std::numeric_limits<uint32_t>::min(), "Incorrect sector size");
@@ -32,9 +32,9 @@ private:
 	Access getPossibleAccess() const override { return Access::None; }
 
 	std::optional<uint64_t> readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout) override;
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) override;
 	std::optional<uint64_t> writeLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout) override;
+		uint64_t pos, const uint8_t* from, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) override;
 };
 
 } // namespace Disk

include/icsneo/disk/plasiondiskreaddriver.h

@@ -28,7 +28,7 @@ private:
 	Access getPossibleAccess() const override { return Access::EntireCard; }
 
 	std::optional<uint64_t> readLogicalDiskAligned(Communication& com, device_eventhandler_t report,
-		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout) override;
+		uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, MemoryType memType = MemoryType::SD) override;
 };
 
 } // namespace Disk