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

- Removed unused function for getting current date in ISO8601 format.
- Updated JSON key names in filament and spool creation to use shorter identifiers.
- Enhanced NFC interface reset procedure with detailed logging and retry mechanisms.
- Improved stability checks after write operations to ensure NFC interface readiness.
- Added comprehensive error handling and diagnostics for NFC read/write operations.
- Streamlined the quick spool ID check to optimize performance and reliability.

CHANGELOG.md

@@ -1,5 +1,218 @@
 # Changelog
 
+## [2.0.0-beta2] - 2025-08-29
+### Added
+- add Manufacturer Tags support documentation in German and English
+
+### Changed
+- update platformio.ini for beta version v2.0.0-beta2
+- clarify product URL description for Manufacturer Tags in German and English documentation
+
+### Fixed
+- increase delay in start_scale function for improved stability
+
+
+## [2.0.0-beta1] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v2.0.0-beta1
+- update version to 2.0.0 in platformio.ini
+
+
+## [1.5.12-beta18] - 2025-08-29
+### Added
+- add display delay for vendor, filament, and spool creation processes
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta18
+
+### Fixed
+- replace progress bar with message display for remaining weight in sendToApi function
+
+
+## [1.5.12-beta17] - 2025-08-29
+### Added
+- add progress bar updates for vendor and filament creation processes
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta17
+- optimize page limit detection and remove redundant verification code
+
+### Fixed
+- update vendor check to use shorthand key in payload
+
+
+## [1.5.12-beta16] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta16
+- Refactor NFC interface handling and improve error diagnostics
+
+
+## [1.5.12-beta15] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta15
+- enhance NFC write operation diagnostics and improve error handling
+- enhance NFC write operation handling and prevent tag operations during write
+
+
+## [1.5.12-beta14] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta14
+- optimize JSON payload structure and enhance NFC tag validation process
+
+
+## [1.5.12-beta13] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta13
+- reorganize clearUserDataArea function for improved clarity and safety
+
+
+## [1.5.12-beta12] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta12
+
+### Fixed
+- reset NFC state on API send failure to allow retry
+- update createdFilamentId reset value to 65535 for better task handling
+- update createdVendorId reset value to 65535 for improved API handling
+
+
+## [1.5.12-beta11] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta11
+
+### Fixed
+- update spoolman ID reset values to 65535 for better API response detection
+
+
+## [1.5.12-beta10] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta10
+- streamline task creation in checkVendor and checkFilament functions
+
+
+## [1.5.12-beta9] - 2025-08-29
+### Added
+- update vendor and filament ID handling to use NULL and add delays for stability
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta9
+
+
+## [1.5.12-beta8] - 2025-08-29
+### Added
+- add delay to ensure proper setting of vendor and filament IDs after API state changes
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta8
+
+### Fixed
+- correct color_hex key usage and comment out unused date fields in spool creation
+
+
+## [1.5.12-beta7] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta7
+
+### Fixed
+- improve API state handling and vendor name formatting
+
+
+## [1.5.12-beta6] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta6
+- improve task synchronization in vendor, filament, and spool creation functions
+
+
+## [1.5.12-beta5] - 2025-08-29
+### Added
+- enhance NDEF decoding with detailed validation and debugging output
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta5
+
+
+## [1.5.12-beta4] - 2025-08-29
+### Added
+- enhance NDEF decoding to validate structure and extract JSON payload
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta4
+
+
+## [1.5.12-beta3] - 2025-08-29
+### Added
+- add logging for decoded JSON data in NFC processing
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta3
+
+
+## [1.5.12-beta2] - 2025-08-29
+### Changed
+- update platformio.ini for beta version v1.5.12-beta2
+
+### Fixed
+- enhance filament creation logic to include dynamic comments based on payload
+
+
+## [1.5.12-beta1] - 2025-08-28
+### Added
+- implement filament and spool creation in Spoolman API
+- Add JSON structure comments for filament and spool creation
+- Add vendor and filament management to API; implement recycling factory handling in NFC
+
+### Changed
+- update platformio.ini for beta version v1.5.12-beta1
+- Merge branch 'main' into recyclingfabrik
+- Merge branch 'main' into recyclingfabrik
+
+
+## [1.5.12] - 2025-08-28
+### Added
+- add numbering to update sections in upgrade.html refactor: improve readability of checkSpoolmanInstance function
+
+### Changed
+- update platformio.ini for version v1.5.12
+- clean up library dependencies in platformio.ini
+
+
+## [1.5.11-beta4] - 2025-08-28
+### Changed
+- update platformio.ini for beta version v1.5.11-beta4
+
+### Fixed
+- remove debug logging from checkSpoolmanInstance function
+
+
+## [1.5.11-beta3] - 2025-08-28
+### Added
+- add logging for spoolman status in checkSpoolmanInstance function
+
+### Changed
+- update platformio.ini for beta version v1.5.11-beta3
+
+
+## [1.5.11-beta2] - 2025-08-28
+### Added
+- add logging for healthy spoolman instance check
+
+### Changed
+- update platformio.ini for beta version v1.5.11-beta2
+
+
+## [1.5.11-beta1] - 2025-08-28
+### Changed
+- update platformio.ini for beta version v1.5.11-beta1
+
+### Fixed
+- adjust spacing in loop structure and enable tare function in scale loop
+
+
+## [1.5.11] - 2025-08-27
+### Changed
+- update platformio.ini for version v1.5.11
+
+
 ## [1.5.10] - 2025-08-27
 ### Added
 - improve weight processing logic and add auto-send feature for Bambu spool ID

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.

