docs: update changelog and header for version v2.0.0-beta9

fix: improve get_last_tag function to handle non-beta tags and fallback to newest tag

.github/workflows/gitea-release.yml

@@ -0,0 +1,208 @@
+name: Gitea Release
+
+on:
+  workflow_call:
+    secrets:
+      GITEA_TOKEN:
+        description: 'Token für Gitea API-Zugriff'
+        required: true
+
+    outputs:
+      version:
+        description: 'The version that was released'
+        value: ${{ jobs.create-release.outputs.version }}
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.get_version.outputs.VERSION }}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio esptool
+    
+    - name: Install xxd
+      run: |
+        sudo apt-get update
+        sudo apt-get install xxd
+    
+    - name: Build Firmware
+      run: |
+        VERSION=$(grep '^version = ' platformio.ini | cut -d'"' -f2)
+        
+        # Build firmware and LittleFS
+        echo "Building firmware and LittleFS..."
+        pio run -e esp32dev
+        pio run -t buildfs
+        
+        # Copy firmware binary
+        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/upgrade_filaman_firmware_v${VERSION}.bin
+        
+        # Create LittleFS binary - direct copy without header
+        cp .pio/build/esp32dev/littlefs.bin .pio/build/esp32dev/upgrade_filaman_website_v${VERSION}.bin
+        
+        # Create full binary
+        (cd .pio/build/esp32dev && 
+        esptool.py --chip esp32 merge_bin \
+          --fill-flash-size 4MB \
+          --flash_mode dio \
+          --flash_freq 40m \
+          --flash_size 4MB \
+          -o filaman_full_${VERSION}.bin \
+          0x1000 bootloader.bin \
+          0x8000 partitions.bin \
+          0x10000 firmware.bin \
+          0x3D0000 littlefs.bin)
+        
+        # Verify file sizes
+        echo "File sizes:"
+        (cd .pio/build/esp32dev && ls -lh *.bin)
+    
+    - name: Get version from platformio.ini
+      id: get_version
+      run: |
+        VERSION=$(grep '^version = ' platformio.ini | cut -d'"' -f2)
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      
+    - name: Generate Release Notes
+      id: release_notes
+      run: |
+        # Get the latest tag
+        LATEST_TAG=$(git for-each-ref --sort=-creatordate --format '%(refname:short)' refs/tags | sed -n '2p')
+        
+        if [ -n "$LATEST_TAG" ]; then
+          echo "CHANGES<<EOF" >> $GITHUB_OUTPUT
+          echo "Changes since ${LATEST_TAG}:" >> $GITHUB_OUTPUT
+          echo "" >> $GITHUB_OUTPUT
+          
+          # Get all commits since last release with commit hash and author
+          echo "### Added" >> $GITHUB_OUTPUT
+          git log ${LATEST_TAG}..HEAD --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - (feat|add|new)' | sed 's/^[a-f0-9]* - feat: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Fixed" >> $GITHUB_OUTPUT
+          git log ${LATEST_TAG}..HEAD --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - fix' | sed 's/^[a-f0-9]* - fix: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Changed" >> $GITHUB_OUTPUT
+          git log ${LATEST_TAG}..HEAD --pretty=format:"%h - %s (%an)" | grep -ivE '^[a-f0-9]+ - (feat|fix|add|new)' | sed 's/^[a-f0-9]* - /- /' >> $GITHUB_OUTPUT || true
+          echo "EOF" >> $GITHUB_OUTPUT
+        else
+          # First release
+          echo "CHANGES<<EOF" >> $GITHUB_OUTPUT
+          echo "Initial Release" >> $GITHUB_OUTPUT
+          echo "" >> $GITHUB_OUTPUT
+          
+          # Add all commits for initial release
+          echo "### Added" >> $GITHUB_OUTPUT
+          git log --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - (feat|add|new)' | sed 's/^[a-f0-9]* - feat: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Fixed" >> $GITHUB_OUTPUT
+          git log --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - fix' | sed 's/^[a-f0-9]* - fix: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Changed" >> $GITHUB_OUTPUT
+          git log --pretty=format:"%h - %s (%an)" | grep -ivE '^[a-f0-9]+ - (feat|fix|add|new)' | sed 's/^[a-f0-9]* - /- /' >> $GITHUB_OUTPUT || true
+          echo "EOF" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Determine Gitea URL
+      id: gitea_url
+      run: |
+        echo "Debug Environment:"
+        echo "GITHUB_SERVER_URL=${GITHUB_SERVER_URL:-not set}"
+        echo "GITEA_SERVER_URL=${GITEA_SERVER_URL:-not set}"
+        echo "GITHUB_REPOSITORY=${GITHUB_REPOSITORY:-not set}"
+        echo "GITEA_REPOSITORY=${GITEA_REPOSITORY:-not set}"
+        echo "RUNNER_NAME=${RUNNER_NAME:-not set}"
+        
+        # Set API URL based on environment
+        if [ -n "${GITEA_ACTIONS}" ] || [ -n "${GITEA_REPOSITORY}" ] || [[ "${RUNNER_NAME}" == *"gitea"* ]]; then
+          GITEA_API_URL="${GITHUB_SERVER_URL}"
+          GITEA_REPO=$(echo "${GITHUB_REPOSITORY}" | cut -d'/' -f2)
+          GITEA_OWNER=$(echo "${GITHUB_REPOSITORY}" | cut -d'/' -f1)
+        else
+          echo "Error: This workflow is only for Gitea"
+          exit 1
+        fi
+        
+        echo "GITEA_API_URL=${GITEA_API_URL}" >> $GITHUB_OUTPUT
+        echo "GITEA_REPO=${GITEA_REPO}" >> $GITHUB_OUTPUT
+        echo "GITEA_OWNER=${GITEA_OWNER}" >> $GITHUB_OUTPUT
+
+    - name: Create Gitea Release
+      env:
+        GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        GITEA_API_URL: ${{ steps.gitea_url.outputs.GITEA_API_URL }}
+        GITEA_REPO: ${{ steps.gitea_url.outputs.GITEA_REPO }}
+        GITEA_OWNER: ${{ steps.gitea_url.outputs.GITEA_OWNER }}
+      run: |
+        # Debug Token (nur Länge ausgeben für Sicherheit)
+        echo "Debug: Token length: ${#GITEA_TOKEN}"
+        if [ -z "$GITEA_TOKEN" ]; then
+          echo "Error: GITEA_TOKEN is empty"
+          exit 1
+        fi
+
+        VERSION=${{ steps.get_version.outputs.VERSION }}
+        cd .pio/build/esp32dev
+        
+        # Debug-Ausgaben
+        echo "Debug: API URL: ${GITEA_API_URL}"
+        echo "Debug: Repository: ${GITEA_OWNER}/${GITEA_REPO}"
+        
+        # Erstelle zuerst den Release ohne Dateien
+        echo "Debug: Creating release..."
+        RELEASE_DATA="{\"tag_name\":\"v${VERSION}\",\"name\":\"v${VERSION}\",\"body\":\"${{ steps.release_notes.outputs.CHANGES }}\"}"
+        
+        RELEASE_RESPONSE=$(curl -s -w "\n%{http_code}" \
+          -X POST \
+          -H "Authorization: token ${GITEA_TOKEN}" \
+          -H "Content-Type: application/json" \
+          -d "${RELEASE_DATA}" \
+          "${GITEA_API_URL}/api/v1/repos/${GITEA_OWNER}/${GITEA_REPO}/releases")
+        
+        RELEASE_STATUS=$(echo "$RELEASE_RESPONSE" | tail -n1)
+        RELEASE_BODY=$(echo "$RELEASE_RESPONSE" | head -n -1)
+        
+        if [ "$RELEASE_STATUS" != "201" ]; then
+          echo "Error: Failed to create release"
+          echo "Response: $RELEASE_BODY"
+          exit 1
+        fi
+        
+        # Extrahiere die Release-ID aus der Antwort
+        RELEASE_ID=$(echo "$RELEASE_BODY" | grep -o '"id":[0-9]*' | cut -d':' -f2)
+        
+        # Lade die Dateien einzeln hoch
+        for file in upgrade_filaman_firmware_v${VERSION}.bin upgrade_filaman_website_v${VERSION}.bin filaman_full_${VERSION}.bin; do
+          if [ -f "$file" ]; then
+            echo "Debug: Uploading $file..."
+            UPLOAD_RESPONSE=$(curl -s -w "\n%{http_code}" \
+              -X POST \
+              -H "Authorization: token ${GITEA_TOKEN}" \
+              -H "Content-Type: application/octet-stream" \
+              --data-binary @"$file" \
+              "${GITEA_API_URL}/api/v1/repos/${GITEA_OWNER}/${GITEA_REPO}/releases/${RELEASE_ID}/assets?name=${file}")
+            
+            UPLOAD_STATUS=$(echo "$UPLOAD_RESPONSE" | tail -n1)
+            if [ "$UPLOAD_STATUS" != "201" ]; then
+              echo "Warning: Failed to upload $file"
+              echo "Response: $(echo "$UPLOAD_RESPONSE" | head -n -1)"
+            else
+              echo "Successfully uploaded $file"
+            fi
+          fi
+        done

.github/workflows/github-release.yml

@@ -0,0 +1,185 @@
+name: GitHub Release
+
+on:
+  workflow_call:
+    secrets:
+      RELEASE_TOKEN:
+        description: 'GitHub token for release creation'
+        required: true
+
+permissions:
+  contents: write
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio esptool
+    
+    - name: Install xxd
+      run: |
+        sudo apt-get update
+        sudo apt-get install xxd
+    
+    - name: Build Firmware
+      run: |
+        VERSION=$(grep '^version = ' platformio.ini | cut -d'"' -f2)
+        
+        # Always build firmware and LittleFS
+        echo "Building firmware and LittleFS..."
+        pio run -e esp32dev
+        pio run -t buildfs
+        
+        # Copy firmware binary
+        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/upgrade_filaman_firmware_v${VERSION}.bin
+        
+        # Create LittleFS binary - direct copy without header
+        cp .pio/build/esp32dev/littlefs.bin .pio/build/esp32dev/upgrade_filaman_website_v${VERSION}.bin
+        
+        # Create full binary (always)
+        (cd .pio/build/esp32dev && 
+        esptool.py --chip esp32 merge_bin \
+          --fill-flash-size 4MB \
+          --flash_mode dio \
+          --flash_freq 40m \
+          --flash_size 4MB \
+          -o filaman_full_${VERSION}.bin \
+          0x1000 bootloader.bin \
+          0x8000 partitions.bin \
+          0x10000 firmware.bin \
+          0x3D0000 littlefs.bin)
+        
+        # Verify file sizes
+        echo "File sizes:"
+        (cd .pio/build/esp32dev && ls -lh *.bin)
+    
+    - name: Get version from platformio.ini
+      id: get_version
+      run: |
+        VERSION=$(grep '^version = ' platformio.ini | cut -d'"' -f2)
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      
+    - name: Generate Release Notes
+      id: release_notes
+      run: |
+        # Get the latest tag
+        LATEST_TAG=$(git for-each-ref --sort=-creatordate --format '%(refname:short)' refs/tags | sed -n '2p')
+        
+        if [ -n "$LATEST_TAG" ]; then
+          echo "CHANGES<<EOF" >> $GITHUB_OUTPUT
+          echo "Changes since ${LATEST_TAG}:" >> $GITHUB_OUTPUT
+          echo "" >> $GITHUB_OUTPUT
+          
+          # Get all commits since last release with commit hash and author
+          echo "### Added" >> $GITHUB_OUTPUT
+          git log ${LATEST_TAG}..HEAD --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - (feat|add|new)' | sed 's/^[a-f0-9]* - feat: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Fixed" >> $GITHUB_OUTPUT
+          git log ${LATEST_TAG}..HEAD --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - fix' | sed 's/^[a-f0-9]* - fix: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Changed" >> $GITHUB_OUTPUT
+          git log ${LATEST_TAG}..HEAD --pretty=format:"%h - %s (%an)" | grep -ivE '^[a-f0-9]+ - (feat|fix|add|new)' | sed 's/^[a-f0-9]* - /- /' >> $GITHUB_OUTPUT || true
+          echo "EOF" >> $GITHUB_OUTPUT
+        else
+          # First release
+          echo "CHANGES<<EOF" >> $GITHUB_OUTPUT
+          echo "Initial Release" >> $GITHUB_OUTPUT
+          echo "" >> $GITHUB_OUTPUT
+          
+          # Add all commits for initial release
+          echo "### Added" >> $GITHUB_OUTPUT
+          git log --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - (feat|add|new)' | sed 's/^[a-f0-9]* - feat: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Fixed" >> $GITHUB_OUTPUT
+          git log --pretty=format:"%h - %s (%an)" | grep -iE '^[a-f0-9]+ - fix' | sed 's/^[a-f0-9]* - fix: /- /' >> $GITHUB_OUTPUT || true
+          echo "" >> $GITHUB_OUTPUT
+          
+          echo "### Changed" >> $GITHUB_OUTPUT
+          git log --pretty=format:"%h - %s (%an)" | grep -ivE '^[a-f0-9]+ - (feat|fix|add|new)' | sed 's/^[a-f0-9]* - /- /' >> $GITHUB_OUTPUT || true
+          echo "EOF" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Create GitHub Release
+      env:
+        GH_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+      run: |
+        VERSION=${{ steps.get_version.outputs.VERSION }}
+        cd .pio/build/esp32dev
+        
+        # Create release with available files
+        FILES_TO_UPLOAD=""
+        
+        # Always add firmware
+        if [ -f "upgrade_filaman_firmware_v${VERSION}.bin" ]; then
+          FILES_TO_UPLOAD="$FILES_TO_UPLOAD upgrade_filaman_firmware_v${VERSION}.bin"
+        fi
+        
+        # Add LittleFS and full binary only if they exist
+        if [ -f "upgrade_filaman_website_v${VERSION}.bin" ]; then
+          FILES_TO_UPLOAD="$FILES_TO_UPLOAD upgrade_filaman_website_v${VERSION}.bin"
+        fi
+        
+        if [ -f "filaman_full_${VERSION}.bin" ]; then
+          FILES_TO_UPLOAD="$FILES_TO_UPLOAD filaman_full_${VERSION}.bin"
+        fi
+        
+        # Create release with available files
+        if [ -n "$FILES_TO_UPLOAD" ]; then
+          gh release create "v${VERSION}" \
+            --title "Release ${VERSION}" \
+            --notes "${{ steps.release_notes.outputs.CHANGES }}" \
+            $FILES_TO_UPLOAD
+        else
+          echo "Error: No files found to upload"
+          exit 1
+        fi
+
+    - name: Install lftp
+      run: sudo apt-get install -y lftp
+        
+    - name: Upload Firmware via FTP
+      if: success()
+      env:
+        FTP_PASSWORD: ${{ vars.FTP_PASSWORD }}
+        FTP_USER: ${{ vars.FTP_USER }}
+        FTP_HOST: ${{ vars.FTP_HOST }}
+        VERSION: ${{ steps.get_version.outputs.VERSION }}
+      run: |
+        echo "Environment variables:"
+        env | grep -E '^FTP_' | while read -r line; do
+          var_name=$(echo "$line" | cut -d= -f1)
+          var_value=$(echo "$line" | cut -d= -f2-)
+          echo "$var_name is $(if [ -n "$var_value" ]; then echo "set"; else echo "empty"; fi)"
+        done
+        
+        cd .pio/build/esp32dev
+        if [ -n "$FTP_USER" ] && [ -n "$FTP_PASSWORD" ] && [ -n "$FTP_HOST" ]; then
+          echo "All FTP credentials are present, attempting upload..."
+          lftp -c "set ssl:verify-certificate no; \
+                    set ftp:ssl-protect-data true; \
+                    set ftp:ssl-force true; \
+                    set ssl:check-hostname false; \
+                    set ftp:ssl-auth TLS; \
+                    open -u $FTP_USER,$FTP_PASSWORD $FTP_HOST; \
+                    put -O / filaman_full_${VERSION}.bin -o filaman_full.bin"
+        else
+          echo "Error: Some FTP credentials are missing"
+          exit 1
+        fi

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Create Release
+name: Release Workflow
 
 on:
   push:
@@ -6,80 +6,36 @@ on:
       - 'v*'
 
 permissions:
-  contents: write      # Required for creating releases
-  issues: read        # Required for reading changelog
-  pull-requests: read # Required for reading changelog
+  contents: write
 
 jobs:
-  build:
+  detect-provider:
     runs-on: ubuntu-latest
-    permissions:
-      contents: write # Required for creating releases at job level
+    outputs:
+      provider: ${{ steps.provider.outputs.provider }}
     steps:
-    - uses: actions/checkout@v4
-    
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: '3.x'
-    
-    - name: Install PlatformIO
-      run: |
-        python -m pip install --upgrade pip
-        pip install --upgrade platformio
-    
-    - name: Build Firmware
-      run: |
-        pio run -t buildfs  # Build SPIFFS
-        pio run            # Build firmware
-        
-    - name: Install esptool
-      run: |
-        pip install esptool
-        
-    - name: Merge firmware and SPIFFS
-      run: |
-        esptool.py --chip esp32 merge_bin \
-          --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 \
-          0x290000 .pio/build/esp32dev/spiffs.bin
+      - name: Determine CI Provider
+        id: provider
+        shell: bash
+        run: |
+          if [ -n "${GITEA_ACTIONS}" ] || [ -n "${GITEA_REPOSITORY}" ] || [[ "${RUNNER_NAME}" == *"gitea"* ]]; then
+            echo "provider=gitea" >> "$GITHUB_OUTPUT"
+          else
+            echo "provider=github" >> "$GITHUB_OUTPUT"
+          fi
 
