docs: update changelog for version 1.2.92

fix: correct version number in HTML files and platformio.ini to v1.2.76
enhance: streamline OTA update handling by removing unnecessary magic byte checks

.github/workflows/providers/gitea-release.yml

@@ -30,33 +30,56 @@ jobs:
     - name: Install PlatformIO
       run: |
         python -m pip install --upgrade pip
-        pip install --upgrade platformio
+        pip install --upgrade platformio esptool
+    
+    - name: Install xxd
+      run: |
+        sudo apt-get update
+        sudo apt-get install xxd
     
     - name: Build Firmware
       run: |
-        pio run -t buildfs  # Build SPIFFS
-        pio run            # Build firmware
+        pio run -e esp32dev -t buildfs  # Build SPIFFS
+        pio run -e esp32dev            # Build firmware
+        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/filaman.bin
+        cp .pio/build/esp32dev/spiffs.bin .pio/build/esp32dev/filaman_spiffs.bin
         
-    - name: Install esptool
+    - name: Prepare binaries
       run: |
-        pip install esptool
+        # Ensure we're in the project root
+        cd $GITHUB_WORKSPACE
         
-    - name: Merge firmware and SPIFFS
-      run: |
+        # Create SPIFFS directory if it doesn't exist
+        mkdir -p .pio/build/esp32dev/spiffs
+        
+        # Copy firmware to SPIFFS directory
+        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/spiffs/firmware.bin
+        
+        # Build new SPIFFS image with firmware included
+        pio run -t buildfs
+        
+        cd .pio/build/esp32dev
+        
+        # Create release files
+        cp spiffs.bin filaman_spiffs.bin
+        
+        # Create full binary
+        echo "Creating full binary..."
         esptool.py --chip esp32 merge_bin \
+          --fill-flash-size 4MB \
           --flash_mode dio \
           --flash_freq 40m \
           --flash_size 4MB \
-          -o .pio/build/esp32dev/filaman_full.bin \
-          0x1000 .pio/build/esp32dev/bootloader.bin \
-          0x8000 .pio/build/esp32dev/partitions.bin \
-          0x10000 .pio/build/esp32dev/firmware.bin \
-          0x3D0000 .pio/build/esp32dev/spiffs.bin
-
-    - name: Prepare OTA firmware
-      run: |
-        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/filaman_ota.bin
-    
+          -o filaman_full.bin \
+          0x0000 bootloader.bin \
+          0x8000 partitions.bin \
+          0x10000 firmware.bin \
+          0x390000 spiffs.bin
+        
+        # Verify file sizes
+        echo "File sizes:"
+        ls -lh *.bin
+        
     - name: Create Release
       env:
         TOKEN: ${{ secrets.GITEA_TOKEN }}
@@ -84,14 +107,20 @@ jobs:
           
           # Upload binaries
           cd .pio/build/esp32dev
-          for file in filaman_full.bin filaman_ota.bin; do
-            echo "Uploading $file..."
-            curl -k -s \
-              -X POST \
-              -H "Authorization: token ${TOKEN}" \
-              -H "Content-Type: application/octet-stream" \
-              --data-binary "@$file" \
-              "${API_URL}/repos/${REPO}/releases/${RELEASE_ID}/assets?name=$file"
+          
+          # Check if files exist before uploading
+          for file in filaman_spiffs.bin filaman_full.bin; do
+            if [ -f "$file" ]; then
+              echo "Uploading $file..."
+              curl -k -s \
+                -X POST \
+                -H "Authorization: token ${TOKEN}" \
+                -H "Content-Type: application/octet-stream" \
+                --data-binary "@$file" \
+                "${API_URL}/repos/${REPO}/releases/${RELEASE_ID}/assets?name=$file"
+            else
+              echo "Warning: $file not found"
+            fi
           done
         else
           echo "Failed to create release. Response:"

.github/workflows/providers/github-release.yml

@@ -19,32 +19,55 @@ jobs:
     - name: Install PlatformIO
       run: |
         python -m pip install --upgrade pip
-        pip install --upgrade platformio
+        pip install --upgrade platformio esptool
+    
+    - name: Install xxd
+      run: |
+        sudo apt-get update
+        sudo apt-get install xxd
     
     - name: Build Firmware
       run: |