html/upgrade.html

@@ -56,7 +56,7 @@
 
         <div class="update-options">
             <div class="update-section">
-                <h2>Firmware Update</h2>
+                <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">
@@ -67,7 +67,7 @@
             </div>
 
             <div class="update-section">
-                <h2>Webpage Update</h2>
+                <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">

platformio.ini

@@ -9,8 +9,8 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [common]
-version = "1.5.10"
-to_old_version = "1.5.0"
+version = "2.0.0-beta2"
+to_old_version = "2.0.0"
 
 ##
 [env:esp32dev]
@@ -23,10 +23,7 @@ monitor_speed = 115200
 lib_deps =
     tzapu/WiFiManager @ ^2.0.17
     https://github.com/me-no-dev/ESPAsyncWebServer.git#master
-    #me-no-dev/AsyncTCP @ ^1.1.1
     https://github.com/esphome/AsyncTCP.git
-    #mathieucarbou/ESPAsyncWebServer @ ^3.6.0
-    #esp32async/AsyncTCP @ ^3.3.5
     bogde/HX711 @ ^0.7.5
     adafruit/Adafruit SSD1306 @ ^2.5.13
     adafruit/Adafruit GFX Library @ ^1.11.11
@@ -36,7 +33,6 @@ lib_deps =
     digitaldragon/SSLClient @ ^1.3.2
     
 ; Enable SPIFFS upload
-#board_build.filesystem = spiffs
 board_build.filesystem = littlefs
 ; Update partition settings
 board_build.partitions = partitions.csv

src/api.cpp

@@ -5,8 +5,10 @@
 #include <Preferences.h>
 #include "debug.h"
 #include "scale.h"
-
+#include "nfc.h"
+#include <time.h>
 volatile spoolmanApiStateType spoolmanApiState = API_IDLE;
+
 //bool spoolman_connected = false;
 String spoolmanUrl = "";
 bool octoEnabled = false;
@@ -14,6 +16,11 @@ bool sendOctoUpdate = false;
 String octoUrl = "";
 String octoToken = "";
 uint16_t remainingWeight = 0;
+uint16_t createdVendorId = 0;  // Store ID of newly created vendor
+uint16_t foundVendorId = 0;    // Store ID of found vendor
+uint16_t foundFilamentId = 0;  // Store ID of found filament
+uint16_t createdFilamentId = 0;  // Store ID of newly created filament
+uint16_t createdSpoolId = 0;  // Store ID of newly created spool
 bool spoolmanConnected = false;
 bool spoolmanExtraFieldsChecked = false;
 TaskHandle_t* apiTask;
