docs: add German and English wiki documentation

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

.gitignore

@@ -39,4 +39,5 @@ _local/*
 website/*
 release.sh
 .github/copilot-instructions.md
-data
+data
+wiki

README.de.md

@@ -27,6 +27,7 @@ Discord Server: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
     - 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.
@@ -39,8 +40,35 @@ Discord Server: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
   - 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

README.md

@@ -31,6 +31,7 @@ Discord Server: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
 	- 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.
@@ -43,8 +44,35 @@ Discord Server: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
   - 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

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.

WIKI_DE.md

@@ -0,0 +1,468 @@
+# FilaMan Wiki - Deutsch
+
+## Inhaltsverzeichnis
+
+1. [Überblick](#überblick)
+2. [Installation](#installation)
+3. [Hardware-Anforderungen](#hardware-anforderungen)
+4. [Ersteinrichtung](#ersteinrichtung)
+5. [Konfiguration](#konfiguration)
+6. [Benutzung](#benutzung)
+7. [NFC-Tags](#nfc-tags)
+8. [Bambu Lab Integration](#bambu-lab-integration)
+9. [Spoolman Integration](#spoolman-integration)
+10. [Octoprint Integration](#octoprint-integration)
+11. [Hersteller Tags](#hersteller-tags)
+12. [Fehlerbehebung](#fehlerbehebung)
+13. [Support](#support)
+
+---
+
+## Überblick
+
+FilaMan ist ein umfassendes Filament-Managementsystem für 3D-Drucker, das auf ESP32-Hardware basiert. Es bietet Gewichtsmessung, NFC-Tag-Management und nahtlose Integration mit Spoolman und Bambu Lab 3D-Druckern.
+
+### Hauptfunktionen
+
+- **Präzise Gewichtsmessung** mit HX711 Wägezellen-Verstärker
+- **NFC-Tag Lesen und Schreiben** für Filament-Identifikation
+- **OLED-Display** für Status-Anzeigen
+- **WiFi-Konnektivität** mit einfacher Konfiguration
+- **Webbasierte Benutzeroberfläche** mit Echtzeit-Updates
+- **Spoolman-Integration** für Lagerverwaltung
+- **Bambu Lab AMS-Steuerung** via MQTT
+- **Openspool NFC-Format** Kompatibilität
+- **Hersteller Tag Unterstützung** für automatische Einrichtung
+
+### Systemvoraussetzungen
+
+- **ESP32 Development Board**
+- **Spoolman Instanz** (erforderlich für volle Funktionalität)
+- **WiFi-Netzwerk**
+- **Webbrowser** (Chrome/Firefox/Safari)
+
+---
+
+## Installation
+
+### Einfache Installation (Empfohlen)
+
+1. **Öffnen Sie den [FilaMan Web-Installer](https://www.filaman.app/installer.html)**
+   - Verwenden Sie einen Chrome-basierten Browser
+
+2. **ESP32 vorbereiten**
+   - Verbinden Sie den ESP32 über USB mit Ihrem Computer
+   - Klicken Sie auf "Connect"
+
+3. **Port auswählen**
+   - Wählen Sie den entsprechenden USB-Port aus
+   - Bestätigen Sie die Auswahl
+
+4. **Installation starten**
+   - Klicken Sie auf "FilaMan installieren"
+   - Warten Sie, bis der Installationsvorgang abgeschlossen ist
+
+### Manuelle Kompilierung
+
+Für erfahrene Benutzer mit PlatformIO:
+
+```bash
+git clone https://github.com/ManuelW77/Filaman.git
+cd FilaMan/esp32
+pio lib install
+pio run --target upload
+```
+
+---
+
+## Hardware-Anforderungen
+
+### Erforderliche Komponenten
+
+| Komponente | Beschreibung | Amazon Link (Affiliate) |
+|------------|--------------|-------------------------|
+| ESP32 Development Board | Jede ESP32-Variante | [Amazon](https://amzn.to/3FHea6D) |
+| HX711 + Wägezelle | 5kg Load Cell Amplifier | [Amazon](https://amzn.to/4ja1KTe) |
+| OLED Display | 0.96" I2C 128x64 SSD1306 | [Amazon](https://amzn.to/445aaa9) |
+| PN532 NFC Modul | V3 RFID-Modul | [Amazon](https://amzn.eu/d/gy9vaBX) |
+| NFC Tags | NTAG213/NTAG215 | [Amazon](https://amzn.to/3E071xO) |
+| TTP223 Touch Sensor | Optional für Tara-Funktion | [Amazon](https://amzn.to/4hTChMK) |
+
+### Pin-Konfiguration
+
+| Komponente | ESP32 Pin | Funktion |
+|------------|-----------|----------|
+| HX711 DOUT | 16 | Datenausgang Wägezelle |
+| HX711 SCK | 17 | Takt Wägezelle |
+| OLED SDA | 21 | I2C Daten |
+| OLED SCL | 22 | I2C Takt |
+| PN532 IRQ | 32 | Interrupt |
+| PN532 RESET | 33 | Reset |
+| PN532 SDA | 21 | I2C Daten (geteilt) |
+| PN532 SCL | 22 | I2C Takt (geteilt) |
+| TTP223 I/O | 25 | Touch-Sensor (optional) |
+
+### Wichtige Hinweise
+
+- **PN532 DIP-Schalter** müssen auf I2C-Modus eingestellt sein
+- **3V Pin** vom ESP32 für Touch-Sensor verwenden
+- **Wägezellen-Verkabelung**: E+ (rot), E- (schwarz), A- (weiß), A+ (grün)
+
+![Schaltplan](./img/Schaltplan.png)
+
+---
+
+## Ersteinrichtung
+
+### Nach der Installation
+
+1. **ESP32 Neustart**
+   - Das System erstellt automatisch einen WiFi-Hotspot "FilaMan"
+
+2. **WiFi-Konfiguration**
+   - Verbinden Sie sich mit dem "FilaMan" Netzwerk
+   - Öffnen Sie einen Browser (automatisches Portal oder http://192.168.4.1)
+   - Konfigurieren Sie Ihre WiFi-Zugangsdaten
+
+3. **Erster Zugriff**
+   - Nach erfolgreicher WiFi-Verbindung ist das System unter http://filaman.local erreichbar
+   - Alternativ über die vom Router zugewiesene IP-Adresse
+
+### Spoolman Vorbereitung
+
+**Wichtiger Hinweis**: Spoolman muss im Debug-Modus laufen:
+
+```env
+# In der .env Datei von Spoolman auskommentieren:
+SPOOLMAN_DEBUG_MODE=TRUE
+```
+
+Dies ist erforderlich, da Spoolman noch keine CORS-Domain-Konfiguration unterstützt.
+
+---
+
+## Konfiguration
+
+### Waagen-Kalibrierung
+
+1. **Kalibrierung starten**
+   - Gehen Sie zur "Scale" (Waage) Seite
+   - Bereiten Sie ein 500g Referenzgewicht vor (z.B. Wasserglas)
+
+2. **Kalibrierungsschritte**
+   - Folgen Sie den Anweisungen auf dem Display
+   - Legen Sie das Gewicht auf, wenn gefordert
+   - Warten Sie, bis die Kalibrierung abgeschlossen ist
+
+3. **Validierung**
+   - Testen Sie die Genauigkeit mit bekannten Gewichten
+   - Bei Bedarf "Tare Scale" für Nullstellung verwenden
+
+### Spoolman-Verbindung
+
+1. **Spoolman-URL eingeben**
+   - Gehen Sie zur "Spoolman/Bambu" Seite
+   - Geben Sie die vollständige URL Ihrer Spoolman-Instanz ein
+   - Format: `http://spoolman-server:7912`
+
+2. **Verbindung testen**
+   - Das System prüft automatisch die Verbindung
+   - Erfolgreiche Verbindung wird durch grünen Status angezeigt
+
+### Bambu Lab Drucker (optional)
+
+1. **Drucker-Einstellungen**
+   - Öffnen Sie das Einstellungsmenü auf Ihrem Bambu-Drucker
+   - Notieren Sie sich die folgenden Daten:
+     - IP-Adresse des Druckers
+     - Access Code
+     - Serial Number
+
+2. **FilaMan Konfiguration**
+   - Geben Sie die Drucker-Daten in der "Spoolman/Bambu" Seite ein
+   - Aktivieren Sie "Auto Send to Bambu" für automatische AMS-Zuordnung
+
+3. **Auto-Send Timeout**
+   - Konfigurieren Sie die Wartezeit für automatische Spulen-Erkennung
+   - Empfohlener Wert: 10-30 Sekunden
+
+---
+
+## Benutzung
+
+### Grundlegende Bedienung
+
+1. **Filament wiegen**
+   - Platzieren Sie die Spule auf der Waage
+   - Das Gewicht wird automatisch auf dem Display und in der Weboberfläche angezeigt
+
+2. **NFC-Tag scannen**
+   - Halten Sie den Tag in die Nähe des PN532-Moduls
+   - Bei erkannten Tags wird die Spulen-Information angezeigt
+   - Das Gewicht wird automatisch in Spoolman aktualisiert
+
+3. **Status-Überwachung**
+   - **OLED-Display** zeigt aktuelles Gewicht und Verbindungsstatus
+   - **Weboberfläche** bietet detaillierte Informationen und Steuerung
+
+### Weboberfläche Navigation
+
+- **Startseite**: Hauptfunktionen und aktueller Status
+- **Scale**: Waagen-Kalibrierung und -Einstellungen
+- **Spoolman/Bambu**: System-Konfiguration
+- **Statistics**: Nutzungsstatistiken (falls aktiviert)
+
+---
+
+## NFC-Tags
+
+### Unterstützte Tag-Typen
+
+- **NTAG213**: 144 Bytes (grundlegende Funktionen)
+- **NTAG215**: 504 Bytes (empfohlen)
+- **NTAG216**: 888 Bytes (erweiterte Funktionen)
+
+### Tag beschreiben
+
+1. **Spule in Spoolman vorbereiten**
+   - Erstellen Sie eine neue Spule in Spoolman
+   - Stellen Sie sicher, dass alle erforderlichen Daten eingegeben sind
+
+2. **Tag-Beschreibung starten**
+   - Wählen Sie die Spule aus der Liste
+   - Klicken Sie auf "Write Tag"
+   - Das Display zeigt "Waiting for Tag"
+
+3. **Tag auflegen**
+   - Platzieren Sie den NFC-Tag auf dem PN532-Modul
+   - Warten Sie auf die Bestätigung
+
+4. **Erfolgsmeldung**
+   - Bei erfolgreichem Beschreiben wird ein Häkchen angezeigt
+   - Der Tag ist nun mit der Spoolman-Spule verknüpft
+
+### Tag lesen
+
+1. **Tag scannen**
+   - Platzieren Sie die Spule mit dem NFC-Tag auf die Waage über dem NFC-Reader
+   - Bei Problemen beim Lesen: Spule etwas anders positionieren (nicht ganz an den Rand)
+   - Die Spulen-Information wird automatisch geladen
+
+2. **Automatische Updates**
+   - Das aktuelle Gewicht wird in Spoolman übertragen
+   - Die Spule wird in der Weboberfläche automatisch ausgewählt
+
+---
+
+## Bambu Lab Integration
+
+### AMS (Automatic Material System)
+
+1. **AMS-Status anzeigen**
+   - Die Weboberfläche zeigt den aktuellen Zustand aller AMS-Fächer
+   - Beladene Fächer werden mit Filament-Informationen angezeigt
+
+2. **Filament manuell zuordnen**
+   - Wählen Sie eine Spule aus der Spoolman-Liste
+   - Klicken Sie auf das entsprechende AMS-Fach-Symbol
+   - Das Filament wird dem Fach zugeordnet
+
+3. **Automatische Zuordnung**
+   - Nach dem Wiegen mit aktiviertem "Auto Send to Bambu"
+   - Das System wartet auf neue Spulen im AMS
+   - Kalibrierte Filamente werden automatisch zugeordnet
+
+### Bambu Studio Integration
+
+1. **Filament-Profile synchronisieren**
+   - Kalibrieren Sie Filamente in Bambu Studio
+   - Verwenden Sie Device → AMS → Bleistift-Symbol → Auswählen
+
+2. **Setting-IDs speichern**
+   - FilaMan erkennt verfügbare Setting-IDs automatisch
+   - Klicken Sie auf "Settings in Spoolman speichern"
+   - Die Profile werden für zukünftige Drucke verwendet
+
+### Verbindung wiederherstellen
+
+- Bei Verbindungsproblemen klicken Sie den roten Punkt in der Menüleiste
+- Das System stellt automatisch eine neue Verbindung her
+
+---
+
+## Spoolman Integration
+
+### Automatische Funktionen
+
+1. **Spulen-Synchronisation**
+   - Automatische Übertragung von Gewichtsänderungen
+   - Echtzeit-Updates der Spulen-Daten
+
+2. **Extra-Felder**
+   - FilaMan erstellt automatisch erforderliche benutzerdefinierte Felder
+   - NFC-Tag-UID wird als Referenz gespeichert
+
+3. **Filterung**
+   - "Nur Spulen ohne NFC-Tag anzeigen" für einfache Tag-Zuordnung
+   - Kategorisierung nach Herstellern und Materialtypen
+
+### Spoolman Octoprint Plugin
+
+Für Octoprint-Benutzer ist eine automatische Spulen-Zuordnung verfügbar:
+
+1. **Plugin installieren**
+   ```
+   https://github.com/ManuelW77/OctoPrint-Spoolman-Filaman/archive/refs/heads/master.zip
+   ```
+
+2. **FilaMan konfigurieren**
+   - Aktivieren Sie "Send to Octo-Plugin"
+   - Geben Sie Octoprint-URL und API-Key ein
+
+3. **Automatische Zuordnung**
+   - Nach dem Wiegen wird die Spule automatisch in Octoprint aktiviert
+   - Unterstützt aktuell nur Tool0 (erste Düse)
+
+---
+
+## Hersteller Tags
+
+### Überblick
+
+Hersteller Tags ermöglichen es Filament-Produzenten, vorkonfigurierte NFC-Tags zu liefern, die automatisch alle notwendigen Einträge in Spoolman erstellen.
+
+### Erste Schritte mit Hersteller Tags
+
+1. **Tag scannen**
+   - Platzieren Sie die Spule mit dem Hersteller-Tag auf die Waage über dem NFC-Reader
+   - Bei Problemen beim Lesen: Spule etwas anders positionieren (nicht ganz an den Rand)
+   - Das System erkennt automatisch das Hersteller-Format
+
+2. **Automatische Erstellung**
+   - **Marke** wird in Spoolman angelegt (falls nicht vorhanden)
+   - **Filament-Typ** wird mit allen Spezifikationen erstellt
+   - **Spule** wird automatisch registriert
+
+3. **Zukünftige Scans**
+   - Nach der ersten Einrichtung nutzen Tags das Fast-Path-System
+   - Sofortige Gewichtsmessung ohne erneute Einrichtung
+
+### Unterstützte Hersteller
+
+- **RecyclingFabrik**: Erster offizieller Partner
+- Weitere Hersteller folgen
+
+### Vorteile
+
+- ✅ **Null manuelle Einrichtung**
+- ✅ **Perfekte Datengenauigkeit**
+- ✅ **Sofortige Integration**
+- ✅ **Zukunftssicher**
+
+---
+
+## Fehlerbehebung
+
+### Häufige Probleme
+
+#### WiFi-Verbindung
+
+**Problem**: Kann nicht mit FilaMan-Hotspot verbinden
+- Lösung: Stellen Sie sicher, dass der ESP32 gestartet ist
+- Alternative: Manuell zu http://192.168.4.1 navigieren
+
+**Problem**: Weboberfläche nicht erreichbar
+- Lösung: Prüfen Sie die IP-Adresse im Router
+- Alternative: Verwenden Sie http://filaman.local
+
+#### Waage
+
+**Problem**: Ungenaue Gewichtsmessungen
+- Lösung: Kalibrierung wiederholen
+- Tipp: Verwenden Sie "Tare Scale" für Nullstellung
+
+**Problem**: Wägezelle reagiert nicht
+- Lösung: Überprüfen Sie die Verkabelung (E+, E-, A+, A-)
+- Tipp: Testen Sie mit einem Multimeter
+
+#### NFC-Tags
+
+**Problem**: Tag wird nicht erkannt
+- Lösung: Überprüfen Sie die PN532 DIP-Schalter (I2C-Modus)
+- Tipp: Spule etwas anders auf der Waage positionieren (nicht ganz an den Rand)
+
+**Problem**: Tag kann nicht beschrieben werden
+- Lösung: Verwenden Sie NTAG215 für bessere Kompatibilität
+- Tipp: Stellen Sie sicher, dass der Tag nicht schreibgeschützt ist
+
+#### Spoolman
+
+**Problem**: Verbindung zu Spoolman schlägt fehl
+- Lösung: Aktivieren Sie SPOOLMAN_DEBUG_MODE=TRUE
+- Tipp: Überprüfen Sie die URL-Formatierung
+
+**Problem**: Spulen werden nicht angezeigt
+- Lösung: Stellen Sie sicher, dass Spoolman läuft
+- Tipp: Prüfen Sie die Netzwerk-Firewall-Einstellungen
+
+#### Bambu Lab
+
+**Problem**: Drucker verbindet nicht
+- Lösung: Überprüfen Sie Access Code und IP-Adresse
+- Tipp: Stellen Sie sicher, dass der Drucker im LAN-Modus ist
+
+**Problem**: AMS-Status wird nicht angezeigt
+- Lösung: Prüfen Sie die MQTT-Verbindung
+- Hinweis: Bambu kann die API jederzeit schließen
+
+### Debug-Informationen
+
+Falls Sie Probleme haben, können Sie diese Schritte zur Diagnose verwenden:
+
+#### Serieller Monitor (für Entwickler)
+- Verbinden Sie den ESP32 über USB mit Ihrem Computer
+- Öffnen Sie einen seriellen Monitor (z.B. Arduino IDE) mit 115200 Baud
+- Sie sehen detaillierte Log-Nachrichten des Systems
+
+#### Browser-Konsole
+- Öffnen Sie die Weboberfläche von FilaMan
+- Drücken Sie F12 um die Entwicklertools zu öffnen  
+- Schauen Sie in der Konsole nach Fehlermeldungen
+
+#### Neustart bei anhaltenden Problemen
+1. ESP32 vom Strom trennen
+2. 10 Sekunden warten
+3. Wieder anschließen
+4. 30 Sekunden für vollständigen Start warten
+
+---
+
+## Support
+
+### Community
+
+- **Discord Server**: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
+- **GitHub Issues**: [Filaman Repository](https://github.com/ManuelW77/Filaman/issues)
+- **YouTube Kanal**: [Deutsches Erklärvideo](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaOHU)
+
+### Dokumentation
+
+- **Offizielle Website**: [www.filaman.app](https://www.filaman.app)
+- **GitHub Wiki**: [Detaillierte Dokumentation](https://github.com/ManuelW77/Filaman/wiki)
+- **Hardware-Referenz**: ESP32 Pinout-Diagramme in `/img/`
+
+### Entwicklung unterstützen
+
+Wenn Sie das Projekt unterstützen möchten:
+
+[![Buy Me A Coffee](https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png)](https://www.buymeacoffee.com/manuelw)
+
+### Lizenz
+
+Dieses Projekt ist unter der MIT-Lizenz veröffentlicht. Siehe [LICENSE](LICENSE.txt) für Details.
+
+---
+
+**Letzte Aktualisierung**: August 2025
+**Version**: 2.0
+**Maintainer**: Manuel W.

WIKI_EN.md

@@ -0,0 +1,746 @@
+# FilaMan Wiki - English
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Installation](#installation)
+3. [Hardware Requirements](#hardware-requirements)
+4. [Initial Setup](#initial-setup)
+5. [Configuration](#configuration)
+6. [Usage](#usage)
+7. [NFC Tags](#nfc-tags)
+8. [Bambu Lab Integration](#bambu-lab-integration)
+9. [Spoolman Integration](#spoolman-integration)
+10. [Octoprint Integration](#octoprint-integration)
+11. [Manufacturer Tags](#manufacturer-tags)
+12. [Troubleshooting](#troubleshooting)
+13. [Support](#support)
+
+---
+
+## Overview
+
+FilaMan is a comprehensive filament management system for 3D printers based on ESP32 hardware. It provides weight measurement, NFC tag management, and seamless integration with Spoolman and Bambu Lab 3D printers.
+
+### Key Features
+
+- **Precise weight measurement** with HX711 load cell amplifier
+- **NFC tag reading and writing** for filament identification
+- **OLED display** for status information
+- **WiFi connectivity** with easy configuration
+- **Web-based user interface** with real-time updates
+- **Spoolman integration** for inventory management
+- **Bambu Lab AMS control** via MQTT
+- **OpenSpool NFC format** compatibility
+- **Manufacturer tag support** for automatic setup
+
+### System Requirements
+
+- **ESP32 Development Board**
+- **Spoolman Instance** (required for full functionality)
+- **WiFi Network**
+- **Web Browser** (Chrome/Firefox/Safari)
+
+---
+
+## Installation
+
+### Easy Installation (Recommended)
+
+1. **Open the [FilaMan Web Installer](https://www.filaman.app/installer.html)**
+   - Use a Chrome-based browser
+
+2. **Prepare ESP32**
+   - Connect ESP32 via USB to your computer
+   - Click "Connect"
+
+3. **Select Port**
+   - Choose the appropriate USB port
+   - Confirm selection
+
+4. **Start Installation**
+   - Click "Install FilaMan"
+   - Wait for installation to complete
+
+### Manual Compilation
+
+For advanced users with PlatformIO:
+
+```bash
+git clone https://github.com/ManuelW77/Filaman.git
+cd FilaMan/esp32
+pio lib install
+pio run --target upload
+```
+
+---
+
+## Hardware Requirements
+
+### Required Components
+
+| Component | Description | Amazon Link (Affiliate) |
+|-----------|-------------|-------------------------|
+| ESP32 Development Board | Any ESP32 variant | [Amazon](https://amzn.to/3FHea6D) |
+| HX711 + Load Cell | 5kg Load Cell Amplifier | [Amazon](https://amzn.to/4ja1KTe) |
+| OLED Display | 0.96" I2C 128x64 SSD1306 | [Amazon](https://amzn.to/445aaa9) |
+| PN532 NFC Module | V3 RFID Module | [Amazon](https://amzn.eu/d/gy9vaBX) |
+| NFC Tags | NTAG213/NTAG215 | [Amazon](https://amzn.to/3E071xO) |
+| TTP223 Touch Sensor | Optional for tare function | [Amazon](https://amzn.to/4hTChMK) |
+
+### Pin Configuration
+
+| Component | ESP32 Pin | Function |
+|-----------|-----------|----------|
+| HX711 DOUT | 16 | Load cell data output |
+| HX711 SCK | 17 | Load cell clock |
+| OLED SDA | 21 | I2C data |
+| OLED SCL | 22 | I2C clock |
+| PN532 IRQ | 32 | Interrupt |
+| PN532 RESET | 33 | Reset |
+| PN532 SDA | 21 | I2C data (shared) |
+| PN532 SCL | 22 | I2C clock (shared) |
+| TTP223 I/O | 25 | Touch sensor (optional) |
+
+### Important Notes
+
+- **PN532 DIP switches** must be set to I2C mode
+- **3V pin** from ESP32 for touch sensor
+- **Load cell wiring**: E+ (red), E- (black), A- (white), A+ (green)
+
+![Wiring Diagram](./img/Schaltplan.png)
+
+---
+
+## Initial Setup
+
+### After Installation
+
+1. **ESP32 Restart**
+   - System automatically creates a WiFi hotspot "FilaMan"
+
+2. **WiFi Configuration**
+   - Connect to the "FilaMan" network
+   - Open browser (automatic portal or <http://192.168.4.1>)
+   - Configure your WiFi credentials
+
+3. **First Access**
+   - After successful WiFi connection, access system at <http://filaman.local>
+   - Alternative: Use IP address assigned by router
+
+### Spoolman Preparation
+
+**Important Note**: Spoolman must run in debug mode:
+
+```env
+# Uncomment in Spoolman's .env file:
+SPOOLMAN_DEBUG_MODE=TRUE
+```
+
+This is required as Spoolman doesn't support CORS domain configuration yet.
+
+---
+
+## Configuration
+
+### Scale Calibration
+
+1. **Start Calibration**
+   - Go to "Scale" page
+   - Prepare a 500g reference weight (e.g., water glass)
+
+2. **Calibration Steps**
+   - Follow instructions on display
+   - Place weight when prompted
+   - Wait for calibration to complete
+
+3. **Validation**
+   - Test accuracy with known weights
+   - Use "Tare Scale" for zero adjustment if needed
+
+### Spoolman Connection
+
+1. **Enter Spoolman URL**
+   - Go to "Spoolman/Bambu" page
+   - Enter complete URL of your Spoolman instance
+   - Format: `http://spoolman-server:7912`
+
+2. **Test Connection**
+   - System automatically checks connection
+   - Successful connection shown by green status
+
+### Bambu Lab Printer (Optional)
+
+1. **Printer Settings**
+   - Open settings menu on your Bambu printer
+   - Note the following data:
+     - Printer IP address
+     - Access Code
+     - Serial Number
+
+2. **FilaMan Configuration**
+   - Enter printer data on "Spoolman/Bambu" page
+   - Enable "Auto Send to Bambu" for automatic AMS assignment
+
+3. **Auto-Send Timeout**
+   - Configure waiting time for automatic spool detection
+   - Recommended value: 10-30 seconds
+
+---
+
+## Usage
+
+### Basic Operation
+
+1. **Weigh Filament**
+   - Place spool on scale
+   - Weight automatically displayed on screen and web interface
+
+2. **Scan NFC Tag**
+   - Hold tag near PN532 module
+   - Recognized tags display spool information
+   - Weight automatically updated in Spoolman
+
+3. **Status Monitoring**
+   - **OLED Display** shows current weight and connection status
+   - **Web Interface** provides detailed information and control
+
+### Web Interface Navigation
+
+- **Home**: Main functions and current status
+- **Scale**: Scale calibration and settings
+- **Spoolman/Bambu**: System configuration
+- **Statistics**: Usage statistics (if enabled)
+
+---
+
+## NFC Tags
+
+### Supported Tag Types
+
+- **NTAG213**: 144 bytes (basic functions)
+- **NTAG215**: 504 bytes (recommended)
+- **NTAG216**: 888 bytes (extended functions)
+
+### Writing Tags
+
+1. **Prepare Spool in Spoolman**
+   - Create new spool in Spoolman
+   - Ensure all required data is entered
+
+2. **Start Tag Writing**
+   - Select spool from list
+   - Click "Write Tag"
+   - Display shows "Waiting for Tag"
+
+3. **Place Tag**
+   - Position NFC tag on PN532 module
+   - Wait for confirmation
+
+4. **Success Message**
+   - Successful writing shows checkmark
+   - Tag is now linked to Spoolman spool
+
+### Reading Tags
+
+1. **Scan Tag**
+   - Place the spool with NFC tag on the scale over the NFC reader
+   - If reading fails: Reposition spool slightly (not completely at the edge)
+   - Spool information automatically loaded
+
+2. **Automatic Updates**
+   - Current weight transferred to Spoolman
+   - Spool automatically selected in web interface
+
+---
+
+## Bambu Lab Integration
+
+### AMS (Automatic Material System)
+
+1. **Display AMS Status**
+   - Web interface shows current state of all AMS slots
+   - Loaded slots display filament information
+
+2. **Manual Filament Assignment**
+   - Select spool from Spoolman list
+   - Click corresponding AMS slot icon
+   - Filament assigned to slot
+
+3. **Automatic Assignment**
+   - After weighing with "Auto Send to Bambu" enabled
+   - System waits for new spools in AMS
+   - Calibrated filaments automatically assigned
+
+### Bambu Studio Integration
+
+1. **Sync Filament Profiles**
+   - Calibrate filaments in Bambu Studio
+   - Use Device → AMS → Pencil icon → Select
+
+2. **Save Setting IDs**
+   - FilaMan automatically detects available setting IDs
+   - Click "Save Settings to Spoolman"
+   - Profiles used for future prints
+
+### Restore Connection
+
+- For connection issues, click red dot in menu bar
+- System automatically establishes new connection
+
+---
+
+## Spoolman Integration
+
+### Automatic Functions
+
+1. **Spool Synchronization**
+   - Automatic transfer of weight changes
+   - Real-time updates of spool data
+
+2. **Extra Fields**
+   - FilaMan automatically creates required custom fields
+   - NFC tag UID stored as reference
+
+3. **Filtering**
+   - "Show only spools without NFC tag" for easy tag assignment
+   - Categorization by manufacturers and material types
+
+### Spoolman Octoprint Plugin
+
+For Octoprint users, automatic spool assignment is available:
+
+1. **Install Plugin**
+
+   ```text
+   https://github.com/ManuelW77/OctoPrint-Spoolman-Filaman/archive/refs/heads/master.zip
+   ```
+
+2. **Configure FilaMan**
+   - Enable "Send to Octo-Plugin"
+   - Enter Octoprint URL and API key
+
+3. **Automatic Assignment**
+   - After weighing, spool automatically activated in Octoprint
+   - Currently supports only Tool0 (first nozzle)
+
+---
+
+## Manufacturer Tags
+
+### Overview
+
+Manufacturer tags allow filament producers to provide pre-configured NFC tags that automatically create all necessary entries in Spoolman.
+
+### Getting Started with Manufacturer Tags
+
+1. **Scan Tag**
+   - Place spool with manufacturer tag on the scale over the NFC reader
+   - If reading fails: Reposition spool slightly (not completely at the edge)
+   - System automatically recognizes manufacturer format
+
+2. **Automatic Creation**
+   - **Brand** created in Spoolman (if not present)
+   - **Filament type** created with all specifications
+   - **Spool** automatically registered
+
+3. **Future Scans**
+   - After initial setup, tags use fast-path system
+   - Immediate weight measurement without re-setup
+
+### Supported Manufacturers
+
+- **RecyclingFabrik**: First official partner
+- More manufacturers coming soon
+
+### Benefits
+
+- ✅ **Zero manual setup**
+- ✅ **Perfect data accuracy**
+- ✅ **Instant integration**
+- ✅ **Future-proof**
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+#### WiFi Connection
+
+**Issue**: Cannot connect to FilaMan hotspot
+
+- Solution: Ensure ESP32 is started
+- Alternative: Manually navigate to <http://192.168.4.1>
+
+**Issue**: Web interface not accessible
+
+- Solution: Check IP address in router
+- Alternative: Use <http://filaman.local>
+
+#### Scale
+
+**Issue**: Inaccurate weight measurements
+
+- Solution: Repeat calibration
+- Tip: Use "Tare Scale" for zero adjustment
+
+**Issue**: Load cell not responding
+
+- Solution: Check wiring (E+, E-, A+, A-)
+- Tip: Test with multimeter
+
+#### NFC Tags
+
+**Issue**: Tag not recognized
+
+- Solution: Check PN532 DIP switches (I2C mode)
+- Tip: Reposition spool slightly on scale (not completely at the edge)
+
+**Issue**: Cannot write tag
+
+- Solution: Use NTAG215 for better compatibility
+- Tip: Ensure tag is not write-protected
+
+#### Spoolman
+
+**Issue**: Connection to Spoolman fails
+
+- Solution: Enable SPOOLMAN_DEBUG_MODE=TRUE
+- Tip: Check URL formatting
+
+**Issue**: Spools not displayed
+
+- Solution: Ensure Spoolman is running
+- Tip: Check network firewall settings
+
+#### Bambu Lab
+
+**Issue**: Printer won't connect
+
+- Solution: Check access code and IP address
+- Tip: Ensure printer is in LAN mode
+
+**Issue**: AMS status not displayed
+
+- Solution: Check MQTT connection
+- Note: Bambu may close API at any time
+
+### Debug Information
+
+If you have problems, you can use these steps for diagnosis:
+
+#### Serial Monitor (for developers)
+
+- Connect the ESP32 via USB to your computer
+- Open a serial monitor (e.g., Arduino IDE) with 115200 baud
+- You will see detailed log messages from the system
+
+#### Browser Console
+
+- Open the FilaMan web interface
+- Press F12 to open developer tools
+- Check the console for error messages
+
+---
+
+## Maintenance and Updates
+
+### Firmware Update
+
+1. **Via Web Interface**: Access `http://filaman.local/upgrade.html`
+2. **Select firmware file** (.bin format)
+3. **Upload** - System restarts automatically
+4. **Configuration preserved** - Settings remain intact
+
+### System Reset
+
+For persistent issues:
+
+1. Disconnect ESP32 from power
+2. Wait 10 seconds
+3. Reconnect
+4. Wait 30 seconds for complete startup
+
+---
+
+## Support and Information
+
+**Manufacturer**: Your Company Name
+**Maintainer**: Manuel W.
+
+### Scale Technology
+
+#### Weight Stabilization
+
+The system uses multiple filters for precise measurements:
+
+```cpp
+// Moving Average Filter with 8 values
+#define MOVING_AVERAGE_SIZE 8
+// Low-Pass Filter for smoothing
+#define LOW_PASS_ALPHA 0.3f
+// Thresholds for updates
+#define DISPLAY_THRESHOLD 0.3f    // Display update
+#define API_THRESHOLD 1.5f        // API actions
+```
+
+#### Calibration Algorithm
+
+1. **System Pause**: All tasks are temporarily paused
+2. **Zero Setting**: Tare scale without weight
+3. **Reference Measurement**: 500g weight for 10 measurements
+4. **Calculation**: `newValue = rawValue / SCALE_LEVEL_WEIGHT`
+5. **NVS Storage**: Permanent value with verification
+6. **Filter Reset**: New baseline for stabilization
+
+#### Auto-Tare Logic
+
+```cpp
+// Conditions for Auto-Tare
+if (autoTare && (weight > 2 && weight < 7) || weight < -2) {
+    scale_tare_counter++;
+    if (scale_tare_counter >= 5) {
+        // Automatic zero setting
+        scale.tare();
+        resetWeightFilter();
+    }
+}
+```
+
+### NFC Technology
+
+#### PN532 Communication
+
+- **Interface**: I2C at 400kHz
+- **IRQ Pin**: Interrupt-based tag detection
+- **Reset Handling**: Automatic recovery from communication errors
+- **DIP Switches**: Must be set to I2C mode (00)
+
+#### NDEF Implementation
+
+```json
+// FilaMan Spoolman Format (with sm_id)
+{
+  "sm_id": "123",
+  "color": "#FF5733",
+  "type": "PLA", 
+  "brand": "Example Brand"
+}
+```
+
+#### Manufacturer Tag Schema
+
+Compact JSON format for storage efficiency:
+
+```json
+{
+  "b": "RecyclingFabrik",           // brand
+  "an": "FX1_PLA-S175-1000-RED",  // article number
+  "t": "PLA",                      // type
+  "c": "FF0000",                   // color (hex without #)
+  "cn": "Red",                     // color name
+  "et": "210",                     // extruder temp
+  "bt": "60",                      // bed temp
+  "di": "1.75",                    // diameter
+  "de": "1.24",                    // density
+  "sw": "240",                      // spool weight
+  "u": "https://www.yoururl.com/search?q=" // URL used vor Brand Link and Filament Link
+}
+```
+
+### Display System
+
+#### OLED Architecture (SSD1306)
+
+- **Resolution**: 128x64 pixels monochrome
+- **Areas**:
+  - Status bar: 0-16 pixels (version, icons)
+  - Main area: 17-64 pixels (weight, messages)
+- **Update Interval**: 1 second for status line
+
+#### Icon System
+
+Bitmap icons for various states:
+
+```cpp
+// Status Icons (16x16 pixels)
+- icon_success: Checkmark for successful operations
+- icon_failed: X for errors
+- icon_transfer: Arrow for data transmission
+- icon_loading: Loading circle for ongoing operations
+
+// Connection Icons with strikethrough indicator
+- wifi_on/wifi_off: WLAN status
+- bambu_on: Bambu Lab connection
+- spoolman_on: Spoolman API status
+```
+
+### API Integration
+
+#### Spoolman REST API
+
+FilaMan interacts with the following endpoints:
+
+```http
+GET  /api/v1/spool/          # List spools
+POST /api/v1/spool/          # Create new spool
+PUT  /api/v1/spool/{id}/     # Update spool
+
+GET  /api/v1/vendor/         # List vendors
+POST /api/v1/vendor/         # Create new vendor
+
+GET  /api/v1/filament/       # List filaments
+POST /api/v1/filament/       # Create new filament
+```
+
+#### Request Handling
+
+```cpp
+// Sequential API processing
+enum spoolmanApiStateType {
+    API_IDLE = 0,
+    API_PROCESSING = 1,
+    API_ERROR = 2
+};
+```
+
+Prevents simultaneous API calls and deadlocks.
+
+#### Weight Update Logic
+
+```cpp
+// Conditions for Spoolman update
+if (activeSpoolId != "" && 
+    weigthCouterToApi > 3 &&    // 3+ stable measurements
+    weightSend == 0 &&          // Not yet sent
+    weight > 5 &&               // Minimum weight 5g
+    spoolmanApiState == API_IDLE) {
+    updateSpoolWeight(activeSpoolId, weight);
+}
+```
+
+### Bambu Lab MQTT
+
+#### Connection Parameters
+
+```cpp
+// SSL/TLS Configuration
+#define BAMBU_PORT 8883
+#define BAMBU_USERNAME "bblp"
+
+// Topic Structure
+String topic = "device/" + bambu_serial + "/report";
+String request_topic = "device/" + bambu_serial + "/request";
+```
+
+#### AMS Data Structure
+
+```cpp
+struct AMSData {
+    String tray_id;
+    String tray_type;
+    String tray_color;
+    String tray_material;
+    String setting_id;
+    String tray_info_idx;
+    bool has_spool;
+};
+```
+
+#### Auto-Send Mechanism
+
+```cpp
+// After tag recognition
+if (bambuCredentials.autosend_enable) {
+    autoSetToBambuSpoolId = activeSpoolId.toInt();
+    // Countdown starts automatically
+    // Waits for new spool in AMS
+}
+```
+
+### WebSocket Communication
+
+#### Message Types
+
+```javascript
+// Client → Server
+{
+  "type": "writeNfcTag",
+  "tagType": "spool",
+  "payload": { /* JSON data */ }
+}
+
+{
+  "type": "scale",
+  "payload": "tare|calibrate|setAutoTare",
+  "enabled": true
+}
+
+// Server → Client
+{
+  "type": "heartbeat",
+  "freeHeap": 245,
+  "bambu_connected": true,
+  "spoolman_connected": true
+}
+
+{
+  "type": "amsData",
+  "data": [ /* AMS array */ ]
+}
+```
+
+#### Connection Management
+
+- **Auto-Reconnect**: Client-side reconnection
+- **Heartbeat**: Every 30 seconds for connection monitoring
+- **Cleanup**: Automatic removal of dead connections
+
+### Watchdog and Error Handling
+
+#### System Watchdog
+
+```cpp
+// WDT Configuration
+esp_task_wdt_init(10, true);  // 10s timeout, panic on overflow
+esp_task_wdt_add(NULL);       // Add current task
+```
+
+#### Error Recovery
+
+- **NFC Reset**: Automatic PN532 restart on communication errors
+- **MQTT Reconnect**: Bambu Lab connection automatically restored
+- **WiFi Monitoring**: Connection check every 60 seconds
+
+---
+
+## Support
+
+### Community
+
+- **Discord Server**: [https://discord.gg/my7Gvaxj2v](https://discord.gg/my7Gvaxj2v)
+- **GitHub Issues**: [Filaman Repository](https://github.com/ManuelW77/Filaman/issues)
+- **YouTube Channel**: [German explanation video](https://youtu.be/uNDe2wh9SS8?si=b-jYx4I1w62zaOHU)
+
+### Documentation
+
+- **Official Website**: [www.filaman.app](https://www.filaman.app)
+- **GitHub Wiki**: [Detailed documentation](https://github.com/ManuelW77/Filaman/wiki)
+- **Hardware Reference**: ESP32 pinout diagrams in `/img/`
+
+### Support Development
+
+If you'd like to support the project:
+
+[![Buy Me A Coffee](https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png)](https://www.buymeacoffee.com/manuelw)
+
+### License
+
+This project is released under the MIT License. See [LICENSE](LICENSE.txt) for details.
+
+---
+
+**Last Updated**: August 2025  
+**Version**: 2.0  
+**Maintainer**: Manuel W.

platformio.ini

@@ -9,8 +9,8 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [common]
-version = "2.0.0-beta1"
-to_old_version = "2.0.0"
+version = "2.0.1"
+to_old_version = "1.5.10"
 
 ##
 [env:esp32dev]

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:

src/api.cpp

@@ -124,28 +124,69 @@ void sendToApi(void *parameter) {
     String octoToken = params->octoToken;
     bool triggerWeightUpdate = params->triggerWeightUpdate;
     String spoolIdForWeight = params->spoolIdForWeight;
-    uint16_t weightValue = params->weightValue;    
+    uint16_t weightValue = params->weightValue;
 
-    HTTPClient http;
-    http.setReuse(false);
+    // Retry mechanism with configurable parameters
+    const uint8_t MAX_RETRIES = 3;
+    const uint16_t RETRY_DELAY_MS = 1000; // 1 second between retries
+    const uint16_t HTTP_TIMEOUT_MS = 10000; // 10 second HTTP timeout
+    
+    bool success = false;
+    int httpCode = -1;
+    String responsePayload = "";
+    
+    // Try request with retries
+    for (uint8_t attempt = 1; attempt <= MAX_RETRIES && !success; attempt++) {
+        Serial.printf("API Request attempt %d/%d to: %s\n", attempt, MAX_RETRIES, spoolsUrl.c_str());
+        
+        HTTPClient http;
+        http.setReuse(false);
+        http.setTimeout(HTTP_TIMEOUT_MS); // Set HTTP timeout
+        
+        http.begin(spoolsUrl);
+        http.addHeader("Content-Type", "application/json");
+        if (octoEnabled && octoToken != "") http.addHeader("X-Api-Key", octoToken);
 
-    http.begin(spoolsUrl);
-    http.addHeader("Content-Type", "application/json");
-    if (octoEnabled && octoToken != "") http.addHeader("X-Api-Key", octoToken);
+        // Execute HTTP request based on type
+        if (httpType == "PATCH") httpCode = http.PATCH(updatePayload);
+        else if (httpType == "POST") httpCode = http.POST(updatePayload);
+        else if (httpType == "GET") httpCode = http.GET();
+        else httpCode = http.PUT(updatePayload);
 
-    int httpCode;
-    if (httpType == "PATCH") httpCode = http.PATCH(updatePayload);
-    else if (httpType == "POST") httpCode = http.POST(updatePayload);
-    else if (httpType == "GET") httpCode = http.GET();
-    else httpCode = http.PUT(updatePayload);
+        // Check if request was successful
+        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_CREATED) {
+            responsePayload = http.getString();
+            success = true;
+            Serial.printf("API Request successful on attempt %d, HTTP Code: %d\n", attempt, httpCode);
+        } else {
+            Serial.printf("API Request failed on attempt %d, HTTP Code: %d (%s)\n", 
+                         attempt, httpCode, http.errorToString(httpCode).c_str());
+            
+            // Don't retry on certain error codes (client errors)
+            if (httpCode >= 400 && httpCode < 500 && httpCode != 408 && httpCode != 429) {
+                Serial.println("Client error detected, stopping retries");
+                break;
+            }
+            
+            // Wait before retry (except on last attempt)
+            if (attempt < MAX_RETRIES) {
+                Serial.printf("Waiting %dms before retry...\n", RETRY_DELAY_MS);
+                http.end();
+                vTaskDelay(RETRY_DELAY_MS / portTICK_PERIOD_MS);
+                continue;
+            }
+        }
+        
+        http.end();
+    }
 
-    if (httpCode == HTTP_CODE_OK) {
+    // Process successful response
+    if (success) {
         Serial.println("Spoolman Abfrage erfolgreich");
 
         // Restgewicht der Spule auslesen
-        String payload = http.getString();
         JsonDocument doc;
-        DeserializationError error = deserializeJson(doc, payload);
+        DeserializationError error = deserializeJson(doc, responsePayload);
         if (error) {
             Serial.print("Fehler beim Parsen der JSON-Antwort: ");
             Serial.println(error.c_str());
@@ -225,10 +266,9 @@ void sendToApi(void *parameter) {
     } else if (httpCode == HTTP_CODE_CREATED) {
         Serial.println("Spoolman erfolgreich erstellt");
         
-        // Parse response for created resources
-        String payload = http.getString();
+        // Parse response for created resources  
         JsonDocument doc;
-        DeserializationError error = deserializeJson(doc, payload);
+        DeserializationError error = deserializeJson(doc, responsePayload);
         if (error) {
             Serial.print("Fehler beim Parsen der JSON-Antwort: ");
             Serial.println(error.c_str());
@@ -280,14 +320,17 @@ void sendToApi(void *parameter) {
             Serial.println(weightPayload);
 
             // Execute weight update
-            http.begin(weightUrl);
-            http.addHeader("Content-Type", "application/json");
+            HTTPClient weightHttp;
+            weightHttp.setReuse(false);
+            weightHttp.setTimeout(HTTP_TIMEOUT_MS);
+            weightHttp.begin(weightUrl);
+            weightHttp.addHeader("Content-Type", "application/json");
             
-            int weightHttpCode = http.PUT(weightPayload);
+            int weightHttpCode = weightHttp.PUT(weightPayload);
             
             if (weightHttpCode == HTTP_CODE_OK) {
                 Serial.println("Weight update successful");
-                String weightResponse = http.getString();
+                String weightResponse = weightHttp.getString();
                 JsonDocument weightResponseDoc;
                 DeserializationError weightError = deserializeJson(weightResponseDoc, weightResponse);
                 
@@ -310,6 +353,7 @@ void sendToApi(void *parameter) {
                 oledShowProgressBar(1, 1, "Failure!", "Weight update");
             }
             
+            weightHttp.end();
             weightDoc.clear();
         }
     } else {
@@ -325,14 +369,25 @@ void sendToApi(void *parameter) {
         case API_REQUEST_BAMBU_UPDATE:
             oledShowProgressBar(1, 1, "Failure!", "Bambu update");
             break;
+        case API_REQUEST_VENDOR_CHECK:
+            oledShowProgressBar(1, 1, "Failure!", "Vendor check");
+            foundVendorId = 0; // Set to 0 to indicate error/not found
+            break;
         case API_REQUEST_VENDOR_CREATE:
             oledShowProgressBar(1, 1, "Failure!", "Vendor create");
+            createdVendorId = 0; // Set to 0 to indicate error
+            break;
+        case API_REQUEST_FILAMENT_CHECK:
+            oledShowProgressBar(1, 1, "Failure!", "Filament check");
+            foundFilamentId = 0; // Set to 0 to indicate error/not found
             break;
         case API_REQUEST_FILAMENT_CREATE:
             oledShowProgressBar(1, 1, "Failure!", "Filament create");
+            createdFilamentId = 0; // Set to 0 to indicate error
             break;
         case API_REQUEST_SPOOL_CREATE:
             oledShowProgressBar(1, 1, "Failure!", "Spool create");
+            createdSpoolId = 0; // Set to 0 to indicate error instead of hanging
             break;
         }
         Serial.println("Fehler beim Senden an Spoolman! HTTP Code: " + String(httpCode));
@@ -340,7 +395,6 @@ void sendToApi(void *parameter) {
         nfcReaderState = NFC_IDLE; // Reset NFC state to allow retry
     }
 
-    http.end();
     vTaskDelay(50 / portTICK_PERIOD_MS);
 
     // Speicher freigeben
@@ -603,7 +657,7 @@ bool updateSpoolBambuData(String payload) {
 }
 
 // #### Brand Filament
-uint16_t createVendor(String vendor) {
+uint16_t createVendor(const JsonDocument& payload) {
     oledShowProgressBar(2, 5, "New Brand", "Create new Vendor");
 
     // Create new vendor in Spoolman database using task system
@@ -617,9 +671,24 @@ uint16_t createVendor(String vendor) {
 
     // Create JSON payload for vendor creation
     JsonDocument vendorDoc;
-    vendorDoc["name"] = vendor;
-    vendorDoc["comment"] = "automatically generated";
-    vendorDoc["external_id"] = vendor;
+    vendorDoc["name"] = payload["b"].as<String>();
+    
+    // Extract domain from URL if present, otherwise use brand name
+    String externalId = "";
+    if (payload["u"].is<String>()) {
+        String url = payload["u"].as<String>();
+        // Extract domain from URL (e.g., "https://www.blubb.de/f1234/?suche=irgendwas" -> "https://www.blubb.de")
+        int protocolEnd = url.indexOf("://");
+        if (protocolEnd != -1) {
+            int pathStart = url.indexOf("/", protocolEnd + 3);
+            externalId = (pathStart != -1) ? url.substring(0, pathStart) : url;
+        } else {
+            externalId = url; // No protocol found, use as is
+        }
+    } else {
+        externalId = payload["b"].as<String>();
+    }
+    vendorDoc["comment"] = externalId;
 
     String vendorPayload;
     serializeJson(vendorDoc, vendorPayload);
@@ -668,13 +737,13 @@ uint16_t createVendor(String vendor) {
     return createdVendorId;
 }
 
-uint16_t checkVendor(String vendor) {
+uint16_t checkVendor(const JsonDocument& payload) {
     oledShowProgressBar(1, 5, "New Brand", "Check Vendor");
 
     // Check if vendor exists using task system
     foundVendorId = 65535; // Reset to invalid value to detect when API response is received
     
-    String vendorName = vendor;
+    String vendorName = payload["b"].as<String>();
     vendorName.trim();
     vendorName.replace(" ", "+");
     String spoolsUrl = spoolmanUrl + apiUrl + "/vendor?name=" + vendorName;
@@ -716,7 +785,7 @@ uint16_t checkVendor(String vendor) {
     // Check if vendor was found
     if (foundVendorId == 0) {
         Serial.println("Vendor not found, creating new vendor...");
-        uint16_t vendorId = createVendor(vendor);
+        uint16_t vendorId = createVendor(payload);
         if (vendorId == 0) {
             Serial.println("Failed to create vendor, returning 0.");
             return 0; // Failed to create vendor
@@ -725,7 +794,7 @@ uint16_t checkVendor(String vendor) {
             return vendorId;
         }
     } else {
-        Serial.println("Vendor found: " + vendor);
+        Serial.println("Vendor found: " + payload["b"].as<String>());
         Serial.print("Vendor ID: ");
         Serial.println(foundVendorId);
         return foundVendorId;
@@ -937,6 +1006,13 @@ uint16_t createSpool(uint16_t vendorId, uint16_t filamentId, JsonDocument& paylo
     while(createdSpoolId == 65535) {
         vTaskDelay(50 / portTICK_PERIOD_MS);
     }
+    
+    // Check if spool creation was successful
+    if (createdSpoolId == 0) {
+        Serial.println("ERROR: Spool creation failed");
+        nfcReaderState = NFC_IDLE; // Reset NFC state
+        return 0;
+    }
 
     // Write data to tag with startWriteJsonToTag
     // void startWriteJsonToTag(const bool isSpoolTag, const char* payload);
@@ -966,7 +1042,7 @@ uint16_t createSpool(uint16_t vendorId, uint16_t filamentId, JsonDocument& paylo
 }
 
 bool createBrandFilament(JsonDocument& payload, String uidString) {
-    uint16_t vendorId = checkVendor(payload["b"].as<String>());
+    uint16_t vendorId = checkVendor(payload);
     if (vendorId == 0) {
         Serial.println("ERROR: Failed to create/find vendor");
         return false;

src/main.cpp

@@ -59,6 +59,7 @@ void setup() {
 
   // 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
@@ -177,9 +178,11 @@ void loop() {
     // Ausgabe der Waage auf Display
     if(pauseMainTask == 0)
     {
+      // Use filtered weight for smooth display, but still check API weight for significant changes
+      int16_t displayWeight = getFilteredDisplayWeight();
       if (mainTaskWasPaused || (weight != lastWeight && nfcReaderState == NFC_IDLE && (!bambuCredentials.autosend_enable || autoSetToBambuSpoolId == 0)))
       {
-        (weight < 2) ? ((weight < -2) ? oledShowMessage("!! -0") : oledShowWeight(0)) : oledShowWeight(weight);
+        (displayWeight < 2) ? ((displayWeight < -2) ? oledShowMessage("!! -0") : oledShowWeight(0)) : oledShowWeight(displayWeight);
       }
       mainTaskWasPaused = false;
     }
@@ -249,6 +252,25 @@ void loop() {
       }
     }
 
+    // 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);

src/nfc.cpp

@@ -108,6 +108,37 @@ bool formatNdefTag() {
   return buffer[2]*8;
 }
 
+// Robust page reading with error recovery
+bool robustPageRead(uint8_t page, uint8_t* buffer) {
+    const int MAX_READ_ATTEMPTS = 3;
+    
+    for (int attempt = 0; attempt < MAX_READ_ATTEMPTS; attempt++) {
+        esp_task_wdt_reset();
+        yield();
+        
+        if (nfc.ntag2xx_ReadPage(page, buffer)) {
+            return true;
+        }
+        
+        Serial.printf("Page %d read failed, attempt %d/%d\n", page, attempt + 1, MAX_READ_ATTEMPTS);
+        
+        // Try to stabilize connection between attempts
+        if (attempt < MAX_READ_ATTEMPTS - 1) {
+            vTaskDelay(pdMS_TO_TICKS(25));
+            
+            // Re-verify tag presence with quick check
+            uint8_t uid[7];
+            uint8_t uidLength;
+            if (!nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 100)) {
+                Serial.println("Tag lost during read operation");
+                return false;
+            }
+        }
+    }
+    
+    return false;
+}
+
 String detectNtagType()
 {
   // Read capability container from page 3 to determine exact NTAG type
@@ -1268,6 +1299,61 @@ bool decodeNdefAndReturnJson(const byte* encodedMessage, String uidString) {
   return true;
 }
 
+// Read complete JSON data for fast-path to enable web interface display
+bool readCompleteJsonForFastPath() {
+    Serial.println("=== FAST-PATH: Reading complete JSON for web interface ===");
+    
+    // Read tag size first
+    uint16_t tagSize = readTagSize();
+    if (tagSize == 0) {
+        Serial.println("FAST-PATH: Could not determine tag size");
+        return false;
+    }
+    
+    // Create buffer for complete data
+    uint8_t* data = (uint8_t*)malloc(tagSize);
+    if (!data) {
+        Serial.println("FAST-PATH: Could not allocate memory for complete read");
+        return false;
+    }
+    memset(data, 0, tagSize);
+    
+    // Read all pages
+    uint8_t numPages = tagSize / 4;
+    for (uint8_t i = 4; i < 4 + numPages; i++) {
+        if (!robustPageRead(i, data + (i - 4) * 4)) {
+            Serial.printf("FAST-PATH: Failed to read page %d\n", i);
+            free(data);
+            return false;
+        }
+        
+        // Check for NDEF message end
+        if (data[(i - 4) * 4] == 0xFE) {
+            Serial.println("FAST-PATH: Found NDEF message end marker");
+            break;
+        }
+        
+        yield();
+        esp_task_wdt_reset();
+        vTaskDelay(pdMS_TO_TICKS(2));
+    }
+    
+    // Decode NDEF and extract JSON
+    bool success = decodeNdefAndReturnJson(data, ""); // Empty UID string for fast-path
+    
+    free(data);
+    
+    if (success) {
+        Serial.println("✓ FAST-PATH: Complete JSON data successfully loaded");
+        Serial.print("nfcJsonData length: ");
+        Serial.println(nfcJsonData.length());
+    } else {
+        Serial.println("✗ FAST-PATH: Failed to decode complete JSON data");
+    }
+    
+    return success;
+}
+
 bool quickSpoolIdCheck(String uidString) {
     // Fast-path: Read NDEF structure to quickly locate and check JSON payload
     // This dramatically speeds up known spool recognition
@@ -1285,10 +1371,11 @@ bool quickSpoolIdCheck(String uidString) {
     memset(ndefData, 0, 20);
     
     for (uint8_t page = 4; page < 9; page++) {
-        if (!nfc.ntag2xx_ReadPage(page, ndefData + (page - 4) * 4)) {
-            Serial.print("Failed to read page ");
-            Serial.println(page);
-            return false; // Fall back to full read
+        if (!robustPageRead(page, ndefData + (page - 4) * 4)) {
+            Serial.print("FAST-PATH: Failed to read page ");
+            Serial.print(page);
+            Serial.println(" - falling back to full read");
+            return false; // Fall back to full read if any page read fails
         }
     }
     
@@ -1358,10 +1445,11 @@ bool quickSpoolIdCheck(String uidString) {
         memset(extraData, 0, 16);
         
         for (uint8_t page = 9; page < 13; page++) {
-            if (!nfc.ntag2xx_ReadPage(page, extraData + (page - 9) * 4)) {
-                Serial.print("Failed to read additional page ");
-                Serial.println(page);
-                return false;
+            if (!robustPageRead(page, extraData + (page - 9) * 4)) {
+                Serial.print("FAST-PATH: Failed to read additional page ");
+                Serial.print(page);
+                Serial.println(" - falling back to full read");
+                return false; // Fall back to full read if extended read fails
             }
         }
         
@@ -1403,6 +1491,14 @@ bool quickSpoolIdCheck(String uidString) {
                     activeSpoolId = quickSpoolId;
                     lastSpoolId = activeSpoolId;
                     
+                    // Read complete JSON data for web interface display
+                    Serial.println("FAST-PATH: Reading complete JSON data for web interface...");
+                    if (readCompleteJsonForFastPath()) {
+                        Serial.println("✓ FAST-PATH: Complete JSON data loaded for web interface");
+                    } else {
+                        Serial.println("⚠ FAST-PATH: Could not read complete JSON, web interface may show limited data");
+                    }
+                    
                     oledShowProgressBar(2, octoEnabled?5:4, "Known Spool", "Quick mode");
                     Serial.println("✓ FAST-PATH SUCCESS: Known spool processed quickly");
                     return true;
@@ -1450,6 +1546,14 @@ bool quickSpoolIdCheck(String uidString) {
                 activeSpoolId = quickSpoolId;
                 lastSpoolId = activeSpoolId;
                 
+                // Read complete JSON data for web interface display
+                Serial.println("FAST-PATH: Reading complete JSON data for web interface...");
+                if (readCompleteJsonForFastPath()) {
+                    Serial.println("✓ FAST-PATH: Complete JSON data loaded for web interface");
+                } else {
+                    Serial.println("⚠ FAST-PATH: Could not read complete JSON, web interface may show limited data");
+                }
+                
                 oledShowProgressBar(2, octoEnabled?5:4, "Known Spool", "Quick mode");
                 Serial.println("✓ FAST-PATH SUCCESS: Known spool processed quickly");
                 return true;
@@ -1496,6 +1600,10 @@ void writeJsonToTag(void *parameter) {
   // aktualisieren der Website wenn sich der Status ändert
   sendNfcData();
   vTaskDelay(100 / portTICK_PERIOD_MS);
+  
+  // Show waiting message for tag detection
+  oledShowProgressBar(0, 1, "Write Tag", "Warte auf Tag");
+  
   // Wait 10sec for tag
   uint8_t success = 0;
   String uidString = "";
@@ -1655,10 +1763,60 @@ void writeJsonToTag(void *parameter) {
   vTaskDelete(NULL);
 }
 
+// Ensures sm_id is always the first key in JSON for fast-path detection
+String optimizeJsonForFastPath(const char* payload) {
+    JsonDocument inputDoc;
+    DeserializationError error = deserializeJson(inputDoc, payload);
+    
+    if (error) {
+        Serial.print("JSON optimization failed: ");
+        Serial.println(error.c_str());
+        return String(payload); // Return original if parsing fails
+    }
+    
+    // Create optimized JSON with sm_id first
+    JsonDocument optimizedDoc;
+    
+    // Always add sm_id first (even if it's "0" for brand filaments)
+    if (inputDoc["sm_id"].is<String>()) {
+        optimizedDoc["sm_id"] = inputDoc["sm_id"].as<String>();
+        Serial.print("Optimizing JSON: sm_id found = ");
+        Serial.println(inputDoc["sm_id"].as<String>());
+    } else {
+        optimizedDoc["sm_id"] = "0"; // Default for brand filaments
+        Serial.println("Optimizing JSON: No sm_id found, setting to '0'");
+    }
+    
+    // Add all other keys in original order
+    for (JsonPair kv : inputDoc.as<JsonObject>()) {
+        String key = kv.key().c_str();
+        if (key != "sm_id") { // Skip sm_id as it's already added first
+            optimizedDoc[key] = kv.value();
+        }
+    }
+    
+    String optimizedJson;
+    serializeJson(optimizedDoc, optimizedJson);
+    
+    Serial.println("JSON optimized for fast-path detection:");
+    Serial.print("Original:  ");
+    Serial.println(payload);
+    Serial.print("Optimized: ");
+    Serial.println(optimizedJson);
+    
+    inputDoc.clear();
+    optimizedDoc.clear();
+    
+    return optimizedJson;
+}
+
 void startWriteJsonToTag(const bool isSpoolTag, const char* payload) {
+  // Optimize JSON to ensure sm_id is first key for fast-path detection
+  String optimizedPayload = optimizeJsonForFastPath(payload);
+  
   NfcWriteParameterType* parameters = new NfcWriteParameterType();
   parameters->tagType = isSpoolTag;
-  parameters->payload = strdup(payload);
+  parameters->payload = strdup(optimizedPayload.c_str()); // Use optimized payload
   
   // Task nicht mehrfach starten
   if (nfcReaderState == NFC_IDLE || nfcReaderState == NFC_READ_ERROR || nfcReaderState == NFC_READ_SUCCESS) {
@@ -1678,9 +1836,44 @@ void startWriteJsonToTag(const bool isSpoolTag, const char* payload) {
   }
 }
 
+// Safe tag detection with manual retry logic and short timeouts
+bool safeTagDetection(uint8_t* uid, uint8_t* uidLength) {
+    const int MAX_ATTEMPTS = 3;
+    const int SHORT_TIMEOUT = 100; // Very short timeout to prevent hanging
+    
+    for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        // Watchdog reset on each attempt
+        esp_task_wdt_reset();
+        yield();
+        
+        // Use short timeout to avoid blocking
+        bool success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, uidLength, SHORT_TIMEOUT);
+        
+        if (success) {
+            Serial.printf("✓ Tag detected on attempt %d with %dms timeout\n", attempt + 1, SHORT_TIMEOUT);
+            return true;
+        }
+        
+        // Short pause between attempts
+        vTaskDelay(pdMS_TO_TICKS(25));
+        
+        // Refresh RF field after failed attempt (but not on last attempt)
+        if (attempt < MAX_ATTEMPTS - 1) {
+            nfc.SAMConfig();
+            vTaskDelay(pdMS_TO_TICKS(10));
+        }
+    }
+    
+    return false;
+}
+
 void scanRfidTask(void * parameter) {
   Serial.println("RFID Task gestartet");
   for(;;) {
+    // Regular watchdog reset
+    esp_task_wdt_reset();
+    yield();
+    
     // Skip scanning during write operations, but keep NFC interface active
     if (nfcReaderState != NFC_WRITING && !nfcWriteInProgress && !nfcReadingTaskSuspendRequest && !booting)
     {
@@ -1691,10 +1884,16 @@ void scanRfidTask(void * parameter) {
       uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
       uint8_t uidLength;
 
-      success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 500);
+      // Use safe tag detection instead of blocking readPassiveTargetID
+      success = safeTagDetection(uid, &uidLength);
 
       foundNfcTag(nullptr, success);
       
+      // Reset activeSpoolId immediately when no tag is detected to prevent stale autoSet
+      if (!success) {
+        activeSpoolId = "";
+      }
+      
       // As long as there is still a tag on the reader, do not try to read it again
       if (success && nfcReaderState == NFC_IDLE)
       {
@@ -1708,9 +1907,9 @@ void scanRfidTask(void * parameter) {
 
         oledShowProgressBar(0, octoEnabled?5:4, "Reading", "Detecting tag");
 
-        // Wait 1 second after tag detection to stabilize connection
-        Serial.println("Tag detected, waiting 1 second for stabilization...");
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
+        // Reduced stabilization time for better responsiveness
+        Serial.println("Tag detected, minimal stabilization...");
+        vTaskDelay(200 / portTICK_PERIOD_MS); // Reduced from 1000ms to 200ms
 
         // create Tag UID string
         String uidString = "";
@@ -1753,9 +1952,10 @@ void scanRfidTask(void * parameter) {
             
             for (uint8_t i = 4; i < 4+numPages; i++) {
               
-              if (!nfc.ntag2xx_ReadPage(i, data+(i-4) * 4))
+              if (!robustPageRead(i, data+(i-4) * 4))
               {
-                break; // Stop if reading fails
+                Serial.printf("Failed to read page %d after retries, stopping\n", i);
+                break; // Stop if reading fails after retries
               }
              
               // Check for NDEF message end
@@ -1767,8 +1967,8 @@ void scanRfidTask(void * parameter) {
 
               yield();
               esp_task_wdt_reset();
-              // Increased delay to ensure stable reading
-              vTaskDelay(pdMS_TO_TICKS(5)); // Increased from 1ms to 5ms
+              // Reduced delay for faster reading
+              vTaskDelay(pdMS_TO_TICKS(2)); // Reduced from 5ms to 2ms
             }
             
             Serial.println("Tag reading completed, starting NDEF decode...");
@@ -1789,6 +1989,9 @@ void scanRfidTask(void * parameter) {
           {
             oledShowProgressBar(1, 1, "Failure", "Tag read error");
             nfcReaderState = NFC_READ_ERROR;
+            // Reset activeSpoolId when tag reading fails to prevent autoSet
+            activeSpoolId = "";
+            Serial.println("Tag read failed - activeSpoolId reset to prevent autoSet");
           }
         }
         else
@@ -1796,6 +1999,9 @@ void scanRfidTask(void * parameter) {
           //TBD: Show error here?!
           oledShowProgressBar(1, 1, "Failure", "Unkown tag type");
           Serial.println("This doesn't seem to be an NTAG2xx tag (UUID length != 7 bytes)!");
+          // Reset activeSpoolId when tag type is unknown to prevent autoSet
+          activeSpoolId = "";
+          Serial.println("Unknown tag type - activeSpoolId reset to prevent autoSet");
         }
       }
 
@@ -1815,10 +2021,13 @@ void scanRfidTask(void * parameter) {
         Serial.println("Tag nach erfolgreichem Lesen entfernt - bereit für nächsten Tag");
       }
 
-      // Add a longer pause after successful reading to prevent immediate re-reading
+      // Add a pause after successful reading to prevent immediate re-reading
       if (nfcReaderState == NFC_READ_SUCCESS) {
-        Serial.println("Tag erfolgreich gelesen - warte 5 Sekunden vor nächstem Scan");
-        vTaskDelay(5000 / portTICK_PERIOD_MS); // 5 second pause
+        Serial.println("Tag erfolgreich gelesen - warte 3 Sekunden vor nächstem Scan");
+        vTaskDelay(3000 / portTICK_PERIOD_MS); // Reduced from 5 seconds to 3 seconds
+      } else {
+        // Faster scanning when no tag or idle state
+        vTaskDelay(150 / portTICK_PERIOD_MS); // Faster scan interval
       }
 
       // aktualisieren der Website wenn sich der Status ändert

src/nfc.h

@@ -17,6 +17,7 @@ void startNfc();
 void scanRfidTask(void * parameter);
 void startWriteJsonToTag(const bool isSpoolTag, const char* payload);
 bool quickSpoolIdCheck(String uidString);
+bool readCompleteJsonForFastPath(); // Read complete JSON data for fast-path web interface display
 
 extern TaskHandle_t RfidReaderTask;
 extern String nfcJsonData;

src/scale.cpp

@@ -13,6 +13,21 @@ TaskHandle_t ScaleTask;
 
 int16_t weight = 0;
 
+// Weight stabilization variables
+#define MOVING_AVERAGE_SIZE 8           // Reduced from 20 to 8 for faster response
+#define LOW_PASS_ALPHA 0.3f            // Increased from 0.15 to 0.3 for faster tracking
+#define DISPLAY_THRESHOLD 0.3f         // Reduced from 0.5 to 0.3g for more responsive display
+#define API_THRESHOLD 1.5f             // Reduced from 2.0 to 1.5g for faster API actions
+#define MEASUREMENT_INTERVAL_MS 30     // Reduced from 50ms to 30ms for faster updates
+
+float weightBuffer[MOVING_AVERAGE_SIZE];
+uint8_t bufferIndex = 0;
+bool bufferFilled = false;
+float filteredWeight = 0.0f;
+int16_t lastDisplayedWeight = 0;
+int16_t lastStableWeight = 0;        // For API/action triggering
+unsigned long lastMeasurementTime = 0;
+
 uint8_t weigthCouterToApi = 0;
 uint8_t scale_tare_counter = 0;
 bool scaleTareRequest = false;
@@ -21,6 +36,93 @@ bool scaleCalibrated;
 bool autoTare = true;
 bool scaleCalibrationActive = false;
 
+// ##### Weight stabilization functions #####
+
+/**
+ * Reset weight filter buffer - call after tare or calibration
+ */
+void resetWeightFilter() {
+  bufferIndex = 0;
+  bufferFilled = false;
+  filteredWeight = 0.0f;
+  lastDisplayedWeight = 0;
+  lastStableWeight = 0;            // Reset stable weight for API actions
+  
+  // Initialize buffer with zeros
+  for (int i = 0; i < MOVING_AVERAGE_SIZE; i++) {
+    weightBuffer[i] = 0.0f;
+  }
+}
+
+/**
+ * Calculate moving average from weight buffer
+ */
+float calculateMovingAverage() {
+  float sum = 0.0f;
+  int count = bufferFilled ? MOVING_AVERAGE_SIZE : bufferIndex;
+  
+  for (int i = 0; i < count; i++) {
+    sum += weightBuffer[i];
+  }
+  
+  return (count > 0) ? sum / count : 0.0f;
+}
+
+/**
+ * Apply low-pass filter to smooth weight readings
+ * Uses exponential smoothing: y_new = alpha * x_new + (1-alpha) * y_old
+ */
+float applyLowPassFilter(float newValue) {
+  filteredWeight = LOW_PASS_ALPHA * newValue + (1.0f - LOW_PASS_ALPHA) * filteredWeight;
+  return filteredWeight;
+}
+
+/**
+ * Process new weight reading with stabilization
+ * Returns stabilized weight value
+ */
+int16_t processWeightReading(float rawWeight) {
+  // Add to moving average buffer
+  weightBuffer[bufferIndex] = rawWeight;
+  bufferIndex = (bufferIndex + 1) % MOVING_AVERAGE_SIZE;
+  
+  if (bufferIndex == 0) {
+    bufferFilled = true;
+  }
+  
+  // Calculate moving average
+  float avgWeight = calculateMovingAverage();
+  
+  // Apply low-pass filter
+  float smoothedWeight = applyLowPassFilter(avgWeight);
+  
+  // Round to nearest gram
+  int16_t newWeight = round(smoothedWeight);
+  
+  // Update displayed weight if display threshold is reached
+  if (abs(newWeight - lastDisplayedWeight) >= DISPLAY_THRESHOLD) {
+    lastDisplayedWeight = newWeight;
+  }
+  
+  // Update global weight for API actions only if stable threshold is reached
+  int16_t weightToReturn = weight; // Default: keep current weight
+  
+  if (abs(newWeight - lastStableWeight) >= API_THRESHOLD) {
+    lastStableWeight = newWeight;
+    weightToReturn = newWeight;
+  }
+  
+  return weightToReturn;
+}
+
+/**
+ * Get current filtered weight for display purposes
+ * This returns the smoothed weight even if it hasn't triggered API actions
+ */
+int16_t getFilteredDisplayWeight() {
+  return lastDisplayedWeight;
+}
+
 // ##### Funktionen für Waage #####
 uint8_t setAutoTare(bool autoTareValue) {
   Serial.print("Set AutoTare to ");
@@ -39,6 +141,7 @@ uint8_t setAutoTare(bool autoTareValue) {
 uint8_t tareScale() {
   Serial.println("Tare scale");
   scale.tare();
+  resetWeightFilter(); // Reset stabilization filter after tare
   
   return 1;
 }
@@ -48,37 +151,61 @@ void scale_loop(void * parameter) {
   Serial.println("Scale Loop started");
   Serial.println("++++++++++++++++++++++++++++++");
 
+  // Initialize weight filter
+  resetWeightFilter();
+  lastMeasurementTime = millis();
+
   for(;;) {
-    if (scale.is_ready()) 
-    {
-      // Waage automatisch Taren, wenn zu lange Abweichung
-      if (autoTare && scale_tare_counter >= 5) 
+    unsigned long currentTime = millis();
+    
+    // Only measure at defined intervals to reduce noise
+    if (currentTime - lastMeasurementTime >= MEASUREMENT_INTERVAL_MS) {
+      if (scale.is_ready()) 
       {
-        Serial.println("Auto Tare scale");
-        scale.tare();
-        scale_tare_counter = 0;
-      }
+        // Waage automatisch Taren, wenn zu lange Abweichung
+        if (autoTare && scale_tare_counter >= 5) 
+        {
+          Serial.println("Auto Tare scale");
+          scale.tare();
+          resetWeightFilter(); // Reset filter after auto tare
+          scale_tare_counter = 0;
+        }
 
-      // 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;
-      }
+        // Waage manuell Taren
+        if (scaleTareRequest == true) 
+        {
+          Serial.println("Re-Tare scale");
+          oledShowMessage("TARE Scale");
+          vTaskDelay(pdMS_TO_TICKS(1000));
+          scale.tare();
+          resetWeightFilter(); // Reset filter after manual 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;
+        // Get raw weight reading
+        float rawWeight = scale.get_units();
+        
+        // Process weight with stabilization
+        int16_t stabilizedWeight = processWeightReading(rawWeight);
+        
+        // Update global weight variable only if it changed significantly (for API actions)
+        if (stabilizedWeight != weight) {
+          weight = stabilizedWeight;
+        }
+        
+        // Debug output for monitoring (can be removed in production)
+        static unsigned long lastDebugTime = 0;
+        if (currentTime - lastDebugTime > 2000) { // Print every 2 seconds
+          lastDebugTime = currentTime;
+        }
+        
+        lastMeasurementTime = currentTime;
       }
     }
     
-    vTaskDelay(pdMS_TO_TICKS(100));
+    vTaskDelay(pdMS_TO_TICKS(10)); // Shorter delay for more responsive loop
   }
 }
 
@@ -111,7 +238,7 @@ void start_scale(bool touchSensorConnected) {
   scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
 
   oledShowProgressBar(6, 7, DISPLAY_BOOT_TEXT, "Tare scale");
-  for (uint16_t i = 0; i < 2000; i++) {
+  for (uint16_t i = 0; i < 3000; i++) {
     yield();
     vTaskDelay(pdMS_TO_TICKS(1));
     esp_task_wdt_reset();
@@ -121,8 +248,12 @@ void start_scale(bool touchSensorConnected) {
     vTaskDelay(pdMS_TO_TICKS(5000));
   }
 
-  scale.set_scale(calibrationValue); // this value is obtained by calibrating the scale with known weights; see the README for details
-  scale.tare();
+  scale.set_scale(calibrationValue);
+  //vTaskDelay(pdMS_TO_TICKS(5000));
+  //scale.tare();
+
+  // Initialize weight stabilization filter
+  resetWeightFilter();
 
   // Display Gewicht
   oledShowWeight(0);
@@ -208,6 +339,7 @@ uint8_t calibrate_scale() {
       oledShowProgressBar(2, 3, "Scale Cal.", "Remove weight");
 
       scale.set_scale(newCalibrationValue);
+      resetWeightFilter(); // Reset filter after calibration
       for (uint16_t i = 0; i < 2000; i++) {
         yield();
         vTaskDelay(pdMS_TO_TICKS(1));

src/scale.h

@@ -9,6 +9,13 @@ uint8_t start_scale(bool touchSensorConnected);
 uint8_t calibrate_scale();
 uint8_t tareScale();
 
+// Weight stabilization functions
+void resetWeightFilter();
+float calculateMovingAverage();
+float applyLowPassFilter(float newValue);
+int16_t processWeightReading(float rawWeight);
+int16_t getFilteredDisplayWeight();
+
 extern HX711 scale;
 extern int16_t weight;
 extern uint8_t weigthCouterToApi;