-    - name: Prepare OTA firmware
-      run: |
-        # Use PlatformIO to create a proper OTA image
-        cp .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/filaman_ota.bin
-    
-    - name: Get version from tag
-      id: get_version
-      run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
-      
-    - name: Read CHANGELOG.md
-      id: changelog
-      run: |
-        CHANGELOG=$(awk "/## \\[${{ steps.get_version.outputs.VERSION }}\\]/{p=1;print;next} /## \\[/{p=0} p" CHANGELOG.md)
-        echo "CHANGES<<EOF" >> $GITHUB_OUTPUT
-        echo "$CHANGELOG" >> $GITHUB_OUTPUT
-        echo "EOF" >> $GITHUB_OUTPUT
-    
-    - name: Install and Configure GitHub CLI
-      run: |
-        curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \
-        && sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \
-        && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
-        && sudo apt update \
-        && sudo apt install gh -y
-        
-    - name: Create Release with GitHub CLI
-      env:
-        GH_TOKEN: ${{ secrets.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#filaman_full.bin" \
-          ".pio/build/esp32dev/filaman_ota.bin#filaman_ota.bin"
+  github-release:
+    needs: detect-provider
+    permissions:
+      contents: write
+    if: needs.detect-provider.outputs.provider == 'github'
+    uses: ./.github/workflows/github-release.yml
+    secrets:
+      RELEASE_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  gitea-release:
+    needs: detect-provider
+    if: needs.detect-provider.outputs.provider == 'gitea'
+    uses: ./.github/workflows/gitea-release.yml
+    secrets:
+      GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}

.gitignore

@@ -0,0 +1,42 @@
+.pio
+.vscode/
+.aider*
+.DS_Store
+._*
+**/.DS_Store
+**/.Spotlight-V100
+**/.Trashes
+**/.fseventsd
+.AppleDouble
+**/.DS_Store
+**/.Spotlight-V100
+**/.Trashes
+**/.fseventsd
+.AppleDouble
+.aider.chat.history.md
+.aider.input.history
+.DS_Store
+.gitignore
+.aider.tags.cache.v3/cache.db
+.aider.tags.cache.v3/cache.db-shm
+.aider.tags.cache.v3/cache.db-wal
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch
+.vscode/extensions.json
+.vscode/launch.json
+include/README
+lib/README
+test/README
+.aider*
+data/*
+!data/
+!data/.gitkeep
+# important
+html/bambu_credentials.json
+html/spoolman_url.json
+_local/*
+website/*
+release.sh
+.github/copilot-instructions.md
+data

.vscode/settings.json

@@ -1,54 +0,0 @@
-{
-    "files.associations": {
-        "algorithm": "cpp",
-        "vector": "cpp",
-        "cmath": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "*.tcc": "cpp",
-        "bitset": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "deque": "cpp",
-        "unordered_map": "cpp",
-        "unordered_set": "cpp",
-        "exception": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "map": "cpp",
-        "memory": "cpp",
-        "memory_resource": "cpp",
-        "numeric": "cpp",
-        "optional": "cpp",
-        "random": "cpp",
-        "regex": "cpp",
-        "string": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "utility": "cpp",
-        "fstream": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "new": "cpp",
-        "ostream": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "cinttypes": "cpp",
-        "typeinfo": "cpp"
-    }
-}

README.de.md

@@ -6,9 +6,12 @@ Das System integriert sich nahtlos mit der [Spoolman](https://github.com/Donkie/
 
 ![Scale](./img/scale_trans.png)
 
-Weitere Bilder finden Sie im [img Ordner](/img/)  
+Weitere Bilder finden Sie im [img Ordner](/img/)
 oder auf meiner Website: [FilaMan Website](https://www.filaman.app)  
-Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaOHU)
+Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaOHU)  
+Discord Server: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
+
+### Es gibt jetzt auch ein Wiki, dort sind nochmal alle Funktionen beschrieben: [Wiki](https://github.com/ManuelW77/Filaman/wiki)
 
 ### ESP32 Hardware-Funktionen
 - **Gewichtsmessung:** Verwendung einer Wägezelle mit HX711-Verstärker für präzise Gewichtsverfolgung.
@@ -16,7 +19,7 @@ Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaO
 - **OLED-Display:** Zeigt aktuelles Gewicht, Verbindungsstatus (WiFi, Bambu Lab, Spoolman).
 - **WLAN-Konnektivität:** WiFiManager für einfache Netzwerkkonfiguration.
 - **MQTT-Integration:** Verbindet sich mit Bambu Lab Drucker für AMS-Steuerung.
-- **NFC-Tag NTAG215:** Verwendung von NTAG215 wegen ausreichendem Speicherplatz auf dem Tag
+- **NFC-Tag NTAG213 NTAG215:** Verwendung von NTAG213, besser NTAG215 wegen ausreichendem Speicherplatz auf dem Tag
 
 ### Weboberflächen-Funktionen
 - **Echtzeit-Updates:** WebSocket-Verbindung für Live-Daten-Updates.
@@ -24,6 +27,7 @@ Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaO
     - Filamentdaten auf NFC-Tags schreiben.
     - Verwendet das NFC-Tag-Format von [Openspool](https://github.com/spuder/OpenSpool)
     - Ermöglicht automatische Spulenerkennung im AMS
+    - **Hersteller Tag Unterstützung:** Automatische Erstellung von Spoolman-Einträgen aus Hersteller NFC-Tags ([Mehr erfahren](README_ManufacturerTags_DE.md))
 - **Bambulab AMS-Integration:** 
   - Anzeige der aktuellen AMS-Fachbelegung.
   - Zuordnung von Filamenten zu AMS-Slots.
@@ -33,10 +37,38 @@ Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaO
   - Filtern und Auswählen von Filamenten.
   - Automatische Aktualisierung der Spulengewichte.
   - Verfolgung von NFC-Tag-Zuweisungen.
+  - Unterstützt das Spoolman Octoprint Plugin
 
 ### Wenn Sie meine Arbeit unterstützen möchten, freue ich mich über einen Kaffee
+
 <a href="https://www.buymeacoffee.com/manuelw" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 30px !important;width: 108px !important;" ></a>
 
+## Hersteller Tags Unterstützung
+
+🎉 **Aufregende Neuigkeiten!** FilaMan unterstützt jetzt **Hersteller Tags** - NFC-Tags, die direkt von Filament-Herstellern vorprogrammiert geliefert werden!
+
+### Erster Hersteller-Partner: RecyclingFabrik
+
+Wir freuen uns anzukündigen, dass [**RecyclingFabrik**](https://www.recyclingfabrik.de) der **erste Filament-Hersteller** sein wird, der FilaMan unterstützt, indem sie NFC-Tags im FilaMan-Format auf ihren Spulen anbieten!
+
+**Demnächst verfügbar:** RecyclingFabrik-Spulen werden NFC-Tags enthalten, die sich automatisch in Ihr FilaMan-System integrieren, manuelle Einrichtung überflüssig machen und perfekte Kompatibilität gewährleisten.
+
+### Wie Hersteller Tags funktionieren
+
+Wenn Sie zum ersten Mal einen Hersteller NFC-Tag scannen:
+1. **Automatische Markenerkennung:** FilaMan erkennt den Hersteller und erstellt die Marke in Spoolman
+2. **Filament-Typ Erstellung:** Alle Materialspezifikationen werden automatisch hinzugefügt
+3. **Spulen-Registrierung:** Ihre spezifische Spule wird mit korrektem Gewicht und Spezifikationen registriert
+4. **Zukünftige Schnellerkennung:** Nachfolgende Scans verwenden Fast-Path-Erkennung für sofortige Gewichtsmessung
+
+**Für detaillierte technische Informationen:** [Hersteller Tags Dokumentation](README_ManufacturerTags_DE.md)
+
+### Vorteile für Benutzer
+- ✅ **Null manuelle Einrichtung** - Einfach scannen und wiegen
+- ✅ **Perfekte Datengenauigkeit** - Hersteller-verifizierte Spezifikationen
+- ✅ **Sofortige Integration** - Nahtlose Spoolman-Kompatibilität
+- ✅ **Zukunftssicher** - Tags funktionieren mit jedem FilaMan-kompatiblen System
+
 ## Detaillierte Funktionalität
 
 ### ESP32-Funktionalität
@@ -50,20 +82,23 @@ Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaO
 
 ## Hardware-Anforderungen
 
-### Komponenten
-- **ESP32 Entwicklungsboard:** Jede ESP32-Variante.
-[Amazon Link](https://amzn.eu/d/aXThslf)
-- **HX711 Wägezellen-Verstärker:** Für Gewichtsmessung.
-[Amazon Link](https://amzn.eu/d/1wZ4v0x)
-- **OLED Display:** 128x64 SSD1306.
-[Amazon Link](https://amzn.eu/d/dozAYDU)
-- **PN532 NFC Modul:** Für NFC-Tag-Operationen.
-[Amazon Link](https://amzn.eu/d/8205DDh)
-- **NFC-Tag:** NTAG215
-[Amazon Link](https://amzn.eu/d/fywy4c4)
+### Komponenten (Affiliate Links)
+- **ESP32 Development Board:** Any ESP32 variant.
+[Amazon Link](https://amzn.to/3FHea6D)
+- **HX711 5kg Load Cell Amplifier:** For weight measurement.
+[Amazon Link](https://amzn.to/4ja1KTe)
+- **OLED 0.96 Zoll I2C white/yellow Display:** 128x64 SSD1306.
+[Amazon Link](https://amzn.to/445aaa9)
+- **PN532 NFC NXP RFID-Modul V3:** For NFC tag operations.
+[Amazon Link](https://amzn.eu/d/gy9vaBX)
+- **NFC Tags NTAG213 NTAG215:** RFID Tag
+[Amazon Link](https://amzn.to/3E071xO)
+- **TTP223 Touch Sensor (optional):** For reTARE per Button/Touch
+[Amazon Link](https://amzn.to/4hTChMK)
 
-### Pin-Konfiguration
-| Komponente        | ESP32 Pin |
+
+### Pin Konfiguration
+| Component          | ESP32 Pin |
 |-------------------|-----------|
 | HX711 DOUT        | 16        |
 | HX711 SCK         | 17        |
@@ -71,10 +106,23 @@ Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaO
 | OLED SCL          | 22        |
 | PN532 IRQ         | 32        |
 | PN532 RESET       | 33        |
-| PN532 SCK         | 14        |
-| PN532 MOSI        | 13        |
-| PN532 MISO        | 12        |
-| PN532 CS/SS       | 15        |
+| PN532 SDA         | 21        |
+| PN532 SCL         | 22        |
+| TTP223 I/O        | 25        |
+
+**!! Achte darauf, dass am PN532 die DIP-Schalter auf I2C gestellt sind**  
+**Nutze den 3V Pin vom ESP für den Touch Sensor**
+
+![Wiring](./img/Schaltplan.png)
+
+![myWiring](./img/IMG_2589.jpeg)
+![myWiring](./img/IMG_2590.jpeg)
+
+*Die Wägezelle wird bei den meisten HX711 Modulen folgendermaßen verkabelt:  
+E+ rot  
+E- schwarz  
+A- weiß  
+A+ grün*
 
 ## Software-Abhängigkeiten
 
@@ -101,7 +149,31 @@ Deutsches Erklärvideo: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaO
   - PN532 NFC Modul
   - Verbindungskabel
 
-### Schritt-für-Schritt Installation
+## Wichtiger Hinweis
+Du musst Spoolman auf DEBUG Modus setzten, da man bisher in Spoolman keine CORS Domains setzen kann!
+
+```
+# Enable debug mode
+# If enabled, the client will accept requests from any host
+# This can be useful when developing, but is also a security risk
+# Default: FALSE
+#SPOOLMAN_DEBUG_MODE=TRUE
+```
+
+## Schritt-für-Schritt Installation
+### Einfache Installation
+1. **Gehe auf [FilaMan Installer](https://www.filaman.app/installer.html)**
+
+2. **Stecke dein ESP an den Rechner und klicke Connect**
+
+3. **Wähle dein Device Port und klicke Intall**
+
+4. **Ersteinrichtung:**
+    - Mit dem "FilaMan" WLAN-Zugangspunkt verbinden.
+    - WLAN-Einstellungen über das Konfigurationsportal vornehmen.
+    - Weboberfläche unter `http://filaman.local` oder der IP-Adresse aufrufen.
+
+### Compile by yourself
 1. **Repository klonen:**
     ```bash
     git clone https://github.com/ManuelW77/Filaman.git

README.md

@@ -6,12 +6,16 @@ FilaMan is a filament management system for 3D printing. It uses ESP32 hardware
 Users can manage filament spools, monitor the status of the Automatic Material System (AMS) and make settings via a web interface. 
 The system integrates seamlessly with [Bambulab](https://bambulab.com/en-us) 3D printers and [Spoolman](https://github.com/Donkie/Spoolman) filament management as well as the [Openspool](https://github.com/spuder/OpenSpool) NFC-TAG format.
 
+
 ![Scale](./img/scale_trans.png)
 
 
 More Images can be found in the [img Folder](/img/)  
-or my website:[FilaMan Website](https://www.filaman.app)  
-german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaOHU)
+or my website: [FilaMan Website](https://www.filaman.app)  
+german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaOHU)  
+Discord Server: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
+
+### Now more detailed informations about the usage: [Wiki](https://github.com/ManuelW77/Filaman/wiki)
 
 ### ESP32 Hardware Features
 - **Weight Measurement:** Using a load cell with HX711 amplifier for precise weight tracking.
@@ -19,7 +23,7 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
 - **OLED Display:** Shows current weight, connection status (WiFi, Bambu Lab, Spoolman).
 - **WiFi Connectivity:** WiFiManager for easy network configuration.
 - **MQTT Integration:** Connects to Bambu Lab printer for AMS control.
-- **NFC-Tag NTAG215:** Use NTAG215 because of enaught space on the Tag
+- **NFC-Tag NTAG213 NTAG215:** Use NTAG213, better NTAG215 because of enaught space on the Tag
 
 ### Web Interface Features
 - **Real-time Updates:** WebSocket connection for live data updates.
@@ -27,6 +31,7 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
 	- Write filament data to NFC tags.
 	- uses NFC-Tag Format of [Openspool](https://github.com/spuder/OpenSpool)
 	- so you can use it with automatic Spool detection in AMS
+	- **Manufacturer Tag Support:** Automatic creation of Spoolman entries from manufacturer NFC tags ([Learn more](README_ManufacturerTags_EN.md))
 - **Bambulab AMS Integration:** 
   - Display current AMS tray contents.
   - Assign filaments to AMS slots.
@@ -36,10 +41,38 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
   - Filter and select filaments.
   - Update spool weights automatically.
   - Track NFC tag assignments.
+  - Supports Spoolman Octoprint Plugin
 
 ### If you want to support my work, i would be happy to get a coffe
+
 <a href="https://www.buymeacoffee.com/manuelw" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 30px !important;width: 108px !important;" ></a>
 
+## Manufacturer Tags Support
+
+🎉 **Exciting News!** FilaMan now supports **Manufacturer Tags** - NFC tags that come pre-programmed directly from filament manufacturers!
+
+### First Manufacturer Partner: RecyclingFabrik
+
+We're thrilled to announce that [**RecyclingFabrik**](https://www.recyclingfabrik.de) will be the **first filament manufacturer** to support FilaMan by offering NFC tags in the FilaMan format on their spools!
+
+**Coming Soon:** RecyclingFabrik spools will include NFC tags that automatically integrate with your FilaMan system, eliminating manual setup and ensuring perfect compatibility.
+
+### How Manufacturer Tags Work
+
+When you scan a manufacturer NFC tag for the first time:
+1. **Automatic Brand Detection:** FilaMan recognizes the manufacturer and creates the brand in Spoolman
+2. **Filament Type Creation:** All material specifications are automatically added
+3. **Spool Registration:** Your specific spool is registered with proper weight and specifications
+4. **Future Fast Recognition:** Subsequent scans use fast-path detection for instant weight measurement
+
+**For detailed technical information:** [Manufacturer Tags Documentation](README_ManufacturerTags_EN.md)
+
+### Benefits for Users
+- ✅ **Zero Manual Setup** - Just scan and weigh
+- ✅ **Perfect Data Accuracy** - Manufacturer-verified specifications
+- ✅ **Instant Integration** - Seamless Spoolman compatibility
+- ✅ **Future-Proof** - Tags work with any FilaMan-compatible system
+
 ## Detailed Functionality
 
 ### ESP32 Functionality
@@ -53,17 +86,19 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
 
 ## Hardware Requirements
 
-### Components
+### Components (Affiliate Links)
 - **ESP32 Development Board:** Any ESP32 variant.
-[Amazon Link](https://amzn.eu/d/aXThslf)
-- **HX711 Load Cell Amplifier:** For weight measurement.
-[Amazon Link](https://amzn.eu/d/1wZ4v0x)
-- **OLED Display:** 128x64 SSD1306.
-[Amazon Link](https://amzn.eu/d/dozAYDU)
-- **PN532 NFC Module:** For NFC tag operations.
-[Amazon Link](https://amzn.eu/d/8205DDh)
-- **NFC-Tag:** NTAG215
-[Amazon Link](https://amzn.eu/d/fywy4c4)
+[Amazon Link](https://amzn.to/3FHea6D)
+- **HX711 5kg Load Cell Amplifier:** For weight measurement.
+[Amazon Link](https://amzn.to/4ja1KTe)
+- **OLED 0.96 Zoll I2C white/yellow Display:** 128x64 SSD1306.
+[Amazon Link](https://amzn.to/445aaa9)
+- **PN532 NFC NXP RFID-Modul V3:** For NFC tag operations.
+[Amazon Link](https://amzn.eu/d/gy9vaBX)
+- **NFC Tags NTAG213 NTAG215:** RFID Tag
+[Amazon Link](https://amzn.to/3E071xO)
+- **TTP223 Touch Sensor (optional):** For reTARE per Button/Touch
+[Amazon Link](https://amzn.to/4hTChMK)
 
 
 ### Pin Configuration
@@ -75,10 +110,23 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
 | OLED SCL          | 22        |
 | PN532 IRQ         | 32        |
 | PN532 RESET       | 33        |
-| PN532 SCK  	    | 14        |
-| PN532 MOSI    	| 13        |
-| PN532 MISO       	| 12        |
-| PN532 CS/SS       | 15        |
+| PN532 SDA         | 21        |
+| PN532 SCL         | 22        |
+| TTP223 I/O        | 25        |
+
+**!! Make sure that the DIP switches on the PN532 are set to I2C**  
+**Use the 3V pin from the ESP for the touch sensor**
+
+![Wiring](./img/Schaltplan.png)
+
+![myWiring](./img/IMG_2589.jpeg)
+![myWiring](./img/IMG_2590.jpeg)
+
+*The load cell is connected to most HX711 modules as follows:  
+E+ red  
+E- black  
+A- white  
+A+ green*
 
 ## Software Dependencies
 
@@ -91,9 +139,9 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
 - `Adafruit_SSD1306`: OLED display control
 - `HX711`: Load cell communication
 
-## Installation
+### Installation
 
-### Prerequisites
+## Prerequisites
 - **Software:**
   - [PlatformIO](https://platformio.org/) in VS Code
   - [Spoolman](https://github.com/Donkie/Spoolman) instance
@@ -105,7 +153,32 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
   - PN532 NFC Module
   - Connecting wires
 
-### Step-by-Step Installation
+## Important Note
+You have to activate Spoolman in debug mode, because you are not able to set CORS Domains in Spoolman yet.
+
+```
+# Enable debug mode
+# If enabled, the client will accept requests from any host
+# This can be useful when developing, but is also a security risk
+# Default: FALSE
+#SPOOLMAN_DEBUG_MODE=TRUE
+```
+
+
+## Step-by-Step Installation
+### Easy Installation
+1. **Go to [FilaMan Installer](https://www.filaman.app/installer.html)**
+
+2. **Plug you device in and push Connect button**
+
+3. **Select your Device Port and push Intall**
+
+4. **Initial Setup:**
+    - Connect to the "FilaMan" WiFi access point.
+    - Configure WiFi settings through the captive portal.
+    - Access the web interface at `http://filaman.local` or the IP address.
+
+### Compile by yourself
 1. **Clone the Repository:**
     ```bash
     git clone https://github.com/ManuelW77/Filaman.git
@@ -124,7 +197,6 @@ german explanatory video: [Youtube](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62z
     - Configure WiFi settings through the captive portal.
     - Access the web interface at `http://filaman.local` or the IP address.
 
-
 ## Documentation
 
 ### Relevant Links

README_ManufacturerTags_DE.md

@@ -0,0 +1,159 @@
+# Hersteller Tags - Deutsche Dokumentation
+
+## Überblick
+
+Das FilaMan NFC-System unterstützt **Hersteller Tags**, die es Filament-Produzenten ermöglichen, standardisierte NFC-Tags für ihre Produkte zu erstellen. Beim Scannen dieser Tags werden automatisch die notwendigen Einträge in Spoolman (Marke, Filament-Typ und Spule) erstellt, ohne dass eine manuelle Einrichtung erforderlich ist.
+
+## Funktionsweise der Hersteller Tags
+
+### Ablauf
+
+1. **Tag-Erkennung**: Wenn ein Tag ohne `sm_id` gescannt wird, prüft das System auf Hersteller Tag Format
+2. **Marken-Erstellung/Suche**: Das System sucht die Marke in Spoolman oder erstellt sie, falls sie nicht existiert
+3. **Filament-Typ-Erstellung/Suche**: Der Filament-Typ wird basierend auf Marke, Material und Spezifikationen erstellt oder gefunden
+4. **Spulen-Erstellung**: Ein neuer Spulen-Eintrag wird automatisch mit der Tag-UID als Referenz erstellt
+5. **Tag-Update**: Der Tag wird mit der neuen Spoolman Spulen-ID (`sm_id`) aktualisiert
+
+### Warum Hersteller Tags verwenden?
+
+- **Automatische Integration**: Keine manuelle Dateneingabe erforderlich
+- **Standardisiertes Format**: Konsistente Produktinformationen verschiedener Hersteller
+- **Lagerverwaltung**: Automatische Erstellung vollständiger Spoolman-Einträge
+- **Rückverfolgbarkeit**: Direkte Verbindung zwischen physischem Produkt und digitalem Inventar
+
+## Tag-Format Spezifikation
+
+### JSON-Struktur
+
+Hersteller Tags müssen eine JSON-Payload mit spezifischen Feldern enthalten, die **kurze Schlüssel** verwenden, um die Tag-Größe zu minimieren:
+
+```json
+{
+    "b": "Marke/Hersteller Name",
+    "an": "Artikelnummer",
+    "t": "Filament Typ (PLA, PETG, etc)",
+    "c": "Filament Farbe ohne # (FF5733)",
+    "mc": "Optional Mehrfarben-Filament Farben ohne # (FF0000,00FF00,0000FF)",
+    "mcd": "Optional Mehrfarben-Richtung als Wort (coaxial, longitudinal)",
+    "cn": "Farbname (rot, Blaubeere, Arktisches Blau)",
+    "et": "Extruder Temp als Zahl in C° (230)",
+    "bt": "Bett Temp als Zahl in C° (60)",
+    "di": "Durchmesser als Float (1.75)",
+    "de": "Dichte als Float (1.24)",
+    "sw": "Leeres Spulengewicht als Zahl in g (180)",
+    "u": "URL zum Filament mit der Artikelnummer"
+}
+```
+
+### Pflichtfelder
+
+- **`b`** (brand): Hersteller/Markenname
+- **`an`** (article number): Eindeutige Produktkennung
+- **`t`** (type): Materialtyp (PLA, PETG, ABS, etc.)
+- **`c`** (color): Hex-Farbcode ohne #
+- **`cn`** (color name): Lesbare Farbbezeichnung
+- **`et`** (extruder temp): Empfohlene Extruder-Temperatur in Celsius
+- **`bt`** (bed temp): Empfohlene Bett-Temperatur in Celsius
+- **`di`** (diameter): Filamentdurchmesser in mm
+- **`de`** (density): Materialdichte in g/cm³
+- **`sw`** (spool weight): Leeres Spulengewicht in Gramm
+
+### Optionale Felder
+
+- **`mc`** (multicolor): Komma-getrennte Hex-Farben für Mehrfarben-Filamente
+- **`mcd`** (multicolor direction): Richtung für Mehrfarben (coaxial, longitudinal)
+- **`u`** (url): Produkt-URL mit direktem Link zum Artikel zB für Nachbestellung
+
+### Beispiel Tag
+
+```json
+{"b":"Recycling Fabrik","an":"FX1_PETG-S175-1000-DAEM00055","t":"PETG","c":"FF5733","cn":"Lebendiges Orange","et":"230","bt":"70","di":"1.75","de":"1.24","sw":"180","u":"https://www.recyclingfabrik.com/search?q="}
+```
+
+## Implementierungsrichtlinien
+
+### Für Hersteller
+
+1. **Tag-Kodierung**: NDEF-Format mit MIME-Typ `application/json` verwenden
+2. **Datenminimierung**: Kompaktes JSON-Format für Tag-Größenbegrenzungen nutzen
+3. **Qualitätskontrolle**: Sicherstellen, dass alle Pflichtfelder vorhanden und korrekt formatiert sind
+4. **Testen**: Tags vor der Produktion mit dem FilaMan-System verifizieren
+
+### Tag-Größe Überlegungen
+
+- **NTAG213**: 144 Bytes Nutzerdaten (geeignet für einfache Tags)
+- **NTAG215**: 504 Bytes Nutzerdaten (empfohlen für umfassende Daten)
+- **NTAG216**: 888 Bytes Nutzerdaten (maximale Kompatibilität)
+
+### Best Practices
+
+- Markennamen über alle Produkte hinweg konsistent halten
+- Standardisierte Materialtypnamen verwenden (PLA, PETG, ABS, etc.)
+- Genaue Temperaturempfehlungen angeben
+- Aussagekräftige Farbnamen für bessere Benutzererfahrung verwenden
+- Tags vor Massenproduktion mit dem FilaMan-System testen
+
+## System-Integration
+
+### Spoolman Datenbankstruktur
+
+Bei der Verarbeitung eines Hersteller Tags erstellt das System:
+
+1. **Lieferanten-Eintrag**: Markeninformationen in der Spoolman Lieferanten-Datenbank
+2. **Filament-Eintrag**: Materialspezifikationen und Eigenschaften
+3. **Spulen-Eintrag**: Einzelne Spule mit Gewicht und NFC-Tag-Referenz
+
+### Fast-Path Erkennung
+
+Sobald ein Tag verarbeitet und mit `sm_id` aktualisiert wurde, nutzt er das Fast-Path-Erkennungssystem für schnelle nachfolgende Scans.
+
+## Fehlerbehebung
+
+### Häufige Probleme
+
+- **Tag zu klein**: NTAG215 oder NTAG216 für größere JSON-Payloads verwenden
+- **Fehlende Felder**: Sicherstellen, dass alle Pflichtfelder vorhanden sind
+- **Ungültiges Format**: JSON-Syntax und Feldtypen überprüfen
+- **Spoolman-Verbindung**: Sicherstellen, dass FilaMan mit der Spoolman API verbinden kann
+
+### Validierung
+
+Das System validiert:
+
+- JSON-Format Korrektheit
+- Vorhandensein der Pflichtfelder
+- Datentyp-Konformität
+- Tag-Größe Kompatibilität
+
+## Technische Details
+
+### Verarbeitungsalgorithmus
+
+1. Tag-Scan erkennt kein `sm_id` Feld
+2. System prüft auf `b` (Marke) und `an` (Artikelnummer) Felder
+3. `checkVendor()` erstellt oder findet Marke in Spoolman
+4. `checkFilament()` erstellt oder findet Filament-Typ
+5. `createSpool()` erstellt neuen Spulen-Eintrag
+6. Tag wird mit neuer `sm_id` aktualisiert
+
+### Fehlerbehandlung
+
+- Graceful Fallback bei Netzwerkproblemen
+- Detaillierte Protokollierung für Debugging
+- Benutzer-Feedback bei fehlgeschlagenen Operationen
+- Wiederholungsmechanismen für temporäre Fehler
+
+### Systemverhalten
+
+#### Bei fehlendem sm_id:
+- System prüft auf `b` (brand) und `an` (artnr) Felder
+- Falls vorhanden → Hersteller Tag erkannt
+- Automatische Erstellung von Lieferant, Filament und Spule in Spoolman
+- Tag wird mit neuer `sm_id` beschrieben
+
+#### Bei vorhandenem sm_id:
+- Fast-Path Erkennung für bekannte Spulen
+- Sofortige Gewichtsmessung ohne vollständige Tag-Analyse
+- Optimierte Performance für häufig verwendete Tags
+
+Dieses System ermöglicht eine nahtlose Integration von Hersteller-Filamentprodukten in das FilaMan-Ökosystem unter Beibehaltung von Datenkonsistenz und Benutzererfahrung.

README_ManufacturerTags_EN.md

@@ -0,0 +1,145 @@
+# Manufacturer Tags - English Documentation
+
+## Overview
+
+The FilaMan NFC system supports **Manufacturer Tags** that allow filament producers to create standardized NFC tags for their products. When scanned, these tags automatically create the necessary entries in Spoolman (brand, filament type, and spool) without requiring manual setup.
+
+## How Manufacturer Tags Work
+
+### Process Flow
+
+1. **Tag Detection**: When a tag without `sm_id` is scanned, the system checks for manufacturer tag format
+2. **Brand Creation/Lookup**: The system searches for the brand in Spoolman or creates it if it doesn't exist
+3. **Filament Type Creation/Lookup**: The filament type is created or found based on brand, material, and specifications
+4. **Spool Creation**: A new spool entry is automatically created with the tag's UID as reference
+5. **Tag Update**: The tag is updated with the new Spoolman spool ID (`sm_id`)
+
+### Why Use Manufacturer Tags?
+
+- **Automatic Integration**: No manual data entry required
+- **Standardized Format**: Consistent product information across different manufacturers
+- **Inventory Management**: Automatic creation of complete Spoolman entries
+- **Traceability**: Direct link between physical product and digital inventory
+
+## Tag Format Specification
+
+### JSON Structure
+
+Manufacturer tags must contain a JSON payload with specific fields using **short keys** to minimize tag size:
+
+```json
+{
+    "b": "Brand/Vendor Name",
+    "an": "Article Number",
+    "t": "Filament Type (PLA, PETG, etc)",
+    "c": "Filament Color without # (FF5733)",
+    "mc": "Optional Multicolor Filament Colors without # (FF0000,00FF00,0000FF)",
+    "mcd": "Optional Multicolor Direction as Word (coaxial, longitudinal)",
+    "cn": "Color Name (red, Blueberry, Arctic Blue)",
+    "et": "Extruder Temp as Number in C° (230)",
+    "bt": "Bed Temp as Number in C° (60)",
+    "di": "Diameter as Float (1.75)",
+    "de": "Density as Float (1.24)",
+    "sw": "Empty Spool Weight as Number in g (180)",
+    "u": "URL to get the Filament with the Article Number"
+}
+```
+
+### Required Fields
+
+- **`b`** (brand): Manufacturer/brand name
+- **`an`** (article number): Unique product identifier
+- **`t`** (type): Material type (PLA, PETG, ABS, etc.)
+- **`c`** (color): Hex color code without #
+- **`cn`** (color name): Human-readable color name
+- **`et`** (extruder temp): Recommended extruder temperature in Celsius
+- **`bt`** (bed temp): Recommended bed temperature in Celsius
+- **`di`** (diameter): Filament diameter in mm
+- **`de`** (density): Material density in g/cm³
+- **`sw`** (spool weight): Empty spool weight in grams
+
+### Optional Fields
+
+- **`mc`** (multicolor): Comma-separated hex colors for multicolor filaments
+- **`mcd`** (multicolor direction): Direction for multicolor (coaxial, longitudinal)
+- **`u`** (url): Product URL with direct link to the article e.g. for reordering
+
+### Example Tag
+
+```json
+{"b":"Recycling Fabrik","an":"FX1_PETG-S175-1000-DAEM00055","t":"PETG","c":"FF5733","cn":"Vibrant Orange","et":"230","bt":"70","di":"1.75","de":"1.24","sw":"180","u":"https://www.recyclingfabrik.com/search?q="}
+```
+
+## Implementation Guidelines
+
+### For Manufacturers
+
+1. **Tag Encoding**: Use NDEF format with MIME type `application/json`
+2. **Data Minimization**: Use the compact JSON format to fit within tag size limits
+3. **Quality Control**: Ensure all required fields are present and correctly formatted
+4. **Testing**: Verify tags work with FilaMan system before production
+
+### Tag Size Considerations
+
+- **NTAG213**: 144 bytes user data (suitable for basic tags)
+- **NTAG215**: 504 bytes user data (recommended for comprehensive data)
+- **NTAG216**: 888 bytes user data (maximum compatibility)
+
+### Best Practices
+
+- Keep brand names consistent across all products
+- Use standardized material type names (PLA, PETG, ABS, etc.)
+- Provide accurate temperature recommendations
+- Include meaningful color names for user experience
+- Test tags with the FilaMan system before mass production
+
+## System Integration
+
+### Spoolman Database Structure
+
+When a manufacturer tag is processed, the system creates:
+
+1. **Vendor Entry**: Brand information in Spoolman vendor database
+2. **Filament Entry**: Material specifications and properties
+3. **Spool Entry**: Individual spool with weight and NFC tag reference
+
+### Fast-Path Recognition
+
+Once a tag is processed and updated with `sm_id`, it uses the fast-path recognition system for quick subsequent scans.
+
+## Troubleshooting
+
+### Common Issues
+
+- **Tag Too Small**: Use NTAG215 or NTAG216 for larger JSON payloads
+- **Missing Fields**: Ensure all required fields are present
+- **Invalid Format**: Verify JSON syntax and field types
+- **Spoolman Connection**: Ensure FilaMan can connect to Spoolman API
+
+### Validation
+
+The system validates:
+- JSON format correctness
+- Required field presence
+- Data type compliance
+- Tag size compatibility
+
+## Technical Details
+
+### Processing Algorithm
+
+1. Tag scan detects no `sm_id` field
+2. System checks for `b` (brand) and `an` (article number) fields
+3. `checkVendor()` creates or finds brand in Spoolman
+4. `checkFilament()` creates or finds filament type
+5. `createSpool()` creates new spool entry
+6. Tag is updated with new `sm_id`
+
+### Error Handling
+
+- Graceful fallback for network issues
+- Detailed logging for debugging
+- User feedback for failed operations
+- Retry mechanisms for temporary failures
+
+This system enables seamless integration of manufacturer filament products into the FilaMan ecosystem while maintaining data consistency and user experience.

html/bambu_credentials.json

@@ -0,0 +1 @@
+{"bambu_ip": "192.168.1.14", "bambu_accesscode": "22772584", "bambu_serialnr": "01P00C492600230","autoSendToBambu":true,"autoSendTime": 60}

html/bambu_filaments.json

@@ -1,7 +1,31 @@
 {
-    "GFU99": "Generic TPU",
-    "GFN99": "Generic PA",
-    "GFN98": "Generic PA-CF",
+    "GFU99": "TPU",
+    "GFN99": "PA",
+    "GFN98": "PA-CF",
+    "GFL99": "PLA",
+    "GFL96": "PLA Silk",
+    "GFL98": "PLA-CF",
+    "GFL95": "PLA High Speed",
+    "GFG99": "PETG",
+    "GFG98": "PETG-CF",
+    "GFG97": "PCTG",
+    "GFB99": "ABS",
+    "GFC99": "PC",
+    "GFB98": "ASA",
+    "GFS99": "PVA",
+    "GFS98": "HIPS",
+    "GFT98": "PPS-CF",
+    "GFT97": "PPS",
+    "GFN97": "PPA-CF",
+    "GFN96": "PPA-GF",
+    "GFP99": "PE",
+    "GFP98": "PE-CF",
+    "GFP97": "PP",
+    "GFP96": "PP-CF",
+    "GFP95": "PP-GF",
+    "GFR99": "EVA",
+    "GFR98": "PHA",
+    "GFS97": "BVOH",
     "GFA01": "Bambu PLA Matte",
     "GFA00": "Bambu PLA Basic",
     "GFA09": "Bambu PLA Tough",
@@ -13,15 +37,11 @@
     "GFL03": "eSUN PLA+",
     "GFL01": "PolyTerra PLA",
     "GFL00": "PolyLite PLA",
-    "GFL99": "Generic PLA",
-    "GFL96": "Generic PLA Silk",
-    "GFL98": "Generic PLA-CF",
     "GFA50": "Bambu PLA-CF",
     "GFS02": "Bambu Support For PLA",
     "GFA11": "Bambu PLA Aero",
     "GFL04": "Overture PLA",
     "GFL05": "Overture Matte PLA",
-    "GFL95": "Generic PLA High Speed",
     "GFA12": "Bambu PLA Glow",
     "GFA13": "Bambu PLA Dynamic",
     "GFA15": "Bambu PLA Galaxy",
@@ -30,41 +50,21 @@
     "GFU00": "Bambu TPU 95A HF",
     "GFG00": "Bambu PETG Basic",
     "GFT01": "Bambu PET-CF",
-    "GFG99": "Generic PETG",
-    "GFG98": "Generic PETG-CF",
     "GFG50": "Bambu PETG-CF",
     "GFG60": "PolyLite PETG",
     "GFG01": "Bambu PETG Translucent",
-    "GFG97": "Generic PCTG",
     "GFB00": "Bambu ABS",
-    "GFB99": "Generic ABS",
     "GFB60": "PolyLite ABS",
     "GFB50": "Bambu ABS-GF",
     "GFC00": "Bambu PC",
-    "GFC99": "Generic PC",
-    "GFB98": "Generic ASA",
     "GFB01": "Bambu ASA",
     "GFB61": "PolyLite ASA",
     "GFB02": "Bambu ASA-Aero",
-    "GFS99": "Generic PVA",
     "GFS04": "Bambu PVA",
     "GFS01": "Bambu Support G",
     "GFN03": "Bambu PA-CF",
     "GFN04": "Bambu PAHT-CF",
     "GFS03": "Bambu Support For PA/PET",
     "GFN05": "Bambu PA6-CF",
-    "GFN08": "Bambu PA6-GF",
-    "GFS98": "Generic HIPS",
-    "GFT98": "Generic PPS-CF",
-    "GFT97": "Generic PPS",
-    "GFN97": "Generic PPA-CF",
-    "GFN96": "Generic PPA-GF",
-    "GFP99": "Generic PE",
-    "GFP98": "Generic PE-CF",
-    "GFP97": "Generic PP",
-    "GFP96": "Generic PP-CF",
-    "GFP95": "Generic PP-GF",
-    "GFR99": "Generic EVA",
-    "GFR98": "Generic PHA",
-    "GFS97": "Generic BVOH"
+    "GFN08": "Bambu PA6-GF"
 }

html/header.html

@@ -6,13 +6,24 @@
     <title>FilaMan - Filament Management Tool</title>
     <link rel="icon" type="image/png" href="/favicon.ico">
     <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
 </head>
 <body>
     <div class="navbar">
         <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.0</span></h1>
+                <h1>FilaMan<span class="version"></span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>
@@ -21,7 +32,7 @@
             <a href="/waage">Scale</a>
             <a href="/spoolman">Spoolman/Bambu</a>
             <a href="/about">About</a>
-            <a href="/ota">Upgrade</a>
+            <a href="/upgrade">Upgrade</a>
         </nav>
         <div class="status-container">
             <div class="status-item">

html/index.html

@@ -6,13 +6,24 @@
     <title>FilaMan - Filament Management Tool</title>
     <link rel="icon" type="image/png" href="/favicon.ico">
     <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
 </head>
 <body>
     <div class="navbar">
         <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.0</span></h1>
+                <h1>FilaMan<span class="version"></span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>
@@ -36,7 +47,7 @@
 
 <!-- head -->
 
-    <div class="container">
+    <div class="content">
         <h1>FilaMan</h1>
         <p>Filament Management Tool</p>
         <p>Your smart solution for <strong>Filament Management</strong> in 3D printing.</p>
@@ -44,10 +55,11 @@
         <h2>About FilaMan</h2>
         <p>
             FilaMan is a tool designed to simplify filament spool management. It allows you to identify and weigh filament spools, 
-            automatically sync data with the self-hosted <a href="https://github.com/Donkie/Spoolman" target="_blank">Spoolman</a> platform, 
-            and ensure compatibility with <a href="https://github.com/spuder/OpenSpool" target="_blank">OpenSpool</a> for Bambu printers.
+            automatically sync data with the self-hosted <a href="https://github.com/Donkie/Spoolman" target="_blank">Spoolman</a> platform.
         </p>
 
+        <p>Get more information at <a href="https://www.filaman.app" target="_blank">https://www.filaman.app</a> and <a href="https://github.com/ManuelW77/Filaman" target="_blank">https://github.com/ManuelW77/Filaman</a>.</p>
+
         <div class="features">
             <div class="feature">
                 <h3>Spool Identification</h3>
@@ -62,12 +74,6 @@
                 <p>Works with OpenSpool to recognize and activate spools on Bambu printers.</p>
             </div>
         </div>
-
-        <h2>Future Plans</h2>
-        <p>
-            We are working on expanding compatibility to support smaller NFC tags like NTag213 
-            and developing custom software to enhance the OpenSpool experience.
-        </p>
     </div>
 </body>
 </html>

html/own_filaments.json

@@ -0,0 +1,31 @@
+{
+    "TPU": "GFU99",
+    "PA": "GFN99",
+    "PA-CF": "GFN98",
+    "PLA": "GFL99",
+    "PLA Silk": "GFL96",
+    "PLA-CF": "GFL98",
+    "PLA High Speed": "GFL95",
+    "PETG": "GFG99",
+    "PETG-CF": "GFG98",
+    "PCTG": "GFG97",
+    "ABS": "GFB99",
+    "ABS+HS": "GFB99",
+    "PC": "GFC99",
+    "PC/ABS": "GFC99",
+    "ASA": "GFB98",
+    "PVA": "GFS99",
+    "HIPS": "GFS98",
+    "PPS-CF": "GFT98",
+    "PPS": "GFT97",
+    "PPA-CF": "GFN97",
+    "PPA-GF": "GFN96",
+    "PE": "GFP99",
+    "PE-CF": "GFP98",
+    "PP": "GFP97",
+    "PP-CF": "GFP96",
+    "PP-GF": "GFP95",
+    "EVA": "GFR99",
+    "PHA": "GFR98",
+    "BVOH": "GFS97"
+}

html/rfid.html

@@ -6,13 +6,24 @@
     <title>FilaMan - Filament Management Tool</title>
     <link rel="icon" type="image/png" href="/favicon.ico">
     <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
 </head>
 <body>
     <div class="navbar">
         <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.0</span></h1>
+                <h1>FilaMan<span class="version"></span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>
@@ -128,17 +139,20 @@
                 <p id="nfcInfo" class="nfc-status"></p>
                 <button id="writeNfcButton" class="btn btn-primary hidden" onclick="writeNfcTag()">Write Tag</button>
             </div>
-        </div>
 
-        <!-- Rechte Spalte -->
-        <div class="column">
             <div class="feature-box">
-                <h2>Bambu AMS</h2>
-                <div id="amsDataContainer">
-                    <div class="amsData" id="amsData">Wait for AMS-Data...</div>
+                <h2>Spoolman Locations</h2>
+                <label for="locationSelect">Location:</label>
+                <div style="display: flex; justify-content: space-between; align-items: center;">
+                    <select id="locationSelect" class="styled-select">
+                        <option value="">Please choose...</option>
+                    </select>
                 </div>
+                <p id="nfcInfoLocation" class="nfc-status"></p>
+                <button id="writeLocationNfcButton" class="btn btn-primary hidden" onclick="writeLocationNfcTag()">Write Location Tag</button>
             </div>
         </div>
+
     </div>
 </div>
 

html/rfid.js

@@ -7,11 +7,12 @@ let heartbeatTimer = null;
 let lastHeartbeatResponse = Date.now();
 const HEARTBEAT_TIMEOUT = 20000;
 let reconnectTimer = null;
+let spoolDetected = false;
 
 // WebSocket Funktionen
 function startHeartbeat() {
     if (heartbeatTimer) clearInterval(heartbeatTimer);
-    
+
     heartbeatTimer = setInterval(() => {
         // Prüfe ob zu lange keine Antwort kam
         if (Date.now() - lastHeartbeatResponse > HEARTBEAT_TIMEOUT) {
@@ -29,7 +30,7 @@ function startHeartbeat() {
             updateConnectionStatus();
             return;
         }
-        
+
         try {
             // Sende Heartbeat
             socket.send(JSON.stringify({ type: 'heartbeat' }));
@@ -83,7 +84,7 @@ function initWebSocket() {
             isConnected = false;
             updateConnectionStatus();
             if (heartbeatTimer) clearInterval(heartbeatTimer);
-            
+
             // Bei Fehler Verbindung schließen und neu aufbauen
             if (socket) {
                 socket.close();
@@ -109,7 +110,7 @@ function initWebSocket() {
                 const bambuDot = document.getElementById('bambuDot');
                 const spoolmanDot = document.getElementById('spoolmanDot');
                 const ramStatus = document.getElementById('ramStatus');
-                
+
                 if (bambuDot) {
                     bambuDot.className = 'status-dot ' + (data.bambu_connected ? 'online' : 'offline');
                     // Add click handler only when offline
@@ -150,6 +151,13 @@ function initWebSocket() {
                     ramStatus.textContent = `${data.freeHeap}k`;
                 }
             }
+            else if (data.type === 'setSpoolmanSettings') {
+                if (data.payload == 'success') {
+                    showNotification(`Spoolman Settings set successfully`, true);
+                } else {
+                    showNotification(`Error setting Spoolman Settings`, false);
+                }
+            }
         };
     } catch (error) {
         isConnected = false;
@@ -201,27 +209,13 @@ document.addEventListener('spoolmanError', function(event) {
     showNotification(`Spoolman Error: ${event.detail.message}`, false);
 });
 
-document.addEventListener('filamentSelected', function(event) {
+document.addEventListener('filamentSelected', function (event) {
     updateNfcInfo();
     // Zeige Spool-Buttons wenn ein Filament ausgewählt wurde
     const selectedText = document.getElementById("selected-filament").textContent;
     updateSpoolButtons(selectedText !== "Please choose...");
 });
 
-// Hilfsfunktion für kontrastreiche Textfarbe
-function getContrastColor(hexcolor) {
-    // Konvertiere Hex zu RGB
-    const r = parseInt(hexcolor.substr(0,2),16);
-    const g = parseInt(hexcolor.substr(2,2),16);
-    const b = parseInt(hexcolor.substr(4,2),16);
-    
-    // Berechne Helligkeit (YIQ Formel)
-    const yiq = ((r*299)+(g*587)+(b*114))/1000;
-    
-    // Return schwarz oder weiß basierend auf Helligkeit
-    return (yiq >= 128) ? '#000000' : '#FFFFFF';
-}
-
 function updateNfcInfo() {
     const selectedText = document.getElementById("selected-filament").textContent;
     const nfcInfo = document.getElementById("nfcInfo");
@@ -285,6 +279,14 @@ function displayAmsData(amsData) {
                     <img src="spool_in.png" alt="Spool In" style="width: 48px; height: 48px; transform: rotate(180deg) scaleX(-1);">
                 </button>`;
 
+            const spoolmanButtonHtml = `
+                <button class="spool-button" onclick="handleSpoolmanSettings('${tray.tray_info_idx}', '${tray.setting_id}', '${tray.cali_idx}', '${tray.nozzle_temp_min}', '${tray.nozzle_temp_max}')" 
+                        style="position: absolute; bottom: 0px; right: 0px; 
+                               background: none; border: none; padding: 0; 
+                               cursor: pointer; display: none;">
+                    <img src="set_spoolman.png" alt="Spool In" style="width: 38px; height: 38px;">
+                </button>`;
+
             if (!hasAnyContent) {
                 return `
                     <div class="tray">
@@ -348,6 +350,7 @@ function displayAmsData(amsData) {
                         ${trayDetails}
                         ${tempHTML}
                         ${(ams.ams_id === 255 && tray.tray_type !== '') ? outButtonHtml : ''}
+                        ${(tray.setting_id != "" && tray.setting_id != "null") ? spoolmanButtonHtml : ''}
                     </div>
                     
                 </div>`;
@@ -373,6 +376,36 @@ function updateSpoolButtons(show) {
     });
 }
 
+function handleSpoolmanSettings(tray_info_idx, setting_id, cali_idx, nozzle_temp_min, nozzle_temp_max) {
+    // Hole das ausgewählte Filament
+    const selectedText = document.getElementById("selected-filament").textContent;
+
+    // Finde die ausgewählte Spule in den Daten
+    const selectedSpool = spoolsData.find(spool => 
+        `${spool.id} | ${spool.filament.name} (${spool.filament.material})` === selectedText
+    );
+
+    const payload = {
+        type: 'setSpoolmanSettings',
+        payload: {
+            filament_id: selectedSpool.filament.id,
+            tray_info_idx: tray_info_idx,
+            setting_id: setting_id,
+            cali_idx: cali_idx,
+            temp_min: nozzle_temp_min,
+            temp_max: nozzle_temp_max
+        }
+    };
+
+    try {
+        socket.send(JSON.stringify(payload));
+        showNotification(`Setting send to Spoolman`, true);
+    } catch (error) {
+        console.error("Error while sending settings to Spoolman:", error);
+        showNotification("Error while sending!", false);
+    }
+}
+
 function handleSpoolOut() {
     // Erstelle Payload
     const payload = {
@@ -444,7 +477,7 @@ function handleSpoolIn(amsId, trayId) {
             nozzle_temp_max: parseInt(maxTemp),
             type: selectedSpool.filament.material,
             brand: selectedSpool.filament.vendor.name,
-            tray_info_idx: selectedSpool.filament.extra.bambu_idx.replace(/['"]+/g, '').trim(),
+            tray_info_idx: selectedSpool.filament.extra.bambu_idx?.replace(/['"]+/g, '').trim() || '',
             cali_idx: "-1"  // Default-Wert setzen
         }
     };
@@ -476,12 +509,15 @@ function updateNfcStatusIndicator(data) {
     if (data.found === 0) {
         // Kein NFC Tag gefunden
         indicator.className = 'status-circle';
+        spoolDetected = false;
     } else if (data.found === 1) {
         // NFC Tag erfolgreich gelesen
         indicator.className = 'status-circle success';
+        spoolDetected = true;
     } else {
         // Fehler beim Lesen
         indicator.className = 'status-circle error';
+        spoolDetected = true;
     }
 }
 
@@ -523,7 +559,10 @@ function updateNfcData(data) {
     }
 
     // HTML für die Datenanzeige erstellen
-    let html = `
+    let html = "";
+
+    if(data.sm_id){
+        html = `
         <div class="nfc-card-data" style="margin-top: 10px;">
             <p><strong>Brand:</strong> ${data.brand || 'N/A'}</p>
             <p><strong>Type:</strong> ${data.type || 'N/A'} ${data.color_hex ? `<span style="
@@ -536,10 +575,27 @@ function updateNfcData(data) {
                 border-radius: 3px;
                 margin-left: 5px;
             "></span>` : ''}</p>
-    `;
+        `;
 
-    // Spoolman ID anzeigen
-    html += `<p><strong>Spoolman ID:</strong> ${data.sm_id || 'No Spoolman ID'}</p>`;
+        // Spoolman ID anzeigen
+        html += `<p><strong>Spoolman ID:</strong> ${data.sm_id} (<a href="${spoolmanUrl}/spool/show/${data.sm_id}">Open in Spoolman</a>)</p>`;
+     }
+     else if(data.location)
+     {
+        html = `
+        <div class="nfc-card-data" style="margin-top: 10px;">
+            <p><strong>Location:</strong> ${data.location || 'N/A'}</p>
+        `;
+     }
+     else
+     {
+        html = `
+        <div class="nfc-card-data" style="margin-top: 10px;">
+            <p><strong>Unknown tag</strong></p>
+        `;
+     }
+
+    
 
     // Nur wenn eine sm_id vorhanden ist, aktualisiere die Dropdowns
     if (data.sm_id) {
@@ -566,67 +622,112 @@ function updateNfcData(data) {
 }
 
 function writeNfcTag() {
-    const selectedText = document.getElementById("selected-filament").textContent;
-    if (selectedText === "Please choose...") {
-        alert('Please select a Spool first.');
-        return;
+    if(!spoolDetected || confirm("Are you sure you want to overwrite the Tag?") == true){
+        const selectedText = document.getElementById("selected-filament").textContent;
+        if (selectedText === "Please choose...") {
+            alert('Please select a Spool first.');
+            return;
+        }
+
+        const spoolsData = window.getSpoolData();
+        const selectedSpool = spoolsData.find(spool => 
+            `${spool.id} | ${spool.filament.name} (${spool.filament.material})` === selectedText
+        );
+
+        if (!selectedSpool) {
+            alert('Ausgewählte Spule konnte nicht gefunden werden.');
+            return;
+        }
+
+        // Temperaturwerte korrekt extrahieren
+        let minTemp = "175";
+        let maxTemp = "275";
+        
+        if (Array.isArray(selectedSpool.filament.nozzle_temperature) && 
+            selectedSpool.filament.nozzle_temperature.length >= 2) {
+            minTemp = String(selectedSpool.filament.nozzle_temperature[0]);
+            maxTemp = String(selectedSpool.filament.nozzle_temperature[1]);
+        }
+
+        // Erstelle das NFC-Datenpaket mit korrekten Datentypen
+        const nfcData = {
+            color_hex: selectedSpool.filament.color_hex || "FFFFFF",
+            type: selectedSpool.filament.material,
+            min_temp: minTemp,
+            max_temp: maxTemp,
+            brand: selectedSpool.filament.vendor.name,
+            sm_id: String(selectedSpool.id) // Konvertiere zu String
+        };
+
+        if (socket?.readyState === WebSocket.OPEN) {
+            const writeButton = document.getElementById("writeNfcButton");
+            writeButton.classList.add("writing");
+            writeButton.textContent = "Writing";
+            socket.send(JSON.stringify({
+                type: 'writeNfcTag',
+                tagType: 'spool',
+                payload: nfcData
+            }));
+        } else {
+            alert('Not connected to Server. Please check connection.');
+        }
     }
+}
 
-    const spoolsData = window.getSpoolData();
-    const selectedSpool = spoolsData.find(spool => 
-        `${spool.id} | ${spool.filament.name} (${spool.filament.material})` === selectedText
-    );
+function writeLocationNfcTag() {
+    if(!spoolDetected || confirm("Are you sure you want to overwrite the Tag?") == true){
+        const selectedText = document.getElementById("locationSelect").value;
+        if (selectedText === "Please choose...") {
+            alert('Please select a location first.');
+            return;
+        }
+        // Erstelle das NFC-Datenpaket mit korrekten Datentypen
+        const nfcData = {
+            location: String(selectedText)
+        };
 
-    if (!selectedSpool) {
-        alert('Ausgewählte Spule konnte nicht gefunden werden.');
-        return;
-    }
 
-    // Temperaturwerte korrekt extrahieren
-    let minTemp = "175";
-    let maxTemp = "275";
-    
-    if (Array.isArray(selectedSpool.filament.nozzle_temperature) && 
-        selectedSpool.filament.nozzle_temperature.length >= 2) {
-        minTemp = String(selectedSpool.filament.nozzle_temperature[0]);
-        maxTemp = String(selectedSpool.filament.nozzle_temperature[1]);
-    }
-
-    // Erstelle das NFC-Datenpaket mit korrekten Datentypen
-    const nfcData = {
-        version: "2.0",
-        protocol: "openspool",
-        color_hex: selectedSpool.filament.color_hex || "FFFFFF",
-        type: selectedSpool.filament.material,
-        min_temp: minTemp,
-        max_temp: maxTemp,
-        brand: selectedSpool.filament.vendor.name,
-        sm_id: String(selectedSpool.id) // Konvertiere zu String
-    };
-
-    if (socket?.readyState === WebSocket.OPEN) {
-        const writeButton = document.getElementById("writeNfcButton");
-        writeButton.classList.add("writing");
-        writeButton.textContent = "Writing";
-        socket.send(JSON.stringify({
-            type: 'writeNfcTag',
-            payload: nfcData
-        }));
-    } else {
-        alert('Not connected to Server. Please check connection.');
+        if (socket?.readyState === WebSocket.OPEN) {
+            const writeButton = document.getElementById("writeLocationNfcButton");
+            writeButton.classList.add("writing");
+            writeButton.textContent = "Writing";
+            socket.send(JSON.stringify({
+                type: 'writeNfcTag',
+                tagType: 'location',
+                payload: nfcData
+            }));
+        } else {
+            alert('Not connected to Server. Please check connection.');
+        }
     }
 }
 
 function handleWriteNfcTagResponse(success) {
     const writeButton = document.getElementById("writeNfcButton");
-    writeButton.classList.remove("writing");
-    writeButton.classList.add(success ? "success" : "error");
-    writeButton.textContent = success ? "Write success" : "Write failed";
+    const writeLocationButton = document.getElementById("writeLocationNfcButton");
+    if(writeButton.classList.contains("writing")){
+        writeButton.classList.remove("writing");
+        writeButton.classList.add(success ? "success" : "error");
+        writeButton.textContent = success ? "Write success" : "Write failed";
 
-    setTimeout(() => {
-        writeButton.classList.remove("success", "error");
-        writeButton.textContent = "Write Tag";
-    }, 5000);
+        setTimeout(() => {
+            writeButton.classList.remove("success", "error");
+            writeButton.textContent = "Write Tag";
+        }, 5000);
+    }
+
+    if(writeLocationButton.classList.contains("writing")){
+        writeLocationButton.classList.remove("writing");
+        writeLocationButton.classList.add(success ? "success" : "error");
+        writeLocationButton.textContent = success ? "Write success" : "Write failed";
+
+        setTimeout(() => {
+            writeLocationButton.classList.remove("success", "error");
+            writeLocationButton.textContent = "Write Location Tag";
+        }, 5000);
+    }
+
+    
 }
 
 function showNotification(message, isSuccess) {
@@ -642,4 +743,4 @@ function showNotification(message, isSuccess) {
             notification.remove();
         }, 300);
     }, 3000);
-}
+}

html/rfid_bambu.html

@@ -0,0 +1,172 @@
+<!-- head --><!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FilaMan - Filament Management Tool</title>
+    <link rel="icon" type="image/png" href="/favicon.ico">
+    <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
+</head>
+<body>
+    <div class="navbar">
+        <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"></span></h1>
+                <h4>Filament Management Tool</h4>
+            </div>
+        </div>
+        <nav style="display: flex; gap: 1rem;">
+            <a href="/">Start</a>
+            <a href="/waage">Scale</a>
+            <a href="/spoolman">Spoolman/Bambu</a>
+            <a href="/about">About</a>
+            <a href="/upgrade">Upgrade</a>
+        </nav>
+        <div class="status-container">
+            <div class="status-item">
+                <span class="status-dot" id="bambuDot"></span>B
+            </div>
+            <div class="status-item">
+                <span class="status-dot" id="spoolmanDot"></span>S
+            </div>
+            <div class="ram-status" id="ramStatus"></div>
+        </div>
+    </div>
+
+<!-- head -->
+
+<div class="connection-status hidden">
+    <div class="spinner"></div>
+    <span>Connection lost. Trying to reconnect...</span>
+</div>
+<div class="content">
+    <div class="three-column-layout">
+        <!-- Linke Spalte -->
+        <div class="column">
+            <div class="feature-box">
+                <div class="statistics-header">
+                    <h2>Statistics</h2>
+                    <button id="refreshSpoolman" class="refresh-button">
+                        <span>Refresh Spoolman</span>
+                    </button>
+                </div>
+                <div class="statistics-column">
+                    <h3>Spools</h3>
+                        <div class="spool-stat" style="display: flex; justify-content: center; align-items: center;">
+                            <span class="stat-label">total:</span>
+                            <span class="stat-value" id="totalSpools"></span>
+                            <div style="width: auto;"></div>
+                            <span class="stat-label">without Tag:</span>
+                            <span class="stat-value" id="spoolsWithoutTag"></span>
+                        </div>
+                </div>
+
+                <div class="statistics-grid">
+                    <div class="statistics-column">
+                        <h3>Overview</h3>
+                        <ul class="statistics-list">
+                            <li>
+                                <span class="stat-label">Manufacturer:</span>
+                                <span class="stat-value" id="totalVendors"></span>
+                            </li>
+                            <li>
+                                <span class="stat-label">Weight:</span>
+                                <span class="stat-value"><span id="totalWeight"></span></span>
+                            </li>
+                            <li>
+                                <span class="stat-label">Length:</span>
+                                <span class="stat-value"><span id="totalLength"></span></span>
+                            </li>
+                        </ul>
+                    </div>
+                    <div class="statistics-column">
+                        <h3>Materials</h3>
+                        <ul class="statistics-list" id="materialsList">
+                            <!-- Wird dynamisch befüllt -->
+                        </ul>
+                    </div>
+                </div>
+            </div>
+            <div class="feature-box">
+                <div class="nfc-header">
+                    <h2>NFC-Tag</h2>
+                    <span id="nfcStatusIndicator" class="status-circle"></span>
+                </div>
+                <div class="nfc-status-display"></div>
+            </div>
+        </div>
+
+        <!-- Mittlere Spalte -->
+        <div class="column">
+            <div class="feature-box">
+                <h2>Spoolman Spools</h2>
+                <label for="vendorSelect">Manufacturer:</label>
+                <div style="display: flex; justify-content: space-between; align-items: center;">
+                    <select id="vendorSelect" class="styled-select">
+                        <option value="">Please choose...</option>
+                    </select>
+                    <label style="margin-left: 10px;">
+                        <input type="checkbox" id="onlyWithoutSmId" checked onchange="updateFilamentDropdown()">
+                        Only Spools without SM ID
+                    </label>
+                </div>
+            </div>
+
+            <div id="filamentSection" class="feature-box hidden">
+                <label>Spool / Filament:</label>
+                <div class="custom-dropdown">
+                    <div class="dropdown-button" onclick="toggleFilamentDropdown()">
+                        <div class="selected-color" id="selected-color"></div>
+                        <span id="selected-filament">Please choose...</span>
+                        <span class="dropdown-arrow">▼</span>
+                    </div>
+                    <div class="dropdown-content" id="filament-dropdown-content">
+                        <!-- Optionen werden dynamisch hinzugefügt -->
+                    </div>
+                </div>
+                <p id="nfcInfo" class="nfc-status"></p>
+                <button id="writeNfcButton" class="btn btn-primary hidden" onclick="writeNfcTag()">Write Tag</button>
+            </div>
+
+            <div class="feature-box">
+                <h2>Spoolman Locations</h2>
+                <label for="locationSelect">Location:</label>
+                <div style="display: flex; justify-content: space-between; align-items: center;">
+                    <select id="locationSelect" class="styled-select">
+                        <option value="">Please choose...</option>
+                    </select>
+                </div>
+                <p id="nfcInfoLocation" class="nfc-status"></p>
+                <button id="writeLocationNfcButton" class="btn btn-primary hidden" onclick="writeLocationNfcTag()">Write Location Tag</button>
+            </div>
+        </div>
+
+        <!-- Rechte Spalte -->
+        <div class="column">
+            <div class="feature-box">
+                <h2>Bambu AMS</h2>
+                <div id="amsDataContainer">
+                    <div class="amsData" id="amsData">Wait for AMS-Data...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="spoolman.js"></script>
+<script src="rfid.js"></script>
+
+</body>
+</html>

html/spoolman.html

@@ -6,13 +6,24 @@
     <title>FilaMan - Filament Management Tool</title>
     <link rel="icon" type="image/png" href="/favicon.ico">
     <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
 </head>
 <body>
     <div class="navbar">
         <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.0</span></h1>
+                <h1>FilaMan<span class="version"></span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>
@@ -41,11 +52,43 @@
             if (spoolmanUrl && spoolmanUrl.trim() !== "") {
                 document.getElementById('spoolmanUrl').value = spoolmanUrl;
             }
+            
+            // Initialize OctoPrint fields visibility
+            toggleOctoFields();
         };
 
+        function removeBambuCredentials() {
+            fetch('/api/bambu?remove=true')
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success) {
+                        document.getElementById('bambuIp').value = '';
+                        document.getElementById('bambuSerial').value = '';
+                        document.getElementById('bambuCode').value = '';
+                        document.getElementById('autoSend').checked = false;
+                        document.getElementById('autoSendTime').value = '';
+                        document.getElementById('bambuStatusMessage').innerText = 'Bambu Credentials removed!';
+                        // Reload with forced cache refresh after short delay
+                        setTimeout(() => {
+                            window.location.reload(true);
+                            window.location.href = '/';
+                        }, 1500);
+                    } else {
+                        document.getElementById('bambuStatusMessage').innerText = 'Error while removing Bambu Credentials.';
+                    }
+                })
+                .catch(error => {
+                    document.getElementById('bambuStatusMessage').innerText = 'Error while removing: ' + error.message;
+                });
+        }
+
         function checkSpoolmanInstance() {
             const url = document.getElementById('spoolmanUrl').value;
-            fetch(`/api/checkSpoolman?url=${encodeURIComponent(url)}`)
+            const spoolmanOctoEnabled = document.getElementById('spoolmanOctoEnabled').checked;
+            const spoolmanOctoUrl = document.getElementById('spoolmanOctoUrl').value;
+            const spoolmanOctoToken = document.getElementById('spoolmanOctoToken').value;
+            
+            fetch(`/api/checkSpoolman?url=${encodeURIComponent(url)}&octoEnabled=${spoolmanOctoEnabled}&octoUrl=${spoolmanOctoUrl}&octoToken=${spoolmanOctoToken}`)
                 .then(response => response.json())
                 .then(data => {
                     if (data.healthy) {
@@ -63,12 +106,19 @@
             const ip = document.getElementById('bambuIp').value;
             const serial = document.getElementById('bambuSerial').value;
             const code = document.getElementById('bambuCode').value;
+            const autoSend = document.getElementById('autoSend').checked;
+            const autoSendTime = document.getElementById('autoSendTime').value;
 
-            fetch(`/api/bambu?bambu_ip=${encodeURIComponent(ip)}&bambu_serialnr=${encodeURIComponent(serial)}&bambu_accesscode=${encodeURIComponent(code)}`)
+            fetch(`/api/bambu?bambu_ip=${encodeURIComponent(ip)}&bambu_serialnr=${encodeURIComponent(serial)}&bambu_accesscode=${encodeURIComponent(code)}&autoSend=${autoSend}&autoSendTime=${autoSendTime}`)
                 .then(response => response.json())
                 .then(data => {
                     if (data.healthy) {
                         document.getElementById('bambuStatusMessage').innerText = 'Bambu Credentials saved!';
+                        // Reload with forced cache refresh after short delay
+                        setTimeout(() => {
+                            window.location.reload(true);
+                            window.location.href = '/';
+                        }, 1500);
                     } else {
                         document.getElementById('bambuStatusMessage').innerText = 'Error while saving Bambu Credentials.';
                     }
@@ -77,6 +127,15 @@
                     document.getElementById('bambuStatusMessage').innerText = 'Error while saving: ' + error.message;
                 });
         }
+
+        /**
+         * Controls visibility of OctoPrint configuration fields based on checkbox state
+         * Called on page load and when checkbox changes
+         */
+        function toggleOctoFields() {
+            const octoEnabled = document.getElementById('spoolmanOctoEnabled').checked;
+            document.getElementById('octoFields').style.display = octoEnabled ? 'block' : 'none';
+        }
     </script>
     <script>
         var spoolmanUrl = "{{spoolmanUrl}}";
@@ -84,27 +143,59 @@
     
     <div class="content">
         <h1>Spoolman API URL / Bambu Credentials</h1>
-        <label for="spoolmanUrl">Set URL/IP to your Spoolman-Instanz:</label>
-        <input type="text" id="spoolmanUrl" placeholder="http://ip-or-url-of-your-spoolman-instanz:port">
-        <button onclick="checkSpoolmanInstance()">Save Spoolman URL</button>
-        <p id="statusMessage"></p>
 
-        <h2>Bambu Lab Printer Credentials</h2>
-        <div class="bambu-settings">
-            <div class="input-group">
-                <label for="bambuIp">Bambu Drucker IP-Adresse:</label>
-                <input type="text" id="bambuIp" placeholder="192.168.1.xxx" value="{{bambuIp}}">
+        <div class="card">
+            <div class="card-body">
+                <h5 class="card-title">Set URL/IP to your Spoolman instance</h5>
+                <input type="text" id="spoolmanUrl" onkeydown="if(event.keyCode == 13) document.getElementById('btnSaveSpoolmanUrl').click()" placeholder="http://ip-or-url-of-your-spoolman-instance:port">
+                <h5 class="card-title">If you want to enable sending the spool to the Spoolman Octoprint plugin:</h5>
+                <p>
+                    <input type="checkbox" id="spoolmanOctoEnabled" {{spoolmanOctoEnabled}} onchange="toggleOctoFields()"> Send to Octo-Plugin
+                </p>
+                <div id="octoFields" style="display: none;">
+                    <p>
+                        <input type="text" id="spoolmanOctoUrl" placeholder="http://ip-or-url-of-your-octoprint-instance:port" value="{{spoolmanOctoUrl}}">
+                        <input type="text" id="spoolmanOctoToken" placeholder="Your Octoprint Token" value="{{spoolmanOctoToken}}">
+                    </p>
+                </div>
+                
+                <button id="btnSaveSpoolmanUrl" onclick="checkSpoolmanInstance()">Save Spoolman URL</button>
+                <p id="statusMessage"></p>
             </div>
-            <div class="input-group">
-                <label for="bambuSerial">Drucker Seriennummer:</label>
-                <input type="text" id="bambuSerial" placeholder="BBLXXXXXXXX" value="{{bambuSerial}}">
+        </div>
+
+        <div class="card">
+            <div class="card-body">
+                <h5 class="card-title">Bambu Lab Printer Credentials</h5>
+                <div class="bambu-settings">
+                    <div class="input-group">
+                        <label for="bambuIp">Bambu Printer IP Address:</label>
+                        <input type="text" id="bambuIp" placeholder="192.168.1.xxx" value="{{bambuIp}}">
+                    </div>
+                    <div class="input-group">
+                        <label for="bambuSerial">Printer Serial Number:</label>
+                        <input type="text" id="bambuSerial" placeholder="BBLXXXXXXXX" value="{{bambuSerial}}">
+                    </div>
+                    <div class="input-group">
+                        <label for="bambuCode">Access Code:</label>
+                        <input type="text" id="bambuCode" placeholder="Access Code of the printer" value="{{bambuCode}}">
+                    </div>
+                    <hr>
+                    <p>If activated, FilaMan will automatically update the next filled tray with the last scanned and weighed spool.</p>
+                    <div class="input-group" style="display: flex; margin-bottom: 0;">
+                        <label for="autoSend" style="width: 250px; margin-right: 5px;">Auto Send to Bambu:</label>
+                        <label for="autoSendTime" style="width: 250px; margin-right: 5px;">Wait for Spool in Sec:</label>
+                    </div>
+                    <div class="input-group" style="display: flex;">
+                        <input type="checkbox" id="autoSend" {{autoSendToBambu}} style="width: 190px; margin-right: 10px;">
+                        <input type="number" min="60" id="autoSendTime" placeholder="Time to wait" value="{{autoSendTime}}" style="width: 100px;">
+                    </div>
+
+                    <button style="margin: 0;" onclick="saveBambuCredentials()">Save Bambu Credentials</button>
+                    <button style="margin: 0; background-color: red;" onclick="removeBambuCredentials()">Remove Credentials</button>
+                    <p id="bambuStatusMessage"></p>
+                </div>
             </div>
-            <div class="input-group">
-                <label for="bambuCode">Access Code:</label>
-                <input type="text" id="bambuCode" placeholder="Access Code vom Drucker" value="{{bambuCode}}">
-            </div>
-            <button onclick="saveBambuCredentials()">Save Bambu Credentials</button>
-            <p id="bambuStatusMessage"></p>
         </div>
     </div>
 </body>

html/spoolman.js

@@ -1,6 +1,7 @@
 // Globale Variablen
 let spoolmanUrl = '';
 let spoolsData = [];
+let locationData = [];
 
 // Hilfsfunktionen für Datenmanipulation
 function processSpoolData(data) {
@@ -86,10 +87,10 @@ function populateVendorDropdown(data, selectedSmId = null) {
     });
 
     // Nach der Schleife: Formatierung der Gesamtlänge
-    console.log("Total Lenght: ", totalLength);
-    const formattedLength = totalLength > 1000 
-        ? (totalLength / 1000).toFixed(2) + " km" 
-        : totalLength.toFixed(2) + " m";
+    const lengthInM = totalLength / 1000;  // erst in m umrechnen
+    const formattedLength = lengthInM > 1000 
+        ? (lengthInM / 1000).toFixed(2) + " km" 
+        : lengthInM.toFixed(2) + " m";
 
     // Formatierung des Gesamtgewichts (von g zu kg zu t)
     const weightInKg = totalWeight / 1000;  // erst in kg umrechnen
@@ -97,13 +98,15 @@ function populateVendorDropdown(data, selectedSmId = null) {
         ? (weightInKg / 1000).toFixed(2) + " t" 
         : weightInKg.toFixed(2) + " kg";
 
-    // Dropdown mit gefilterten Herstellern befüllen
-    Object.entries(filteredVendors).forEach(([id, name]) => {
-        const option = document.createElement("option");
-        option.value = id;
-        option.textContent = name;
-        vendorSelect.appendChild(option);
-    });
+    // Dropdown mit gefilterten Herstellern befüllen - alphabetisch sortiert
+    Object.entries(filteredVendors)
+        .sort(([, nameA], [, nameB]) => nameA.localeCompare(nameB)) // Sort vendors alphabetically by name
+        .forEach(([id, name]) => {
+            const option = document.createElement("option");
+            option.value = id;
+            option.textContent = name;
+            vendorSelect.appendChild(option);
+        });
 
     document.getElementById("totalSpools").textContent = totalSpools;
     document.getElementById("spoolsWithoutTag").textContent = spoolsWithoutTag;
@@ -131,6 +134,26 @@ function populateVendorDropdown(data, selectedSmId = null) {
     }
 }
 
+// Dropdown-Funktionen
+function populateLocationDropdown(data) {
+    const locationSelect = document.getElementById("locationSelect");
+    if (!locationSelect) {
+        console.error('locationSelect Element nicht gefunden');
+        return;
+    }
+
+    locationSelect.innerHTML = '<option value="">Bitte wählen...</option>';
+    // Dropdown mit gefilterten Herstellern befüllen - alphabetisch sortiert
+    Object.entries(data)
+        .sort(([, nameA], [, nameB]) => nameA.localeCompare(nameB)) // Sort vendors alphabetically by name
+        .forEach(([id, name]) => {
+            const option = document.createElement("option");
+            option.value = name;
+            option.textContent = name;
+            locationSelect.appendChild(option);
+        });
+}
+
 function updateFilamentDropdown(selectedSmId = null) {
     const vendorId = document.getElementById("vendorSelect").value;
     const dropdownContentInner = document.getElementById("filament-dropdown-content");
@@ -145,6 +168,13 @@ function updateFilamentDropdown(selectedSmId = null) {
 
     if (vendorId) {
         const filteredFilaments = spoolsData.filter(spool => {
+            if (!spool?.filament?.vendor?.id) {
+                console.log('Problem aufgetreten bei: ', spool?.filament?.vendor);
+                console.log('Problematische Spulen:', 
+                    spoolsData.filter(spool => !spool?.filament?.vendor?.id));
+                return false;
+            }
+
             const hasValidNfcId = spool.extra && 
                                  spool.extra.nfc_id && 
                                  spool.extra.nfc_id !== '""' && 
@@ -160,9 +190,32 @@ function updateFilamentDropdown(selectedSmId = null) {
             option.setAttribute("data-value", spool.filament.id);
             option.setAttribute("data-nfc-id", spool.extra.nfc_id || "");
             
-            const colorHex = spool.filament.color_hex || 'FFFFFF';
+
+            // Generate color representation based on filament type (single or multi color)
+            let colorHTML = '';
+            
+            // Check if this is a multicolor filament
+            if (spool.filament.multi_color_hexes) {
+                // Parse multi color hexes from comma-separated string
+                const colors = spool.filament.multi_color_hexes.replace(/#/g, '').split(',');
+                
+                // Determine the display style based on direction
+                const direction = spool.filament.multi_color_direction || 'coaxial';
+                
+                // Generate color circles for each color
+                colorHTML = '<div class="option-colors">';
+                colors.forEach(color => {
+                    colorHTML += `<div class="option-color multi-color ${direction}" style="background-color: #${color}"></div>`;
+                });
+                colorHTML += '</div>';
+            } else {
+                // Single color filament
+                const colorHex = spool.filament.color_hex || 'FFFFFF';
+                colorHTML = `<div class="option-color" style="background-color: #${colorHex}"></div>`;
+            }
+            
             option.innerHTML = `
-                <div class="option-color" style="background-color: #${colorHex}"></div>
+                ${colorHTML}
                 <span>${spool.id} | ${spool.filament.name} (${spool.filament.material})</span>
             `;
             
@@ -176,12 +229,41 @@ function updateFilamentDropdown(selectedSmId = null) {
     }
 }
 
+function updateLocationSelect(){
+    const writeLocationNfcButton = document.getElementById('writeLocationNfcButton');
+    if(writeLocationNfcButton){
+        writeLocationNfcButton.classList.remove("hidden");
+    }
+}
+
 function selectFilament(spool) {
     const selectedColor = document.getElementById("selected-color");
     const selectedText = document.getElementById("selected-filament");
     const dropdownContent = document.getElementById("filament-dropdown-content");
     
-    selectedColor.style.backgroundColor = `#${spool.filament.color_hex || 'FFFFFF'}`;
+    // Update the selected color display
+    if (spool.filament.multi_color_hexes) {
+        // Handle multicolor filament display in the selection header
+        const colors = spool.filament.multi_color_hexes.replace(/#/g, '').split(',');
+        const direction = spool.filament.multi_color_direction || 'coaxial';
+        
+        // Replace the single color div with multiple color divs
+        selectedColor.innerHTML = '';
+        colors.forEach(color => {
+            const colorDiv = document.createElement('div');
+            colorDiv.className = `color-segment multi-color ${direction}`;
+            colorDiv.style.backgroundColor = `#${color}`;
+            selectedColor.appendChild(colorDiv);
+        });
+        // Add multiple color class to the container
+        selectedColor.classList.add('multi-color-container');
+    } else {
+        // Single color filament - reset to default display
+        selectedColor.innerHTML = '';
+        selectedColor.classList.remove('multi-color-container');
+        selectedColor.style.backgroundColor = `#${spool.filament.color_hex || 'FFFFFF'}`;
+    }
+    
     selectedText.textContent = `${spool.id} | ${spool.filament.name} (${spool.filament.material})`;
     dropdownContent.classList.remove("show");
     
@@ -207,10 +289,18 @@ async function initSpoolman() {
         
         const fetchedData = await fetchSpoolData();
         spoolsData = processSpoolData(fetchedData);
-        
+
         document.dispatchEvent(new CustomEvent('spoolDataLoaded', { 
             detail: spoolsData 
         }));
+        
+        locationData = await fetchLocationData();
+        
+        document.dispatchEvent(new CustomEvent('locationDataLoaded', { 
+            detail: locationData 
+        }));
+
+
     } catch (error) {
         console.error('Fehler beim Initialisieren von Spoolman:', error);
         document.dispatchEvent(new CustomEvent('spoolmanError', { 
@@ -238,17 +328,24 @@ async function fetchSpoolData() {
     }
 }
 
-/*
-// Exportiere Funktionen
-window.getSpoolData = () => spoolsData;
-window.reloadSpoolData = initSpoolman;
-window.populateVendorDropdown = populateVendorDropdown;
-window.updateFilamentDropdown = updateFilamentDropdown;
-window.toggleFilamentDropdown = () => {
-    const content = document.getElementById("filament-dropdown-content");
-    content.classList.toggle("show");
-};
-*/
+async function fetchLocationData() {
+    try {
+        if (!spoolmanUrl) {
+            throw new Error('Spoolman URL ist nicht initialisiert');
+        }
+        
+        const response = await fetch(`${spoolmanUrl}/api/v1/location`);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        return data;
+    } catch (error) {
+        console.error('Fehler beim Abrufen der Location-Daten:', error);
+        return [];
+    }
+}
 
 // Event Listener
 document.addEventListener('DOMContentLoaded', () => {
@@ -258,6 +355,11 @@ document.addEventListener('DOMContentLoaded', () => {
     if (vendorSelect) {
         vendorSelect.addEventListener('change', () => updateFilamentDropdown());
     }
+
+    const locationSelect = document.getElementById('locationSelect');
+    if (locationSelect) {
+        locationSelect.addEventListener('change', () => updateLocationSelect());
+    }
     
     const onlyWithoutSmId = document.getElementById('onlyWithoutSmId');
     if (onlyWithoutSmId) {
@@ -270,6 +372,10 @@ document.addEventListener('DOMContentLoaded', () => {
     document.addEventListener('spoolDataLoaded', (event) => {
         populateVendorDropdown(event.detail);
     });
+
+    document.addEventListener('locationDataLoaded', (event) => {
+        populateLocationDropdown(event.detail);
+    });
     
     window.onclick = function(event) {
         if (!event.target.closest('.custom-dropdown')) {
@@ -300,6 +406,7 @@ window.getSpoolData = () => spoolsData;
 window.setSpoolData = (data) => { spoolsData = data; };
 window.reloadSpoolData = initSpoolman;
 window.populateVendorDropdown = populateVendorDropdown;
+window.populateLocationDropdown = populateLocationDropdown;
 window.updateFilamentDropdown = updateFilamentDropdown;
 window.toggleFilamentDropdown = () => {
     const content = document.getElementById("filament-dropdown-content");

html/spoolman_url.json

@@ -0,0 +1 @@
+{"url": "http://192.168.1.5:7912", "octoEnabled": true, "octoUrl": "http://192.168.1.17:5001", "octoToken": "O5zZ58mXRAyeGpVEj2ZZj-UPAPqJ2N7JgtD36mw1M4g"}

html/style.css

@@ -188,14 +188,18 @@ label {
     font-weight: bold; 
 }
 
-input[type="text"], input[type="submit"] { 
+input[type="text"], input[type="submit"], input[type="number"] { 
     padding: 10px; 
     border: 1px solid #ccc; 
     border-radius: 5px; 
     font-size: 16px; 
 }
 
-input[type="text"]:focus { 
+input[type="number"] { 
+    width: 108px !important; 
+}
+
+input[type="text"]:focus, input[type="number"]:focus { 
     border-color: #007bff; 
     outline: none; 
 }
@@ -279,9 +283,10 @@ a:hover {
 
 /* Karten-Stil für optische Trennung */
 .card {
-    background: #f9f9f9;
+    background: var(--primary-color);
+    width: 500px;
     padding: 15px;
-    margin: 20px 0;
+    margin: 20px auto;
     border-radius: 8px;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
 }
@@ -754,23 +759,69 @@ a:hover {
     flex-shrink: 0;
 }
 
+/* Multi-color filament styles */
+.option-colors {
+    display: flex;
+    flex-shrink: 0;
+    gap: 2px;
+}
+
+.multi-color {
+    width: 14px;
+    height: 14px;
+    border-radius: 50%;
+    border: 1px solid #333;
+}
+
+/* Coaxial pattern (horizontal stripes) */
+.multi-color.coaxial {
+    border-radius: 50%;
+    position: relative;
+}
+
+/* Longitudinal pattern (vertical stripes) */
+.multi-color.longitudinal {
+    border-radius: 50%;
+    position: relative;
+}
+
+/* Container for multiple colors in selected display */
+.multi-color-container {
+    display: flex !important;
+    background: none !important;
+    border: none !important;
+    gap: 2px;
+    align-items: center;
+    justify-content: flex-start;
+    width: auto !important;
+}
+
+.color-segment {
+    width: 16px;
+    height: 16px;
+    border-radius: 50%;
+    border: 1px solid #333;
+}
+
 .notification {
     position: fixed;
     top: 20px;
     right: 20px;
     padding: 15px 25px;
     border-radius: 4px;
-    color: white;
+    color: black;
     z-index: 1000;
     animation: slideIn 0.3s ease-out;
 }
 
 .notification.success {
     background-color: #28a745;
+    color: black !important;
 }
 
 .notification.error {
     background-color: #dc3545;
+    color: white !important;
 }
 
 .notification.fade-out {
@@ -920,31 +971,35 @@ input[type="submit"]:disabled,
 }
 
 /* Schreib-Button */
-#writeNfcButton {
+#writeNfcButton, #writeLocationNfcButton {
     background-color: #007bff;
     color: white;
     transition: background-color 0.3s, color 0.3s;
     width: 160px;
 }
 
-#writeNfcButton.writing {
+#writeNfcButton.writing, #writeLocationNfcButton.writing {
     background-color: #ffc107;
     color: black;
     width: 160px;
 }
 
-#writeNfcButton.success {
+#writeNfcButton.success, #writeLocationNfcButton.success {
     background-color: #28a745;
     color: white;
     width: 160px;
 }
 
-#writeNfcButton.error {
+#writeNfcButton.error, #writeLocationNfcButton.error {
     background-color: #dc3545;
     color: white;
     width: 160px;
 }
 
+#writeLocationNfcButton{
+    width: 250px;
+}
+
 @keyframes dots {
     0% { content: ""; }
     33% { content: "."; }
@@ -952,14 +1007,13 @@ input[type="submit"]:disabled,
     100% { content: "..."; }
 }
 
-#writeNfcButton.writing::after {
+#writeNfcButton.writing::after, #writeLocationNfcButton.writing::after {
     content: "...";
     animation: dots 1s steps(3, end) infinite;
 }
 
 /* Bambu Settings Erweiterung */
 .bambu-settings {
-    background: white;
     padding: 20px;
     border-radius: 8px;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
@@ -1013,4 +1067,141 @@ input[type="submit"]:disabled,
     color: #000;
     vertical-align: middle;
     margin-left: 0.5rem;
+    text-shadow: none !important;
+}
+
+.progress-container {
+    width: 100%;
+    margin: 20px 0;
+    display: none;
+    background: #f0f0f0;
+    border-radius: 4px;
+    overflow: hidden;
+}
+.progress-bar {
+    width: 0%;
+    height: 24px;
+    background-color: #4CAF50;
+    text-align: center;
+    line-height: 24px;
+    color: white;
+    transition: width 0.3s ease-in-out;
+    font-weight: bold;
+}
+.status {
+    margin: 10px 0;
+    padding: 15px;
+    border-radius: 4px;
+    display: none;
+}
+.error { 
+    background-color: #ffebee; 
+    color: #c62828; 
+    border: 1px solid #ef9a9a;
+}
+.success { 
+    background-color: #e8f5e9; 
+    color: #2e7d32; 
+    border: 1px solid #a5d6a7;
+}
+.update-form {
+    background: var(--primary-color);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.05);
+    border: var(--glass-border);
+    padding: 20px;
+    border-radius: 8px;
+    margin: 0 auto;
+    width: 400px;
+    text-align: center;
+}
+.update-form input[type="file"] {
+    margin-bottom: 15px;
+    width: 80%;
+    padding: 8px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    background-color: #4CAF50;
+}
+.update-form input[type="submit"] {
+    background-color: #4CAF50;
+    color: white;
+    padding: 10px 20px;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 16px;
+    transition: background-color 0.3s;
+}
+.update-form input[type="submit"]:hover {
+    background-color: #45a049;
+}
+.update-form input[type="submit"]:disabled {
+    background-color: #cccccc;
+    cursor: not-allowed;
+}
+.warning {
+    background-color: var(--primary-color);
+    border: 1px solid #ffe0b2;
+    margin: 20px auto;
+    border-radius: 4px;
+    max-width: 600px;
+    text-align: center;
+    color: #e65100;
+    padding: 15px;
+}
+
+.update-options {
+    display: flex;
+    gap: 2rem;
+    margin: 2rem 0;
+}
+.update-section {
+    flex: 1;
+    background: var(--background-green);
+    padding: 1.5rem;
+    border-radius: 8px;
+}
+.update-section h2 {
+    margin-top: 0;
+    color: #333;
+}
+.update-section p {
+    color: #666;
+    margin-bottom: 1rem;
+}
+.progress-container {
+    margin: 20px 0;
+    background: #f0f0f0;
+    border-radius: 4px;
+    overflow: hidden;
+}
+.progress-bar {
+    width: 0;
+    height: 20px;
+    background: #4CAF50;
+    transition: width 0.3s ease-in-out;
+    text-align: center;
+    line-height: 20px;
+    color: white;
+}
+.status {
+    margin-top: 20px;
+    padding: 10px;
+    border-radius: 4px;
+    display: none;
+}
+.status.success {
+    background: #e8f5e9;
+    color: #2e7d32;
+}
+.status.error {
+    background: #ffebee;
+    color: #c62828;
+}
+.warning {
+    background: #fff3e0;
+    color: #e65100;
+    padding: 15px;
+    border-radius: 4px;
+    margin-bottom: 20px;
 }

html/upgrade.html

@@ -0,0 +1,255 @@
+<!-- head --><!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FilaMan - Filament Management Tool</title>
+    <link rel="icon" type="image/png" href="/favicon.ico">
+    <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
+</head>
+<body>
+    <div class="navbar">
+        <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"></span></h1>
+                <h4>Filament Management Tool</h4>
+            </div>
+        </div>
+        <nav style="display: flex; gap: 1rem;">
+            <a href="/">Start</a>
+            <a href="/waage">Scale</a>
+            <a href="/spoolman">Spoolman/Bambu</a>
+            <a href="/about">About</a>
+            <a href="/upgrade">Upgrade</a>
+        </nav>
+        <div class="status-container">
+            <div class="status-item">
+                <span class="status-dot" id="bambuDot"></span>B
+            </div>
+            <div class="status-item">
+                <span class="status-dot" id="spoolmanDot"></span>S
+            </div>
+            <div class="ram-status" id="ramStatus"></div>
+        </div>
+    </div>
+
+<!-- head -->
+    
+    <div class="content">
+        <h1>Firmware Upgrade</h1>
+
+        <div class="warning">
+            <strong>Warning:</strong> Do not power off the device during update.
+        </div>
+
+        <div class="update-options">
+            <div class="update-section">
+                <h2>1) Firmware Update</h2>
+                <p>Upload a new firmware file (upgrade_filaman_firmware_*.bin)</p>
+                <div class="update-form">
+                    <form id="firmwareForm" enctype='multipart/form-data' data-type="firmware">
+                        <input type='file' name='update' accept='.bin' required>
+                        <input type='submit' value='Start Firmware Update'>
+                    </form>
+                </div>
+            </div>
+
+            <div class="update-section">
+                <h2>2) Webpage Update</h2>
+                <p>Upload a new webpage file (upgrade_filaman_website_*.bin)</p>
+                <div class="update-form">
+                    <form id="webpageForm" enctype='multipart/form-data' data-type="webpage">
+                        <input type='file' name='update' accept='.bin' required>
+                        <input type='submit' value='Start Webpage Update'>
+                    </form>
+                </div>
+            </div>
+        </div>
+
+        <div class="progress-container" style="display: none;">
+            <div class="progress-bar">0%</div>
+        </div>
+        <div class="status"></div>
+    </div>
+
+    <script>
+        // Hide status indicators during update
+        const statusContainer = document.querySelector('.status-container');
+        if (statusContainer) {
+            statusContainer.style.display = 'none';
+        }
+
+        const progress = document.querySelector('.progress-bar');
+        const progressContainer = document.querySelector('.progress-container');
+        const status = document.querySelector('.status');
+        let updateInProgress = false;
+        let lastReceivedProgress = 0;
+
+        // WebSocket Handling
+        let ws = null;
+        let wsReconnectTimer = null;
+
+        function connectWebSocket() {
+            ws = new WebSocket('ws://' + window.location.host + '/ws');
+            
+            ws.onmessage = function(event) {
+                try {
+                    const data = JSON.parse(event.data);
+                    if (data.type === "updateProgress" && updateInProgress) {
+                        // Zeige Fortschrittsbalken
+                        progressContainer.style.display = 'block';
+                        
+                        // Aktualisiere den Fortschritt nur wenn er größer ist
+                        const newProgress = parseInt(data.progress);
+                        if (!isNaN(newProgress) && newProgress >= lastReceivedProgress) {
+                            progress.style.width = newProgress + '%';
+                            progress.textContent = newProgress + '%';
+                            lastReceivedProgress = newProgress;
+                        }
+                        
+                        // Zeige Status-Nachricht
+                        if (data.message || data.status) {
+                            status.textContent = data.message || getStatusMessage(data.status);
+                            status.className = 'status success';
+                            status.style.display = 'block';
+                            
+                            // Starte Reload wenn Update erfolgreich
+                            if (data.status === 'success' || lastReceivedProgress >= 98) {
+                                clearTimeout(wsReconnectTimer);
+                                setTimeout(() => {
+                                    window.location.reload(true);
+                                    window.location.href = '/';
+                                }, 30000);
+                            }
+                        }
+                    }
+                } catch (e) {
+                    console.error('WebSocket message error:', e);
+                }
+            };
+
+            ws.onclose = function() {
+                if (updateInProgress) {
+                    // Wenn der Fortschritt hoch genug ist, gehen wir von einem erfolgreichen Update aus
+                    if (lastReceivedProgress >= 85) {
+                        status.textContent = "Update appears successful! Device is restarting... Page will reload in 30 seconds.";
+                        status.className = 'status success';
+                        status.style.display = 'block';
+                        clearTimeout(wsReconnectTimer);
+                        setTimeout(() => {
+                            window.location.reload(true);
+                            window.location.href = '/';
+                        }, 30000);
+                    } else {
+                        // Versuche Reconnect bei niedrigem Fortschritt
+                        wsReconnectTimer = setTimeout(connectWebSocket, 1000);
+                    }
+                }
+            };
+
+            ws.onerror = function(err) {
+                console.error('WebSocket error:', err);
+                if (updateInProgress && lastReceivedProgress >= 85) {
+                    status.textContent = "Update appears successful! Device is restarting... Page will reload in 30 seconds.";
+                    status.className = 'status success';
+                    status.style.display = 'block';
+                    setTimeout(() => {
+                        window.location.href = '/';
+                    }, 30000);
+                }
+            };
+        }
+
+        // Initial WebSocket connection
+        connectWebSocket();
+
+        function getStatusMessage(status) {
+            switch(status) {
+                case 'starting': return 'Starting update...';
+                case 'uploading': return 'Uploading...';
+                case 'finalizing': return 'Finalizing update...';
+                case 'restoring': return 'Restoring configurations...';
+                case 'preparing': return 'Preparing for restart...';
+                case 'success': return 'Update successful! Device is restarting... Page will reload in 30 seconds.';
+                default: return 'Updating...';
+            }
+        }
+
+        function handleUpdate(e) {
+            e.preventDefault();
+            const form = e.target;
+            const file = form.update.files[0];
+            const updateType = form.dataset.type;
+            
+            if (!file) {
+                alert('Please select a file.');
+                return;
+            }
+            
+            // Validate file name pattern
+            if (updateType === 'firmware' && !file.name.startsWith('upgrade_filaman_firmware_')) {
+                alert('Please select a valid firmware file (upgrade_filaman_firmware_*.bin)');
+                return;
+            }
+            if (updateType === 'webpage' && !file.name.startsWith('upgrade_filaman_website_')) {
+                alert('Please select a valid webpage file (upgrade_filaman_website_*.bin)');
+                return;
+            }
+            
+            // Reset UI
+            updateInProgress = true;
+            progressContainer.style.display = 'block';
+            status.style.display = 'none';
+            status.className = 'status';
+            progress.style.width = '0%';
+            progress.textContent = '0%';
+            
+            // Disable submit buttons
+            document.querySelectorAll('form input[type=submit]').forEach(btn => btn.disabled = true);
+
+            // Send update
+            const xhr = new XMLHttpRequest();
+            xhr.open('POST', '/update', true);
+            
+            xhr.onload = function() {
+                if (xhr.status !== 200 && !progress.textContent.startsWith('100')) {
+                    status.textContent = "Update failed: " + (xhr.responseText || "Unknown error");
+                    status.className = 'status error';
+                    status.style.display = 'block';
+                    updateInProgress = false;
+                    document.querySelectorAll('form input[type=submit]').forEach(btn => btn.disabled = false);
+                }
+            };
+            
+            xhr.onerror = function() {
+                if (!progress.textContent.startsWith('100')) {
+                    status.textContent = "Network error during update";
+                    status.className = 'status error';
+                    status.style.display = 'block';
+                    updateInProgress = false;
+                    document.querySelectorAll('form input[type=submit]').forEach(btn => btn.disabled = false);
+                }
+            };
+
+            const formData = new FormData();
+            formData.append('update', file);
+            xhr.send(formData);
+        }
+
+        document.getElementById('firmwareForm').addEventListener('submit', handleUpdate);
+        document.getElementById('webpageForm').addEventListener('submit', handleUpdate);
+    </script>
+</body>
+</html>

html/waage.html

@@ -6,13 +6,24 @@
     <title>FilaMan - Filament Management Tool</title>
     <link rel="icon" type="image/png" href="/favicon.ico">
     <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
 </head>
 <body>
     <div class="navbar">
         <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.0</span></h1>
+                <h1>FilaMan<span class="version"></span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>
@@ -44,6 +55,7 @@
                 <h5 class="card-title">Sacle Calibration</h5>
                 <button id="calibrateBtn" class="btn btn-primary">Calibrate Scale</button>
                 <button id="tareBtn" class="btn btn-secondary">Tare Scale</button>
+                &nbsp;&nbsp;&nbsp;Enable Auto-TARE <input type="checkbox" id="autoTareCheckbox" onchange="setAutoTare(this.checked);" {{autoTare}}>
                 <div id="statusMessage" class="mt-3"></div>
             </div>
         </div>
@@ -129,6 +141,15 @@
             }));
         });
 
+        // Add auto-tare function
+        function setAutoTare(enabled) {
+            ws.send(JSON.stringify({
+                type: 'scale',
+                payload: 'setAutoTare',
+                enabled: enabled
+            }));
+        }
+
         // WebSocket-Verbindung beim Laden der Seite initiieren
         connectWebSocket();
     </script>

html/wifi.html

@@ -6,13 +6,24 @@
     <title>FilaMan - Filament Management Tool</title>
     <link rel="icon" type="image/png" href="/favicon.ico">
     <link rel="stylesheet" href="style.css">
+    <script>
+        fetch('/api/version')
+            .then(response => response.json())
+            .then(data => {
+                const versionSpan = document.querySelector('.version');
+                if (versionSpan) {
+                    versionSpan.textContent = 'v' + data.version;
+                }
+            })
+            .catch(error => console.error('Error fetching version:', error));
+    </script>
 </head>
 <body>
     <div class="navbar">
         <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.0</span></h1>
+                <h1>FilaMan<span class="version"></span></h1>
                 <h4>Filament Management Tool</h4>
             </div>
         </div>

partitions.csv

@@ -1,5 +1,6 @@
-# Name,   Type, SubType, Offset,   Size,     Flags
-nvs,      data, nvs,     0x9000,   0x5000,
-otadata,  data, ota,     0xe000,   0x2000,
-app0,     app,  ota_0,   0x10000,  0x280000,
-spiffs,   data, spiffs,  0x290000, 0x170000,
+# 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,

platformio.ini

@@ -9,19 +9,21 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [common]
-version = "1.2.0"
+version = "2.0.0-beta9"
+to_old_version = "1.5.10"
 
+##
 [env:esp32dev]
 platform = espressif32
 board = esp32dev
 framework = arduino
 monitor_speed = 115200
+#monitor_port = /dev/cu.usbmodem01
 
 lib_deps =
     tzapu/WiFiManager @ ^2.0.17
-    #me-no-dev/ESP Async WebServer @ ^1.2.4
     https://github.com/me-no-dev/ESPAsyncWebServer.git#master
-    me-no-dev/AsyncTCP @ ^1.1.1
+    https://github.com/esphome/AsyncTCP.git
     bogde/HX711 @ ^0.7.5
     adafruit/Adafruit SSD1306 @ ^2.5.13
     adafruit/Adafruit GFX Library @ ^1.11.11
@@ -29,36 +31,43 @@ lib_deps =
     bblanchon/ArduinoJson @ ^7.3.0
     knolleary/PubSubClient @ ^2.8
     digitaldragon/SSLClient @ ^1.3.2
-    ipdotsetaf/ESPAsyncHTTPUpdateServer @ ^2.0.0
     
 ; Enable SPIFFS upload
-board_build.filesystem = spiffs
+board_build.filesystem = littlefs
 ; Update partition settings
 board_build.partitions = partitions.csv
 board_upload.flash_size = 4MB
-; Remove these as they're now defined in partitions.csv
-; board_build.spiffs.partition = 2M
-; board_build.spiffs.upload_size = 2M
+board_build.flash_mode = dio
+board_upload.flash_freq = "40m"
 
 build_flags = 
     -Os
     -ffunction-sections
     -fdata-sections
-    -DNDEBUG
+    #-DNDEBUG
     -mtext-section-literals
-    '-D VERSION="${common.version}"'
-
+    -DVERSION=\"${common.version}\"
+    -DTOOLDVERSION=\"${common.to_old_version}\"
+    #-DENABLE_HEAP_DEBUGGING
+    -DASYNCWEBSERVER_REGEX
+    #-DCORE_DEBUG_LEVEL=3
+    -DCONFIG_ARDUHAL_LOG_COLORS=1
+    #-DOTA_DEBUG=1
+    -DCONFIG_OPTIMIZATION_LEVEL_DEBUG=1
+    -DBOOT_APP_PARTITION_OTA_0=1
+    -DCONFIG_LWIP_TCP_MSL=60000
+    -DCONFIG_LWIP_TCP_RCV_BUF_DEFAULT=4096
+    -DCONFIG_LWIP_MAX_ACTIVE_TCP=16
+    
 extra_scripts = 
     scripts/extra_script.py
-    pre:scripts/pre_build.py     ; wird zuerst ausgeführt
-    pre:scripts/pre_spiffs.py    ; wird als zweites ausgeführt
-    pre:scripts/combine_html.py  ; wird als drittes ausgeführt
-    scripts/gzip_files.py
+    ${env:buildfs.extra_scripts}
 
-; Remove or comment out the targets line
-;targets = buildfs, build
+[env:buildfs]
+extra_scripts =
+    pre:scripts/combine_html.py  ; Combine header with HTML files
+    scripts/gzip_files.py       ; Compress files for SPIFFS
 
-; Add a custom target to build both
 [platformio]
 default_envs = esp32dev
 

scripts/gzip_files.py

@@ -14,7 +14,7 @@ def copy_file(input_file, output_file):
 
 def should_compress(file):
      # Skip compression for spoolman.html
-    if file == 'spoolman.html':
+    if file == 'spoolman.html' or file == 'waage.html':
         return False
     # Komprimiere nur bestimmte Dateitypen
     return file.endswith(('.js', '.png', '.css', '.html'))

scripts/pre_spiffs.py

@@ -1,7 +1,39 @@
 Import("env")
 
+board_config = env.BoardConfig()
+
+# Calculate SPIFFS size based on partition table
+SPIFFS_START = 0x310000  # From partitions.csv
+SPIFFS_SIZE = 0xE0000   # From partitions.csv
+SPIFFS_PAGE = 256
+SPIFFS_BLOCK = 4096
+
+env.Replace(
+    MKSPIFFSTOOL="mkspiffs",
+    SPIFFSBLOCKSZ=SPIFFS_BLOCK,
+    SPIFFSBLOCKSIZE=SPIFFS_BLOCK,
+    SPIFFSSTART=SPIFFS_START,
+    SPIFFSEND=SPIFFS_START + SPIFFS_SIZE,
+    SPIFFSPAGESZ=SPIFFS_PAGE,
+    SPIFFSSIZE=SPIFFS_SIZE
+)
+
 # Wiederverwendung der replace_version Funktion
 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.")

scripts/update_changelog.py

@@ -14,17 +14,39 @@ def get_version():
         return version_match.group(1) if version_match else None
 
 def get_last_tag():
+    """Get the last non-beta tag for changelog generation"""
     try:
-        result = subprocess.run(['git', 'describe', '--tags', '--abbrev=0'], 
+        # Get all tags sorted by version
+        result = subprocess.run(['git', 'tag', '-l', '--sort=-version:refname'], 
                               capture_output=True, text=True)
-        return result.stdout.strip()
+        if result.returncode != 0:
+            return None
+            
+        tags = result.stdout.strip().split('\n')
+        
+        # Find the first (newest) non-beta tag
+        for tag in tags:
+            if tag and not '-beta' in tag.lower():
+                print(f"Using last stable tag for changelog: {tag}")
+                return tag
+        
+        # Fallback: if no non-beta tags found, use the newest tag
+        print("No stable tags found, using newest tag")
+        if tags and tags[0]:
+            return tags[0]
+        return None
     except subprocess.CalledProcessError:
         return None
 
 def categorize_commit(commit_msg):
     """Categorize commit messages based on conventional commits"""
     lower_msg = commit_msg.lower()
-    if any(x in lower_msg for x in ['feat', 'add', 'new']):
+    
+    # Check for breaking changes first
+    if ('!' in commit_msg and any(x in lower_msg for x in ['feat!', 'fix!', 'chore!', 'refactor!'])) or \
+       'breaking change' in lower_msg or 'breaking:' in lower_msg:
+        return 'Breaking Changes'
+    elif any(x in lower_msg for x in ['feat', 'add', 'new']):
         return 'Added'
     elif any(x in lower_msg for x in ['fix', 'bug']):
         return 'Fixed'
@@ -34,6 +56,7 @@ def categorize_commit(commit_msg):
 def get_changes_from_git():
     """Get changes from git commits since last tag"""
     changes = {
+        'Breaking Changes': [],
         'Added': [],
         'Changed': [],
         'Fixed': []
@@ -55,7 +78,9 @@ def get_changes_from_git():
             if commit:
                 category = categorize_commit(commit)
                 # Clean up commit message
-                clean_msg = re.sub(r'^(feat|fix|chore|docs|style|refactor|perf|test)(\(.*\))?:', '', commit).strip()
+                clean_msg = re.sub(r'^(feat|fix|chore|docs|style|refactor|perf|test)(\(.*\))?!?:', '', commit).strip()
+                # Remove BREAKING CHANGE prefix if present
+                clean_msg = re.sub(r'^breaking change:\s*', '', clean_msg, flags=re.IGNORECASE).strip()
                 changes[category].append(clean_msg)
                 
     except subprocess.CalledProcessError:
@@ -64,29 +89,10 @@ def get_changes_from_git():
     
     return changes
 
-def push_changes(version):
-    """Push changes to upstream"""
-    try:
-        # Stage the CHANGELOG.md
-        subprocess.run(['git', 'add', 'CHANGELOG.md'], check=True)
-        
-        # Commit the changelog
-        commit_msg = f"docs: update changelog for version {version}"
-        subprocess.run(['git', 'commit', '-m', commit_msg], check=True)
-        
-        # Push to origin (local)
-        subprocess.run(['git', 'push', 'origin'], check=True)
-        print("Successfully pushed to origin")
-        
-    except subprocess.CalledProcessError as e:
-        print(f"Error during git operations: {e}")
-        return False
-    return True
-
 def update_changelog():
-    print("Starting changelog update...")  # Add this line
+    print("Starting changelog update...")
     version = get_version()
-    print(f"Current version: {version}")   # Add this line
+    print(f"Current version: {version}")
     today = datetime.now().strftime('%Y-%m-%d')
     
     script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -111,7 +117,7 @@ def update_changelog():
     if not os.path.exists(changelog_path):
         with open(changelog_path, 'w') as f:
             f.write(f"# Changelog\n\n{changelog_entry}")
-        push_changes(version)
+        print(f"Created new changelog file with version {version}")
     else:
         with open(changelog_path, 'r') as f:
             content = f.read()
@@ -120,9 +126,30 @@ def update_changelog():
             updated_content = content.replace("# Changelog\n", f"# Changelog\n\n{changelog_entry}")
             with open(changelog_path, 'w') as f:
                 f.write(updated_content)
-            push_changes(version)
+            print(f"Added new version {version} to changelog")
         else:
-            print(f"Version {version} already exists in changelog")
+            # Version existiert bereits, aktualisiere die bestehenden Einträge
+            version_pattern = f"## \\[{version}\\] - \\d{{4}}-\\d{{2}}-\\d{{2}}"
+            next_version_pattern = "## \\[.*?\\] - \\d{4}-\\d{2}-\\d{2}"
+            
+            # Finde den Start der aktuellen Version
+            version_match = re.search(version_pattern, content)
+            if version_match:
+                version_start = version_match.start()
+                # Suche nach der nächsten Version
+                next_version_match = re.search(next_version_pattern, content[version_start + 1:])
+                
+                if next_version_match:
+                    # Ersetze den Inhalt zwischen aktueller und nächster Version
+                    next_version_pos = version_start + 1 + next_version_match.start()
+                    updated_content = content[:version_start] + changelog_entry + content[next_version_pos:]
+                else:
+                    # Wenn keine nächste Version existiert, ersetze bis zum Ende
+                    updated_content = content[:version_start] + changelog_entry + "\n"
+                
+                with open(changelog_path, 'w') as f:
+                    f.write(updated_content)
+                print(f"Updated entries for version {version}")
 
 if __name__ == "__main__":
     update_changelog()

src/api.h

@@ -6,19 +6,45 @@
 #include "website.h"
 #include "display.h"
 #include <ArduinoJson.h>
+typedef enum {
+    API_INIT,
+    API_IDLE,
+    API_TRANSMITTING
+} spoolmanApiStateType;
 
+typedef enum {
+    API_REQUEST_OCTO_SPOOL_UPDATE,
+    API_REQUEST_BAMBU_UPDATE,
+    API_REQUEST_SPOOL_TAG_ID_UPDATE,
+    API_REQUEST_SPOOL_WEIGHT_UPDATE,
+    API_REQUEST_SPOOL_LOCATION_UPDATE,
+    API_REQUEST_VENDOR_CREATE,
+    API_REQUEST_VENDOR_CHECK,
+    API_REQUEST_FILAMENT_CHECK,
+    API_REQUEST_FILAMENT_CREATE,
+    API_REQUEST_SPOOL_CREATE
+} SpoolmanApiRequestType;
+
+extern volatile spoolmanApiStateType spoolmanApiState;
 extern bool spoolman_connected;
 extern String spoolmanUrl;
+extern bool octoEnabled;
+extern bool sendOctoUpdate;
+extern String octoUrl;
+extern String octoToken;
+extern bool spoolmanConnected;
 
-bool checkSpoolmanInstance(const String& url);
-bool saveSpoolmanUrl(const String& url);
+bool checkSpoolmanInstance();
+bool saveSpoolmanUrl(const String& url, bool octoOn, const String& octoWh, const String& octoTk);
 String loadSpoolmanUrl(); // Neue Funktion zum Laden der URL
 bool checkSpoolmanExtraFields(); // Neue Funktion zum Überprüfen der Extrafelder
-JsonDocument fetchSpoolsForWebsite(); // API-Funktion für die Webseite
-JsonDocument fetchAllSpoolsInfo();
-void sendAmsData(AsyncWebSocketClient *client); // Neue Funktion zum Senden von AMS-Daten
-uint8_t updateSpoolTagId(String uidString, const char* payload); // Neue Funktion zum Aktualisieren eines Spools
+JsonDocument fetchSingleSpoolInfo(int spoolId); // API-Funktion für die Webseite
+bool updateSpoolTagId(String uidString, const char* payload); // Neue Funktion zum Aktualisieren eines Spools
 uint8_t updateSpoolWeight(String spoolId, uint16_t weight); // Neue Funktion zum Aktualisieren des Gewichts
+uint8_t updateSpoolLocation(String spoolId, String location);
 bool initSpoolman(); // Neue Funktion zum Initialisieren von Spoolman
+bool updateSpoolBambuData(String payload); // Neue Funktion zum Aktualisieren der Bambu-Daten
+bool updateSpoolOcto(int spoolId); // Neue Funktion zum Aktualisieren der Octo-Daten
+bool createBrandFilament(JsonDocument& payload, String uidString);
 
 #endif

src/bambu.cpp

@@ -10,6 +10,7 @@
 #include "esp_task_wdt.h"
 #include "config.h"
 #include "display.h"
+#include <Preferences.h>
 
 WiFiClient espClient;
 SSLClient sslClient(&espClient);
@@ -17,38 +18,69 @@ PubSubClient client(sslClient);
 
 TaskHandle_t BambuMqttTask;
 
-String report_topic = "";
-//String request_topic = "";
-const char* bambu_username = "bblp";
-const char* bambu_ip = nullptr;
-const char* bambu_accesscode = nullptr;
-const char* bambu_serialnr = nullptr;
+bool bambuDisabled = false;
+
 bool bambu_connected = false;
+int autoSetToBambuSpoolId = 0;
+
+BambuCredentials bambuCredentials;
 
 // Globale Variablen für AMS-Daten
 int ams_count = 0;
 String amsJsonData;  // Speichert das fertige JSON für WebSocket-Clients
-AMSData ams_data[MAX_AMS];  // Definition des Arrays
+AMSData ams_data[MAX_AMS];  // Definition des Arrays;
 
-bool saveBambuCredentials(const String& ip, const String& serialnr, const String& accesscode) {
+bool removeBambuCredentials() {
     if (BambuMqttTask) {
         vTaskDelete(BambuMqttTask);
+        BambuMqttTask = NULL;
     }
     
-    JsonDocument doc;
-    doc["bambu_ip"] = ip;
-    doc["bambu_accesscode"] = accesscode;
-    doc["bambu_serialnr"] = serialnr;
+    Preferences preferences;
+    preferences.begin(NVS_NAMESPACE_BAMBU, false); // false = readwrite
+    preferences.remove(NVS_KEY_BAMBU_IP);
+    preferences.remove(NVS_KEY_BAMBU_SERIAL);
+    preferences.remove(NVS_KEY_BAMBU_ACCESSCODE);
+    preferences.remove(NVS_KEY_BAMBU_AUTOSEND_ENABLE);
+    preferences.remove(NVS_KEY_BAMBU_AUTOSEND_TIME);
+    preferences.end();
 
-    if (!saveJsonValue("/bambu_credentials.json", doc)) {
-        Serial.println("Fehler beim Speichern der Bambu-Credentials.");
-        return false;
+    // Löschen der globalen Variablen
+    bambuCredentials.ip = "";
+    bambuCredentials.serial = "";
+    bambuCredentials.accesscode = "";
+    bambuCredentials.autosend_enable = false;
+    bambuCredentials.autosend_time = BAMBU_DEFAULT_AUTOSEND_TIME;
+
+    autoSetToBambuSpoolId = 0;
+    ams_count = 0;
+    amsJsonData = "";
+
+    bambuDisabled = true;
+
+    return true;
+}
+
+bool saveBambuCredentials(const String& ip, const String& serialnr, const String& accesscode, bool autoSend, const String& autoSendTime) {
+    if (BambuMqttTask) {
+        vTaskDelete(BambuMqttTask);
+        BambuMqttTask = NULL;
     }
 
-    // Dynamische Speicherallokation für die globalen Pointer
-    bambu_ip = ip.c_str();
-    bambu_accesscode = accesscode.c_str();
-    bambu_serialnr = serialnr.c_str();
+    bambuCredentials.ip = ip.c_str();
+    bambuCredentials.serial = serialnr.c_str();
+    bambuCredentials.accesscode = accesscode.c_str();
+    bambuCredentials.autosend_enable = autoSend;
+    bambuCredentials.autosend_time = autoSendTime.toInt();
+
+    Preferences preferences;
+    preferences.begin(NVS_NAMESPACE_BAMBU, false); // false = readwrite
+    preferences.putString(NVS_KEY_BAMBU_IP, bambuCredentials.ip);
+    preferences.putString(NVS_KEY_BAMBU_SERIAL, bambuCredentials.serial);
+    preferences.putString(NVS_KEY_BAMBU_ACCESSCODE, bambuCredentials.accesscode);
+    preferences.putBool(NVS_KEY_BAMBU_AUTOSEND_ENABLE, bambuCredentials.autosend_enable);
+    preferences.putInt(NVS_KEY_BAMBU_AUTOSEND_TIME, bambuCredentials.autosend_time);
+    preferences.end();
 
     vTaskDelay(100 / portTICK_PERIOD_MS);
     if (!setupMqtt()) return false;
@@ -57,43 +89,81 @@ bool saveBambuCredentials(const String& ip, const String& serialnr, const String
 }
 
 bool loadBambuCredentials() {
-    JsonDocument doc;
-    if (loadJsonValue("/bambu_credentials.json", doc) && doc.containsKey("bambu_ip")) {
-        // Temporäre Strings für die Werte
-        String ip = doc["bambu_ip"].as<String>();
-        String code = doc["bambu_accesscode"].as<String>();
-        String serial = doc["bambu_serialnr"].as<String>();
+    Preferences preferences;
+    preferences.begin(NVS_NAMESPACE_BAMBU, true);
+    String ip = preferences.getString(NVS_KEY_BAMBU_IP, "");
+    String serial = preferences.getString(NVS_KEY_BAMBU_SERIAL, "");
+    String code = preferences.getString(NVS_KEY_BAMBU_ACCESSCODE, "");
+    bool autosendEnable = preferences.getBool(NVS_KEY_BAMBU_AUTOSEND_ENABLE, false);
+    int autosendTime = preferences.getInt(NVS_KEY_BAMBU_AUTOSEND_TIME, BAMBU_DEFAULT_AUTOSEND_TIME);
+    preferences.end();
 
-        ip.trim();
-        code.trim();
-        serial.trim();
+    if(ip != ""){
+        bambuCredentials.ip = ip.c_str();
+        bambuCredentials.serial = serial.c_str();
+        bambuCredentials.accesscode = code.c_str();
+        bambuCredentials.autosend_enable = autosendEnable;
+        bambuCredentials.autosend_time = autosendTime;
 
-        // Dynamische Speicherallokation für die globalen Pointer
-        bambu_ip = strdup(ip.c_str());
-        bambu_accesscode = strdup(code.c_str());
-        bambu_serialnr = strdup(serial.c_str());
+        Serial.println("credentials loaded loadCredentials!");
+        Serial.println(bambuCredentials.ip);
+        Serial.println(bambuCredentials.serial);
+        Serial.println(bambuCredentials.accesscode);
+        Serial.println(String(bambuCredentials.autosend_enable));
+        Serial.println(String(bambuCredentials.autosend_time));
 
-        report_topic = "device/" + String(bambu_serialnr) + "/report";
-        //request_topic = "device/" + String(bambu_serialnr) + "/request";
         return true;
     }
-    Serial.println("Keine gültigen Bambu-Credentials gefunden.");
-    return false;
+    else
+    {
+        Serial.println("Keine gültigen Bambu-Credentials gefunden.");
+        return false;
+    }
 }
 
-String findFilamentIdx(String brand, String type) {
+struct FilamentResult {
+    String key;
+    String type;
+};
+
+FilamentResult findFilamentIdx(String brand, String type) {
     // JSON-Dokument für die Filament-Daten erstellen
     JsonDocument doc;
     
+    // Laden der own_filaments.json
+    String ownFilament = "";
+    if (!loadJsonValue("/own_filaments.json", doc)) 
+    {
+        Serial.println("Fehler beim Laden der eigenen Filament-Daten");
+    }
+    else
+    {
+        // Durchsuche direkt nach dem Type als Schlüssel
+        if (doc[type].is<String>()) {
+            ownFilament = doc[type].as<String>();
+        }
+        doc.clear();
+    }
+    doc.clear();
+
     // Laden der bambu_filaments.json
-    if (!loadJsonValue("/bambu_filaments.json", doc)) {
+    if (!loadJsonValue("/bambu_filaments.json", doc)) 
+    {
         Serial.println("Fehler beim Laden der Filament-Daten");
-        return "GFL99"; // Fallback auf Generic PLA
+        return {"GFL99", "PLA"}; // Fallback auf Generic PLA
     }
 
+    // Wenn eigener Typ
+    if (ownFilament != "")
+    {
+        if (doc[ownFilament].is<String>()) 
+        {
+            return {ownFilament, doc[ownFilament].as<String>()};
+        }
+    }
+
+    // 1. Erst versuchen wir die exakte Brand + Type Kombination zu finden
     String searchKey;
-    
-    // 1. Suche nach Brand + Type Kombination
     if (brand == "Bambu" || brand == "Bambulab") {
         searchKey = "Bambu " + type;
     } else if (brand == "PolyLite") {
@@ -109,26 +179,49 @@ String findFilamentIdx(String brand, String type) {
     // Durchsuche alle Einträge nach der Brand + Type Kombination
     for (JsonPair kv : doc.as<JsonObject>()) {
         if (kv.value().as<String>() == searchKey) {
-            return kv.key().c_str();
+            return {kv.key().c_str(), kv.value().as<String>()};
         }
     }
 
-    // 2. Wenn nicht gefunden, suche nach Generic + Type
-    searchKey = "Generic " + type;
+    // 2. Wenn nicht gefunden, zerlege den type String in Wörter und suche nach jedem Wort
+    // Sammle alle vorhandenen Filamenttypen aus der JSON
+    std::vector<String> knownTypes;
     for (JsonPair kv : doc.as<JsonObject>()) {
-        if (kv.value().as<String>() == searchKey) {
-            return kv.key().c_str();
+        String value = kv.value().as<String>();
+        // Extrahiere den Typ ohne Markennamen
+        if (value.indexOf(" ") != -1) {
+            value = value.substring(value.indexOf(" ") + 1);
+        }
+        if (!value.isEmpty()) {
+            knownTypes.push_back(value);
+        }
+    }
+
+    // Zerlege den Input-Type in Wörter
+    String typeStr = type;
+    typeStr.trim();
+    
+    // Durchsuche für jedes bekannte Filament, ob es im Input vorkommt
+    for (const String& knownType : knownTypes) {
+        if (typeStr.indexOf(knownType) != -1) {
+            // Suche nach diesem Typ in der Original-JSON
+            for (JsonPair kv : doc.as<JsonObject>()) {
+                String value = kv.value().as<String>();
+                if (value.indexOf(knownType) != -1) {
+                    return {kv.key().c_str(), knownType};
+                }
+            }
         }
     }
 
     // 3. Wenn immer noch nichts gefunden, gebe GFL99 zurück (Generic PLA)
-    return "GFL99";
+    return {"GFL99", "PLA"};
 }
 
-bool sendMqttMessage(String payload) {
+bool sendMqttMessage(const String& payload) {
     Serial.println("Sending MQTT message");
     Serial.println(payload);
-    if (client.publish(report_topic.c_str(), payload.c_str())) 
+    if (client.publish(("device/"+bambuCredentials.serial+"/request").c_str(), payload.c_str())) 
     {
         return true;
     }
@@ -156,15 +249,22 @@ bool setBambuSpool(String payload) {
     int minTemp = doc["nozzle_temp_min"];
     int maxTemp = doc["nozzle_temp_max"];
     String type = doc["type"].as<String>();
+    (type == "PLA+") ? type = "PLA" : type;
     String brand = doc["brand"].as<String>();
     String tray_info_idx = (doc["tray_info_idx"].as<String>() != "-1") ? doc["tray_info_idx"].as<String>() : "";
-    if (tray_info_idx == "") tray_info_idx = (brand != "" && type != "") ? findFilamentIdx(brand, type) : "";
+    if (tray_info_idx == "") {
+        if (brand != "" && type != "") {
+            FilamentResult result = findFilamentIdx(brand, type);
+            tray_info_idx = result.key;
+            type = result.type;  // Aktualisiere den type mit dem gefundenen Basistyp
+        }
+    }
     String setting_id = doc["bambu_setting_id"].as<String>();
     String cali_idx = doc["cali_idx"].as<String>();
 
     doc.clear();
 
-    doc["print"]["sequence_id"] = 0;
+    doc["print"]["sequence_id"] = "0";
     doc["print"]["command"] = "ams_filament_setting";
     doc["print"]["ams_id"] = amsId < 200 ? amsId : 255;
     doc["print"]["tray_id"] = trayId < 200 ? trayId : 254;
@@ -172,10 +272,10 @@ bool setBambuSpool(String payload) {
     doc["print"]["nozzle_temp_min"] = minTemp;
     doc["print"]["nozzle_temp_max"] = maxTemp;
     doc["print"]["tray_type"] = type;
-    doc["print"]["cali_idx"] = (cali_idx != "") ? cali_idx : "";
+    //doc["print"]["cali_idx"] = (cali_idx != "") ? cali_idx : "";
     doc["print"]["tray_info_idx"] = tray_info_idx;
     doc["print"]["setting_id"] = setting_id;
-
+    
     // Serialize the JSON
     String output;
     serializeJson(doc, output);
@@ -194,13 +294,13 @@ bool setBambuSpool(String payload) {
 
     if (cali_idx != "") {
         yield();
-        doc["print"]["sequence_id"] = 0;
+        doc["print"]["sequence_id"] = "0";
         doc["print"]["command"] = "extrusion_cali_sel";
         doc["print"]["filament_id"] = tray_info_idx;
         doc["print"]["nozzle_diameter"] = "0.4";
         doc["print"]["cali_idx"] = cali_idx.toInt();
         doc["print"]["tray_id"] = trayId < 200 ? trayId : 254;
-        doc["print"]["ams_id"] = amsId < 200 ? amsId : 255;
+        //doc["print"]["ams_id"] = amsId < 200 ? amsId : 255;
 
         // Serialize the JSON
         String output;
@@ -218,44 +318,120 @@ bool setBambuSpool(String payload) {
         doc.clear();
         yield();
     }
-/*
-    if (setting_id != "") {
-        yield();
-        doc["print"]["sequence_id"] = 0;
-        doc["print"]["command"] = "ams_filament_setting";
-        doc["print"]["nozzle_temp_min"] = minTemp;
-        doc["print"]["nozzle_temp_max"] = maxTemp;
-        doc["print"]["setting_id"] = setting_id;
-        doc["print"]["tray_color"] = color.length() == 8 ? color : color+"FF";
-        doc["print"]["ams_id"] = amsId < 200 ? amsId : 255;
-        doc["print"]["tray_id"] = trayId < 200 ? trayId : 254;
-        doc["print"]["tray_info_idx"] = tray_info_idx;
-        doc["print"]["tray_type"] = type;
 
-        // Serialize the JSON
-        String output;
-        serializeJson(doc, output);
+    return true;
+}
 
-        if (sendMqttMessage(output)) {
-            Serial.println("Filament Setting successfully set");
+void autoSetSpool(int spoolId, uint8_t trayId) {
+    // wenn neue spule erkannt und autoSetToBambu > 0
+    JsonDocument spoolInfo = fetchSingleSpoolInfo(spoolId);
+
+    if (!spoolInfo.isNull())
+    {
+        // AMS und TRAY id ergänzen
+        spoolInfo["amsId"] = 0;
+        spoolInfo["trayId"] = trayId;
+
+        Serial.println("Auto set spool");
+        Serial.println(spoolInfo.as<String>());
+
+        setBambuSpool(spoolInfo.as<String>());
+
+        oledShowMessage("Spool set");
+    }
+
+    // id wieder zurücksetzen damit abgeschlossen
+    autoSetToBambuSpoolId = 0;
+}
+
+void updateAmsWsData(JsonDocument& doc, JsonArray& amsArray, int& ams_count, JsonObject& vtTray) {
+    // Fortfahren mit der bestehenden Verarbeitung, da Änderungen gefunden wurden
+    ams_count = amsArray.size();
+        
+    for (int i = 0; i < ams_count && i < 16; i++) {
+        JsonObject amsObj = amsArray[i];
+        JsonArray trayArray = amsObj["tray"].as<JsonArray>();
+
+        ams_data[i].ams_id = i; // Setze die AMS-ID
+        for (int j = 0; j < trayArray.size() && j < 4; j++) { // Annahme: Maximal 4 Trays pro AMS
+            JsonObject trayObj = trayArray[j];
+
+            ams_data[i].trays[j].id = trayObj["id"].as<uint8_t>();
+            ams_data[i].trays[j].tray_info_idx = trayObj["tray_info_idx"].as<String>();
+            ams_data[i].trays[j].tray_type = trayObj["tray_type"].as<String>();
+            ams_data[i].trays[j].tray_sub_brands = trayObj["tray_sub_brands"].as<String>();
+            ams_data[i].trays[j].tray_color = trayObj["tray_color"].as<String>();
+            ams_data[i].trays[j].nozzle_temp_min = trayObj["nozzle_temp_min"].as<int>();
+            ams_data[i].trays[j].nozzle_temp_max = trayObj["nozzle_temp_max"].as<int>();
+            if (trayObj["tray_type"].as<String>() == "") ams_data[i].trays[j].setting_id = "";
+            ams_data[i].trays[j].cali_idx = trayObj["cali_idx"].as<String>();
+        }
+    }
+    
+    // Setze ams_count auf die Anzahl der normalen AMS
+    ams_count = amsArray.size();
+
+    // Wenn externe Spule vorhanden, füge sie hinzu
+    if (doc["print"]["vt_tray"].is<JsonObject>()) {
+        //JsonObject vtTray = doc["print"]["vt_tray"];
+        int extIdx = ams_count;  // Index für externe Spule
+        ams_data[extIdx].ams_id = 255;  // Spezielle ID für externe Spule
+        ams_data[extIdx].trays[0].id = 254;  // Spezielle ID für externes Tray
+        ams_data[extIdx].trays[0].tray_info_idx = vtTray["tray_info_idx"].as<String>();
+        ams_data[extIdx].trays[0].tray_type = vtTray["tray_type"].as<String>();
+        ams_data[extIdx].trays[0].tray_sub_brands = vtTray["tray_sub_brands"].as<String>();
+        ams_data[extIdx].trays[0].tray_color = vtTray["tray_color"].as<String>();
+        ams_data[extIdx].trays[0].nozzle_temp_min = vtTray["nozzle_temp_min"].as<int>();
+        ams_data[extIdx].trays[0].nozzle_temp_max = vtTray["nozzle_temp_max"].as<int>();
+
+        if (doc["print"]["vt_tray"]["tray_type"].as<String>() != "")
+        {
+            //ams_data[extIdx].trays[0].setting_id = vtTray["setting_id"].as<String>();
+            ams_data[extIdx].trays[0].cali_idx = vtTray["cali_idx"].as<String>();
         }
         else
         {
-            Serial.println("Failed to set Filament setting");
-            return false;
+            ams_data[extIdx].trays[0].setting_id = "";
+            ams_data[extIdx].trays[0].cali_idx = "";
         }
-
-        doc.clear();
-        yield();
+        ams_count++;  // Erhöhe ams_count für die externe Spule
     }
-*/
 
-    return true;
+    // Erstelle JSON für WebSocket-Clients
+    JsonDocument wsDoc;
+    JsonArray wsArray = wsDoc.to<JsonArray>();
+
+    for (int i = 0; i < ams_count; i++) {
+        JsonObject amsObj = wsArray.add<JsonObject>();
+        amsObj["ams_id"] = ams_data[i].ams_id;
+
+        JsonArray trays = amsObj["tray"].to<JsonArray>();
+        int maxTrays = (ams_data[i].ams_id == 255) ? 1 : 4;
+        
+        for (int j = 0; j < maxTrays; j++) {
+            JsonObject trayObj = trays.add<JsonObject>();
+            trayObj["id"] = ams_data[i].trays[j].id;
+            trayObj["tray_info_idx"] = ams_data[i].trays[j].tray_info_idx;
+            trayObj["tray_type"] = ams_data[i].trays[j].tray_type;
+            trayObj["tray_sub_brands"] = ams_data[i].trays[j].tray_sub_brands;
+            trayObj["tray_color"] = ams_data[i].trays[j].tray_color;
+            trayObj["nozzle_temp_min"] = ams_data[i].trays[j].nozzle_temp_min;
+            trayObj["nozzle_temp_max"] = ams_data[i].trays[j].nozzle_temp_max;
+            trayObj["setting_id"] = ams_data[i].trays[j].setting_id;
+            trayObj["cali_idx"] = ams_data[i].trays[j].cali_idx;
+        }
+    }
+
+    serializeJson(wsArray, amsJsonData);
+    wsDoc.clear();
+    Serial.println("AMS data updated");
+    sendAmsData(nullptr);
 }
 
 // init
 void mqtt_callback(char* topic, byte* payload, unsigned int length) {
     String message;
+    
     for (int i = 0; i < length; i++) {
         message += (char)payload[i];
     }
@@ -263,21 +439,25 @@ void mqtt_callback(char* topic, byte* payload, unsigned int length) {
     // JSON-Dokument parsen
     JsonDocument doc;
     DeserializationError error = deserializeJson(doc, message);
-    if (error) {
+    message = "";
+    if (error) 
+    {
         Serial.print("Fehler beim Parsen des JSON: ");
         Serial.println(error.c_str());
         return;
     }
 
     // Prüfen, ob "print->upgrade_state" und "print.ams.ams" existieren
-    if (doc["print"].containsKey("upgrade_state")) {
+    if (doc["print"]["upgrade_state"].is<JsonObject>() || (doc["print"]["command"].is<String>() && doc["print"]["command"] == "push_status")) 
+    {
         // Prüfen ob AMS-Daten vorhanden sind
-        if (!doc["print"].containsKey("ams") || !doc["print"]["ams"].containsKey("ams")) {
+        if (!doc["print"]["ams"].is<JsonObject>() || !doc["print"]["ams"]["ams"].is<JsonArray>()) 
+        {
             return;
         }
 
         JsonArray amsArray = doc["print"]["ams"]["ams"].as<JsonArray>();
-        
+
         // Prüfe ob sich die AMS-Daten geändert haben
         bool hasChanges = false;
         
@@ -304,154 +484,81 @@ void mqtt_callback(char* topic, byte* payload, unsigned int length) {
             // Vergleiche die Trays
             for (int j = 0; j < trayArray.size() && j < 4 && !hasChanges; j++) {
                 JsonObject trayObj = trayArray[j];
+
+                if (trayObj["tray_type"].as<String>() == "") ams_data[storedIndex].trays[j].setting_id = "";
+                if (trayObj["setting_id"].isNull()) trayObj["setting_id"] = "";
                 if (trayObj["tray_info_idx"].as<String>() != ams_data[storedIndex].trays[j].tray_info_idx ||
                     trayObj["tray_type"].as<String>() != ams_data[storedIndex].trays[j].tray_type ||
                     trayObj["tray_color"].as<String>() != ams_data[storedIndex].trays[j].tray_color ||
+                    (trayObj["setting_id"].as<String>() != "" && trayObj["setting_id"].as<String>() != ams_data[storedIndex].trays[j].setting_id) ||
                     trayObj["cali_idx"].as<String>() != ams_data[storedIndex].trays[j].cali_idx) {
                     hasChanges = true;
+
+                    if (bambuCredentials.autosend_enable && autoSetToBambuSpoolId > 0 && hasChanges)
+                    {
+                        autoSetSpool(autoSetToBambuSpoolId, ams_data[storedIndex].trays[j].id);
+                    }
+
                     break;
                 }
             }
         }
 
         // Prüfe die externe Spule
-        if (!hasChanges && doc["print"].containsKey("vt_tray")) {
-            JsonObject vtTray = doc["print"]["vt_tray"];
-            bool foundExternal = false;
-            
+        JsonObject vtTray = doc["print"]["vt_tray"];
+        if (doc["print"]["vt_tray"].is<JsonObject>()) {
             for (int i = 0; i < ams_count; i++) {
                 if (ams_data[i].ams_id == 255) {
-                    foundExternal = true;
+                    if (vtTray["tray_type"].as<String>() == "") ams_data[i].trays[0].setting_id = "";
+                    if (vtTray["setting_id"].isNull()) vtTray["setting_id"] = "";
                     if (vtTray["tray_info_idx"].as<String>() != ams_data[i].trays[0].tray_info_idx ||
                         vtTray["tray_type"].as<String>() != ams_data[i].trays[0].tray_type ||
                         vtTray["tray_color"].as<String>() != ams_data[i].trays[0].tray_color ||
-                        vtTray["cali_idx"].as<String>() != ams_data[i].trays[0].cali_idx) {
+                        (vtTray["setting_id"].as<String>() != "" && vtTray["setting_id"].as<String>() != ams_data[i].trays[0].setting_id) ||
+                        (vtTray["tray_type"].as<String>() != "" && vtTray["cali_idx"].as<String>() != ams_data[i].trays[0].cali_idx)) {
                         hasChanges = true;
+
+                        if (bambuCredentials.autosend_enable && autoSetToBambuSpoolId > 0 && hasChanges)
+                        {
+                            autoSetSpool(autoSetToBambuSpoolId, 254);
+                        }
                     }
                     break;
                 }
             }
-            if (!foundExternal) hasChanges = true;
         }
 
         if (!hasChanges) return;
 
-        // Fortfahren mit der bestehenden Verarbeitung, da Änderungen gefunden wurden
-        ams_count = amsArray.size();
-        
-        for (int i = 0; i < ams_count && i < 16; i++) {
-            JsonObject amsObj = amsArray[i];
-            JsonArray trayArray = amsObj["tray"].as<JsonArray>();
-
-            ams_data[i].ams_id = i; // Setze die AMS-ID
-            for (int j = 0; j < trayArray.size() && j < 4; j++) { // Annahme: Maximal 4 Trays pro AMS
-                JsonObject trayObj = trayArray[j];
-
-                ams_data[i].trays[j].id = trayObj["id"].as<uint8_t>();
-                ams_data[i].trays[j].tray_info_idx = trayObj["tray_info_idx"].as<String>();
-                ams_data[i].trays[j].tray_type = trayObj["tray_type"].as<String>();
-                ams_data[i].trays[j].tray_sub_brands = trayObj["tray_sub_brands"].as<String>();
-                ams_data[i].trays[j].tray_color = trayObj["tray_color"].as<String>();
-                ams_data[i].trays[j].nozzle_temp_min = trayObj["nozzle_temp_min"].as<int>();
-                ams_data[i].trays[j].nozzle_temp_max = trayObj["nozzle_temp_max"].as<int>();
-                ams_data[i].trays[j].setting_id = trayObj["setting_id"].as<String>();
-                ams_data[i].trays[j].cali_idx = trayObj["cali_idx"].as<String>();
-            }
-        }
-        
-        // Setze ams_count auf die Anzahl der normalen AMS
-        ams_count = amsArray.size();
-
-        // Wenn externe Spule vorhanden, füge sie hinzu
-        if (doc["print"].containsKey("vt_tray")) {
-            JsonObject vtTray = doc["print"]["vt_tray"];
-            int extIdx = ams_count;  // Index für externe Spule
-            ams_data[extIdx].ams_id = 255;  // Spezielle ID für externe Spule
-            ams_data[extIdx].trays[0].id = 254;  // Spezielle ID für externes Tray
-            ams_data[extIdx].trays[0].tray_info_idx = vtTray["tray_info_idx"].as<String>();
-            ams_data[extIdx].trays[0].tray_type = vtTray["tray_type"].as<String>();
-            ams_data[extIdx].trays[0].tray_sub_brands = vtTray["tray_sub_brands"].as<String>();
-            ams_data[extIdx].trays[0].tray_color = vtTray["tray_color"].as<String>();
-            ams_data[extIdx].trays[0].nozzle_temp_min = vtTray["nozzle_temp_min"].as<int>();
-            ams_data[extIdx].trays[0].nozzle_temp_max = vtTray["nozzle_temp_max"].as<int>();
-            ams_data[extIdx].trays[0].setting_id = vtTray["setting_id"].as<String>();
-            ams_data[extIdx].trays[0].cali_idx = vtTray["cali_idx"].as<String>();
-            ams_count++;  // Erhöhe ams_count für die externe Spule
-        }
-
-        // Sende die aktualisierten AMS-Daten
-        //sendAmsData(nullptr);
-
-        // Erstelle JSON für WebSocket-Clients
-        JsonDocument wsDoc;
-        JsonArray wsArray = wsDoc.to<JsonArray>();
-
-        for (int i = 0; i < ams_count; i++) {
-            JsonObject amsObj = wsArray.createNestedObject();
-            amsObj["ams_id"] = ams_data[i].ams_id;
-
-            JsonArray trays = amsObj.createNestedArray("tray");
-            int maxTrays = (ams_data[i].ams_id == 255) ? 1 : 4;
-            
-            for (int j = 0; j < maxTrays; j++) {
-                JsonObject trayObj = trays.createNestedObject();
-                trayObj["id"] = ams_data[i].trays[j].id;
-                trayObj["tray_info_idx"] = ams_data[i].trays[j].tray_info_idx;
-                trayObj["tray_type"] = ams_data[i].trays[j].tray_type;
-                trayObj["tray_sub_brands"] = ams_data[i].trays[j].tray_sub_brands;
-                trayObj["tray_color"] = ams_data[i].trays[j].tray_color;
-                trayObj["nozzle_temp_min"] = ams_data[i].trays[j].nozzle_temp_min;
-                trayObj["nozzle_temp_max"] = ams_data[i].trays[j].nozzle_temp_max;
-                trayObj["setting_id"] = ams_data[i].trays[j].setting_id;
-                trayObj["cali_idx"] = ams_data[i].trays[j].cali_idx;
-            }
-        }
-
-        serializeJson(wsArray, amsJsonData);
-        sendAmsData(nullptr);
+        updateAmsWsData(doc, amsArray, ams_count, vtTray);
     }
+    
     // Neue Bedingung für ams_filament_setting
-    else if (doc["print"]["command"] == "ams_filament_setting") {
+    if (doc["print"]["command"] == "ams_filament_setting") {
         int amsId = doc["print"]["ams_id"].as<int>();
         int trayId = doc["print"]["tray_id"].as<int>();
-        String settingId = doc["print"]["setting_id"].as<String>();
-        
+        String settingId = (doc["print"]["setting_id"].is<String>()) ? doc["print"]["setting_id"].as<String>() : "";
+
         // Finde das entsprechende AMS und Tray
         for (int i = 0; i < ams_count; i++) {
             if (ams_data[i].ams_id == amsId) {
-                // Update setting_id im entsprechenden Tray
-                ams_data[i].trays[trayId].setting_id = settingId;
-                
-                // Erstelle neues JSON für WebSocket-Clients
-                JsonDocument wsDoc;
-                JsonArray wsArray = wsDoc.to<JsonArray>();
-
-                for (int j = 0; j < ams_count; j++) {
-                    JsonObject amsObj = wsArray.createNestedObject();
-                    amsObj["ams_id"] = ams_data[j].ams_id;
-
-                    JsonArray trays = amsObj.createNestedArray("tray");
-                    int maxTrays = (ams_data[j].ams_id == 255) ? 1 : 4;
-                    
-                    for (int k = 0; k < maxTrays; k++) {
-                        JsonObject trayObj = trays.createNestedObject();
-                        trayObj["id"] = ams_data[j].trays[k].id;
-                        trayObj["tray_info_idx"] = ams_data[j].trays[k].tray_info_idx;
-                        trayObj["tray_type"] = ams_data[j].trays[k].tray_type;
-                        trayObj["tray_sub_brands"] = ams_data[j].trays[k].tray_sub_brands;
-                        trayObj["tray_color"] = ams_data[j].trays[k].tray_color;
-                        trayObj["nozzle_temp_min"] = ams_data[j].trays[k].nozzle_temp_min;
-                        trayObj["nozzle_temp_max"] = ams_data[j].trays[k].nozzle_temp_max;
-                        trayObj["setting_id"] = ams_data[j].trays[k].setting_id;
-                        trayObj["cali_idx"] = ams_data[j].trays[k].cali_idx;
+                if (trayId == 254)
+                {
+                    // Suche AMS mit ID 255 (externe Spule)
+                    for (int j = 0; j < ams_count; j++) {
+                        if (ams_data[j].ams_id == 255) {
+                            ams_data[j].trays[0].setting_id = settingId;
+                            break;
+                        }
                     }
                 }
-
-                // Aktualisiere das globale amsJsonData
-                amsJsonData = "";
-                serializeJson(wsArray, amsJsonData);
-                
+                else
+                {
+                    ams_data[i].trays[trayId].setting_id = settingId;
+                }
+               
                 // Sende an WebSocket Clients
+                Serial.println("Filament setting updated");
                 sendAmsData(nullptr);
                 break;
             }
@@ -461,16 +568,18 @@ void mqtt_callback(char* topic, byte* payload, unsigned int length) {
 
 void reconnect() {
     // Loop until we're reconnected
+    uint8_t retries = 0;
     while (!client.connected()) {
-        Serial.print("Attempting MQTT connection...");
+        Serial.println("Attempting MQTT re/connection...");
         bambu_connected = false;
         oledShowTopRow();
 
         // Attempt to connect
-        if (client.connect(bambu_serialnr, bambu_username, bambu_accesscode)) {
-            Serial.println("... re-connected");
-            // ... and resubscribe
-            client.subscribe(report_topic.c_str());
+        String clientId = bambuCredentials.serial + "_" + String(random(0, 100));
+        if (client.connect(clientId.c_str(), BAMBU_USERNAME, bambuCredentials.accesscode.c_str())) {
+            Serial.println("MQTT re/connected");
+
+            client.subscribe(("device/"+bambuCredentials.serial+"/report").c_str());
             bambu_connected = true;
             oledShowTopRow();
         } else {
@@ -479,14 +588,24 @@ void reconnect() {
             Serial.println(" try again in 5 seconds");
             bambu_connected = false;
             oledShowTopRow();
-            // Wait 5 seconds before retrying
+            
             yield();
             vTaskDelay(5000 / portTICK_PERIOD_MS);
+            if (retries > 5) {
+                Serial.println("Disable Bambu MQTT Task after 5 retries");
+                //vTaskSuspend(BambuMqttTask);
+                vTaskDelete(BambuMqttTask);
+                BambuMqttTask = NULL;
+                break;
+            }
+
+            retries++;
         }
     }
 }
 
 void mqtt_loop(void * parameter) {
+    Serial.println("Bambu MQTT Task gestartet");
     for(;;) {
         if (pauseBambuMqttTask) {
             vTaskDelay(10000);
@@ -500,37 +619,31 @@ void mqtt_loop(void * parameter) {
         }
         client.loop();
         yield();
+        esp_task_wdt_reset();
         vTaskDelay(100);
     }
 }
 
 bool setupMqtt() {
     // Wenn Bambu Daten vorhanden
-    bool success = loadBambuCredentials();
-    vTaskDelay(100 / portTICK_PERIOD_MS);
+    //bool success = loadBambuCredentials();
 
-    if (!success) {
-        Serial.println("Failed to load Bambu credentials");
-        oledShowMessage("Bambu Credentials Missing");
-        vTaskDelay(2000 / portTICK_PERIOD_MS);
-        return false;
-    }
-
-    if (success && bambu_ip != "" && bambu_accesscode != "" && bambu_serialnr != "") 
+    if (bambuCredentials.ip != "" && bambuCredentials.accesscode != "" && bambuCredentials.serial != "") 
     {
+        oledShowProgressBar(4, 7, DISPLAY_BOOT_TEXT, "Bambu init");
+        bambuDisabled = false;
         sslClient.setCACert(root_ca);
         sslClient.setInsecure();
-        client.setServer(bambu_ip, 8883);
+        client.setServer(bambuCredentials.ip.c_str(), 8883);
 
         // Verbinden mit dem MQTT-Server
         bool connected = true;
-        if (client.connect(bambu_serialnr, bambu_username, bambu_accesscode)) 
+        String clientId = String(bambuCredentials.serial) + "_" + String(random(0, 100));
+        if (client.connect(bambuCredentials.ip.c_str(), BAMBU_USERNAME, bambuCredentials.accesscode.c_str())) 
         {
             client.setCallback(mqtt_callback);
-            client.setBufferSize(5120);
-            // Optional: Topic abonnieren
-            client.subscribe(report_topic.c_str());
-            //client.subscribe(request_topic.c_str());
+            client.setBufferSize(15488);
+            client.subscribe(("device/"+bambuCredentials.serial+"/report").c_str());
             Serial.println("MQTT-Client initialisiert");
 
             oledShowMessage("Bambu Connected");
@@ -540,7 +653,7 @@ bool setupMqtt() {
             xTaskCreatePinnedToCore(
                 mqtt_loop, /* Function to implement the task */
                 "BambuMqtt", /* Name of the task */
-                10000,  /* Stack size in words */
+                8192,  /* Stack size in words */
                 NULL,  /* Task input parameter */
                 mqttTaskPrio,  /* Priority of the task */
                 &BambuMqttTask,  /* Task handle. */
@@ -553,24 +666,26 @@ bool setupMqtt() {
             vTaskDelay(2000 / portTICK_PERIOD_MS);
             connected = false;
             oledShowTopRow();
+            autoSetToBambuSpoolId = 0;
         }
 
         if (!connected) return false;
     } 
     else 
     {
-        Serial.println("Fehler: Keine MQTT-Daten vorhanden");
-        oledShowMessage("Bambu Credentials Missing");
-        oledShowTopRow();
-        vTaskDelay(2000 / portTICK_PERIOD_MS);
+        bambuDisabled = true;
         return false;
     }
     return true;
 }
 
 void bambu_restart() {
+    Serial.println("Bambu restart");
+
     if (BambuMqttTask) {
         vTaskDelete(BambuMqttTask);
+        BambuMqttTask = NULL;
+        delay(10);
     }
     setupMqtt();
 }

src/bambu.h

@@ -16,6 +16,14 @@ struct TrayData {
     String cali_idx;
 };
 
+struct BambuCredentials {
+    String ip;
+    String serial;
+    String accesscode;
+    bool autosend_enable;
+    int autosend_time;
+};
+
 #define MAX_AMS 17  // 16 normale AMS + 1 externe Spule
 extern String amsJsonData;  // Für die vorbereiteten JSON-Daten
 
@@ -28,12 +36,18 @@ extern bool bambu_connected;
 
 extern int ams_count;
 extern AMSData ams_data[MAX_AMS];
+//extern bool autoSendToBambu;
+extern int autoSetToBambuSpoolId;
+extern bool bambuDisabled;
+extern BambuCredentials bambuCredentials;
 
+bool removeBambuCredentials();
 bool loadBambuCredentials();
-bool saveBambuCredentials(const String& bambu_ip, const String& bambu_serialnr, const String& bambu_accesscode);
+bool saveBambuCredentials(const String& bambu_ip, const String& bambu_serialnr, const String& bambu_accesscode, const bool autoSend, const String& autoSendTime);
 bool setupMqtt();
 void mqtt_loop(void * parameter);
 bool setBambuSpool(String payload);
 void bambu_restart();
 
+extern TaskHandle_t BambuMqttTask;
 #endif

src/commonFS.cpp

@@ -1,7 +1,22 @@
 #include "commonFS.h"
+#include <LittleFS.h>
+
+bool removeJsonValue(const char* filename) {
+    File file = LittleFS.open(filename, "r");
+    if (!file) {
+        return true;
+    }
+    file.close();
+    if (!LittleFS.remove(filename)) {
+        Serial.print("Fehler beim Löschen der Datei: ");
+        Serial.println(filename);
+        return false;
+    }
+    return true;
+}
 
 bool saveJsonValue(const char* filename, const JsonDocument& doc) {
-    File file = SPIFFS.open(filename, "w");
+    File file = LittleFS.open(filename, "w");
     if (!file) {
         Serial.print("Fehler beim Öffnen der Datei zum Schreiben: ");
         Serial.println(filename);
@@ -19,7 +34,7 @@ bool saveJsonValue(const char* filename, const JsonDocument& doc) {
 }
 
 bool loadJsonValue(const char* filename, JsonDocument& doc) {
-    File file = SPIFFS.open(filename, "r");
+    File file = LittleFS.open(filename, "r");
     if (!file) {
         Serial.print("Fehler beim Öffnen der Datei zum Lesen: ");
         Serial.println(filename);
@@ -35,23 +50,12 @@ bool loadJsonValue(const char* filename, JsonDocument& doc) {
     return true;
 }
 
-bool initializeSPIFFS() {
-    // Erster Versuch
-    if (SPIFFS.begin(true)) {
-        Serial.println("SPIFFS mounted successfully.");
-        return true;
+void initializeFileSystem() {
+    if (!LittleFS.begin(true)) {
+        Serial.println("LittleFS Mount Failed");
+        return;
     }
-    
-    // Formatierung versuchen
-    Serial.println("Failed to mount SPIFFS. Formatting...");
-    SPIFFS.format();
-    
-    // Zweiter Versuch nach Formatierung
-    if (SPIFFS.begin(true)) {
-        Serial.println("SPIFFS formatted and mounted successfully.");
-        return true;
-    }
-    
-    Serial.println("SPIFFS initialization failed completely.");
-    return false;
+    Serial.printf("LittleFS Total: %u bytes\n", LittleFS.totalBytes());
+    Serial.printf("LittleFS Used: %u bytes\n", LittleFS.usedBytes());
+    Serial.printf("LittleFS Free: %u bytes\n", LittleFS.totalBytes() - LittleFS.usedBytes());
 }

src/commonFS.h

@@ -2,11 +2,12 @@
 #define COMMONFS_H
 
 #include <Arduino.h>
-#include <SPIFFS.h>
 #include <ArduinoJson.h>
+#include <LittleFS.h>
 
+bool removeJsonValue(const char* filename);
 bool saveJsonValue(const char* filename, const JsonDocument& doc);
 bool loadJsonValue(const char* filename, JsonDocument& doc);
-bool initializeSPIFFS();
+void initializeFileSystem();
 
 #endif

src/config.cpp

@@ -16,20 +16,20 @@ const uint8_t LOADCELL_DOUT_PIN = 16; //16;
 const uint8_t LOADCELL_SCK_PIN = 17; //17;
 const uint8_t calVal_eepromAdress = 0;
 const uint16_t SCALE_LEVEL_WEIGHT = 500;
-uint16_t defaultScaleCalibrationValue = 430;
 // ***** HX711
 
+// ***** TTP223 (Touch Sensor)
+// TTP223 circuit wiring
+const uint8_t TTP223_PIN = 25;
+// ***** TTP223
+
+
 // ***** Display
-// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
-// On an ESP32:   21(SDA),  22(SCL)
-const int8_t OLED_RESET = -1; // Reset pin # (or -1 if sharing Arduino reset pin)
-const uint8_t SCREEN_ADDRESS = 0x3C; ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
-const uint8_t SCREEN_WIDTH = 128; // OLED display width, in pixels
-const uint8_t SCREEN_HEIGHT = 64; // OLED display height, in pixels
 const uint8_t OLED_TOP_START = 0;
 const uint8_t OLED_TOP_END = 16;
 const uint8_t OLED_DATA_START = 17;
 const uint8_t OLED_DATA_END = SCREEN_HEIGHT;
+
 // ***** Display
 
 // ***** Webserver
@@ -40,6 +40,8 @@ const uint8_t webserverPort = 80;
 const char* apiUrl = "/api/v1";
 // ***** API
 
+// ***** Bambu Auto Set Spool
+
 // ***** Task Prios
 uint8_t rfidTaskCore = 1;
 uint8_t rfidTaskPrio = 1;

src/config.h

@@ -3,6 +3,40 @@
 
 #include <Arduino.h>
 
+#define BAMBU_DEFAULT_AUTOSEND_TIME         60
+
+#define NVS_NAMESPACE_API                   "api"
+#define NVS_KEY_SPOOLMAN_URL                "spoolmanUrl"
+#define NVS_KEY_OCTOPRINT_ENABLED           "octoEnabled"
+#define NVS_KEY_OCTOPRINT_URL               "octoUrl"
+#define NVS_KEY_OCTOPRINT_TOKEN             "octoToken"
+
+#define NVS_NAMESPACE_BAMBU                 "bambu"
+#define NVS_KEY_BAMBU_IP                    "bambuIp"
+#define NVS_KEY_BAMBU_ACCESSCODE            "bambuCode"
+#define NVS_KEY_BAMBU_SERIAL                "bambuSerial"
+#define NVS_KEY_BAMBU_AUTOSEND_ENABLE       "autosendEnable"
+#define NVS_KEY_BAMBU_AUTOSEND_TIME         "autosendTime"
+
+#define NVS_NAMESPACE_SCALE                 "scale"
+#define NVS_KEY_CALIBRATION                 "cal_value"
+#define NVS_KEY_AUTOTARE                    "auto_tare"
+#define SCALE_DEFAULT_CALIBRATION_VALUE     430.0f;
+
+#define BAMBU_USERNAME                      "bblp"
+
+#define OLED_RESET                          -1      // Reset pin # (or -1 if sharing Arduino reset pin)
+#define SCREEN_ADDRESS                      0x3CU   // See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
+#define SCREEN_WIDTH                        128U
+#define SCREEN_HEIGHT                       64U
+#define SCREEN_TOP_BAR_HEIGHT               16U
+#define SCREEN_PROGRESS_BAR_HEIGHT          12U
+#define DISPLAY_BOOT_TEXT                   "FilaMan"
+
+#define WIFI_CHECK_INTERVAL                 60000U
+#define DISPLAY_UPDATE_INTERVAL             1000U
+#define SPOOLMAN_HEALTHCHECK_INTERVAL       60000U
+
 extern const uint8_t PN532_IRQ;
 extern const uint8_t PN532_RESET;
 
@@ -11,10 +45,8 @@ extern const uint8_t LOADCELL_SCK_PIN;
 extern const uint8_t calVal_eepromAdress;
 extern const uint16_t SCALE_LEVEL_WEIGHT;
 
-extern const int8_t OLED_RESET;
-extern const uint8_t SCREEN_ADDRESS;
-extern const uint8_t SCREEN_WIDTH;
-extern const uint8_t SCREEN_HEIGHT;
+extern const uint8_t TTP223_PIN;
+
 extern const uint8_t OLED_TOP_START;
 extern const uint8_t OLED_TOP_END;
 extern const uint8_t OLED_DATA_START;
@@ -23,6 +55,8 @@ extern const uint8_t OLED_DATA_END;
 extern const char* apiUrl;
 extern const uint8_t webserverPort;
 
+
+
 extern const unsigned char wifi_on[];
 extern const unsigned char wifi_off[];
 extern const unsigned char cloud_on[];

src/debug.h

@@ -0,0 +1,12 @@
+#include <Arduino.h>
+
+
+#ifdef ENABLE_HEAP_DEBUGGING
+    #define HEAP_DEBUG_MESSAGE(location) printHeapDebugData(location);
+#else
+    #define HEAP_DEBUG_MESSAGE(location) 
+#endif
+
+inline void printHeapDebugData(const char *location){
+    Serial.println("Heap: " + String(ESP.getMinFreeHeap()/1024) + "\t" + String(ESP.getFreeHeap()/1024) + "\t" + String(ESP.getMaxAllocHeap()/1024) + "\t" + location);
+}

src/display.cpp

@@ -2,10 +2,12 @@
 #include "api.h"
 #include <vector>
 #include "icons.h"
+#include "main.h"
 
 Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
 
 bool wifiOn = false;
+bool iconToggle = false;
 
 void setupDisplay() {
     if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
@@ -14,15 +16,10 @@ void setupDisplay() {
     }
     display.setTextColor(WHITE);
     display.clearDisplay();
-    display.display();
 
-    // Show initial display buffer contents on the screen --
-    // the library initializes this with an Adafruit splash screen.
-    display.setTextColor(WHITE);
-    display.display();
-    delay(1000); // Pause for 2 seconds
+
     oledShowTopRow();
-    delay(2000);
+    oledShowProgressBar(0, 7, DISPLAY_BOOT_TEXT, "Display init");
 }
 
 void oledclearline() {
@@ -45,14 +42,14 @@ void oledcleardata() {
     //display.display();
 }
 
-int oled_center_h(String text) {
+int oled_center_h(const String &text) {
     int16_t x1, y1;
     uint16_t w, h;
     display.getTextBounds(text, 0, 0, &x1, &y1, &w, &h);
     return (SCREEN_WIDTH - w) / 2;
 }
 
-int oled_center_v(String text) {
+int oled_center_v(const String &text) {
     int16_t x1, y1;
     uint16_t w, h;
     display.getTextBounds(text, 0, OLED_DATA_START, &x1, &y1, &w, &h);
@@ -60,7 +57,7 @@ int oled_center_v(String text) {
     return OLED_DATA_START + ((OLED_DATA_END - OLED_DATA_START - h) / 2);
 }
 
-std::vector<String> splitTextIntoLines(String text, uint8_t textSize) {
+std::vector<String> splitTextIntoLines(const String &text, uint8_t textSize) {
     std::vector<String> lines;
     display.setTextSize(textSize);
     
@@ -117,11 +114,10 @@ std::vector<String> splitTextIntoLines(String text, uint8_t textSize) {
         lines.push_back(currentLine);
     }
     
-    Serial.println(lines.size());
     return lines;
 }
 
-void oledShowMultilineMessage(String message, uint8_t size) {
+void oledShowMultilineMessage(const String &message, uint8_t size) {
     std::vector<String> lines;
     int maxLines = 3;  // Maximale Anzahl Zeilen für size 2
     
@@ -140,15 +136,16 @@ void oledShowMultilineMessage(String message, uint8_t size) {
     int totalHeight = lines.size() * lineHeight;
     int startY = OLED_DATA_START + ((OLED_DATA_END - OLED_DATA_START - totalHeight) / 2);
     
+    uint8_t lineDistance = (lines.size() == 2) ? 5 : 0;
     for (size_t i = 0; i < lines.size(); i++) {
-        display.setCursor(oled_center_h(lines[i]), startY + (i * lineHeight));
+        display.setCursor(oled_center_h(lines[i]), startY + (i * lineHeight) + (i == 1 ? lineDistance : 0));
         display.print(lines[i]);
     }
     
     display.display();
 }
 
-void oledShowMessage(String message, uint8_t size) {
+void oledShowMessage(const String &message, uint8_t size) {
     oledcleardata();
     display.setTextSize(size);
     display.setTextWrap(false);
@@ -171,22 +168,46 @@ void oledShowMessage(String message, uint8_t size) {
 void oledShowTopRow() {
     oledclearline();
 
-    if (bambu_connected == 1) {
-        display.drawBitmap(50, 0, bitmap_bambu_on , 16, 16, WHITE);
-    } else {
-        display.drawBitmap(50, 0, bitmap_off , 16, 16, WHITE);
-    }
+    display.setTextSize(1);
+    display.setCursor(0, 4);
+    display.print("v");
+    display.print(VERSION);
 
-    if (spoolman_connected == 1) {
-        display.drawBitmap(80, 0, bitmap_spoolman_on , 16, 16, WHITE);
-    } else {
-        display.drawBitmap(80, 0, bitmap_off , 16, 16, WHITE);
-    }
+    iconToggle = !iconToggle;
 
-    if (wifiOn == 1) {
-        display.drawBitmap(107, 0, wifi_on , 16, 16, WHITE);
-    } else {
-        display.drawBitmap(107, 0, wifi_off , 16, 16, WHITE);
+    // Do not show status indicators during boot
+    if(!booting){
+        if(bambuDisabled == false) {
+            if (bambu_connected == 1) {
+                display.drawBitmap(50, 0, bitmap_bambu_on , 16, 16, WHITE);
+            } else {
+                if(iconToggle){
+                    display.drawBitmap(50, 0, bitmap_bambu_on , 16, 16, WHITE);
+                    display.drawLine(50, 15, 66, 0, WHITE);
+                    display.drawLine(51, 15, 67, 0, WHITE);
+                }
+            }
+        }
+
+        if (spoolmanConnected) {
+            display.drawBitmap(80, 0, bitmap_spoolman_on , 16, 16, WHITE);
+        } else {
+            if(iconToggle){
+                display.drawBitmap(80, 0, bitmap_spoolman_on , 16, 16, WHITE);
+                display.drawLine(80, 15, 96, 0, WHITE);
+                display.drawLine(81, 15, 97, 0, WHITE);
+            }
+        }
+
+        if (wifiOn == 1) {
+            display.drawBitmap(107, 0, wifi_on , 16, 16, WHITE);
+        } else {
+            if(iconToggle){
+                display.drawBitmap(107, 0, wifi_on , 16, 16, WHITE);
+                display.drawLine(107, 15, 123, 0, WHITE);
+                display.drawLine(108, 15, 124, 0, WHITE);
+            }
+        }
     }
     
     display.display();
@@ -214,6 +235,27 @@ void oledShowIcon(const char* icon) {
     display.display();
 }
 
+void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char* largeText, const char* statusMessage) {
+    assert(step <= numSteps);
+
+    // clear data and bar area
+    display.fillRect(0, OLED_DATA_START, SCREEN_WIDTH, SCREEN_HEIGHT-16, BLACK);
+
+    
+    display.setTextWrap(false);
+    display.setTextSize(2);
+    display.setCursor(0, OLED_DATA_START+4);
+    display.print(largeText);
+    display.setTextSize(1);
+    display.setCursor(0, OLED_DATA_END-SCREEN_PROGRESS_BAR_HEIGHT-10);
+    display.print(statusMessage);
+
+    const int barLength = ((SCREEN_WIDTH-2)*step)/numSteps;
+    display.drawRoundRect(0, SCREEN_HEIGHT-SCREEN_PROGRESS_BAR_HEIGHT, SCREEN_WIDTH, 12, 6, WHITE);
+    display.fillRoundRect(1, SCREEN_HEIGHT-SCREEN_PROGRESS_BAR_HEIGHT+1, barLength, 10, 6, WHITE);
+    display.display();
+}
+
 void oledShowWeight(uint16_t weight) {
     // Display Gewicht
     oledcleardata();

src/display.h

@@ -13,11 +13,13 @@ extern bool wifiOn;
 void setupDisplay();
 void oledclearline();
 void oledcleardata();
-int oled_center_h(String text);
-int oled_center_v(String text);
+int oled_center_h(const String &text);
+int oled_center_v(const String &text);
+
+void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char* largeText, const char* statusMessage);
 
 void oledShowWeight(uint16_t weight);
-void oledShowMessage(String message, uint8_t size = 2);
+void oledShowMessage(const String &message, uint8_t size = 2);
 void oledShowTopRow();
 void oledShowIcon(const char* icon);
 

src/main.cpp

@@ -1,6 +1,4 @@
 #include <Arduino.h>
-#include <DNSServer.h>
-#include <ESPmDNS.h>
 #include <Wire.h>
 #include <WiFi.h>
 
@@ -15,12 +13,23 @@
 #include "esp_task_wdt.h"
 #include "commonFS.h"
 
+bool mainTaskWasPaused = 0;
+uint8_t scaleTareCounter = 0;
+bool touchSensorConnected = false;
+bool booting = true;
+
 // ##### SETUP #####
 void setup() {
   Serial.begin(115200);
 
+  uint64_t chipid;
+
+  chipid = ESP.getEfuseMac(); //The chip ID is essentially its MAC address(length: 6 bytes).
+  Serial.printf("ESP32 Chip ID = %04X", (uint16_t)(chipid >> 32)); //print High 2 bytes
+  Serial.printf("%08X\n", (uint32_t)chipid); //print Low 4bytes.
+
   // Initialize SPIFFS
-  initializeSPIFFS();
+  initializeFileSystem();
 
   // Start Display
   setupDisplay();
@@ -29,129 +38,243 @@ void setup() {
   initWiFi();
 
   // Webserver
-  Serial.println("Starte Webserver");
   setupWebserver(server);
 
   // Spoolman API
-  // api.cpp
   initSpoolman();
 
   // Bambu MQTT
-  // bambu.cpp
   setupMqtt();
 
-  // mDNS
-  Serial.println("Starte MDNS");
-  if (!MDNS.begin("filaman")) {   // Set the hostname to "esp32.local"
-    Serial.println("Error setting up MDNS responder!");
-    while(1) {
-      delay(1000);
-    }
-  }
-  Serial.println("mDNS responder started");
-  
+  // NFC Reader
   startNfc();
 
-  start_scale();
-  
+  // Touch Sensor
+  pinMode(TTP223_PIN, INPUT_PULLUP);
+  if (digitalRead(TTP223_PIN) == LOW) 
+  {
+    Serial.println("Touch Sensor is connected");
+    touchSensorConnected = true;
+  }
+
+  // Scale
+  start_scale(touchSensorConnected);
+  scale.tare();
+
   // WDT initialisieren mit 10 Sekunden Timeout
   bool panic = true; // Wenn true, löst ein WDT-Timeout einen System-Panik aus
-  esp_task_wdt_init(10, panic); 
+  esp_task_wdt_init(10, panic);
 
+  booting = false;
   // Aktuellen Task (loopTask) zum Watchdog hinzufügen
   esp_task_wdt_add(NULL);
-
-  // Optional: Andere Tasks zum Watchdog hinzufügen, falls nötig
-  // esp_task_wdt_add(task_handle);
 }
 
 
+/**
+ * Safe interval check that handles millis() overflow
+ * @param currentTime Current millis() value
+ * @param lastTime Last recorded time
+ * @param interval Desired interval in milliseconds
+ * @return True if interval has elapsed
+ */
+bool intervalElapsed(unsigned long currentTime, unsigned long &lastTime, unsigned long interval) {
+  if (currentTime - lastTime >= interval || currentTime < lastTime) {
+    lastTime = currentTime;
+    return true;
+  }
+  return false;
+}
+
 unsigned long lastWeightReadTime = 0;
 const unsigned long weightReadInterval = 1000; // 1 second
 
-unsigned long lastAmsSendTime = 0;
-const unsigned long amsSendInterval = 60000; // 1 minute
+unsigned long lastAutoSetBambuAmsTime = 0;
+const unsigned long autoSetBambuAmsInterval = 1000; // 1 second
+uint8_t autoAmsCounter = 0;
 
 uint8_t weightSend = 0;
 int16_t lastWeight = 0;
-uint8_t wifiErrorCounter = 0;
+
+// WIFI check variables
+unsigned long lastWifiCheckTime = 0;
+unsigned long lastTopRowUpdateTime = 0;
+unsigned long lastSpoolmanHealcheckTime = 0;
+
+// Button debounce variables
+unsigned long lastButtonPress = 0;
+const unsigned long debounceDelay = 500; // 500 ms debounce delay
 
 // ##### PROGRAM START #####
 void loop() {
-  // Überprüfe den WLAN-Status
-  if (WiFi.status() != WL_CONNECTED) {
-    wifiErrorCounter++;
-    wifiOn = false;
-  } else {
-    wifiErrorCounter = 0;
-    wifiOn = true;
-  }
-  if (wifiErrorCounter > 20) ESP.restart();
-
   unsigned long currentMillis = millis();
 
-  // Send AMS Data min every Minute
-  if (currentMillis - lastAmsSendTime >= amsSendInterval) {
-    lastAmsSendTime = currentMillis;
-    sendAmsData(nullptr);
+  // Überprüfe den Status des Touch Sensors
+  if (touchSensorConnected && digitalRead(TTP223_PIN) == HIGH && currentMillis - lastButtonPress > debounceDelay) 
+  {
+    lastButtonPress = currentMillis;
+    scaleTareRequest = true;
   }
 
-  // Ausgabe der Waage auf Display
-  if (pauseMainTask == 0 && weight != lastWeight && hasReadRfidTag == 0)
+  // Überprüfe regelmäßig die WLAN-Verbindung
+  if (intervalElapsed(currentMillis, lastWifiCheckTime, WIFI_CHECK_INTERVAL)) 
   {
-    (weight < 0) ? oledShowMessage("!! -1") : oledShowWeight(weight);
+    checkWiFiConnection();
   }
 
-  // Wenn Timer abgelaufen und nicht gerade ein RFID-Tag geschrieben wird
-  if (currentMillis - lastWeightReadTime >= weightReadInterval && hasReadRfidTag < 3)
+  // Periodic display update
+  if (intervalElapsed(currentMillis, lastTopRowUpdateTime, DISPLAY_UPDATE_INTERVAL)) 
   {
-    lastWeightReadTime = currentMillis;
+    oledShowTopRow();
+  }
 
-    // Prüfen ob die Waage korrekt genullt ist
-    if ((weight > 0 && weight < 5) || weight < 0)
+  // Periodic spoolman health check
+  if (intervalElapsed(currentMillis, lastSpoolmanHealcheckTime, SPOOLMAN_HEALTHCHECK_INTERVAL)) 
+  {
+    checkSpoolmanInstance();
+  }
+
+  // Wenn Bambu auto set Spool aktiv
+  if (bambuCredentials.autosend_enable && autoSetToBambuSpoolId > 0) 
+  {
+    if (!bambuDisabled && !bambu_connected) 
     {
-      scale_tare_counter++;
+      bambu_restart();
+    }
+
+    if (intervalElapsed(currentMillis, lastAutoSetBambuAmsTime, autoSetBambuAmsInterval)) 
+    {
+      if (nfcReaderState == NFC_IDLE)
+      {
+        lastAutoSetBambuAmsTime = currentMillis;
+        oledShowMessage("Auto Set         " + String(bambuCredentials.autosend_time - autoAmsCounter) + "s");
+        autoAmsCounter++;
+
+        if (autoAmsCounter >= bambuCredentials.autosend_time) 
+        {
+          autoSetToBambuSpoolId = 0;
+          autoAmsCounter = 0;
+          oledShowWeight(weight);
+        }
+      }
+      else
+      {
+        autoAmsCounter = 0;
+      }
+    }
+  }
+
+  // If scale is not calibrated, only show a warning
+  if (!scaleCalibrated) 
+  {
+    // Do not show the warning if the calibratin process is onging
+    if(!scaleCalibrationActive){
+      oledShowMessage("Scale not calibrated");
+      vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+  } 
+  else 
+  {
+    // Ausgabe der Waage auf Display
+    if(pauseMainTask == 0)
+    {
+      if (mainTaskWasPaused || (weight != lastWeight && nfcReaderState == NFC_IDLE && (!bambuCredentials.autosend_enable || autoSetToBambuSpoolId == 0)))
+      {
+        (weight < 2) ? ((weight < -2) ? oledShowMessage("!! -0") : oledShowWeight(0)) : oledShowWeight(weight);
+      }
+      mainTaskWasPaused = false;
     }
     else
     {
-      scale_tare_counter = 0;
+      mainTaskWasPaused = true;
     }
 
-    // Prüfen ob das Gewicht gleich bleibt und dann senden
-    if (weight == lastWeight && weight > 5)
+
+    // Wenn Timer abgelaufen und nicht gerade ein RFID-Tag geschrieben wird
+    if (currentMillis - lastWeightReadTime >= weightReadInterval && nfcReaderState < NFC_WRITING)
     {
-      weigthCouterToApi++;
-    } 
-    else 
+      lastWeightReadTime = currentMillis;
+
+      // Prüfen ob die Waage korrekt genullt ist
+      // Abweichung von 2g ignorieren
+      if (autoTare && (weight > 2 && weight < 7) || weight < -2)
+      {
+        scale_tare_counter++;
+      }
+      else
+      {
+        scale_tare_counter = 0;
+      }
+
+      // Prüfen ob das Gewicht gleich bleibt und dann senden
+      if (abs(weight - lastWeight) <= 2 && weight > 5)
+      {
+        weigthCouterToApi++;
+      } 
+      else 
+      {
+        weigthCouterToApi = 0;
+        weightSend = 0;
+      }
+    }
+
+    // reset weight counter after writing tag
+    // TBD: what exactly is the logic behind this?
+    if (currentMillis - lastWeightReadTime >= weightReadInterval && nfcReaderState != NFC_IDLE && nfcReaderState != NFC_READ_SUCCESS)
     {
       weigthCouterToApi = 0;
-      weightSend = 0;
     }
-  }
-  // reset weight counter after writing tag
-  if (currentMillis - lastWeightReadTime >= weightReadInterval && hasReadRfidTag > 1)
-  {
-    weigthCouterToApi = 0;
+    
+    lastWeight = weight;
+
+    // Wenn ein Tag mit SM id erkannte wurde und der Waage Counter anspricht an SM Senden
+    if (activeSpoolId != "" && weigthCouterToApi > 3 && weightSend == 0 && nfcReaderState == NFC_READ_SUCCESS && tagProcessed == false && spoolmanApiState == API_IDLE) 
+    {
+      // set the current tag as processed to prevent it beeing processed again
+      tagProcessed = true;
+
+      if (updateSpoolWeight(activeSpoolId, weight)) 
+      {
+        weightSend = 1;
+        
+        // Set Bambu spool ID for auto-send if enabled
+        if (bambuCredentials.autosend_enable) 
+        {
+          autoSetToBambuSpoolId = activeSpoolId.toInt();
+        }
+      }
+      else
+      {
+        oledShowIcon("failed");
+        vTaskDelay(2000 / portTICK_PERIOD_MS);
+      }
+    }
+
+    // Handle successful tag write: Send weight to Spoolman but NEVER auto-send to Bambu
+    if (activeSpoolId != "" && weigthCouterToApi > 3 && weightSend == 0 && nfcReaderState == NFC_WRITE_SUCCESS && tagProcessed == false && spoolmanApiState == API_IDLE) 
+    {
+      // set the current tag as processed to prevent it beeing processed again
+      tagProcessed = true;
+
+      if (updateSpoolWeight(activeSpoolId, weight)) 
+      {
+        weightSend = 1;
+        Serial.println("Tag written: Weight sent to Spoolman, but NO auto-send to Bambu");
+        // INTENTIONALLY do NOT set autoSetToBambuSpoolId here to prevent Bambu auto-send
+      }
+      else
+      {
+        oledShowIcon("failed");
+        vTaskDelay(2000 / portTICK_PERIOD_MS);
+      }
+    }
+
+    if(octoEnabled && sendOctoUpdate && spoolmanApiState == API_IDLE)
+    {
+      updateSpoolOcto(autoSetToBambuSpoolId);
+      sendOctoUpdate = false;
+    }
   }
   
-  lastWeight = weight;
-
-  // Wenn ein Tag mit SM id erkannte wurde und der Waage Counter anspricht an SM Senden
-  if (spoolId != "" && weigthCouterToApi > 5 && weightSend == 0 && hasReadRfidTag == 1) {
-    oledShowIcon("loading");
-    if (updateSpoolWeight(spoolId, weight)) 
-    {
-      oledShowIcon("success");
-      vTaskDelay(2000 / portTICK_PERIOD_MS);
-      weightSend = 1;
-    }
-    else
-    {
-      oledShowIcon("failed");
-      vTaskDelay(2000 / portTICK_PERIOD_MS);
-    }
-  }
-
-  yield();
   esp_task_wdt_reset();
 }

src/main.h

@@ -0,0 +1,9 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <Arduino.h>
+
+
+extern bool booting;
+
+#endif

src/nfc.h

@@ -3,14 +3,30 @@
 
 #include <Arduino.h>
 
+typedef enum{
+    NFC_IDLE,
+    NFC_READING,
+    NFC_READ_SUCCESS,
+    NFC_READ_ERROR,
+    NFC_WRITING,
+    NFC_WRITE_SUCCESS,
+    NFC_WRITE_ERROR
+} nfcReaderStateType;
+
 void startNfc();
 void scanRfidTask(void * parameter);
-void startWriteJsonToTag(const char* payload);
+void startWriteJsonToTag(const bool isSpoolTag, const char* payload);
+bool quickSpoolIdCheck(String uidString);
 
 extern TaskHandle_t RfidReaderTask;
 extern String nfcJsonData;
-extern String spoolId;
-extern volatile uint8_t hasReadRfidTag;
+extern String activeSpoolId;
+extern String lastSpoolId;
+extern volatile nfcReaderStateType nfcReaderState;
 extern volatile bool pauseBambuMqttTask;
+extern volatile bool nfcWriteInProgress;
+extern bool tagProcessed;
+
+
 
 #endif

src/ota.cpp

@@ -1,11 +1,266 @@
 #include <Arduino.h>
-#include "ota.h"
-#include <ESPAsyncWebServer.h>
-#include <ESPAsyncHTTPUpdateServer.h>
+#include <website.h>
+#include <commonFS.h>
+#include "scale.h"
+#include "bambu.h"
+#include "nfc.h"
 
-ESPAsyncHTTPUpdateServer updateServer;
 
-void setupOTA(AsyncWebServer &server) {
-    updateServer.setup(&server, "/ota", "admin", "admin");
-    //updateServer.setup(&server);
+// Globale Variablen für Config Backups hinzufügen
+String bambuCredentialsBackup;
+String spoolmanUrlBackup;
+
+// Globale Variable für den Update-Typ
+static int currentUpdateCommand = 0;
+
+// Globale Update-Variablen
+static size_t updateTotalSize = 0;
+static size_t updateWritten = 0;
+static bool isSpiffsUpdate = false;
+
+/**
+ * Compares two version strings and determines if version1 is less than version2
+ * 
+ * @param version1 First version string (format: x.y.z)
+ * @param version2 Second version string (format: x.y.z)
+ * @return true if version1 is less than version2
+ */
+bool isVersionLessThan(const String& version1, const String& version2) {
+    int major1 = 0, minor1 = 0, patch1 = 0;
+    int major2 = 0, minor2 = 0, patch2 = 0;
+    
+    // Parse version1
+    sscanf(version1.c_str(), "%d.%d.%d", &major1, &minor1, &patch1);
+    
+    // Parse version2
+    sscanf(version2.c_str(), "%d.%d.%d", &major2, &minor2, &patch2);
+    
+    // Compare major version
+    if (major1 < major2) return true;
+    if (major1 > major2) return false;
+    
+    // Major versions equal, compare minor
+    if (minor1 < minor2) return true;
+    if (minor1 > minor2) return false;
+    
+    // Minor versions equal, compare patch
+    return patch1 < patch2;
 }
+
+void backupJsonConfigs() {
+    // Bambu Credentials backup
+    if (LittleFS.exists("/bambu_credentials.json")) {
+        File file = LittleFS.open("/bambu_credentials.json", "r");
+        if (file) {
+            bambuCredentialsBackup = file.readString();
+            file.close();
+            Serial.println("Bambu credentials backed up");
+        }
+    }
+
+    // Spoolman URL backup
+    if (LittleFS.exists("/spoolman_url.json")) {
+        File file = LittleFS.open("/spoolman_url.json", "r");
+        if (file) {
+            spoolmanUrlBackup = file.readString();
+            file.close();
+            Serial.println("Spoolman URL backed up");
+        }
+    }
+}
+
+void restoreJsonConfigs() {
+    // Restore Bambu credentials
+    if (bambuCredentialsBackup.length() > 0) {
+        File file = LittleFS.open("/bambu_credentials.json", "w");
+        if (file) {
+            file.print(bambuCredentialsBackup);
+            file.close();
+            Serial.println("Bambu credentials restored");
+        }
+        bambuCredentialsBackup = ""; // Clear backup
+    }
+
+    // Restore Spoolman URL
+    if (spoolmanUrlBackup.length() > 0) {
+        File file = LittleFS.open("/spoolman_url.json", "w");
+        if (file) {
+            file.print(spoolmanUrlBackup);
+            file.close();
+            Serial.println("Spoolman URL restored");
+        }
+        spoolmanUrlBackup = ""; // Clear backup
+    }
+}
+
+void espRestart() {
+    yield();
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+
+    ESP.restart();
+}
+
+
+void sendUpdateProgress(int progress, const char* status = nullptr, const char* message = nullptr) {
+    static int lastSentProgress = -1;
+    
+    // Verhindere zu häufige Updates
+    if (progress == lastSentProgress && !status && !message) {
+        return;
+    }
+    
+    String progressMsg = "{\"type\":\"updateProgress\",\"progress\":" + String(progress);
+    if (status) {
+        progressMsg += ",\"status\":\"" + String(status) + "\"";
+    }
+    if (message) {
+        progressMsg += ",\"message\":\"" + String(message) + "\"";
+    }
+    progressMsg += "}";
+    
+    if (progress >= 100) {
+        // Sende die Nachricht nur einmal für den Abschluss
+        ws.textAll("{\"type\":\"updateProgress\",\"progress\":100,\"status\":\"success\",\"message\":\"Update successful! Restarting device...\"}");
+        delay(50);
+    }
+
+    // Sende die Nachricht mehrmals mit Verzögerung für wichtige Updates
+    if (status || abs(progress - lastSentProgress) >= 10 || progress == 100) {
+        for (int i = 0; i < 2; i++) {
+            ws.textAll(progressMsg);
+            delay(100);  // Längerer Delay zwischen Nachrichten
+        }
+    } else {
+        ws.textAll(progressMsg);
+        delay(50);
+    }
+    
+    lastSentProgress = progress;
+}
+
+void handleUpdate(AsyncWebServer &server) {
+    AsyncCallbackWebHandler* updateHandler = new AsyncCallbackWebHandler();
+    updateHandler->setUri("/update");
+    updateHandler->setMethod(HTTP_POST);
+    
+    // Check if current version is less than defined TOOLVERSION before proceeding with update
+    if (isVersionLessThan(VERSION, TOOLDVERSION)) {
+        updateHandler->onRequest([](AsyncWebServerRequest *request) {
+            request->send(400, "application/json", 
+                "{\"success\":false,\"message\":\"Your current version is too old. Please perform a full upgrade.\"}");
+        });
+        server.addHandler(updateHandler);
+        return;
+    }
+
+    updateHandler->onUpload([](AsyncWebServerRequest *request, String filename,
+                             size_t index, uint8_t *data, size_t len, bool final) {
+
+        // Disable all Tasks
+        if (BambuMqttTask != NULL) 
+        {
+            Serial.println("Delete BambuMqttTask");
+            vTaskDelete(BambuMqttTask);
+            BambuMqttTask = NULL;
+        }
+        if (ScaleTask) {
+            Serial.println("Delete ScaleTask");
+            vTaskDelete(ScaleTask);
+            ScaleTask = NULL;
+        }
+        if (RfidReaderTask) {
+            Serial.println("Delete RfidReaderTask");
+            vTaskDelete(RfidReaderTask);
+            RfidReaderTask = NULL;
+        }
+
+        if (!index) {
+            updateTotalSize = request->contentLength();
+            updateWritten = 0;
+            isSpiffsUpdate = (filename.indexOf("website") > -1);
+            
+            if (isSpiffsUpdate) {
+                // Backup vor dem Update
+                sendUpdateProgress(0, "backup", "Backing up configurations...");
+                vTaskDelay(200 / portTICK_PERIOD_MS);
+                backupJsonConfigs();
+                vTaskDelay(200 / portTICK_PERIOD_MS);
+                
+                const esp_partition_t *partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_SPIFFS, NULL);
+                if (!partition || !Update.begin(partition->size, U_SPIFFS)) {
+                    request->send(400, "application/json", "{\"success\":false,\"message\":\"Update initialization failed\"}");
+                    return;
+                }
+                sendUpdateProgress(5, "starting", "Starting SPIFFS update...");
+                vTaskDelay(200 / portTICK_PERIOD_MS);
+            } else {
+                if (!Update.begin(updateTotalSize)) {
+                    request->send(400, "application/json", "{\"success\":false,\"message\":\"Update initialization failed\"}");
+                    return;
+                }
+                sendUpdateProgress(0, "starting", "Starting firmware update...");
+                vTaskDelay(200 / portTICK_PERIOD_MS);
+            }
+        }
+
+        if (len) {
+            if (Update.write(data, len) != len) {
+                request->send(400, "application/json", "{\"success\":false,\"message\":\"Write failed\"}");
+                return;
+            }
+            
+            updateWritten += len;
+            int currentProgress;
+            
+            // Berechne den Fortschritt basierend auf dem Update-Typ
+            if (isSpiffsUpdate) {
+                // SPIFFS: 5-75% für Upload
+                currentProgress = 6 + (updateWritten * 100) / updateTotalSize;
+            } else {
+                // Firmware: 0-100% für Upload
+                currentProgress = 1 + (updateWritten * 100) / updateTotalSize;
+            }
+            
+            static int lastProgress = -1;
+            if (currentProgress != lastProgress && (currentProgress % 10 == 0 || final)) {
+                sendUpdateProgress(currentProgress, "uploading");
+                oledShowProgressBar(currentProgress, 100, "Update", "Download");
+                vTaskDelay(50 / portTICK_PERIOD_MS);
+                lastProgress = currentProgress;
+            }
+        }
+
+        if (final) {
+            if (Update.end(true)) {
+                if (isSpiffsUpdate) {
+                    restoreJsonConfigs();
+                }
+            } else {
+                request->send(400, "application/json", "{\"success\":false,\"message\":\"Update finalization failed\"}");
+            }
+        }
+    });
+
+    updateHandler->onRequest([](AsyncWebServerRequest *request) {
+        if (Update.hasError()) {
+            request->send(400, "application/json", "{\"success\":false,\"message\":\"Update failed\"}");
+            return;
+        }
+
+        // Erste 100% Nachricht
+        ws.textAll("{\"type\":\"updateProgress\",\"progress\":100,\"status\":\"success\",\"message\":\"Update successful! Restarting device...\"}");
+        vTaskDelay(2000 / portTICK_PERIOD_MS);
+        
+        AsyncWebServerResponse *response = request->beginResponse(200, "application/json", 
+            "{\"success\":true,\"message\":\"Update successful! Restarting device...\"}");
+        response->addHeader("Connection", "close");
+        request->send(response);
+        
+        // Zweite 100% Nachricht zur Sicherheit
+        ws.textAll("{\"type\":\"updateProgress\",\"progress\":100,\"status\":\"success\",\"message\":\"Update successful! Restarting device...\"}");
+        
+        espRestart();
+    });
+
+    server.addHandler(updateHandler);
+}

src/ota.h

@@ -1,8 +1,9 @@
 #ifndef OTA_H
 #define OTA_H
 
+#include <ArduinoOTA.h>
 #include <ESPAsyncWebServer.h>
 
-void setupOTA(AsyncWebServer &server);
+void handleUpdate(AsyncWebServer &server);
 
 #endif

src/scale.cpp

@@ -3,9 +3,9 @@
 #include <ArduinoJson.h>
 #include "config.h"
 #include "HX711.h"
-#include <EEPROM.h>
 #include "display.h"
 #include "esp_task_wdt.h"
+#include <Preferences.h>
 
 HX711 scale;
 
@@ -15,9 +15,27 @@ int16_t weight = 0;
 
 uint8_t weigthCouterToApi = 0;
 uint8_t scale_tare_counter = 0;
+bool scaleTareRequest = false;
 uint8_t pauseMainTask = 0;
+bool scaleCalibrated;
+bool autoTare = true;
+bool scaleCalibrationActive = false;
 
 // ##### Funktionen für Waage #####
+uint8_t setAutoTare(bool autoTareValue) {
+  Serial.print("Set AutoTare to ");
+  Serial.println(autoTareValue);
+  autoTare = autoTareValue;
+
+  // Speichern mit NVS
+  Preferences preferences;
+  preferences.begin(NVS_NAMESPACE_SCALE, false); // false = readwrite
+  preferences.putBool(NVS_KEY_AUTOTARE, autoTare);
+  preferences.end();
+
+  return 1;
+}
+
 uint8_t tareScale() {
   Serial.println("Tare scale");
   scale.tare();
@@ -29,53 +47,84 @@ void scale_loop(void * parameter) {
   Serial.println("++++++++++++++++++++++++++++++");
   Serial.println("Scale Loop started");
   Serial.println("++++++++++++++++++++++++++++++");
+
   for(;;) {
     if (scale.is_ready()) 
     {
-      // Waage nochmal Taren, wenn zu lange Abweichung
-      if (scale_tare_counter >= 5) 
+      // Waage automatisch Taren, wenn zu lange Abweichung
+      if (autoTare && scale_tare_counter >= 5) 
       {
+        Serial.println("Auto Tare scale");
         scale.tare();
         scale_tare_counter = 0;
       }
 
-      weight = round(scale.get_units());
+      // Waage manuell Taren
+      if (scaleTareRequest == true) 
+      {
+        Serial.println("Re-Tare scale");
+        oledShowMessage("TARE Scale");
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        scale.tare();
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        oledShowWeight(0);
+        scaleTareRequest = false;
+      }
+
+      // Only update weight if median changed more than 1
+      int16_t newWeight = round(scale.get_units());
+      if(abs(weight-newWeight) > 1){
+        weight = newWeight;
+      }
     }
     
-    vTaskDelay(pdMS_TO_TICKS(100)); // Verzögerung, um die CPU nicht zu überlasten
+    vTaskDelay(pdMS_TO_TICKS(100));
   }
 }
 
-void start_scale() {
+void start_scale(bool touchSensorConnected) {
   Serial.println("Prüfe Calibration Value");
-  long calibrationValue; // calibration value (see example file "Calibration.ino")
-  //calibrationValue = 696.0; // uncomment this if you want to set the calibration value in the sketch
+  float calibrationValue;
 
-  EEPROM.begin(512);
-  EEPROM.get(calVal_eepromAdress, calibrationValue); // uncomment this if you want to fetch the calibration value from eeprom
+  // NVS lesen
+  Preferences preferences;
+  preferences.begin(NVS_NAMESPACE_SCALE, true); // true = readonly
+  if(preferences.isKey(NVS_KEY_CALIBRATION)){
+    calibrationValue = preferences.getFloat(NVS_KEY_CALIBRATION);
+    scaleCalibrated = true;
+  }else{
+    calibrationValue = SCALE_DEFAULT_CALIBRATION_VALUE;
+    scaleCalibrated = false;
+  }
+  
+  // auto Tare
+  // Wenn Touch Sensor verbunden, dann autoTare auf false setzen
+  // Danach prüfen was in NVS gespeichert ist
+  autoTare = (touchSensorConnected) ? false : true;
+  autoTare = preferences.getBool(NVS_KEY_AUTOTARE, autoTare);
 
-  //calibrationValue = EEPROM.read(calVal_eepromAdress);
+  preferences.end();
 
   Serial.print("Read Scale Calibration Value ");
   Serial.println(calibrationValue);
 
   scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
 
-  if (isnan(calibrationValue) || calibrationValue < 1) calibrationValue = defaultScaleCalibrationValue;
-
-  oledShowMessage("Scale Tare Please remove all");
-  for (uint16_t i = 0; i < 2000; i++) {
+  oledShowProgressBar(6, 7, DISPLAY_BOOT_TEXT, "Tare scale");
+  for (uint16_t i = 0; i < 3000; i++) {
     yield();
     vTaskDelay(pdMS_TO_TICKS(1));
     esp_task_wdt_reset();
   }
 
-  if (scale.wait_ready_timeout(1000))
-  {
-    scale.set_scale(calibrationValue); // this value is obtained by calibrating the scale with known weights; see the README for details
-    scale.tare();
+  while(!scale.is_ready()) {
+    vTaskDelay(pdMS_TO_TICKS(5000));
   }
 
+  scale.set_scale(calibrationValue);
+  //vTaskDelay(pdMS_TO_TICKS(5000));
+  //scale.tare();
+
   // Display Gewicht
   oledShowWeight(0);
 
@@ -83,7 +132,7 @@ void start_scale() {
   BaseType_t result = xTaskCreatePinnedToCore(
     scale_loop, /* Function to implement the task */
     "ScaleLoop", /* Name of the task */
-    10000,  /* Stack size in words */
+    2048,  /* Stack size in words */
     NULL,  /* Task input parameter */
     scaleTaskPrio,  /* Priority of the task */
     &ScaleTask,  /* Task handle. */
@@ -97,17 +146,22 @@ void start_scale() {
 }
 
 uint8_t calibrate_scale() {
-  long newCalibrationValue;
+  uint8_t returnState = 0;
+  float newCalibrationValue;
+
+  scaleCalibrationActive = true;
+
+  vTaskSuspend(RfidReaderTask);
+  vTaskSuspend(ScaleTask);
 
-  //vTaskSuspend(RfidReaderTask);
-  vTaskDelete(RfidReaderTask);
   pauseBambuMqttTask = true;
   pauseMainTask = 1;
-
+  
   if (scale.wait_ready_timeout(1000))
   {
+    
     scale.set_scale();
-    oledShowMessage("Step 1 empty Scale");
+    oledShowProgressBar(0, 3, "Scale Cal.", "Empty Scale");
 
     for (uint16_t i = 0; i < 5000; i++) {
       yield();
@@ -119,7 +173,7 @@ uint8_t calibrate_scale() {
     Serial.println("Tare done...");
     Serial.print("Place a known weight on the scale...");
 
-    oledShowMessage("Step 2 Place the weight");
+    oledShowProgressBar(1, 3, "Scale Cal.", "Place the weight");
 
     for (uint16_t i = 0; i < 5000; i++) {
       yield();
@@ -127,7 +181,7 @@ uint8_t calibrate_scale() {
       esp_task_wdt_reset();
     }
     
-    long newCalibrationValue = scale.get_units(10);
+    float newCalibrationValue = scale.get_units(10);
     Serial.print("Result: ");
     Serial.println(newCalibrationValue);
 
@@ -137,22 +191,35 @@ uint8_t calibrate_scale() {
     {
       Serial.print("New calibration value has been set to: ");
       Serial.println(newCalibrationValue);
-      Serial.print("Save this value to EEPROM adress ");
-      Serial.println(calVal_eepromAdress);
 
-      //EEPROM.put(calVal_eepromAdress, newCalibrationValue);
-      EEPROM.put(calVal_eepromAdress, newCalibrationValue);
-      EEPROM.commit();
+      // Speichern mit NVS
+      Preferences preferences;
+      preferences.begin(NVS_NAMESPACE_SCALE, false); // false = readwrite
+      preferences.putFloat(NVS_KEY_CALIBRATION, newCalibrationValue);
+      preferences.end();
 
-      EEPROM.get(calVal_eepromAdress, newCalibrationValue);
-      //newCalibrationValue = EEPROM.read(calVal_eepromAdress);
+      // Verifizieren
+      preferences.begin(NVS_NAMESPACE_SCALE, true);
+      float verifyValue = preferences.getFloat(NVS_KEY_CALIBRATION, 0);
+      preferences.end();
 
-      Serial.print("Read Value ");
-      Serial.println(newCalibrationValue);
+      Serial.print("Verified stored value: ");
+      Serial.println(verifyValue);
 
-      Serial.println("End calibration, revome weight");
+      oledShowProgressBar(2, 3, "Scale Cal.", "Remove weight");
 
-      oledShowMessage("Remove weight");
+      scale.set_scale(newCalibrationValue);
+      for (uint16_t i = 0; i < 2000; i++) {
+        yield();
+        vTaskDelay(pdMS_TO_TICKS(1));
+        esp_task_wdt_reset();
+      }
+      
+      oledShowProgressBar(3, 3, "Scale Cal.", "Completed");
+
+      // For some reason it is not possible to re-tare the scale here, it will result in a wdt timeout. Instead let the scale loop do the taring
+      //scale.tare();
+      scaleTareRequest = true;
 
       for (uint16_t i = 0; i < 2000; i++) {
         yield();
@@ -160,32 +227,23 @@ uint8_t calibrate_scale() {
         esp_task_wdt_reset();
       }
 
-      oledShowMessage("Calibration done");
-
-      for (uint16_t i = 0; i < 2000; i++) {
-        yield();
-        vTaskDelay(pdMS_TO_TICKS(1));
-        esp_task_wdt_reset();
-      }
-
-      //ESP.restart();
+      scaleCalibrated = true;
+      returnState = 1;
     }
     else
     {
-      {
-        Serial.println("Calibration value is invalid. Please recalibrate.");
+      Serial.println("Calibration value is invalid. Please recalibrate.");
 
-        oledShowMessage("Calibration ERROR Try again");
+      oledShowProgressBar(3, 3, "Failure", "Calibration error");
 
-        for (uint16_t i = 0; i < 50000; i++) {
-          yield();
-          vTaskDelay(pdMS_TO_TICKS(1));
-          esp_task_wdt_reset();
-        }
-        return 0;
+      for (uint16_t i = 0; i < 50000; i++) {
+        yield();
+        vTaskDelay(pdMS_TO_TICKS(1));
+        esp_task_wdt_reset();
       }
-    }
-  } 
+      returnState = 0;
+    } 
+  }
   else 
   {
     Serial.println("HX711 not found.");
@@ -197,17 +255,14 @@ uint8_t calibrate_scale() {
       vTaskDelay(pdMS_TO_TICKS(1));
       esp_task_wdt_reset();
     }
-    return 0;
+    returnState = 0;
   }
 
-  oledShowMessage("Scale Ready");
-
-  
-  Serial.println("starte Scale Task");
-  start_scale();
-
+  vTaskResume(RfidReaderTask);
+  vTaskResume(ScaleTask);
   pauseBambuMqttTask = false;
   pauseMainTask = 0;
+  scaleCalibrationActive = false;
 
-  return 1;
+  return returnState;
 }

src/scale.h

@@ -4,8 +4,8 @@
 #include <Arduino.h>
 #include "HX711.h"
 
-
-void start_scale();
+uint8_t setAutoTare(bool autoTareValue);
+uint8_t start_scale(bool touchSensorConnected);
 uint8_t calibrate_scale();
 uint8_t tareScale();
 
@@ -13,6 +13,12 @@ extern HX711 scale;
 extern int16_t weight;
 extern uint8_t weigthCouterToApi;
 extern uint8_t scale_tare_counter;
+extern uint8_t scaleTareRequest;
 extern uint8_t pauseMainTask;
+extern bool scaleCalibrated;
+extern bool autoTare;
+extern bool scaleCalibrationActive;
+
+extern TaskHandle_t ScaleTask;
 
 #endif

src/website.cpp

@@ -7,48 +7,74 @@
 #include "nfc.h"
 #include "scale.h"
 #include "esp_task_wdt.h"
+#include <Update.h>
+#include "display.h"
 #include "ota.h"
+#include "config.h"
+#include "debug.h"
+
+
+#ifndef VERSION
+  #define VERSION "1.1.0"
+#endif
 
 // Cache-Control Header definieren
-#define CACHE_CONTROL "max-age=31536000" // Cache für 1 Jahr
+#define CACHE_CONTROL "max-age=604800" // Cache für 1 Woche
 
 AsyncWebServer server(webserverPort);
 AsyncWebSocket ws("/ws");
 
 uint8_t lastSuccess = 0;
-uint8_t lastHasReadRfidTag = 0;
+nfcReaderStateType lastnfcReaderState = NFC_IDLE;
+
 
 void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
+    HEAP_DEBUG_MESSAGE("onWsEvent begin");
     if (type == WS_EVT_CONNECT) {
         Serial.println("Neuer Client verbunden!");
         // Sende die AMS-Daten an den neuen Client
-        sendAmsData(client);
-        sendNfcData(client);
+        if (!bambuDisabled) sendAmsData(client);
+        sendNfcData();
         foundNfcTag(client, 0);
         sendWriteResult(client, 3);
+
+        // Clean up dead connections
+        (*server).cleanupClients();
+        Serial.println("Currently connected number of clients: " + String((*server).getClients().size()));
     } else if (type == WS_EVT_DISCONNECT) {
         Serial.println("Client getrennt.");
+    } else if (type == WS_EVT_ERROR) {
+        Serial.printf("WebSocket Client #%u error(%u): %s\n", client->id(), *((uint16_t*)arg), (char*)data);
+    } else if (type == WS_EVT_PONG) {
+        Serial.printf("WebSocket Client #%u pong\n", client->id());
     } else if (type == WS_EVT_DATA) {
-        String message = String((char*)data);
         JsonDocument doc;
-        deserializeJson(doc, message);
-        
+        DeserializationError error = deserializeJson(doc, (char*)data, len);
+        //String message = String((char*)data);
+        //deserializeJson(doc, message);
+
+        if (error) {
+            Serial.println("JSON deserialization failed: " + String(error.c_str()));
+            return;
+        }
+
         if (doc["type"] == "heartbeat") {
             // Sende Heartbeat-Antwort
             ws.text(client->id(), "{"
                 "\"type\":\"heartbeat\","
                 "\"freeHeap\":" + String(ESP.getFreeHeap()/1024) + ","
                 "\"bambu_connected\":" + String(bambu_connected) + ","
-                "\"spoolman_connected\":" + String(spoolman_connected) + ""
+                "\"spoolman_connected\":" + String(spoolmanConnected) + ""
                 "}");
         }
 
         else if (doc["type"] == "writeNfcTag") {
-            if (doc.containsKey("payload")) {
+            if (doc["payload"].is<JsonObject>()) {
                 // Versuche NFC-Daten zu schreiben
                 String payloadString;
                 serializeJson(doc["payload"], payloadString);
-                startWriteJsonToTag(payloadString.c_str());
+
+                startWriteJsonToTag((doc["tagType"] == "spool") ? true : false, payloadString.c_str());
             }
         }
 
@@ -62,6 +88,10 @@ void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventTyp
                 success = calibrate_scale();
             }
 
+            if (doc["payload"] == "setAutoTare") {
+                success = setAutoTare(doc["enabled"].as<bool>());
+            }
+
             if (success) {
                 ws.textAll("{\"type\":\"scale\",\"payload\":\"success\"}");
             } else {
@@ -84,21 +114,32 @@ void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventTyp
             setBambuSpool(doc["payload"]);
         }
 
+        else if (doc["type"] == "setSpoolmanSettings") {
+            Serial.println(doc["payload"].as<String>());
+            if (updateSpoolBambuData(doc["payload"].as<String>())) {
+                ws.textAll("{\"type\":\"setSpoolmanSettings\",\"payload\":\"success\"}");
+            } else {
+                ws.textAll("{\"type\":\"setSpoolmanSettings\",\"payload\":\"error\"}");
+            }
+        }
+
         else {
             Serial.println("Unbekannter WebSocket-Typ: " + doc["type"].as<String>());
         }
+        doc.clear();
     }
+    HEAP_DEBUG_MESSAGE("onWsEvent end");
 }
 
 // Funktion zum Laden und Ersetzen des Headers in einer HTML-Datei
 String loadHtmlWithHeader(const char* filename) {
     Serial.println("Lade HTML-Datei: " + String(filename));
-    if (!SPIFFS.exists(filename)) {
+    if (!LittleFS.exists(filename)) {
         Serial.println("Fehler: Datei nicht gefunden!");
         return "Fehler: Datei nicht gefunden!";
     }
 
-    File file = SPIFFS.open(filename, "r");
+    File file = LittleFS.open(filename, "r");
     String html = file.readString();
     file.close();
 
@@ -114,59 +155,69 @@ void sendWriteResult(AsyncWebSocketClient *client, uint8_t success) {
 void foundNfcTag(AsyncWebSocketClient *client, uint8_t success) {
     if (success == lastSuccess) return;
     ws.textAll("{\"type\":\"nfcTag\", \"payload\":{\"found\": " + String(success) + "}}");
-    sendNfcData(nullptr);
+    sendNfcData();
     lastSuccess = success;
 }
 
-void sendNfcData(AsyncWebSocketClient *client) {
-    if (lastHasReadRfidTag == hasReadRfidTag) return;
-    if (hasReadRfidTag == 0) {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":{}}");
+void sendNfcData() {
+    if (lastnfcReaderState == nfcReaderState) return;
+    // TBD: Why is there no status for reading the tag?
+    switch(nfcReaderState){
+        case NFC_IDLE:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":{}}");
+            break;
+        case NFC_READ_SUCCESS:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":" + nfcJsonData + "}");
+            break;
+        case NFC_READ_ERROR:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"error\":\"Empty Tag or Data not readable\"}}");
+            break;
+        case NFC_WRITING:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"info\":\"Schreibe Tag...\"}}");
+            break;
+        case NFC_WRITE_SUCCESS:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"info\":\"Tag erfolgreich geschrieben\"}}");
+            break;
+        case NFC_WRITE_ERROR:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"error\":\"Error writing to Tag\"}}");
+            break;
+        case DEFAULT:
+            ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"error\":\"Something went wrong\"}}");
     }
-    else if (hasReadRfidTag == 1) {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":" + nfcJsonData + "}");
-    }
-    else if (hasReadRfidTag == 2)
-    {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"error\":\"Empty Tag or Data not readable\"}}");
-    }
-    else if (hasReadRfidTag == 3)
-    {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"info\":\"Schreibe Tag...\"}}");
-    }
-    else if (hasReadRfidTag == 4)
-    {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"error\":\"Error writing to Tag\"}}");
-    }
-    else if (hasReadRfidTag == 5)
-    {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"info\":\"Tag erfolgreich geschrieben\"}}");
-    }
-    else 
-    {
-        ws.textAll("{\"type\":\"nfcData\", \"payload\":{\"error\":\"Something went wrong\"}}");
-    }
-    lastHasReadRfidTag = hasReadRfidTag;
+    lastnfcReaderState = nfcReaderState;
 }
 
 void sendAmsData(AsyncWebSocketClient *client) {
     if (ams_count > 0) {
-        ws.textAll("{\"type\":\"amsData\", \"payload\":" + amsJsonData + "}");
+        ws.textAll("{\"type\":\"amsData\",\"payload\":" + amsJsonData + "}");
     }
 }
 
 void setupWebserver(AsyncWebServer &server) {
+    oledShowProgressBar(2, 7, DISPLAY_BOOT_TEXT, "Webserver init");
+    // Deaktiviere alle Debug-Ausgaben
+    Serial.setDebugOutput(false);
+    
+    // WebSocket-Optimierungen
+    ws.onEvent(onWsEvent);
+    ws.enable(true);
+
+    // Konfiguriere Server für große Uploads
+    server.onRequestBody([](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total){});
+    server.onFileUpload([](AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final){});
+
     // Lade die Spoolman-URL beim Booten
     spoolmanUrl = loadSpoolmanUrl();
     Serial.print("Geladene Spoolman-URL: ");
     Serial.println(spoolmanUrl);
 
-    setupOTA(server);
+    // Load Bamb credentials:
+    loadBambuCredentials();
 
     // Route für about
     server.on("/about", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /about erhalten");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/about.html.gz", "text/html");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/index.html.gz", "text/html");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
@@ -175,33 +226,29 @@ void setupWebserver(AsyncWebServer &server) {
     // Route für Waage
     server.on("/waage", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /waage erhalten");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/waage.html.gz", "text/html");
-        response->addHeader("Content-Encoding", "gzip");
-        response->addHeader("Cache-Control", CACHE_CONTROL);
-        request->send(response);
+        //AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/waage.html.gz", "text/html");
+        //response->addHeader("Content-Encoding", "gzip");
+        //response->addHeader("Cache-Control", CACHE_CONTROL);
+
+        String html = loadHtmlWithHeader("/waage.html");
+        html.replace("{{autoTare}}", (autoTare) ? "checked" : "");
+
+        request->send(200, "text/html", html);
     });
 
     // Route für RFID
     server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /rfid erhalten");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/rfid.html.gz", "text/html");
+        
+        String page = (bambuDisabled) ? "/rfid.html.gz" : "/rfid_bambu.html.gz";
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, page, "text/html");
+        
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
         Serial.println("RFID-Seite gesendet");
     });
 
-    /*
-    // Neue API-Route für das Abrufen der Spool-Daten
-    server.on("/api/spools", HTTP_GET, [](AsyncWebServerRequest *request){
-        Serial.println("API-Aufruf: /api/spools");
-        JsonDocument spoolsData = fetchSpoolsForWebsite();
-        String response;
-        serializeJson(spoolsData, response);
-        request->send(200, "application/json", response);
-    });
-    */
-
     server.on("/api/url", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("API-Aufruf: /api/url");
         String jsonResponse = "{\"spoolman_url\": \"" + String(spoolmanUrl) + "\"}";
@@ -211,7 +258,7 @@ void setupWebserver(AsyncWebServer &server) {
     // Route für WiFi
     server.on("/wifi", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /wifi erhalten");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/wifi.html.gz", "text/html");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/wifi.html.gz", "text/html");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
@@ -221,21 +268,16 @@ void setupWebserver(AsyncWebServer &server) {
     server.on("/spoolman", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /spoolman erhalten");
         String html = loadHtmlWithHeader("/spoolman.html");
-        html.replace("{{spoolmanUrl}}", spoolmanUrl);
+        html.replace("{{spoolmanUrl}}", (spoolmanUrl != "") ? spoolmanUrl : "");
+        html.replace("{{spoolmanOctoEnabled}}", octoEnabled ? "checked" : "");
+        html.replace("{{spoolmanOctoUrl}}", (octoUrl != "") ? octoUrl : "");
+        html.replace("{{spoolmanOctoToken}}", (octoToken != "") ? octoToken : "");
 
-        JsonDocument doc;
-        if (loadJsonValue("/bambu_credentials.json", doc) && doc.containsKey("bambu_ip")) {
-            String bambuIp = doc["bambu_ip"].as<String>();
-            String bambuSerial = doc["bambu_serialnr"].as<String>();
-            String bambuCode = doc["bambu_accesscode"].as<String>();
-            bambuIp.trim();
-            bambuSerial.trim();
-            bambuCode.trim();
-
-            html.replace("{{bambuIp}}", bambuIp ? bambuIp : "");            
-            html.replace("{{bambuSerial}}", bambuSerial ? bambuSerial : "");
-            html.replace("{{bambuCode}}", bambuCode ? bambuCode : "");
-        }   
+        html.replace("{{bambuIp}}", bambuCredentials.ip);            
+        html.replace("{{bambuSerial}}", bambuCredentials.serial);
+        html.replace("{{bambuCode}}", bambuCredentials.accesscode ? bambuCredentials.accesscode : "");
+        html.replace("{{autoSendToBambu}}", bambuCredentials.autosend_enable ? "checked" : "");
+        html.replace("{{autoSendTime}}", (bambuCredentials.autosend_time != 0) ? String(bambuCredentials.autosend_time) : String(BAMBU_DEFAULT_AUTOSEND_TIME));
 
         request->send(200, "text/html", html);
     });
@@ -247,17 +289,45 @@ void setupWebserver(AsyncWebServer &server) {
             return;
         }
 
+        if (request->getParam("octoEnabled")->value() == "true" && (!request->hasParam("octoUrl") || !request->hasParam("octoToken"))) {
+            request->send(400, "application/json", "{\"success\": false, \"error\": \"Missing OctoPrint URL or Token parameter\"}");
+            return;
+        }
+
         String url = request->getParam("url")->value();
-        url.trim();
+        if (url.indexOf("http://") == -1 && url.indexOf("https://") == -1) {
+            url = "http://" + url;
+        }
+        // Remove trailing slash if exists
+        if (url.length() > 0 && url.charAt(url.length()-1) == '/') {
+            url = url.substring(0, url.length()-1);
+        }
         
-        bool healthy = saveSpoolmanUrl(url);
+        bool octoEnabled = (request->getParam("octoEnabled")->value() == "true") ? true : false;
+        String octoUrl = request->getParam("octoUrl")->value();
+        String octoToken = (request->getParam("octoToken")->value() != "") ? request->getParam("octoToken")->value() : "";
+
+        url.trim();
+        octoUrl.trim();
+        octoToken.trim();
+        
+        bool healthy = saveSpoolmanUrl(url, octoEnabled, octoUrl, octoToken);
         String jsonResponse = "{\"healthy\": " + String(healthy ? "true" : "false") + "}";
 
         request->send(200, "application/json", jsonResponse);
     });
 
-    // Route für das Überprüfen der Spoolman-Instanz
+    // Route für das Überprüfen der Bambu-Instanz
     server.on("/api/bambu", HTTP_GET, [](AsyncWebServerRequest *request){
+        if (request->hasParam("remove")) {
+            if (removeBambuCredentials()) {
+                request->send(200, "application/json", "{\"success\": true}");
+            } else {
+                request->send(500, "application/json", "{\"success\": false, \"error\": \"Fehler beim Löschen der Bambu-Credentials\"}");
+            }
+            return;
+        }
+
         if (!request->hasParam("bambu_ip") || !request->hasParam("bambu_serialnr") || !request->hasParam("bambu_accesscode")) {
             request->send(400, "application/json", "{\"success\": false, \"error\": \"Missing parameter\"}");
             return;
@@ -266,16 +336,20 @@ void setupWebserver(AsyncWebServer &server) {
         String bambu_ip = request->getParam("bambu_ip")->value();
         String bambu_serialnr = request->getParam("bambu_serialnr")->value();
         String bambu_accesscode = request->getParam("bambu_accesscode")->value();
+        bool autoSend = (request->getParam("autoSend")->value() == "true") ? true : false;
+        String autoSendTime = request->getParam("autoSendTime")->value();
+        
         bambu_ip.trim();
         bambu_serialnr.trim();
         bambu_accesscode.trim();
+        autoSendTime.trim();
 
         if (bambu_ip.length() == 0 || bambu_serialnr.length() == 0 || bambu_accesscode.length() == 0) {
             request->send(400, "application/json", "{\"success\": false, \"error\": \"Empty parameter\"}");
             return;
         }
 
-        bool success = saveBambuCredentials(bambu_ip, bambu_serialnr, bambu_accesscode);
+        bool success = saveBambuCredentials(bambu_ip, bambu_serialnr, bambu_accesscode, autoSend, autoSendTime);
 
         request->send(200, "application/json", "{\"healthy\": " + String(success ? "true" : "false") + "}");
     });
@@ -288,7 +362,7 @@ void setupWebserver(AsyncWebServer &server) {
     // Route für das Laden der CSS-Datei
     server.on("/style.css", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Lade style.css");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/style.css.gz", "text/css");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/style.css.gz", "text/css");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
@@ -297,7 +371,7 @@ void setupWebserver(AsyncWebServer &server) {
 
     // Route für das Logo
     server.on("/logo.png", HTTP_GET, [](AsyncWebServerRequest *request){
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/logo.png.gz", "image/png");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/logo.png.gz", "image/png");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
@@ -306,7 +380,7 @@ void setupWebserver(AsyncWebServer &server) {
 
     // Route für Favicon
     server.on("/favicon.ico", HTTP_GET, [](AsyncWebServerRequest *request){
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/favicon.ico", "image/x-icon");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/favicon.ico", "image/x-icon");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
         Serial.println("favicon.ico gesendet");
@@ -314,17 +388,26 @@ void setupWebserver(AsyncWebServer &server) {
 
     // Route für spool_in.png
     server.on("/spool_in.png", HTTP_GET, [](AsyncWebServerRequest *request){
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/spool_in.png.gz", "image/png");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/spool_in.png.gz", "image/png");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
         Serial.println("spool_in.png gesendet");
     });
 
+    // Route für set_spoolman.png
+    server.on("/set_spoolman.png", HTTP_GET, [](AsyncWebServerRequest *request){
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/set_spoolman.png.gz", "image/png");
+        response->addHeader("Content-Encoding", "gzip");
+        response->addHeader("Cache-Control", CACHE_CONTROL);
+        request->send(response);
+        Serial.println("set_spoolman.png gesendet");
+    });
+
     // Route für JavaScript Dateien
     server.on("/spoolman.js", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /spoolman.js erhalten");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS, "/spoolman.js.gz", "text/javascript");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/spoolman.js.gz", "text/javascript");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
@@ -333,13 +416,30 @@ void setupWebserver(AsyncWebServer &server) {
 
     server.on("/rfid.js", HTTP_GET, [](AsyncWebServerRequest *request){
         Serial.println("Anfrage für /rfid.js erhalten");
-        AsyncWebServerResponse *response = request->beginResponse(SPIFFS,"/rfid.js.gz", "text/javascript");
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS,"/rfid.js.gz", "text/javascript");
         response->addHeader("Content-Encoding", "gzip");
         response->addHeader("Cache-Control", CACHE_CONTROL);
         request->send(response);
         Serial.println("RFID.js gesendet");
     });
-    
+
+    // Vereinfachter Update-Handler
+    server.on("/upgrade", HTTP_GET, [](AsyncWebServerRequest *request) {
+        AsyncWebServerResponse *response = request->beginResponse(LittleFS, "/upgrade.html.gz", "text/html");
+        response->addHeader("Content-Encoding", "gzip");
+        response->addHeader("Cache-Control", "no-store");
+        request->send(response);
+    });
+
+    // Update-Handler registrieren
+    handleUpdate(server);
+
+    server.on("/api/version", HTTP_GET, [](AsyncWebServerRequest *request){
+        String fm_version = VERSION;
+        String jsonResponse = "{\"version\": \""+ fm_version +"\"}";
+        request->send(200, "application/json", jsonResponse);
+    });
+
     // Fehlerbehandlung für nicht gefundene Seiten
     server.onNotFound([](AsyncWebServerRequest *request){
         Serial.print("404 - Nicht gefunden: ");

src/website.h

@@ -6,8 +6,8 @@
 #include "commonFS.h"
 #include "api.h"
 #include <ArduinoJson.h>
-#include <ESPAsyncWebServer.h>
-#include <AsyncWebSocket.h>
+#include <Update.h>
+#include <AsyncTCP.h>
 #include "bambu.h"
 #include "nfc.h"
 #include "scale.h"
@@ -17,9 +17,14 @@ extern String spoolmanUrl;
 extern AsyncWebServer server;
 extern AsyncWebSocket ws;
 
+// Server-Initialisierung und Handler
+void initWebServer();
+void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total);
 void setupWebserver(AsyncWebServer &server);
+
+// WebSocket-Funktionen
 void sendAmsData(AsyncWebSocketClient *client);
-void sendNfcData(AsyncWebSocketClient *client);
+void sendNfcData();
 void foundNfcTag(AsyncWebSocketClient *client, uint8_t success);
 void sendWriteResult(AsyncWebSocketClient *client, uint8_t success);
 

src/wlan.cpp

@@ -3,43 +3,123 @@
 #include <WiFi.h>
 #include <esp_wifi.h>
 #include <WiFiManager.h>
+#include <DNSServer.h>
+#include <ESPmDNS.h>
 #include "display.h"
 #include "config.h"
 
 WiFiManager wm;
 bool wm_nonblocking = false;
+uint8_t wifiErrorCounter = 0;
+
+void wifiSettings() {
+    // Optimierte WiFi-Einstellungen
+    WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
+    WiFi.setSleep(false); // disable sleep mode
+    WiFi.setHostname("FilaMan");
+    esp_wifi_set_ps(WIFI_PS_NONE);
+    
+    // Maximale Sendeleistung
+    WiFi.setTxPower(WIFI_POWER_19_5dBm); // Set maximum transmit power
+  
+    // Optimiere TCP/IP Stack
+    esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N);
+    
+    // Aktiviere WiFi-Roaming für bessere Stabilität
+    esp_wifi_set_rssi_threshold(-80);
+}
+
+void startMDNS() {
+  if (!MDNS.begin("filaman")) {
+    Serial.println("Error setting up MDNS responder!");
+    while(1) {
+      vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+  }
+  Serial.println("mDNS responder started");
+}
+
+void configModeCallback (WiFiManager *myWiFiManager) {
+  Serial.println("Entered config mode");
+  oledShowTopRow();
+  oledShowMessage("WiFi Config Mode");
+}
 
 void initWiFi() {
-    WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
-  
-    esp_wifi_set_max_tx_power(72); // Setze maximale Sendeleistung auf 20dBm
-  
-    if(wm_nonblocking) wm.setConfigPortalBlocking(false);
-    wm.setConfigPortalTimeout(320); // Portal nach 5min schließen
+  // load Wifi settings
+  wifiSettings();
+
+  wm.setAPCallback(configModeCallback);
+
+  wm.setSaveConfigCallback([]() {
+    Serial.println("Configurations updated");
+    ESP.restart();
+  });
+
+  if(wm_nonblocking) wm.setConfigPortalBlocking(false);
+  //wm.setConfigPortalTimeout(320); // Portal nach 5min schließen
+  wm.setWiFiAutoReconnect(true);
+  wm.setConnectTimeout(10);
+
+  oledShowProgressBar(1, 7, DISPLAY_BOOT_TEXT, "WiFi init");
   
+  //bool res = wm.autoConnect("FilaMan"); // anonymous ap
+  if(!wm.autoConnect("FilaMan")) {
+    Serial.println("Failed to connect or hit timeout");
+    // ESP.restart();
     oledShowTopRow();
-    oledShowMessage("WiFi Setup");
-    
-    bool res;
-    // res = wm.autoConnect(); // auto generated AP name from chipid
-    res = wm.autoConnect("FilaMan"); // anonymous ap
-    // res = wm.autoConnect("spoolman","password"); // password protected ap
-  
-    if(!res) {
-      Serial.println("Failed to connect or hit timeout");
-      // ESP.restart();
-      oledShowTopRow();
-      oledShowMessage("WiFi not connected Check Portal");
+    oledShowMessage("WiFi not connected Check Portal");
+  } 
+  else {
+    wifiOn = true;
+
+    //if you get here you have connected to the WiFi    
+    Serial.println("connected...yeey :)");
+    Serial.print("IP address: ");
+    Serial.println(WiFi.localIP());
+
+    oledShowTopRow();
+
+    // mDNS
+    startMDNS();
+  }
+}
+
+void checkWiFiConnection() {
+  if (WiFi.status() != WL_CONNECTED) 
+  {
+    Serial.println("WiFi connection lost. Reconnecting...");
+    wifiOn = false;
+    oledShowTopRow();
+    oledShowMessage("WiFi reconnecting");
+    WiFi.reconnect(); // Versuche, die Verbindung wiederherzustellen
+    vTaskDelay(5000 / portTICK_PERIOD_MS); // Warte 5 Sekunden, bevor erneut geprüft wird
+    if (WiFi.status() != WL_CONNECTED) 
+    {
+      Serial.println("Failed to reconnect. Restarting WiFi...");
+      WiFi.disconnect();
+      Serial.println("WiFi disconnected.");
+      vTaskDelay(1000 / portTICK_PERIOD_MS);
+      wifiErrorCounter++;
+
+      //wifiSettings();
+      WiFi.reconnect();
+      Serial.println("WiFi reconnecting...");
+      WiFi.waitForConnectResult();
     } 
-    else {
+    else 
+    {
+      Serial.println("WiFi reconnected.");
+      wifiErrorCounter = 0;
       wifiOn = true;
-  
-      //if you get here you have connected to the WiFi    
-      Serial.println("connected...yeey :)");
-      Serial.print("IP address: ");
-      Serial.println(WiFi.localIP());
-  
       oledShowTopRow();
-      display.display();
+      startMDNS();
     }
-  }
+  }
+
+  if (wifiErrorCounter >= 5) 
+  {
+    Serial.println("Too many WiFi errors. Restarting...");
+    ESP.restart();
+  }
+}

src/wlan.h

@@ -4,5 +4,6 @@
 #include <Arduino.h>
 
 void initWiFi();
+void checkWiFiConnection();
 
 #endif

usermod/spitzbirne32/Images/README.md

@@ -0,0 +1,12 @@
+## **Heat insert location**
+
+Housing: 
+- every hole is made to fit a heat insert
+![](./Housing_Heatinsert_Location_usermod_spitzbirne32_.png)
+
+---
+Scale top: 
+- two heat inserts for the NFC Reader
+![](./ScaleTop_Heatinsert_Location_usermod_spitzbirne32_.png)
+  
+

usermod/spitzbirne32/README.md

@@ -0,0 +1,69 @@
+## Modifications
+
+To reduce costs, components were sourced from AliExpress instead of Amazon. However, differences in dimensions and mounting hole spacing necessitated adjustments to the 3D-printed parts. Additionally M3 heat inserts were used to limit M4 screws to a minimum.
+![](./Images/Showcase_usermod_spitzbirne32.gif)
+---
+
+List of parts that were used:
+- Display: https://aliexpress.com/item/1005007389730469.html
+- Scale(5KG with HX711): https://aliexpress.com/item/1005006827930173.html
+- NFC Reader: https://aliexpress.com/item/1005005973913526.html
+- NFC Chips: https://aliexpress.com/item/1005006332360160.html
+- [VORON](https://vorondesign.com/) Heat Inserts M3 OD5mm L4mm: https://aliexpress.com/item/1005003582355741.html  - make sure to select the correct size
+
+---
+
+- **Parts are designed to be printed in ABS/ASA.** Shrinking compensation not needed.
+
+- **Display and Scale Adjustments:** The AliExpress-sourced display and scale had different dimensions and hole spacings compared to the Amazon versions. The 3D models were modified to accommodate these differences, ensuring proper fit and functionality.
+   -  measurement of my Display & Scale to check if your parts will fit can be found in the images folder
+
+- **Screw Size and Heat Inserts:** All holes originally designed for M4 screws were resized to fit M3 screws. Standard VORON heat inserts were incorporated to provide durable threading. This change standardizes the hardware and simplifies assembly.
+
+- **Display Mounting:** The display is now mounted using M3 screws with VORON heat inserts. The display's mounting holes need to be drilled to 3mm to accommodate the M3 screws.
+
+- **Scale Top Surface:** The top surface of the scale was modified to allow M3 socket head cap screws to sit flush with the 3D-printed part. This design ensures that the filament spool rests flat without interference.
+
+- **NFC Reader Mounting:** The NFC reader is also secured using M3 screws and VORON heat inserts, maintaining consistency across all components.
+
+- **Scale Base Mounting:** The only M4 screws required are for attaching the metal part of the scale to its base.
+
+## Benefits of Modifications
+
+- **Cost Reduction:** Sourcing components from AliExpress offers a more affordable alternative to Amazon, making the project more accessible.
+
+- **Standardized Hardware:** Using M3 screws and [VORON](https://vorondesign.com/) heat inserts throughout the assembly simplifies the build process and reduces the variety of required hardware.
+
+- **Enhanced Compatibility:** Adjustments to the 3D models ensure compatibility with readily available components, accommodating variations in part dimensions.
+
+## Assembly Instructions
+
+1. **Component Preparation:**
+   - Carefully drill the display's mounting holes to 3mm to fit M3 screws.
+
+2. **Heat Insert Installation:**
+   - install VORON M3 heat inserts into the designated holes in the 3D-printed housing/case for the ESP32 and Scale top → [heat insert location pictures](./Images/README.md)
+
+3. **Component Mounting:**
+   - Attach the display, scale, and NFC reader to their respective mounts using M3 screws.
+   - Secure the metal part of the scale to its base using M4 screws.
+
+4. **Final Assembly:**
+   - Assemble all components according to the original FilaMan instructions, ensuring that all modified parts fit correctly and function as intended.
+
+For detailed assembly guides and additional resources, refer to the [original FilaMan documentation](https://github.com/ManuelW77/Filaman).
+
+## Conclusion
+
+These modifications to the FilaMan project provide a cost-effective and standardized approach to building a filament management system. By sourcing components from AliExpress and adjusting the 3D models accordingly, users can achieve the same functionality at a reduced cost, with the added benefit of using uniform hardware throughout the assembly.
+
+## Changelog
+
+### Version 1.0 - 2025-03-04
+- Initial release of modifications for AliExpress-sourced components.
+- Adjusted 3D models to fit different display and scale dimensions.
+- Replaced M4 screws with M3 screws and integrated VORON heat inserts.
+- Modified display mounting, requiring drilling to 3mm for M3 screws.
+- Adjusted scale top surface for flush screw placement.
+- Standardized NFC reader mounting with M3 screws and VORON heat inserts.
+- Retained M4 screws only for metal scale attachment.