ESP8266 alternatív OTA

Eddig jutottam:

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

// Fix: Konfliktus elkerülésére manuálisan definiáljuk a sikeres visszatérési értéket
#define SPI_FLASH_RESULT_OK 0

// --- KÖZÖS DEFINÍCIÓK ÉS BEÁLLÍTÁSOK ---
#define STAGER_SRAM_BUF   0x3ffe8000 // SRAM puffer

// WiFi adatok — ÁLLÍTSA BE A SAJÁT ADATAIRA! 🔑
const char* ssid = "asajah";
const char* pass = "xxxxxxxx";

// A feltöltött bináris adatai
const uint32_t FLASH_WRITE_ADDR = 0x200000;
const uint32_t SECTOR_SIZE = 4096;
const uint32_t COPY_SIZE = 865488U; // EspOS_v508_4MB_Lite.bin mérete

// Globális változók a feltöltéshez
ESP8266WebServer server(80);
uint32_t currentWriteAddr = FLASH_WRITE_ADDR;
bool *erasedSectors = nullptr;
uint32_t firstSector = 0;
uint32_t erasedSectorCount = 0;
#define TMPBUF_SIZE 4096
uint8_t tmpBuf[TMPBUF_SIZE];
uint32_t tmpBufLen = 0;

// --- FÜGGVÉNY PROTOTÍPUSOK ---
void handleUpload();
void uploadBootloaderFromArray();
void ensureSectorErased(uint32_t addr);
void writeFlashAligned(const uint8_t* data, size_t len);

// --- ROM/ALACSONY SZINTŰ DEKLARÁCIÓK ---
extern "C" {
  // Megszakításkezelés
  extern void ets_intr_lock(void);
  extern void ets_intr_unlock(void);
  
  // Flash I/O rutinok (int visszatérési típussal, ahogy az IRAM másolónknak kell)
  extern int spi_flash_read(uint32_t src_addr, void *dest, uint32_t size);
  extern int spi_flash_write(uint32_t dest_addr, const void *src, uint32_t size);
  extern int spi_flash_erase_sector(uint32_t sec);
}


// =================================================================
// KRITIKUS IRAM FUNKCIÓ: A TISZTA ROM MÁSOLÓ
// =================================================================
// Ez a függvény az IRAM-ban fut, és a ROM I/O hívásokkal másolja a firmware-t.
void __attribute__((section(".iram.text"))) copyAndHalt() __attribute__((noreturn));

void __attribute__((section(".iram.text"))) copyAndHalt() {
    
    const uint32_t COPY_SRC = FLASH_WRITE_ADDR; 
    const uint32_t COPY_DST = 0x000000U;        
    
    uint8_t *buf = (uint8_t*)STAGER_SRAM_BUF;
    
    uint32_t remaining = COPY_SIZE;
    uint32_t src = COPY_SRC;
    uint32_t dst = COPY_DST;
    
    ets_intr_lock();
    
    while (remaining > 0) {
        uint32_t this_chunk = (remaining >= SECTOR_SIZE) ? SECTOR_SIZE : remaining;
        uint32_t sector_to_erase = (dst) / SECTOR_SIZE;
        
        if (spi_flash_read(src, buf, this_chunk) != SPI_FLASH_RESULT_OK) {
            ets_intr_unlock();
            while (1); 
        }
        
        if (spi_flash_erase_sector(sector_to_erase) != SPI_FLASH_RESULT_OK) {
            ets_intr_unlock();
            while (1); 
        }
        
        if (spi_flash_write(dst, buf, this_chunk) != SPI_FLASH_RESULT_OK) {
            ets_intr_unlock();
            while (1); 
        }
        
        src += this_chunk;
        dst += this_chunk;
        remaining -= this_chunk;
    }
    
    ets_intr_unlock();
    
    while(1); 
}
// ------------------------------------------

// =================================================================
// WEBSERVER ÉS MÁSOLÁS INDÍTÁSA
// =================================================================
void uploadBootloaderFromArray() {
    Serial.println("RAW STAGER Write OK. Starting IRAM copy of uploaded firmware...");

    // Flash cache kikapcsolása a másolás előtt
    WiFi.disconnect(true);
    WiFi.mode(WIFI_OFF);
    delay(50);
    noInterrupts();
    wdt_disable();
    
    copyAndHalt();
    
    while(1);
}