-        pio run -t buildfs  # Build SPIFFS
-        pio run            # Build firmware
+        pio run -e esp32dev -t buildfs  # Build SPIFFS
+        pio run -e esp32dev            # Build firmware
+        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/filaman.bin
+        cp .pio/build/esp32dev/spiffs.bin .pio/build/esp32dev/filaman_spiffs.bin
         
-    - name: Install esptool
+    - name: Prepare binaries
       run: |
-        pip install esptool
+        # Ensure we're in the project root
+        cd $GITHUB_WORKSPACE
         
-    - name: Merge firmware and SPIFFS
-      run: |
+        # Create SPIFFS directory if it doesn't exist
+        mkdir -p .pio/build/esp32dev/spiffs
+        
+        # Copy firmware to SPIFFS directory
+        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/spiffs/firmware.bin
+        
+        # Build new SPIFFS image with firmware included
+        pio run -t buildfs
+        
+        cd .pio/build/esp32dev
+        
+        # Create release files
+        cp spiffs.bin filaman_spiffs.bin
+        
+        # Create full binary
+        echo "Creating full binary..."
         esptool.py --chip esp32 merge_bin \
+          --fill-flash-size 4MB \
           --flash_mode dio \
           --flash_freq 40m \
           --flash_size 4MB \
-          -o .pio/build/esp32dev/filaman_full.bin \
-          0x1000 .pio/build/esp32dev/bootloader.bin \
-          0x8000 .pio/build/esp32dev/partitions.bin \
-          0x10000 .pio/build/esp32dev/firmware.bin \
-          0x3D0000 .pio/build/esp32dev/spiffs.bin
-
-    - name: Prepare OTA firmware
-      run: |
-        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/filaman_ota.bin
+          -o filaman_full.bin \
+          0x0000 bootloader.bin \
+          0x8000 partitions.bin \
+          0x10000 firmware.bin \
+          0x390000 spiffs.bin
+        
+        # Verify file sizes
+        echo "File sizes:"
+        ls -lh *.bin
     
     - name: Get version from tag
       id: get_version
@@ -64,8 +87,23 @@ jobs:
       env:
         GH_TOKEN: ${{ github.token }}
       run: |
-        gh release create "${{ github.ref_name }}" \
-          --title "Release ${{ steps.get_version.outputs.VERSION }}" \
-          --notes "${{ steps.changelog.outputs.CHANGES }}" \
-          .pio/build/esp32dev/filaman_full.bin \
-          .pio/build/esp32dev/filaman_ota.bin
+        # Check which files exist and create a list for upload
+        cd .pio/build/esp32dev
+        FILES_TO_UPLOAD=""
+        for file in filaman_spiffs.bin filaman_full.bin; do
+          if [ -f "$file" ]; then
+            FILES_TO_UPLOAD="$FILES_TO_UPLOAD .pio/build/esp32dev/$file"
+          else
+            echo "Warning: $file not found"
+          fi
+        done
+        
+        # Create release with available files
+        if [ -n "$FILES_TO_UPLOAD" ]; then
+          gh release create "${{ github.ref_name }}" \
+            --title "Release ${{ steps.get_version.outputs.VERSION }}" \
+            --notes "${{ steps.changelog.outputs.CHANGES }}" \
+            $FILES_TO_UPLOAD
+        else
+          echo "Error: No files found to upload"
+          exit 1

CHANGELOG.md

@@ -1,5 +1,113 @@
 # Changelog
 