@@ -103,7 +110,7 @@ void sendToApi(void *parameter) {
 
     // Wait until API is IDLE
     while(spoolmanApiState != API_IDLE){
-        Serial.println("Waiting!");
+        vTaskDelay(100 / portTICK_PERIOD_MS);
         yield();
     }
     spoolmanApiState = API_TRANSMITTING;
@@ -129,10 +136,11 @@ void sendToApi(void *parameter) {
     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);
 
     if (httpCode == HTTP_CODE_OK) {
-        Serial.println("Spoolman erfolgreich aktualisiert");
+        Serial.println("Spoolman Abfrage erfolgreich");
 
         // Restgewicht der Spule auslesen
         String payload = http.getString();
@@ -150,7 +158,8 @@ void sendToApi(void *parameter) {
                 //oledShowMessage("Remaining: " + String(remaining_weight) + "g");
                 if(!octoEnabled){
                     // TBD: Do not use Strings...
-                    oledShowProgressBar(1, 1, "Spool Tag", ("Done: " + String(remainingWeight) + " g remain").c_str());
+                    //oledShowProgressBar(1, 1, "Spool Tag", ("Done: " + String(remainingWeight) + " g remain").c_str());
+                    oledShowMessage("Remaining: " + String(remainingWeight) + "g");
                     remainingWeight = 0;
                 }else{
                     // ocoto is enabled, trigger octo update
@@ -165,9 +174,90 @@ void sendToApi(void *parameter) {
                 break;
             case API_REQUEST_OCTO_SPOOL_UPDATE:
                 // TBD: Do not use Strings...
-                oledShowProgressBar(5, 5, "Spool Tag", ("Done: " + String(remainingWeight) + " g remain").c_str());
+                //oledShowProgressBar(5, 5, "Spool Tag", ("Done: " + String(remainingWeight) + " g remain").c_str());
+                oledShowMessage("Remaining: " + String(remainingWeight) + "g");
                 remainingWeight = 0;
                 break;
+            case API_REQUEST_VENDOR_CREATE:
+                Serial.println("Vendor successfully created!");
+                createdVendorId = doc["id"].as<uint16_t>();
+                Serial.print("Created Vendor ID: ");
+                Serial.println(createdVendorId);
+                oledShowProgressBar(1, 1, "Vendor", "Created!");
+                break;
+            case API_REQUEST_VENDOR_CHECK:
+                if (doc.isNull() || doc.size() == 0) {
+                    Serial.println("Vendor not found in response");
+                    foundVendorId = 0;
+                } else {
+                    foundVendorId = doc[0]["id"].as<uint16_t>();
+                    Serial.print("Found Vendor ID: ");
+                    Serial.println(foundVendorId);
+                }
+                break;
+            case API_REQUEST_FILAMENT_CHECK:
+                if (doc.isNull() || doc.size() == 0) {
+                    Serial.println("Filament not found in response");
+                    foundFilamentId = 0;
+                } else {
+                    foundFilamentId = doc[0]["id"].as<uint16_t>();
+                    Serial.print("Found Filament ID: ");
+                    Serial.println(foundFilamentId);
+                }
+                break;
+            case API_REQUEST_FILAMENT_CREATE:
+                Serial.println("Filament successfully created!");
+                createdFilamentId = doc["id"].as<uint16_t>();
+                Serial.print("Created Filament ID: ");
+                Serial.println(createdFilamentId);
+                oledShowProgressBar(1, 1, "Filament", "Created!");
+                break;
+            case API_REQUEST_SPOOL_CREATE:
+                Serial.println("Spool successfully created!");
+                createdSpoolId = doc["id"].as<uint16_t>();
+                Serial.print("Created Spool ID: ");
+                Serial.println(createdSpoolId);
+                oledShowProgressBar(1, 1, "Spool", "Created!");
+                break;
+            }
+        }
+        doc.clear();
+    } else if (httpCode == HTTP_CODE_CREATED) {
+        Serial.println("Spoolman erfolgreich erstellt");
+        
+        // Parse response for created resources
+        String payload = http.getString();
+        JsonDocument doc;
+        DeserializationError error = deserializeJson(doc, payload);
+        if (error) {
+            Serial.print("Fehler beim Parsen der JSON-Antwort: ");
+            Serial.println(error.c_str());
+        } else {
+            switch(requestType){
+            case API_REQUEST_VENDOR_CREATE:
+                Serial.println("Vendor successfully created!");
+                createdVendorId = doc["id"].as<uint16_t>();
+                Serial.print("Created Vendor ID: ");
+                Serial.println(createdVendorId);
+                oledShowProgressBar(1, 1, "Vendor", "Created!");
+                break;
+            case API_REQUEST_FILAMENT_CREATE:
+                Serial.println("Filament successfully created!");
+                createdFilamentId = doc["id"].as<uint16_t>();
+                Serial.print("Created Filament ID: ");
+                Serial.println(createdFilamentId);
+                oledShowProgressBar(1, 1, "Filament", "Created!");
+                break;
+            case API_REQUEST_SPOOL_CREATE:
+                Serial.println("Spool successfully created!");
+                createdSpoolId = doc["id"].as<uint16_t>();
+                Serial.print("Created Spool ID: ");
+                Serial.println(createdSpoolId);
+                oledShowProgressBar(1, 1, "Spool", "Created!");
+                break;
+            default:
+                // Handle other create operations if needed
+                break;
             }
         }
         doc.clear();
@@ -235,11 +325,19 @@ void sendToApi(void *parameter) {
         case API_REQUEST_BAMBU_UPDATE:
             oledShowProgressBar(1, 1, "Failure!", "Bambu update");
             break;
+        case API_REQUEST_VENDOR_CREATE:
+            oledShowProgressBar(1, 1, "Failure!", "Vendor create");
+            break;
+        case API_REQUEST_FILAMENT_CREATE:
+            oledShowProgressBar(1, 1, "Failure!", "Filament create");
+            break;
+        case API_REQUEST_SPOOL_CREATE:
+            oledShowProgressBar(1, 1, "Failure!", "Spool create");
+            break;
         }
         Serial.println("Fehler beim Senden an Spoolman! HTTP Code: " + String(httpCode));
-
-        // TBD: really required?
         vTaskDelay(2000 / portTICK_PERIOD_MS);
+        nfcReaderState = NFC_IDLE; // Reset NFC state to allow retry
     }
 
     http.end();
@@ -504,6 +602,392 @@ bool updateSpoolBambuData(String payload) {
     return true;
 }
 
+// #### Brand Filament
+uint16_t createVendor(String vendor) {
+    oledShowProgressBar(2, 5, "New Brand", "Create new Vendor");
+
+    // Create new vendor in Spoolman database using task system
+    // Note: Due to async nature, the ID will be stored in createdVendorId global variable
+    // Note: This function assumes that the caller has already ensured API is IDLE
+    createdVendorId = 65535; // Reset previous value
+    
+    String spoolsUrl = spoolmanUrl + apiUrl + "/vendor";
+    Serial.print("Create vendor with URL: ");
+    Serial.println(spoolsUrl);
+
+    // Create JSON payload for vendor creation
+    JsonDocument vendorDoc;
+    vendorDoc["name"] = vendor;
+    vendorDoc["comment"] = "automatically generated";
+    vendorDoc["external_id"] = vendor;
+
+    String vendorPayload;
+    serializeJson(vendorDoc, vendorPayload);
+    Serial.print("Vendor Payload: ");
+    Serial.println(vendorPayload);
+
+    SendToApiParams* params = new SendToApiParams();
+    if (params == nullptr) {
+        Serial.println("Fehler: Kann Speicher für Task-Parameter nicht allokieren.");
+        vendorDoc.clear();
+        return 0;
+    }
+    params->requestType = API_REQUEST_VENDOR_CREATE;
+    params->httpType = "POST";
+    params->spoolsUrl = spoolsUrl;
+    params->updatePayload = vendorPayload;
+
+    // Create task without additional API state check since caller ensures synchronization
+    BaseType_t result = xTaskCreate(
+        sendToApi,                // Task-Funktion
+        "SendToApiTask",          // Task-Name
+        6144,                     // Stackgröße in Bytes
+        (void*)params,            // Parameter
+        0,                        // Priorität
+        NULL                      // Task-Handle (nicht benötigt)
+    );
+
+    if (result != pdPASS) {
+        Serial.println("Failed to create vendor task!");
+        delete params;
+        vendorDoc.clear();
+        return 0;
+    }
+
+    vendorDoc.clear();
+    
+    // Delay for Display Bar
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+
+    // Wait for task completion and return the created vendor ID
+    // Note: createdVendorId will be set by sendToApi when response is received
+    while(createdVendorId == 65535) {
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+    
+    return createdVendorId;
+}
+
+uint16_t checkVendor(String vendor) {
+    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;
+    vendorName.trim();
+    vendorName.replace(" ", "+");
+    String spoolsUrl = spoolmanUrl + apiUrl + "/vendor?name=" + vendorName;
+    Serial.print("Check vendor with URL: ");
+    Serial.println(spoolsUrl);
+
+    SendToApiParams* params = new SendToApiParams();
+    if (params == nullptr) {
+        Serial.println("Fehler: Kann Speicher für Task-Parameter nicht allokieren.");
+        return 0;
+    }
+    params->requestType = API_REQUEST_VENDOR_CHECK;
+    params->httpType = "GET";
+    params->spoolsUrl = spoolsUrl;
+    params->updatePayload = ""; // Empty for GET request
+
+    // Check if API is idle before creating task
+    while (spoolmanApiState != API_IDLE)
+    {
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+    }
+    
+    // Erstelle die Task
+    BaseType_t result = xTaskCreate(
+        sendToApi,                // Task-Funktion
+        "SendToApiTask",          // Task-Name
+        6144,                     // Stackgröße in Bytes
+        (void*)params,            // Parameter
+        0,                        // Priorität
+        NULL                      // Task-Handle (nicht benötigt)
+    );
+    
+    // Wait until foundVendorId is updated by the API response (not 65535 anymore)
+    while (foundVendorId == 65535)
+    {
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+
+    // Check if vendor was found
+    if (foundVendorId == 0) {
+        Serial.println("Vendor not found, creating new vendor...");
+        uint16_t vendorId = createVendor(vendor);
+        if (vendorId == 0) {
+            Serial.println("Failed to create vendor, returning 0.");
+            return 0; // Failed to create vendor
+        } else {
+            Serial.println("Vendor created with ID: " + String(vendorId));
+            return vendorId;
+        }
+    } else {
+        Serial.println("Vendor found: " + vendor);
+        Serial.print("Vendor ID: ");
+        Serial.println(foundVendorId);
+        return foundVendorId;
+    }
+}
+
+uint16_t createFilament(uint16_t vendorId, const JsonDocument& payload) {
+    oledShowProgressBar(4, 5, "New Brand", "Create Filament");
+
+    // Create new filament in Spoolman database using task system
+    // Note: Due to async nature, the ID will be stored in createdFilamentId global variable
+    // Note: This function assumes that the caller has already ensured API is IDLE
+    createdFilamentId = 65535; // Reset previous value
+    
+    String spoolsUrl = spoolmanUrl + apiUrl + "/filament";
+    Serial.print("Create filament with URL: ");
+    Serial.println(spoolsUrl);
+
+    // Create JSON payload for filament creation
+    JsonDocument filamentDoc;
+    filamentDoc["name"] = payload["cn"].as<String>();
+    filamentDoc["vendor_id"] = String(vendorId);
+    filamentDoc["material"] = payload["t"].as<String>();
+    filamentDoc["density"] = (payload["de"].is<String>() && payload["de"].as<String>().length() > 0) ? payload["de"].as<String>() : "1.24";
+    filamentDoc["diameter"] = (payload["di"].is<String>() && payload["di"].as<String>().length() > 0) ? payload["di"].as<String>() : "1.75";
+    filamentDoc["weight"] = String(weight);
+    filamentDoc["spool_weight"] = payload["sw"].as<String>();
+    filamentDoc["article_number"] = payload["an"].as<String>();
+    filamentDoc["settings_extruder_temp"] = payload["et"].is<String>() ? payload["et"].as<String>() : "";
+    filamentDoc["settings_bed_temp"] = payload["bt"].is<String>() ? payload["bt"].as<String>() : "";
+
+    if (payload["an"].is<String>())
+    {
+        filamentDoc["external_id"] = payload["an"].as<String>();
+        filamentDoc["comment"] = payload["u"].is<String>() ? payload["u"].as<String>() + payload["an"].as<String>() : "automatically generated";
+    }
+    else
+    {
+        filamentDoc["comment"] = payload["u"].is<String>() ? payload["u"].as<String>() : "automatically generated";
+    }
+
+    if (payload["mc"].is<String>()) {
+        filamentDoc["multi_color_hexes"] = payload["mc"].as<String>();
+        filamentDoc["multi_color_direction"] = payload["mcd"].is<String>() ? payload["mcd"].as<String>() : "";
+    }
+    else
+    {
+        filamentDoc["color_hex"] = (payload["c"].is<String>() && payload["c"].as<String>().length() >= 6) ? payload["c"].as<String>() : "FFFFFF";
+    }
+
+    String filamentPayload;
+    serializeJson(filamentDoc, filamentPayload);
+    Serial.print("Filament Payload: ");
+    Serial.println(filamentPayload);
+
+    SendToApiParams* params = new SendToApiParams();
+    if (params == nullptr) {
+        Serial.println("Fehler: Kann Speicher für Task-Parameter nicht allokieren.");
+        filamentDoc.clear();
+        return 0;
+    }
+    params->requestType = API_REQUEST_FILAMENT_CREATE;
+    params->httpType = "POST";
+    params->spoolsUrl = spoolsUrl;
+    params->updatePayload = filamentPayload;
+
+    // Create task without additional API state check since caller ensures synchronization
+    BaseType_t result = xTaskCreate(
+        sendToApi,                // Task-Funktion
+        "SendToApiTask",          // Task-Name
+        6144,                     // Stackgröße in Bytes
+        (void*)params,            // Parameter
+        0,                        // Priorität
+        NULL                      // Task-Handle (nicht benötigt)
+    );
+
+    if (result != pdPASS) {
+        Serial.println("Failed to create filament task!");
+        delete params;
+        filamentDoc.clear();
+        return 0;
+    }
+
+    filamentDoc.clear();
+    
+    // Delay for Display Bar
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+
+    // Wait for task completion and return the created filament ID
+    // Note: createdFilamentId will be set by sendToApi when response is received
+    while(createdFilamentId == 65535) {
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+    
+    return createdFilamentId;
+}
+
+uint16_t checkFilament(uint16_t vendorId, const JsonDocument& payload) {
+    oledShowProgressBar(3, 5, "New Brand", "Check Filament");
+
+    // Check if filament exists using task system
+    foundFilamentId = 65535; // Reset to invalid value to detect when API response is received
+
+    String spoolsUrl = spoolmanUrl + apiUrl + "/filament?vendor.id=" + String(vendorId) + "&external_id=" + String(payload["artnr"].as<String>());
+    Serial.print("Check filament with URL: ");
+    Serial.println(spoolsUrl);
+
+    SendToApiParams* params = new SendToApiParams();
+    if (params == nullptr) {
+        Serial.println("Fehler: Kann Speicher für Task-Parameter nicht allokieren.");
+        return 0;
+    }
+    params->requestType = API_REQUEST_FILAMENT_CHECK;
+    params->httpType = "GET";
+    params->spoolsUrl = spoolsUrl;
+    params->updatePayload = ""; // Empty for GET request
+
+     // Erstelle die Task
+    BaseType_t result = xTaskCreate(
+        sendToApi,                // Task-Funktion
+        "SendToApiTask",          // Task-Name
+        6144,                     // Stackgröße in Bytes
+        (void*)params,            // Parameter
+        0,                        // Priorität
+        NULL                      // Task-Handle (nicht benötigt)
+    );
+    
+    // Wait until foundFilamentId is updated by the API response (not 65535 anymore)
+    while (foundFilamentId == 65535) {
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+
+    // Check if filament was found
+    if (foundFilamentId == 0) {
+        Serial.println("Filament not found, creating new filament...");
+        uint16_t filamentId = createFilament(vendorId, payload);
+        if (filamentId == 0) {
+            Serial.println("Failed to create filament, returning 0.");
+            return 0; // Failed to create filament
+        } else {
+            Serial.println("Filament created with ID: " + String(filamentId));
+            return filamentId;
+        }
+    } else {
+        Serial.println("Filament found for vendor ID: " + String(vendorId));
+        Serial.print("Filament ID: ");
+        Serial.println(foundFilamentId);
+        return foundFilamentId;
+    }
+}
+
+uint16_t createSpool(uint16_t vendorId, uint16_t filamentId, JsonDocument& payload, String uidString) {
+    oledShowProgressBar(5, 5, "New Brand", "Create new Spool");
+
+    // Create new spool in Spoolman database using task system
+    // Note: Due to async nature, the ID will be stored in createdSpoolId global variable
+    // Note: This function assumes that the caller has already ensured API is IDLE
+    createdSpoolId = 65535; // Reset to invalid value to detect when API response is received
+    
+    String spoolsUrl = spoolmanUrl + apiUrl + "/spool";
+    Serial.print("Create spool with URL: ");
+    Serial.println(spoolsUrl);
+
+    // Create JSON payload for spool creation
+    JsonDocument spoolDoc;
+    spoolDoc["filament_id"] = String(filamentId);
+    spoolDoc["initial_weight"] = weight > 10 ? String(weight - payload["sw"].as<int>()) : "1000";
+    spoolDoc["spool_weight"] = (payload["sw"].is<String>() && payload["sw"].as<String>().length() > 0) ? payload["sw"].as<String>() : "180";
+    spoolDoc["remaining_weight"] = spoolDoc["initial_weight"];
+    spoolDoc["lot_nr"] = (payload["an"].is<String>() && payload["an"].as<String>().length() > 0) ? payload["an"].as<String>() : "";
+    spoolDoc["comment"] = "automatically generated";
+    spoolDoc["extra"]["nfc_id"] = "\"" + uidString + "\"";
+
+    String spoolPayload;
+    serializeJson(spoolDoc, spoolPayload);
+    Serial.print("Spool Payload: ");
+    Serial.println(spoolPayload);
+    spoolDoc.clear();
+
+    SendToApiParams* params = new SendToApiParams();
+    if (params == nullptr) {
+        Serial.println("Fehler: Kann Speicher für Task-Parameter nicht allokieren.");
+        spoolDoc.clear();
+        return 0;
+    }
+    params->requestType = API_REQUEST_SPOOL_CREATE;
+    params->httpType = "POST";
+    params->spoolsUrl = spoolsUrl;
+    params->updatePayload = spoolPayload;
+
+    // Create task without additional API state check since caller ensures synchronization
+    BaseType_t result = xTaskCreate(
+        sendToApi,                // Task-Funktion
+        "SendToApiTask",          // Task-Name
+        6144,                     // Stackgröße in Bytes
+        (void*)params,            // Parameter
+        0,                        // Priorität
+        NULL                      // Task-Handle (nicht benötigt)
+    );
+
+    if (result != pdPASS) {
+        Serial.println("Failed to create spool task!");
+        delete params;
+        return 0;
+    }
+    
+    // Wait for task completion and return the created spool ID
+    // Note: createdSpoolId will be set by sendToApi when response is received
+    while(createdSpoolId == 65535) {
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+
+    // Write data to tag with startWriteJsonToTag
+    // void startWriteJsonToTag(const bool isSpoolTag, const char* payload);
+    
+    // Create optimized JSON structure with sm_id at the beginning for fast-path detection
+    JsonDocument optimizedPayload;
+    optimizedPayload["sm_id"] = String(createdSpoolId);  // Place sm_id first for fast scanning
+    optimizedPayload["b"] = payload["b"].as<String>();
+    optimizedPayload["cn"] = payload["an"].as<String>();
+    
+    String payloadString;
+    serializeJson(optimizedPayload, payloadString);
+    
+    Serial.println("Optimized JSON with sm_id first:");
+    Serial.println(payloadString);
+    
+    optimizedPayload.clear();
+    
+    nfcReaderState = NFC_IDLE;
+
+    // Delay for Display Bar
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+    
+    startWriteJsonToTag(true, payloadString.c_str());
+
+    return createdSpoolId;
+}
+
+bool createBrandFilament(JsonDocument& payload, String uidString) {
+    uint16_t vendorId = checkVendor(payload["b"].as<String>());
+    if (vendorId == 0) {
+        Serial.println("ERROR: Failed to create/find vendor");
+        return false;
+    }
+    
+    uint16_t filamentId = checkFilament(vendorId, payload);
+    if (filamentId == 0) {
+        Serial.println("ERROR: Failed to create/find filament");
+        return false;
+    }
+    
+    uint16_t spoolId = createSpool(vendorId, filamentId, payload, uidString);
+    if (spoolId == 0) {
+        Serial.println("ERROR: Failed to create spool");
+        return false;
+    }
+    
+    Serial.println("SUCCESS: Brand filament created with Spool ID: " + String(spoolId));
+    return true;
+}
+
 // #### Spoolman init
 bool checkSpoolmanExtraFields() {
     // Only check extra fields if they have not been checked before
@@ -713,9 +1197,10 @@ bool checkSpoolmanInstance() {
             Serial.println("Error contacting spoolman instance! HTTP Code: " + String(httpCode));
         }
         http.end();
-        returnValue = false;
         spoolmanApiState = API_IDLE;
-    }else{
+    }
+    else
+    {
         // If the check is skipped, return the previous status
         Serial.println("Skipping spoolman healthcheck, API is active.");
         returnValue = spoolmanConnected;

src/api.h

@@ -17,7 +17,12 @@ typedef enum {
     API_REQUEST_BAMBU_UPDATE,
     API_REQUEST_SPOOL_TAG_ID_UPDATE,
     API_REQUEST_SPOOL_WEIGHT_UPDATE,
-    API_REQUEST_SPOOL_LOCATION_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;
@@ -40,5 +45,6 @@ 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

@@ -33,6 +33,7 @@ AMSData ams_data[MAX_AMS];  // Definition des Arrays;
 bool removeBambuCredentials() {
     if (BambuMqttTask) {
         vTaskDelete(BambuMqttTask);
+        BambuMqttTask = NULL;
     }
     
     Preferences preferences;
@@ -63,6 +64,7 @@ bool removeBambuCredentials() {
 bool saveBambuCredentials(const String& ip, const String& serialnr, const String& accesscode, bool autoSend, const String& autoSendTime) {
     if (BambuMqttTask) {
         vTaskDelete(BambuMqttTask);
+        BambuMqttTask = NULL;
     }
 
     bambuCredentials.ip = ip.c_str();
@@ -593,6 +595,7 @@ void reconnect() {
                 Serial.println("Disable Bambu MQTT Task after 5 retries");
                 //vTaskSuspend(BambuMqttTask);
                 vTaskDelete(BambuMqttTask);
+                BambuMqttTask = NULL;
                 break;
             }
 
@@ -681,6 +684,7 @@ void bambu_restart() {
 
     if (BambuMqttTask) {
         vTaskDelete(BambuMqttTask);
+        BambuMqttTask = NULL;
         delay(10);
     }
     setupMqtt();

src/display.cpp

@@ -235,7 +235,7 @@ void oledShowIcon(const char* icon) {
     display.display();
 }
 
-void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char* largeText, const char* statusMessage){
+void oledShowProgressBar(const uint8_t step, const uint8_t numSteps, const char* largeText, const char* statusMessage) {
     assert(step <= numSteps);
 
     // clear data and bar area

src/main.cpp

@@ -171,7 +171,9 @@ void loop() {
       oledShowMessage("Scale not calibrated");
       vTaskDelay(1000 / portTICK_PERIOD_MS);
     }
-  }else{
+  } 
+  else 
+  {
     // Ausgabe der Waage auf Display
     if(pauseMainTask == 0)
     {

src/nfc.h

@@ -16,6 +16,7 @@ typedef enum{
 void startNfc();
 void scanRfidTask(void * parameter);
 void startWriteJsonToTag(const bool isSpoolTag, const char* payload);
+bool quickSpoolIdCheck(String uidString);
 
 extern TaskHandle_t RfidReaderTask;
 extern String nfcJsonData;
@@ -23,6 +24,7 @@ extern String activeSpoolId;
 extern String lastSpoolId;
 extern volatile nfcReaderStateType nfcReaderState;
 extern volatile bool pauseBambuMqttTask;
+extern volatile bool nfcWriteInProgress;
 extern bool tagProcessed;
 
 

src/scale.cpp

@@ -111,18 +111,20 @@ 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();
   }
 
-  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);
 

src/website.cpp

@@ -48,9 +48,15 @@ void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventTyp
     } 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