// =================================================================
// FLASH ÍRÁS SEGÉDFÜGGVÉNYEK
// =================================================================
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 (ESP.flashEraseSector)\n", sector);
        wdt_disable(); 
        ESP.flashEraseSector((uint16_t)sector); 
        wdt_enable(WDTO_8S); 
        erasedSectors[idx] = true;
    }
}

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

    // 1. Puffer feltöltése / Igazítás (tmpBuf)
    if (tmpBufLen > 0) {
        size_t copyLen = min(len, (size_t)TMPBUF_SIZE - tmpBufLen);
        memcpy(tmpBuf + tmpBufLen, data + offset, copyLen);
        tmpBufLen += copyLen;
        offset += copyLen;
        
        if (tmpBufLen == TMPBUF_SIZE) { // Ha a puffer megtelt (4-gyel osztható)
            ensureSectorErased(currentWriteAddr);
            noInterrupts(); wdt_disable();
            ESP.flashWrite(currentWriteAddr, (uint32_t*)tmpBuf, TMPBUF_SIZE / 4);
            wdt_enable(WDTO_8S); interrupts();
            currentWriteAddr += TMPBUF_SIZE;
            tmpBufLen = 0;
        }
    }

    // 2. Igazított darabok írása
    size_t remain = len - offset;
    size_t fullWords = (remain / 4);
    if (fullWords > 0) {
        size_t byteCount = fullWords * 4;
        uint32_t endAddr = currentWriteAddr + byteCount;
        uint32_t s = currentWriteAddr / SECTOR_SIZE;
        uint32_t e = (endAddr - 1) / SECTOR_SIZE;
        for (uint32_t sec = s; sec <= e; ++sec) {
            ensureSectorErased(sec * SECTOR_SIZE);
        }
        noInterrupts();
        wdt_disable();
        ESP.flashWrite(currentWriteAddr, (uint32_t*)(data + offset), fullWords);
        wdt_enable(WDTO_8S);
        interrupts();
        currentWriteAddr += byteCount;
        offset += byteCount;
    }

    // 3. Maradék mentése
    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) {
    if (erasedSectors) { free(erasedSectors); erasedSectors = nullptr; }
    uint32_t sectorCount = (upload.totalSize + SECTOR_SIZE - 1) / SECTOR_SIZE;
    erasedSectors = (bool*)malloc(sectorCount);
    memset(erasedSectors, 0, sectorCount);
    firstSector = FLASH_WRITE_ADDR / SECTOR_SIZE;
    erasedSectorCount = sectorCount;
    currentWriteAddr = FLASH_WRITE_ADDR;
    tmpBufLen = 0;
    Serial.printf("Upload start: %s, size: %u\n", upload.filename.c_str(), (unsigned)upload.totalSize);
  } 
  else if (upload.status == UPLOAD_FILE_WRITE) {
    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) {
    if (tmpBufLen > 0) {
      // Puffer maradék kiírása, zárás 4-gyel osztható méretre
      while ((tmpBufLen % 4) != 0 && tmpBufLen < TMPBUF_SIZE) { tmpBuf[tmpBufLen++] = 0xFF; }
      if (tmpBufLen % 4 == 0) {
        ensureSectorErased(currentWriteAddr);
        noInterrupts(); wdt_disable();
        ESP.flashWrite(currentWriteAddr, (uint32_t*)tmpBuf, tmpBufLen / 4);
        wdt_enable(WDTO_8S); interrupts();
        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 (Initiating copy...)");
    if (erasedSectors) { free(erasedSectors); erasedSectors = nullptr; }

    uploadBootloaderFromArray(); // INDÍTÁS!
  }
}

// =================================================================
// SETUP ÉS LOOP
// =================================================================
void setup() {
    Serial.begin(74880);
    delay(100);
    
    // FIGYELEM: A Flash Mode (DOUT) beállítását az Arduino IDE Eszközök menüjében kell hagyni!
    // A rom_set_flash_mode hívás nélkül ez a kód már lefordul.
    
    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('.');
        yield();
    }
    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);
    });

    server.on("/upload", HTTP_POST, [](){
        // Ez a függvény a feltöltés állapotának kezeléséhez kell (handleUpload hívja)
    }, handleUpload); // Most már deklarálva van!

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

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

Eredmény: 

11:20:05.448 -> Upload END: EspOS_v508_4MB_Lite.bin, total written: 865488 bytes
11:20:05.448 -> RAW STAGER Write OK. Starting IRAM copy of uploaded firmware...
11:20:16.790 -> "@1Q|⸮!⸮@⸮КvX%⸮~⸮h⸮sI    ⸮8t/⸮⸮⸮*1T⸮1    ⸮⸮⸮QQ@⸮y*1⸮"⸮nZAl ⸮^1⸮!⸮q⸮tt⸮⸮,⸮D     5⸮*1⸮⸮
11:20:32.746 ->  ets Jan  8 2013,rst cause:2, boot mode:(3,7)
11:20:32.746 -> 
11:20:32.746 -> load 0x4010f000, len 3424, room 16 
11:20:32.792 -> tail 0
11:20:32.792 -> chksum 0xbe
11:20:32.792 -> load 0xffffffff, len -1, room 8 

Volt egy másik ötlet is hogy írok egy saját bootloadert, ami 0x20000-0x2FFFFF tartományt átmásolja 0x000000-0x0FFFFF területre, de az se sikerült.