ESP8266 alternatív OTA

Ez a feltöltött cuccot 0x000000 címtól beírja. Ha ez lenne 0x100000 címtől, működhetne?

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP.h>

// WiFi adatok — állítsd be a saját hálózatodra
const char* ssid = "asajah";
const char* pass = "xxxxxxxx";

ESP8266WebServer server(80);

// Cél flash kezdőcím (byte-ban)
const uint32_t FLASH_WRITE_ADDR = 0x200000;
// Flash szektor méret (ESP8266: 4 KB)
const uint32_t SECTOR_SIZE = 4096;

uint32_t currentWriteAddr = FLASH_WRITE_ADDR;
bool *erasedSectors = nullptr;
uint32_t firstSector = 0;
uint32_t erasedSectorCount = 0;

// Ideiglenes puffer a 4-bájtos igazításhoz
#define TMPBUF_SIZE 4096
uint8_t tmpBuf[TMPBUF_SIZE];
uint32_t tmpBufLen = 0;

void ensureSectorErased(uint32_t addr) {
  uint32_t sector = addr / SECTOR_SIZE;
  if (sector < firstSector || sector >= firstSector + erasedSectorCount) return;
  uint32_t idx = sector - firstSector;
  if (!erasedSectors[idx]) {
    Serial.printf("Erase sector %u\n", sector);
    ESP.flashEraseSector((uint16_t)sector);
    erasedSectors[idx] = true;
  }
}

void writeFlashAligned(const uint8_t* data, size_t len) {
  size_t offset = 0;

  // Ha van a tmpBufban adat, előbb azt töltjük fel a teljes 4-bájtos blokkhoz
  if (tmpBufLen > 0) {
    size_t need = 4 - (tmpBufLen % 4);
    if (need > len) need = len;
    memcpy(tmpBuf + tmpBufLen, data, need);
    tmpBufLen += need;
    offset += need;

    if ((tmpBufLen % 4) == 0) {
      // írjuk ki tmpBuf-ot
      ensureSectorErased(currentWriteAddr);
      // ESP.flashWrite vár uint32_t* és méret szavakban (4 bájt)
      ESP.flashWrite(currentWriteAddr, (uint32_t*)tmpBuf, tmpBufLen / 4);
      currentWriteAddr += tmpBufLen;
      tmpBufLen = 0;
    }
  }

  // Most a maradék adatot írjuk szóközönként (4 bájt)
  size_t remain = len - offset;
  size_t fullWords = (remain / 4);
  if (fullWords > 0) {
    size_t byteCount = fullWords * 4;
    // Írás előtt gondoskodunk a szükséges szektor(oka)tól
    uint32_t writeAddr = currentWriteAddr;
    uint32_t endAddr = writeAddr + byteCount;
    // erase szektorok szükség szerint
    uint32_t s = writeAddr / SECTOR_SIZE;
    uint32_t e = (endAddr - 1) / SECTOR_SIZE;
    for (uint32_t sec = s; sec <= e; ++sec) {
      ensureSectorErased(sec * SECTOR_SIZE);
    }
    // végleges írás
    ESP.flashWrite(currentWriteAddr, (uint32_t*)(data + offset), fullWords);
    currentWriteAddr += byteCount;
    offset += byteCount;
  }

  // Végül a maradék (<4 bájt) adatot tmpBufba tesszük
  size_t left = len - offset;
  if (left > 0) {
    memcpy(tmpBuf + tmpBufLen, data + offset, left);
    tmpBufLen += left;
  }
}

