docs: update changelog and header for version v1.5.12-beta11

CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## [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

platformio.ini

@@ -9,7 +9,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [common]
-version = "1.5.12-beta4"
+version = "1.5.12-beta11"
 to_old_version = "1.5.0"
 
 ##

src/api.cpp

@@ -5,6 +5,7 @@
 #include <Preferences.h>
 #include "debug.h"
 #include "scale.h"
+#include "nfc.h"
 #include <time.h>
 volatile spoolmanApiStateType spoolmanApiState = API_IDLE;
 
@@ -121,7 +122,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;
@@ -151,7 +152,7 @@ void sendToApi(void *parameter) {
     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();
@@ -616,6 +617,7 @@ bool updateSpoolBambuData(String payload) {
 uint16_t createVendor(String 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 = 0; // Reset previous value
     
     String spoolsUrl = spoolmanUrl + apiUrl + "/vendor";
@@ -645,19 +647,18 @@ uint16_t createVendor(String vendor) {
     params->spoolsUrl = spoolsUrl;
     params->updatePayload = vendorPayload;
 
-    // Check if API is idle before creating task
-    if(spoolmanApiState == API_IDLE){
-        // 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)
-        );
-    } else {
-        Serial.println("Not spawning new task, API still active!");
+    // 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;
@@ -676,9 +677,12 @@ uint16_t createVendor(String vendor) {
 
 uint16_t checkVendor(String vendor) {
     // Check if vendor exists using task system
-    foundVendorId = 0; // Reset previous value
+    foundVendorId = 65535; // Reset to invalid value to detect when API response is received
     
-    String spoolsUrl = spoolmanUrl + apiUrl + "/vendor?name=" + vendor;
+    String vendorName = vendor;
+    vendorName.trim();
+    vendorName.replace(" ", "+");
+    String spoolsUrl = spoolmanUrl + apiUrl + "/vendor?name=" + vendorName;
     Serial.print("Check vendor with URL: ");
     Serial.println(spoolsUrl);
 
@@ -693,25 +697,25 @@ uint16_t checkVendor(String vendor) {
     params->updatePayload = ""; // Empty for GET request
 
     // Check if API is idle before creating task
-    if(spoolmanApiState == API_IDLE){
-        // 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)
-        );
-    } else {
-        Serial.println("Not spawning new task, API still active!");
-        delete params;
-        return 0;
+    while (spoolmanApiState != API_IDLE)
+    {
+        vTaskDelay(100 / portTICK_PERIOD_MS);
     }
     
-    // Wait for task completion
-    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
@@ -736,6 +740,7 @@ uint16_t checkVendor(String vendor) {
 uint16_t createFilament(uint16_t vendorId, const JsonDocument& payload) {
     // 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 = 0; // Reset previous value
     
     String spoolsUrl = spoolmanUrl + apiUrl + "/filament";
@@ -744,12 +749,12 @@ uint16_t createFilament(uint16_t vendorId, const JsonDocument& payload) {
 
     // Create JSON payload for filament creation
     JsonDocument filamentDoc;
-    filamentDoc["name"] = payload["name"].as<String>();
+    filamentDoc["name"] = payload["color_name"].as<String>();
     filamentDoc["vendor_id"] = String(vendorId);
     filamentDoc["material"] = payload["type"].as<String>();
     filamentDoc["density"] = (payload["density"].is<String>() && payload["density"].as<String>().length() > 0) ? payload["density"].as<String>() : "1.24";
     filamentDoc["diameter"] = (payload["diameter"].is<String>() && payload["diameter"].as<String>().length() > 0) ? payload["diameter"].as<String>() : "1.75";
-    filamentDoc["weight"] = payload["weight"].as<String>();
+    filamentDoc["weight"] = String(weight);
     filamentDoc["spool_weight"] = payload["spool_weight"].as<String>();
     filamentDoc["article_number"] = payload["artnr"].as<String>();
     filamentDoc["extruder_temp"] = payload["extruder_temp"].is<String>() ? payload["extruder_temp"].as<String>() : "";
@@ -771,7 +776,7 @@ uint16_t createFilament(uint16_t vendorId, const JsonDocument& payload) {
     }
     else
     {
-        filamentDoc["color_hex"] = (payload["color"].is<String>() && payload["color"].as<String>().length() >= 6) ? payload["color"].as<String>() : "FFFFFF";
+        filamentDoc["color_hex"] = (payload["color_hex"].is<String>() && payload["color_hex"].as<String>().length() >= 6) ? payload["color_hex"].as<String>() : "FFFFFF";
     }
 
     String filamentPayload;
@@ -790,19 +795,18 @@ uint16_t createFilament(uint16_t vendorId, const JsonDocument& payload) {
     params->spoolsUrl = spoolsUrl;
     params->updatePayload = filamentPayload;
 
-    // Check if API is idle before creating task
-    if(spoolmanApiState == API_IDLE){
-        // 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)
-        );
-    } else {
-        Serial.println("Not spawning new task, API still active!");
+    // 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;
@@ -821,7 +825,7 @@ uint16_t createFilament(uint16_t vendorId, const JsonDocument& payload) {
 
 uint16_t checkFilament(uint16_t vendorId, const JsonDocument& payload) {
     // Check if filament exists using task system
-    foundFilamentId = 0; // Reset previous value
+    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: ");
@@ -837,26 +841,19 @@ uint16_t checkFilament(uint16_t vendorId, const JsonDocument& payload) {
     params->spoolsUrl = spoolsUrl;
     params->updatePayload = ""; // Empty for GET request
 
-    // Check if API is idle before creating task
-    if(spoolmanApiState == API_IDLE){
-        // 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)
-        );
-    } else {
-        Serial.println("Not spawning new task, API still active!");
-        delete params;
-        return 0;
-    }
+     // 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 for task completion
-    while(spoolmanApiState != API_IDLE) {
-        vTaskDelay(100 / portTICK_PERIOD_MS);
+    // 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
@@ -881,22 +878,22 @@ uint16_t checkFilament(uint16_t vendorId, const JsonDocument& payload) {
 uint16_t createSpool(uint16_t vendorId, uint16_t filamentId, JsonDocument& payload, String uidString) {
     // Create new spool in Spoolman database using task system
     // Note: Due to async nature, the ID will be stored in createdSpoolId global variable
-    createdSpoolId = 0; // Reset previous value
+    // 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);
-    String currentDate = getCurrentDateISO8601();
+    //String currentDate = getCurrentDateISO8601();
 
     // Create JSON payload for spool creation
     JsonDocument spoolDoc;
-    spoolDoc["first_used"] = String(currentDate);
-    spoolDoc["last_used"] = String(currentDate);
+    //spoolDoc["first_used"] = String(currentDate);
+    //spoolDoc["last_used"] = String(currentDate);
     spoolDoc["filament_id"] = String(filamentId);
-    spoolDoc["initial_weight"] = weight > 10 ? String(weight) : "1000";
+    spoolDoc["initial_weight"] = weight > 10 ? String(weight-payload["spool_weight"].as<int>()) : "1000";
     spoolDoc["spool_weight"] = (payload["spool_weight"].is<String>() && payload["spool_weight"].as<String>().length() > 0) ? payload["spool_weight"].as<String>() : "180";
     spoolDoc["remaining_weight"] = (payload["weight"].is<String>() && payload["weight"].as<String>().length() > 0) ? payload["weight"].as<String>() : "1000";
-    spoolDoc["used_weight"] = "0";
     spoolDoc["lot_nr"] = (payload["lotnr"].is<String>() && payload["lotnr"].as<String>().length() > 0) ? payload["lotnr"].as<String>() : "";
     spoolDoc["comment"] = "automatically generated";
     spoolDoc["extra"]["nfc_id"] = "\"" + uidString + "\"";
@@ -918,35 +915,37 @@ uint16_t createSpool(uint16_t vendorId, uint16_t filamentId, JsonDocument& paylo
     params->spoolsUrl = spoolsUrl;
     params->updatePayload = spoolPayload;
 
-    // Check if API is idle before creating task
-    if(spoolmanApiState == API_IDLE){
-        // 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)
-        );
-    } else {
-        Serial.println("Not spawning new task, API still active!");
+    // 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(spoolmanApiState != API_IDLE) {
-        vTaskDelay(100 / portTICK_PERIOD_MS);
+    while(createdSpoolId == 65535) {
+        vTaskDelay(50 / portTICK_PERIOD_MS);
     }
 
-    // daten mit startWriteJsonToTag schreiben
+    // Write data to tag with startWriteJsonToTag
     // void startWriteJsonToTag(const bool isSpoolTag, const char* payload);
     payload["sm_id"].set(String(createdSpoolId));
     
     String payloadString;
     serializeJson(payload, payloadString);
+    
+    nfcReaderState = NFC_IDLE;
+    vTaskDelay(50 / portTICK_PERIOD_MS);
     startWriteJsonToTag(true, payloadString.c_str());
 
     return createdSpoolId;

src/nfc.cpp

@@ -206,62 +206,181 @@ uint8_t ntag2xx_WriteNDEF(const char *payload) {
 bool decodeNdefAndReturnJson(const byte* encodedMessage, String uidString) {
   oledShowProgressBar(1, octoEnabled?5:4, "Reading", "Decoding data");
 
-  // Check for NDEF TLV (Type-Length-Value) structure
-  if (encodedMessage[0] != 0x03) {
-    Serial.println("Not a valid NDEF message (missing TLV tag 0x03)");
+  // Debug: Print first 32 bytes of the raw data
+  Serial.println("Raw NDEF data (first 32 bytes):");
+  for (int i = 0; i < 32; i++) {
+    if (encodedMessage[i] < 0x10) Serial.print("0");
+    Serial.print(encodedMessage[i], HEX);
+    Serial.print(" ");
+    if ((i + 1) % 16 == 0) Serial.println();
+  }
+  Serial.println();
+
+  // Look for the NDEF TLV structure starting from the beginning
+  int tlvOffset = 0;
+  bool foundNdefTlv = false;
+  
+  // Search for NDEF TLV (0x03) in the first few bytes
+  for (int i = 0; i < 16; i++) {
+    if (encodedMessage[i] == 0x03) {
+      tlvOffset = i;
+      foundNdefTlv = true;
+      Serial.print("Found NDEF TLV at offset: ");
+      Serial.println(tlvOffset);
+      break;
+    }
+  }
+
+  if (!foundNdefTlv) {
+    Serial.println("No NDEF TLV found in tag data");
     return false;
   }
 
-  // Get the total NDEF message length from TLV
-  byte ndefMessageLength = encodedMessage[1];
+  // Get the NDEF message length from TLV
+  uint16_t ndefMessageLength = 0;
+  int ndefRecordOffset = 0;
   
-  // Skip TLV header (2 bytes) to get to NDEF record
-  const byte* ndefRecord = &encodedMessage[2];
+  if (encodedMessage[tlvOffset + 1] == 0xFF) {
+    // Extended length format: next 2 bytes contain the actual length
+    ndefMessageLength = (encodedMessage[tlvOffset + 2] << 8) | encodedMessage[tlvOffset + 3];
+    ndefRecordOffset = tlvOffset + 4; // Skip TLV tag + 0xFF + 2 length bytes
+    Serial.print("NDEF Message Length (extended): ");
+  } else {
+    // Standard length format: single byte contains the length
+    ndefMessageLength = encodedMessage[tlvOffset + 1];
+    ndefRecordOffset = tlvOffset + 2; // Skip TLV tag + 1 length byte
+    Serial.print("NDEF Message Length (standard): ");
+  }
+  Serial.println(ndefMessageLength);
+
+  // Get pointer to NDEF record
+  const byte* ndefRecord = &encodedMessage[ndefRecordOffset];
   
   // Parse NDEF record header
   byte recordHeader = ndefRecord[0];
   byte typeLength = ndefRecord[1];
   
+  Serial.print("NDEF Record Header: 0x");
+  Serial.println(recordHeader, HEX);
+  Serial.print("Type Length: ");
+  Serial.println(typeLength);
+
   // Determine payload length (can be 1 or 4 bytes depending on SR flag)
   uint32_t payloadLength = 0;
   byte payloadLengthBytes = 1;
+  byte payloadLengthOffset = 2;
   
-  // Check if Short Record (SR) flag is set
+  // Check if Short Record (SR) flag is set (bit 4)
   if (recordHeader & 0x10) { // SR flag
     payloadLength = ndefRecord[2];
     payloadLengthBytes = 1;
+    payloadLengthOffset = 2;
   } else {
     // Long record format (4 bytes for payload length)
     payloadLength = (ndefRecord[2] << 24) | (ndefRecord[3] << 16) | 
                    (ndefRecord[4] << 8) | ndefRecord[5];
     payloadLengthBytes = 4;
+    payloadLengthOffset = 2;
   }
 
-  Serial.print("NDEF Record Header: 0x");
-  Serial.println(recordHeader, HEX);
-  Serial.print("Type Length: ");
-  Serial.println(typeLength);
   Serial.print("Payload Length: ");
   Serial.println(payloadLength);
+  Serial.print("Payload Length Bytes: ");
+  Serial.println(payloadLengthBytes);
+
+  // Check for ID field (if IL flag is set)
+  byte idLength = 0;
+  if (recordHeader & 0x08) { // IL flag
+    idLength = ndefRecord[payloadLengthOffset + payloadLengthBytes];
+    Serial.print("ID Length: ");
+    Serial.println(idLength);
+  }
 
   // Calculate offset to payload
-  byte payloadOffset = 2 + payloadLengthBytes + typeLength;
+  byte payloadOffset = 1 + 1 + payloadLengthBytes + typeLength + idLength;
   
+  Serial.print("Calculated payload offset: ");
+  Serial.println(payloadOffset);
+
   // Verify we have enough data
-  if (payloadOffset + payloadLength > ndefMessageLength + 2) {
+  if (payloadOffset + payloadLength > ndefMessageLength) {
     Serial.println("Invalid NDEF structure - payload extends beyond message");
+    Serial.print("Payload offset + length: ");
+    Serial.print(payloadOffset + payloadLength);
+    Serial.print(", NDEF message length: ");
+    Serial.println(ndefMessageLength);
     return false;
   }
 
+  // Print the record type for debugging
+  Serial.print("Record Type: ");
+  for (int i = 0; i < typeLength; i++) {
+    Serial.print((char)ndefRecord[1 + 1 + payloadLengthBytes + i]);
+  }
+  Serial.println();
+
   nfcJsonData = "";
 
-  // Extract JSON payload
+  // Extract JSON payload with validation
+  uint32_t actualJsonLength = 0;
   for (uint32_t i = 0; i < payloadLength; i++) {
-    nfcJsonData += (char)ndefRecord[payloadOffset + i];
+    byte currentByte = ndefRecord[payloadOffset + i];
+    
+    // Stop at null terminator or if we find the end of JSON
+    if (currentByte == 0x00) {
+      Serial.print("Found null terminator at position: ");
+      Serial.println(i);
+      break;
+    }
+    
+    // Only add printable characters and common JSON characters
+    if (currentByte >= 32 && currentByte <= 126) {
+      nfcJsonData += (char)currentByte;
+      actualJsonLength++;
+    } else {
+      Serial.print("Skipping non-printable byte at position ");
+      Serial.print(i);
+      Serial.print(": 0x");
+      Serial.println(currentByte, HEX);
+    }
+    
+    // Check if we've reached the end of a JSON object
+    if (currentByte == '}') {
+      // Count opening and closing braces to detect complete JSON
+      int braceCount = 0;
+      for (uint32_t j = 0; j <= i; j++) {
+        if (ndefRecord[payloadOffset + j] == '{') braceCount++;
+        else if (ndefRecord[payloadOffset + j] == '}') braceCount--;
+      }
+      
+      if (braceCount == 0) {
+        Serial.print("Found complete JSON object at position: ");
+        Serial.println(i);
+        actualJsonLength = i + 1;
+        break;
+      }
+    }
   }
 
-  Serial.println("Decoded JSON Data:");
+  Serial.print("Actual JSON length extracted: ");
+  Serial.println(actualJsonLength);
+  Serial.print("Total nfcJsonData length: ");
+  Serial.println(nfcJsonData.length());
+  Serial.println("=== DECODED JSON DATA START ===");
   Serial.println(nfcJsonData);
+  Serial.println("=== DECODED JSON DATA END ===");
+  
+  // Check if JSON was truncated
+  if (nfcJsonData.length() < payloadLength && !nfcJsonData.endsWith("}")) {
+    Serial.println("WARNING: JSON payload appears to be truncated!");
+    Serial.print("Expected payload length: ");
+    Serial.println(payloadLength);
+    Serial.print("Actual extracted length: ");
+    Serial.println(nfcJsonData.length());
+  }
+  
+  // Trim any trailing whitespace or invalid characters
+  nfcJsonData.trim();
 
   // JSON-Dokument verarbeiten
   JsonDocument doc;
@@ -490,7 +609,9 @@ void scanRfidTask(void * parameter) {
 
         oledShowProgressBar(0, octoEnabled?5:4, "Reading", "Detecting tag");
 
-        //vTaskDelay(500 / portTICK_PERIOD_MS);
+        // Wait 1 second after tag detection to stabilize connection
+        Serial.println("Tag detected, waiting 1 second for stabilization...");
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
 
         // create Tag UID string
         String uidString = "";
@@ -513,24 +634,34 @@ void scanRfidTask(void * parameter) {
 
             // We probably have an NTAG2xx card (though it could be Ultralight as well)
             Serial.println("Seems to be an NTAG2xx tag (7 byte UID)");
+            Serial.print("Tag size: ");
+            Serial.print(tagSize);
+            Serial.println(" bytes");
             
             uint8_t numPages = readTagSize()/4;
+            
             for (uint8_t i = 4; i < 4+numPages; i++) {
+              
               if (!nfc.ntag2xx_ReadPage(i, data+(i-4) * 4))
               {
                 break; // Stop if reading fails
               }
+             
               // Check for NDEF message end
               if (data[(i - 4) * 4] == 0xFE) 
               {
+                Serial.println("Found NDEF message end marker");
                 break; // End of NDEF message
               }
 
               yield();
               esp_task_wdt_reset();
-              vTaskDelay(pdMS_TO_TICKS(1));
+              // Increased delay to ensure stable reading
+              vTaskDelay(pdMS_TO_TICKS(5)); // Increased from 1ms to 5ms
             }
-
+            
+            Serial.println("Tag reading completed, starting NDEF decode...");
+            
             if (!decodeNdefAndReturnJson(data, uidString)) 
             {
               oledShowProgressBar(1, 1, "Failure", "Unknown tag");
@@ -566,6 +697,18 @@ void scanRfidTask(void * parameter) {
         Serial.println("Tag entfernt");
         if (!bambuCredentials.autosend_enable) oledShowWeight(weight);
       }
+      // Reset state after successful read when tag is removed
+      else if (!success && nfcReaderState == NFC_READ_SUCCESS)
+      {
+        nfcReaderState = NFC_IDLE;
+        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
+      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
+      }
 
       // aktualisieren der Website wenn sich der Status ändert
       sendNfcData();

src/scale.cpp

@@ -48,8 +48,9 @@ void scale_loop(void * parameter) {
   Serial.println("Scale Loop started");
   Serial.println("++++++++++++++++++++++++++++++");
 
-  scale.tare();
-
+  vTaskDelay(pdMS_TO_TICKS(500));
+  scale_tare_counter = 10; // damit beim Starten der Waage automatisch getart wird
+  
   for(;;) {
     if (scale.is_ready()) 
     {