+## [1.2.92] - 2025-02-21
+### Added
+- enhance OTA upload handling with chunk validation and timeout checks
+
+### Changed
+- update webpages for version v1.2.92
+
+
+## [1.2.91] - 2025-02-20
+### Added
+- add file existence checks before uploading binaries in release workflows
+
+### Changed
+- update webpages for version v1.2.91
+
+
+## [1.2.90] - 2025-02-20
+### Changed
+- update webpages for version v1.2.90
+- update Gitea and GitHub release workflows to include SPIFFS directory creation and firmware copying
+
+
+## [1.2.89] - 2025-02-20
+### Changed
+- update webpages for version v1.2.89
+- enhance OTA update process with SPIFFS support and improved error handling
+
+
+## [1.2.88] - 2025-02-20
+### Changed
+- update webpages for version v1.2.88
+
+### Fixed
+- improve OTA update handling and logging for better error reporting
+
+
+## [1.2.87] - 2025-02-20
+### Changed
+- update webpages for version v1.2.87
+
+### Fixed
+- update firmware build process and remove unused OTA environment
+
+
+## [1.2.86] - 2025-02-20
+### Changed
+- update webpages for version v1.2.86
+
+### Fixed
+- update SPIFFS offset and size in release workflows and partitions.csv
+
+
+## [1.2.85] - 2025-02-20
+### Added
+- ci: streamline release workflows by removing unnecessary binary uploads and adding SPIFFS formatting
+
+### Changed
+- update webpages for version v1.2.85
+
+
+## [1.2.84] - 2025-02-20
+### Changed
+- update webpages for version v1.2.84
+- ci: update installation steps for xxd to include package list update
+
+
+## [1.2.83] - 2025-02-20
+### Changed
+- update webpages for version v1.2.83
+- replace hexdump with xxd for magic byte verification in release workflows
+
+
+## [1.2.82] - 2025-02-20
+### Changed
+- update webpages for version v1.2.82
+- enhance Gitea and GitHub release workflows to include magic byte handling and improve binary verification
+
+
+## [1.2.81] - 2025-02-20
+### Changed
+- update webpages for version v1.2.81
+- update Gitea and GitHub release workflows to use esp32dev_ota for building and uploading firmware and SPIFFS binaries
+
+
+## [1.2.80] - 2025-02-20
+### Added
+- update Gitea and GitHub release workflows to include new firmware and SPIFFS binaries; fix version display in HTML files to v1.2.78
+
+### Changed
+- update webpages for version v1.2.80
+- bump version to 1.2.79 in platformio.ini
+
+
+## [1.2.79] - 2025-02-20
+### Changed
+- update webpages for version v1.2.79
+- simplify Gitea release workflow by using esptool for binary creation
+
+
+## [1.2.78] - 2025-02-20
+### Changed
+- update webpages for version v1.2.78
+- streamline Gitea release workflow and update version to 1.2.77
+
+### Fixed
+- update Gitea and GitHub release workflows to improve binary preparation and verification fix: correct version number in HTML files and platformio.ini to v1.2.76 enhance: streamline OTA update handling by removing unnecessary magic byte checks
+
+
 ## [1.2.77] - 2025-02-20
 ### Changed
 - optimize Gitea release workflow by simplifying build steps and improving file handling

html/header.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

html/index.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

html/rfid.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

html/spoolman.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

html/upgrade.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>
@@ -64,6 +64,22 @@
             statusContainer.style.display = 'none';
         }
 