void handleUpload() {
  HTTPUpload& upload = server.upload();

  if (upload.status == UPLOAD_FILE_START) {
    Serial.printf("Upload start: %s, size: %u\n", upload.filename.c_str(), (uint)upload.totalSize);

    // Ellenőrizzük a flash méretét
    uint32_t flashSize = ESP.getFlashChipRealSize();
    if (FLASH_WRITE_ADDR >= flashSize) {
      Serial.println("ERROR: write address outside flash!");
      // megszakítás (válasz)
      server.send(500, "text/plain", "Write address outside flash!");
      return;
    }

    // lefoglaljuk a szektor erase állapot tömböt (feltételezzük az upload.totalSize elérhető)
    uint32_t needed = upload.totalSize ? upload.totalSize : (flashSize - FLASH_WRITE_ADDR);
    uint32_t startSec = FLASH_WRITE_ADDR / SECTOR_SIZE;
    uint32_t sectorCount = (needed + SECTOR_SIZE - 1) / SECTOR_SIZE;
    // cap ellenőrzés
    if (FLASH_WRITE_ADDR + needed > flashSize) {
      Serial.println("ERROR: Not enough flash space for file");
      server.send(500, "text/plain", "Not enough flash space for file");
      return;
    }
    firstSector = startSec;
    erasedSectorCount = sectorCount;
    // felszabadítás előző esetben
    if (erasedSectors) free(erasedSectors);
    erasedSectors = (bool*)malloc(sectorCount);
    memset(erasedSectors, 0, sectorCount);

    currentWriteAddr = FLASH_WRITE_ADDR;
    tmpBufLen = 0;

    Serial.printf("Will write to 0x%06X, sectors %u..%u\n", FLASH_WRITE_ADDR, (unsigned)startSec, (unsigned)(startSec + sectorCount - 1));
  } 
  else if (upload.status == UPLOAD_FILE_WRITE) {
    // upload.buf és upload.currentSize áll rendelkezésre
    writeFlashAligned((const uint8_t*)upload.buf, upload.currentSize);
    Serial.printf("Wrote chunk %u bytes, total written so far ~%u\n", (unsigned)upload.currentSize, (unsigned)(currentWriteAddr - FLASH_WRITE_ADDR));
  } 
  else if (upload.status == UPLOAD_FILE_END) {
    // maradék padding: padoljunk 0xFF-el a 4-byte határig (flash erased állapot 0xFF)
    if (tmpBufLen > 0) {
      // pad 0xFF
      while ((tmpBufLen % 4) != 0 && tmpBufLen < TMPBUF_SIZE) {
        tmpBuf[tmpBufLen++] = 0xFF;
      }
      if (tmpBufLen % 4 == 0) {
        ensureSectorErased(currentWriteAddr);
        ESP.flashWrite(currentWriteAddr, (uint32_t*)tmpBuf, tmpBufLen / 4);
        currentWriteAddr += tmpBufLen;
      }
      tmpBufLen = 0;
    }

    Serial.printf("Upload END: %s, total written: %u bytes\n", upload.filename.c_str(), (unsigned)(currentWriteAddr - FLASH_WRITE_ADDR));
    server.send(200, "text/plain", "Upload successful");
    // felszabadítjuk az erase tömböt
    if (erasedSectors) { free(erasedSectors); erasedSectors = nullptr; }
  }
}

void setup() {
  Serial.begin(57600);
  delay(100);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, pass);
  Serial.printf("Connecting to WiFi '%s' ...\n", ssid);
  while (WiFi.status() != WL_CONNECTED) {
    delay(200);
    Serial.print('.');
  }
  Serial.println();
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());

  server.on("/", HTTP_GET, [](){
    String html = "<html><body><form method='POST' action='/upload' enctype='multipart/form-data'>"
                  "<input type='file' name='file'>"
                  "<input type='submit' value='Upload'>"
                  "</form></body></html>";
    server.send(200, "text/html", html);
  });

  // feltöltés végpont: két callback verziója (on() harmadik paraméterként a befejező callback)
  server.on("/upload", HTTP_POST, [](){
    // normál befejező válasz csak itt, de az upload callback küldi vissza a végső státuszt.
    // Üres. A valós választ az upload státuszban küldjük.
  }, handleUpload);

  server.begin();
  Serial.println("HTTP server started");
}

void loop() {
  server.handleClient();
}