Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

add eeprom methods for the spi service

Geo16bc06b127b3
diff --git a/src/Services/SpiService.cpp b/src/Services/SpiService.cpp
index 522ba3a8..8eafa417 100644
--- a/src/Services/SpiService.cpp
+++ b/src/Services/SpiService.cpp
@@ -74,8 +74,8 @@ void SpiService::readFlashData(uint32_t address, uint8_t* buffer, size_t length)
endTransaction();
}
-void SpiService::eraseSector(uint32_t address, uint32_t freq) {
- enableWrite(freq); // 0x06
+void SpiService::eraseFlashSector(uint32_t address, uint32_t freq) {
+ enableFlashWrite(freq); // 0x06
SPI.beginTransaction(SPISettings(freq, MSBFIRST, SPI_MODE0));
digitalWrite(csPin, LOW);
@@ -88,10 +88,10 @@ void SpiService::eraseSector(uint32_t address, uint32_t freq) {
digitalWrite(csPin, HIGH);
SPI.endTransaction();
- waitForWriteComplete(freq);
+ waitForFlashWriteComplete(freq);
}
-void SpiService::enableWrite(uint32_t freq) {
+void SpiService::enableFlashWrite(uint32_t freq) {
SPI.beginTransaction(SPISettings(freq, MSBFIRST, SPI_MODE0));
digitalWrite(csPin, LOW);
@@ -102,7 +102,7 @@ void SpiService::enableWrite(uint32_t freq) {
SPI.endTransaction();
}
-void SpiService::waitForWriteComplete(uint32_t freq) {
+void SpiService::waitForFlashWriteComplete(uint32_t freq) {
SPI.beginTransaction(SPISettings(freq, MSBFIRST, SPI_MODE0));
digitalWrite(csPin, LOW);
@@ -124,7 +124,7 @@ void SpiService::writeFlashPage(uint32_t address, const std::vector<uint8_t>& da
while (offset < data.size()) {
size_t chunkSize = std::min(maxPerPage, data.size() - offset);
- enableWrite(freq);
+ enableFlashWrite(freq);
SPI.beginTransaction(SPISettings(freq, MSBFIRST, SPI_MODE0));
digitalWrite(csPin, LOW);
@@ -141,7 +141,7 @@ void SpiService::writeFlashPage(uint32_t address, const std::vector<uint8_t>& da
digitalWrite(csPin, HIGH);
SPI.endTransaction();
- waitForWriteComplete(freq);
+ waitForFlashWriteComplete(freq);
address += chunkSize;
offset += chunkSize;
@@ -165,7 +165,7 @@ void SpiService::writeFlashPatch(uint32_t address, const std::vector<uint8_t>& d
}
// Erase the sector
- eraseSector(sectorStart, freq);
+ eraseFlashSector(sectorStart, freq);
// Write modified data
for (uint32_t i = 0; i < sectorSize; i += 256) {
@@ -297,4 +297,113 @@ std::vector<std::vector<uint8_t>> SpiService::getSlaveData() {
std::vector<std::vector<uint8_t>> data(slaveBuffer.begin(), slaveBuffer.end());
slaveBuffer.clear();
return data;
-}
\ No newline at end of file
+}
+
+// #### EEPROM ######
+
+bool SpiService::initEeprom(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t cs, uint16_t pageSize, uint32_t memSize, uint8_t wp) {
+ if (eepromInitialized) return true;
+ SPI.end();
+ csPin = cs;
+
+ // Init eeprom
+ eeprom = EEPROM_SPI_WE(csPin);
+ if (!eeprom.init(sclk, miso, mosi, cs, wp)) return false;
+
+ // Size
+ eeprom.setMemorySize((eeprom_size_t)memSize);
+ eeprom.setPageSize(
+ pageSize == 16 ? EEPROM_PAGE_SIZE_16 :
+ pageSize == 32 ? EEPROM_PAGE_SIZE_32 :
+ pageSize == 64 ? EEPROM_PAGE_SIZE_64 :
+ pageSize == 128 ? EEPROM_PAGE_SIZE_128 :
+ EEPROM_PAGE_SIZE_256
+ );
+
+ eepromInitialized = true;
+ return true;
+}
+
+bool SpiService::writeEeprom(uint32_t address, uint8_t value) {
+ if (!eepromInitialized) return false;
+ eeprom.write(address, value);
+ return true;
+}
+
+uint8_t SpiService::readEeprom(uint32_t address) {
+ if (!eepromInitialized) return 0xFF;
+ return eeprom.read(address);
+}
+
+bool SpiService::writeEepromBuffer(uint32_t address, const uint8_t* data, size_t len) {
+ if (!eepromInitialized) return false;
+ for (size_t i = 0; i < len; ++i) {
+ eeprom.write(address + i, data[i]);
+ }
+ return true;
+}
+
+bool SpiService::readEepromBuffer(uint32_t address, uint8_t* buffer, size_t len) {
+ if (!eepromInitialized) return false;
+ for (size_t i = 0; i < len; ++i) {
+ buffer[i] = eeprom.read(address + i);
+ }
+ return true;
+}
+
+bool SpiService::writeEepromInt(uint32_t address, int32_t value) {
+ if (!eepromInitialized) return false;
+ eeprom.put(address, value);
+ return true;
+}
+
+int32_t SpiService::readEepromInt(uint32_t address) {
+ if (!eepromInitialized) return 0;
+ int32_t value = 0;
+ eeprom.get(address, value);
+ return value;
+}
+
+bool SpiService::writeEepromFloat(uint32_t address, float value) {
+ if (!eepromInitialized) return false;
+ eeprom.put(address, value);
+ return true;
+}
+
+float SpiService::readEepromFloat(uint32_t address) {
+ if (!eepromInitialized) return 0.0f;
+ float value = 0.0f;
+ eeprom.get(address, value);
+ return value;
+}
+
+bool SpiService::writeEepromString(uint32_t address, const std::string& str) {
+ if (!eepromInitialized) return false;
+ String arduinoStr = String(str.c_str());
+ eeprom.putString(address, arduinoStr);
+ return true;
+}
+
+bool SpiService::readEepromString(uint32_t address, std::string& str) {
+ if (!eepromInitialized) return false;
+ String arduinoStr = String(str.c_str());
+ eeprom.getString(address, arduinoStr);
+ return true;
+}
+
+void SpiService::eraseEepromChip() {
+ if (eepromInitialized) eeprom.eraseCompleteEEPROM();
+}
+
+void SpiService::eraseEepromSector(uint32_t address) {
+ if (eepromInitialized) eeprom.eraseSector(address);
+}
+
+void SpiService::eraseEepromPage(uint32_t address) {
+ if (eepromInitialized) eeprom.erasePage(address);
+}
+
+void SpiService::closeEeprom() {
+ eepromInitialized = false;
+ eeprom = EEPROM_SPI_WE();
+}
diff --git a/src/Services/SpiService.h b/src/Services/SpiService.h
index a9319d9b..9afc4944 100644
--- a/src/Services/SpiService.h
+++ b/src/Services/SpiService.h
@@ -1,38 +1,52 @@
#pragma once
#include <vector>
+#include <atomic>
+#include <deque>
+#include <mutex>
#include <Arduino.h>
+#include <EEPROM_SPI_WE.h>
#include <SPI.h>
#include <Data/FlashDatabase.h>
#include <Models/ByteCode.h>
-#include <atomic>
-#include <deque>
-#include <mutex>
class SpiService {
public:
+ // Base
void configure(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t cs, uint32_t frequency = 1000000);
void end();
-
void beginTransaction();
void endTransaction();
+ uint8_t transfer(uint8_t data);
// Flash
- uint8_t transfer(uint8_t data);
std::string readFlashID();
void readFlashIdRaw(uint8_t* buffer);
void readFlashData(uint32_t address, uint8_t* buffer, size_t length);
uint32_t calculateFlashCapacity(uint8_t code);
- void eraseSector(uint32_t address, uint32_t freq);
- void enableWrite(uint32_t freq);
- void waitForWriteComplete(uint32_t freq);
-
- // Write page
+ void eraseFlashSector(uint32_t address, uint32_t freq);
+ void enableFlashWrite(uint32_t freq);
+ void waitForFlashWriteComplete(uint32_t freq);
void writeFlashPage(uint32_t address, const std::vector<uint8_t>& data, uint32_t freq);
-
- // Write patch, we save a sector data, modify data, erase sector, write modified data to sector
void writeFlashPatch(uint32_t address, const std::vector<uint8_t>& data, uint32_t freq);
+ // EEPROM
+ bool initEeprom(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t cs, uint16_t pageSize, uint32_t memSize, uint8_t wp=255);
+ bool writeEeprom(uint32_t address, uint8_t value);
+ uint8_t readEeprom(uint32_t address);
+ bool writeEepromBuffer(uint32_t address, const uint8_t* data, size_t len);
+ bool readEepromBuffer(uint32_t address, uint8_t* buffer, size_t len);
+ bool writeEepromInt(uint32_t address, int32_t value);
+ int32_t readEepromInt(uint32_t address);
+ bool writeEepromFloat(uint32_t address, float value);
+ float readEepromFloat(uint32_t address);
+ bool writeEepromString(uint32_t address, const std::string& str);
+ bool readEepromString(uint32_t address, std::string& str);
+ void eraseEepromChip();
+ void eraseEepromSector(uint32_t address);
+ void eraseEepromPage(uint32_t address);
+ void closeEeprom();
+
// Slave
void startSlave(int sclk, int miso, int mosi, int cs);
void stopSlave(int sclk, int miso, int mosi, int cs);
@@ -45,4 +59,8 @@ private:
uint8_t csPin;
uint32_t spiFrequency = 1000000;
bool slaveConfigured = false;
+ EEPROM_SPI_WE eeprom;
+ bool eepromInitialized = false;
};
+
+