+        // Größenbeschränkung für Upload
+        const MAX_FILE_SIZE = 4000000; // 4MB
+
+        async function checkMagicByte(file) {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    const arr = new Uint8Array(reader.result);
+                    // Prüfe auf Magic Byte 0xE9 für ESP32 Firmware
+                    resolve(arr[0] === 0xE9);
+                };
+                reader.onerror = () => reject(reader.error);
+                reader.readAsArrayBuffer(file.slice(0, 1));
+            });
+        }
+
         document.getElementById('updateForm').addEventListener('submit', async (e) => {
             e.preventDefault();
             const form = e.target;
@@ -73,8 +89,25 @@
                 return;
             }
 
-            const formData = new FormData();
-            formData.append('update', file);
+            if (file.size > MAX_FILE_SIZE) {
+                alert('File too large. Maximum size is 4MB.');
+                return;
+            }
+
+            // Prüfe Magic Byte für normale Firmware-Dateien
+            if (!file.name.endsWith('_spiffs.bin')) {
+                try {
+                    const isValidFirmware = await checkMagicByte(file);
+                    if (!isValidFirmware) {
+                        alert('Invalid firmware file. Missing ESP32 magic byte.');
+                        return;
+                    }
+                } catch (error) {
+                    console.error('Error checking magic byte:', error);
+                    alert('Could not verify firmware file.');
+                    return;
+                }
+            }
 
             const progress = document.querySelector('.progress-bar');
             const progressContainer = document.querySelector('.progress-container');
@@ -85,69 +118,74 @@
             status.className = 'status';
             form.querySelector('input[type=submit]').disabled = true;
 
-            const xhr = new XMLHttpRequest();
-            xhr.open('POST', '/update', true);
+            // Chunk-basierter Upload mit Retry-Logik
+            const chunkSize = 8192; // Optimale Chunk-Größe
+            const maxRetries = 3;
+            let offset = 0;
 
-            xhr.upload.onprogress = (e) => {
-                if (e.lengthComputable) {
-                    const percentComplete = (e.loaded / e.total) * 100;
+            async function uploadChunk(chunk, retryCount = 0) {
+                try {
+                    const response = await fetch('/update', {
+                        method: 'POST',
+                        body: chunk,
+                        headers: {
+                            'Content-Type': 'application/octet-stream',
+                            'X-File-Name': file.name,
+                            'X-Chunk-Offset': offset.toString(),
+                            'X-Chunk-Size': chunk.size.toString(),
+                            'X-Total-Size': file.size.toString()
+                        },
+                        timeout: 30000 // 30 Sekunden Timeout
+                    });
+
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        throw new Error(errorText || response.statusText);
+                    }
+
+                    return true;
+                } catch (error) {
+                    console.error(`Chunk upload failed (attempt ${retryCount + 1}):`, error);
+                    if (retryCount < maxRetries) {
+                        await new Promise(resolve => setTimeout(resolve, 1000)); // Warte 1 Sekunde vor Retry
+                        return uploadChunk(chunk, retryCount + 1);
+                    }
+                    throw error;
+                }
+            }
+
+            try {
+                while (offset < file.size) {
+                    const end = Math.min(offset + chunkSize, file.size);
+                    const chunk = file.slice(offset, end);
+                    
+                    await uploadChunk(chunk);
+                    
+                    offset = end;
+                    const percentComplete = (offset / file.size) * 100;
                     progress.style.width = percentComplete + '%';
                     progress.textContent = Math.round(percentComplete) + '%';
-                }
-            };
-
-            xhr.onload = function() {
-                try {
-                    let response = this.responseText;
-                    try {
-                        const jsonResponse = JSON.parse(response);
-                        response = jsonResponse.message;
-                        
-                        if (jsonResponse.restart) {
-                            status.textContent = response + " Redirecting in 20 seconds...";
-                            let countdown = 20;
-                            const timer = setInterval(() => {
-                                countdown--;
-                                if (countdown <= 0) {
-                                    clearInterval(timer);
-                                    window.location.href = '/';
-                                } else {
-                                    status.textContent = response + ` Redirecting in ${countdown} seconds...`;
-                                }
-                            }, 1000);
-                        }
-                    } catch (e) {
-                        if (!isNaN(response)) {
-                            const percent = parseInt(response);
-                            progress.style.width = percent + '%';
-                            progress.textContent = percent + '%';
-                            return;
-                        }
-                    }
                     
-                    status.textContent = response;
-                    status.classList.add(xhr.status === 200 ? 'success' : 'error');
-                    status.style.display = 'block';
-                    
-                    if (xhr.status !== 200) {
-                        form.querySelector('input[type=submit]').disabled = false;
-                    }
-                } catch (error) {
-                    status.textContent = 'Error: ' + error.message;
-                    status.classList.add('error');
-                    status.style.display = 'block';
-                    form.querySelector('input[type=submit]').disabled = false;
+                    // Kleine Pause zwischen den Chunks für bessere Stabilität
+                    await new Promise(resolve => setTimeout(resolve, 100));
                 }
-            };
 
-            xhr.onerror = function() {
-                status.textContent = 'Update failed: Network error';
+                // Final success handler
+                status.textContent = 'Update successful! Device will restart...';
+                status.classList.add('success');
+                status.style.display = 'block';
+                
+                // Warte auf Neustart und Redirect
+                setTimeout(() => {
+                    window.location.href = '/';
+                }, 20000);
+
+            } catch (error) {
+                status.textContent = 'Update failed: ' + error.message;
                 status.classList.add('error');
                 status.style.display = 'block';
                 form.querySelector('input[type=submit]').disabled = false;
-            };
-
-            xhr.send(formData);
+            }
         });
     </script>
 </body>

html/waage.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

html/wifi.html

@@ -12,7 +12,7 @@
         <div style="display: flex; align-items: center; gap: 2rem;">
             <img src="/logo.png" alt="FilaMan Logo" class="logo">
             <div class="logo-text">
-                <h1>FilaMan<span class="version">v1.2.77</span></h1>
+                <h1>FilaMan<span class="version">v1.2.92</span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

partitions.csv

@@ -1,6 +1,6 @@
 # Name,   Type, SubType,    Offset,   Size,     Flags
 nvs,      data, nvs,       0x9000,   0x5000,
 otadata,  data, ota,       0xe000,   0x2000,
-app0,     app,  ota_0,     0x10000,  0x1E0000,
-app1,     app,  ota_1,     0x1F0000, 0x1E0000,
-spiffs,   data, spiffs,    0x3D0000, 0x30000,
+app0,     app,  ota_0,     0x10000,  0x1C0000,
+app1,     app,  ota_1,     0x1D0000, 0x1C0000,
+spiffs,   data, spiffs,    0x390000, 0x60000,

platformio.ini

@@ -9,7 +9,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [common]
-version = "1.2.77"
+version = "1.2.92"
 
 [env:esp32dev]
 platform = espressif32
@@ -45,27 +45,41 @@ build_flags =
     -mtext-section-literals
     '-D VERSION="${common.version}"'
     -DASYNCWEBSERVER_REGEX
-    -DCORE_DEBUG_LEVEL=1
+    -DCORE_DEBUG_LEVEL=3
     -DCONFIG_ARDUHAL_LOG_COLORS=1
     -DOTA_DEBUG=1
     -DARDUINO_RUNNING_CORE=1
     -DARDUINO_EVENT_RUNNING_CORE=1
-    -DCONFIG_OPTIMIZATION_LEVEL_DEBUG=1
     -DCONFIG_ESP32_PANIC_PRINT_REBOOT
-    -DCONFIG_ARDUINO_OTA_READSIZE=1024
+    -DCONFIG_ARDUINO_OTA_READSIZE=8192
     -DCONFIG_ASYNC_TCP_RUNNING_CORE=1
     -DCONFIG_ASYNC_TCP_USE_WDT=0
-    -DCONFIG_LWIP_TCP_MSS=1460
-    -DOTA_PARTITION_SUBTYPE=0x10
-    -DPARTITION_TABLE_OFFSET=0x8000
-    -DPARTITION_TABLE_SIZE=0x1000
-    -DCONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=1
-    -DCONFIG_BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP=1
-    -DCONFIG_BOOTLOADER_SKIP_VALIDATE_ON_POWER_ON=1
-    -DCONFIG_BOOTLOADER_RESERVE_RTC_SIZE=0x1000
-    -DCONFIG_PARTITION_TABLE_OFFSET=0x8000
-    -DCONFIG_PARTITION_TABLE_MD5=y
-    -DBOOT_APP_PARTITION_OTA_0=1
+    -DASYNC_TCP_USE_WDT=0
+    -DCONFIG_LWIP_TCP_TMR_INTERVAL=25
+    -DCONFIG_LWIP_TCP_MSS=1436
+    -DCONFIG_LWIP_TCP_SND_BUF_DEFAULT=5744
+    -DCONFIG_LWIP_TCP_WND_DEFAULT=5744
+    -DCONFIG_LWIP_TCP_RCV_BUF_DEFAULT=11488
+    -DCONFIG_LWIP_TCP_RECVMBOX_SIZE=64
+    -DCONFIG_LWIP_MAX_SOCKETS=10
+    -DCONFIG_LWIP_MAX_ACTIVE_TCP=16
+    -DCONFIG_LWIP_MAX_LISTENING_TCP=16
+    -DCONFIG_LWIP_TCP_MAXRTX=6
+    -DCONFIG_LWIP_TCP_SYNMAXRTX=3
+    -DCONFIG_LWIP_TCP_QUEUE_OOSEQ=0
+    -DCONFIG_LWIP_TCP_OVERSIZE_MSS=0
+    -DCONFIG_LWIP_TCP_RTO_TIME=1500
+    -DCONFIG_LWIP_IPV6=0
+    -DCONFIG_LWIP_STATS=0
+    -DCONFIG_LWIP_USE_ONLY_LWIP_SELECT=1
+    -DCONFIG_LWIP_NETIF_LOOPBACK=0
+    -DCONFIG_LWIP_IRAM_OPTIMIZATION=1
+    -DCONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10
+    -DCONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32
+    -DCONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM=32
+    -DCONFIG_ESP32_WIFI_TX_BA_WIN=6
+    -DCONFIG_ESP32_WIFI_RX_BA_WIN=6
+    -DCONFIG_ESP32_WIFI_CSI_ENABLED=0
     
 extra_scripts = 
     scripts/extra_script.py

scripts/pre_spiffs.py

@@ -4,4 +4,18 @@ Import("env")
 exec(open("./scripts/pre_build.py").read())
 
 # Bind to SPIFFS build
-env.AddPreAction("buildfs", replace_version)
+env.AddPreAction("buildfs", replace_version)
+
+import os
+import shutil
+from SCons.Script import DefaultEnvironment
+
+env = DefaultEnvironment()
+
+# Format SPIFFS partition before uploading new files
+spiffs_dir = os.path.join(env.subst("$BUILD_DIR"), "spiffs")
+if os.path.exists(spiffs_dir):
+    shutil.rmtree(spiffs_dir)
+os.makedirs(spiffs_dir)
+
+print("SPIFFS partition formatted.")

src/main.cpp

@@ -78,6 +78,8 @@ uint8_t wifiErrorCounter = 0;
 
 // ##### PROGRAM START #####
 void loop() {
+
+  /*
   // Überprüfe den WLAN-Status
   if (WiFi.status() != WL_CONNECTED) {
     wifiErrorCounter++;
@@ -87,7 +89,8 @@ void loop() {
     wifiOn = true;
   }
   if (wifiErrorCounter > 20) ESP.restart();
-
+  */
+ 
   unsigned long currentMillis = millis();
 
   // Send AMS Data min every Minute

src/ota.cpp

@@ -7,7 +7,16 @@
 #include "scale.h"
 #include "nfc.h"
 
+#define UPLOAD_TIMEOUT_MS 60000  // 60 Sekunden Timeout für den gesamten Upload
+#define CHUNK_RESPONSE_TIMEOUT_MS 10000  // 10 Sekunden Timeout pro Chunk
+#define MAX_FAILED_CHUNKS 3  // Maximale Anzahl fehlgeschlagener Chunks bevor Abbruch
+#define MAX_FILE_SIZE 4000000    // 4MB Limit
+
 static bool tasksAreStopped = false;
+static uint32_t lastChunkTime = 0;
+static size_t failedChunks = 0;
+static size_t expectedOffset = 0;
+static size_t totalSize = 0;
 
 void stopAllTasks() {
     Serial.println("Stopping RFID Reader");
@@ -20,59 +29,212 @@ void stopAllTasks() {
     Serial.println("All tasks stopped");
 }
 
+void performStageTwo() {
+    if (!SPIFFS.begin(true)) {
+        Serial.println("Error: Could not mount SPIFFS for stage 2");
+        return;
+    }
+
+    File firmwareFile = SPIFFS.open("/firmware.bin", "r");
+    if (!firmwareFile) {
+        Serial.println("Error: Could not open firmware.bin from SPIFFS");
+        return;
+    }
+
+    size_t firmwareSize = firmwareFile.size();
+    size_t maxAppSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+
+    Serial.printf("Stage 2 - Firmware size: %u bytes\n", firmwareSize);
+    Serial.printf("Available space: %u bytes\n", maxAppSpace);
+
+    if (firmwareSize > maxAppSpace) {
+        Serial.printf("Error: Not enough space for firmware. Need %u bytes but only have %u bytes\n", 
+                    firmwareSize, maxAppSpace);
+        return;
+    }
+
+    if (!Update.begin(firmwareSize)) {
+        Update.printError(Serial);
+        return;
+    }
+
+    size_t written = Update.writeStream(firmwareFile);
+    if (written != firmwareSize) {
+        Update.printError(Serial);
+        return;
+    }
+
+    if (!Update.end(true)) {
+        Update.printError(Serial);
+        return;
+    }
+
+    firmwareFile.close();
+    SPIFFS.remove("/firmware.bin"); // Cleanup
+    Serial.println("Stage 2 update successful, restarting...");
+    delay(500);
+    ESP.restart();
+}
+
+void checkForStagedUpdate() {
+    if (!SPIFFS.begin(true)) {
+        return;
+    }
+
+    if (SPIFFS.exists("/firmware.bin")) {
+        Serial.println("Found staged firmware update, initiating stage 2...");
+        performStageTwo();
+    }
+}
+
 void handleOTAUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final) {
-    static size_t contentLength = 0;
+    static File stagingFile;
+    static uint32_t uploadStartTime = 0;
     
     if (!index) {
-        contentLength = request->contentLength();
-        Serial.printf("Update Start: %s (size: %u bytes)\n", filename.c_str(), contentLength);
+        // Überprüfe Gesamtgröße im Header
+        if (request->hasHeader("X-Total-Size")) {
+            totalSize = request->header("X-Total-Size").toInt();
+            if (totalSize > MAX_FILE_SIZE) {
+                request->send(413, "application/json", 
+                            "{\"status\":\"error\",\"message\":\"File too large\"}");
+                return;
+            }
+        }
+
+        uploadStartTime = millis();
+        lastChunkTime = millis();
+        expectedOffset = 0;
+        failedChunks = 0;
         
-        if (contentLength == 0) {
+        bool isSpiffsUpdate = filename.endsWith("_spiffs.bin");
+        Serial.printf("Update Start: %s (type: %s)\n", filename.c_str(), isSpiffsUpdate ? "SPIFFS" : "OTA");
+        Serial.printf("Total size: %u bytes\n", totalSize);
+        
+        // Überprüfe Header für Chunk-Informationen
+        if (request->hasHeader("X-Chunk-Offset")) {
+            String offsetStr = request->header("X-Chunk-Offset");
+            expectedOffset = offsetStr.toInt();
+        }
+
+        if (request->contentLength() == 0) {
             request->send(400, "application/json", "{\"status\":\"error\",\"message\":\"Invalid file size\"}");
             return;
         }
 
-        // Stoppe alle Tasks vor dem Update
-        if (!tasksAreStopped && (RfidReaderTask || BambuMqttTask || ScaleTask)) {
+        if (!tasksAreStopped) {
             stopAllTasks();
             tasksAreStopped = true;
         }
 
-        // Für full.bin keine Magic Byte Prüfung
-        bool isFullImage = (contentLength > 0x300000);
-        if (!isFullImage && data[0] != 0xE9) {
-            Serial.printf("Wrong magic byte: 0x%02X (expected 0xE9)\n", data[0]);
-            request->send(400, "application/json", "{\"status\":\"error\",\"message\":\"Invalid firmware format\"}");
-            return;
+        if (isSpiffsUpdate) {
+            if (!SPIFFS.begin(true)) {
+                request->send(400, "application/json", 
+                            "{\"status\":\"error\",\"message\":\"Could not mount SPIFFS\"}");
+                return;
+            }
+            
+            if (!Update.begin(totalSize > 0 ? totalSize : request->contentLength(), U_SPIFFS)) {
+                Update.printError(Serial);
+                request->send(400, "application/json", 
+                            "{\"status\":\"error\",\"message\":\"SPIFFS update initialization failed\"}");
+                return;
+            }
+        } else {
+            stagingFile = SPIFFS.open("/firmware.bin", "w");
+            if (!stagingFile) {
+                request->send(400, "application/json", 
+                            "{\"status\":\"error\",\"message\":\"Could not create staging file\"}");
+                return;
+            }
         }
-
-        // Bei full.bin UPDATE_SIZE_UNKNOWN verwenden
-        if (!Update.begin(isFullImage ? UPDATE_SIZE_UNKNOWN : contentLength)) {
-            Update.printError(Serial);
-            request->send(400, "application/json", "{\"status\":\"error\",\"message\":\"OTA could not begin\"}");
-            return;
-        }
-        Serial.printf("Starting %s update\n", isFullImage ? "full" : "firmware");
     }
 
-    // Schreibe Update-Daten
-    if (Update.write(data, len) != len) {
-        Update.printError(Serial);
-        request->send(400, "application/json", "{\"status\":\"error\",\"message\":\"OTA write failed\"}");
+    // Chunk Validierung
+    if (request->hasHeader("X-Chunk-Offset")) {
+        size_t chunkOffset = request->header("X-Chunk-Offset").toInt();
+        if (chunkOffset != expectedOffset) {
+            failedChunks++;
+            if (failedChunks >= MAX_FAILED_CHUNKS) {
+                if (stagingFile) {
+                    stagingFile.close();
+                    SPIFFS.remove("/firmware.bin");
+                }
+                Update.abort();
+                request->send(400, "application/json", 
+                            "{\"status\":\"error\",\"message\":\"Too many failed chunks\"}");
+                return;
+            }
+            request->send(400, "application/json", 
+                        "{\"status\":\"error\",\"message\":\"Invalid chunk offset\"}");
+            return;
+        }
+    }
+
+    // Timeout Überprüfungen
+    uint32_t currentTime = millis();
+    if (currentTime - uploadStartTime > UPLOAD_TIMEOUT_MS) {
+        if (stagingFile) {
+            stagingFile.close();
+            SPIFFS.remove("/firmware.bin");
+        }
+        Update.abort();
+        request->send(408, "application/json", "{\"status\":\"error\",\"message\":\"Upload timeout\"}");
         return;
     }
 
-    // Update abschließen
-    if (final) {
-        if (!Update.end(true)) {
-            Update.printError(Serial);
-            request->send(400, "application/json", "{\"status\":\"error\",\"message\":\"OTA end failed\"}");
+    if (currentTime - lastChunkTime > CHUNK_RESPONSE_TIMEOUT_MS) {
+        if (stagingFile) {
+            stagingFile.close();
+            SPIFFS.remove("/firmware.bin");
+        }
+        Update.abort();
+        request->send(408, "application/json", "{\"status\":\"error\",\"message\":\"Chunk timeout\"}");
+        return;
+    }
+    lastChunkTime = currentTime;
+
+    if (stagingFile) {
+        size_t written = stagingFile.write(data, len);
+        if (written != len) {
+            stagingFile.close();
+            SPIFFS.remove("/firmware.bin");
+            request->send(400, "application/json", 
+                        "{\"status\":\"error\",\"message\":\"Write to SPIFFS failed\"}");
             return;
         }
-        Serial.println("Update successful, restarting...");
-        request->send(200, "application/json", "{\"status\":\"success\",\"message\":\"Update successful! Device will restart...\",\"restart\":true}");
-        delay(500);
-        ESP.restart();
+    } else {
+        if (Update.write(data, len) != len) {
+            Update.printError(Serial);
+            request->send(400, "application/json", 
+                        "{\"status\":\"error\",\"message\":\"Write failed\"}");
+            return;
+        }
+    }
+
+    expectedOffset += len;
+
+    if (final) {
+        if (stagingFile) {
+            stagingFile.close();
+            Serial.println("Stage 1 complete - firmware staged in SPIFFS");
+            request->send(200, "application/json", 
+                        "{\"status\":\"success\",\"message\":\"Update staged successfully! Starting stage 2...\"}");
+            delay(100);
+            performStageTwo();
+        } else {
+            if (!Update.end(true)) {
+                Update.printError(Serial);
+                request->send(400, "application/json", 
+                            "{\"status\":\"error\",\"message\":\"Update failed\"}");
+                return;
+            }
+            Serial.println("SPIFFS update successful, restarting...");
+            request->send(200, "application/json", 
+                        "{\"status\":\"success\",\"message\":\"SPIFFS update successful! Device will restart...\",\"restart\":true}");
+            delay(500);
+            ESP.restart();
+        }
     }
 }
 

src/ota.h

@@ -10,5 +10,6 @@
 
 void stopAllTasks();
 void handleOTAUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final);
+void checkForStagedUpdate();
 
 #endif

src/wlan.cpp

@@ -11,6 +11,7 @@ bool wm_nonblocking = false;
 
 void initWiFi() {
     WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
+    WiFi.setSleep(false); // disable sleep mode
   
     //esp_wifi_set_max_tx_power(72); // Setze maximale Sendeleistung auf 20dBm