feat: OpenSpool tag format support (#93)

src/ApplicationManager.cpp

@@ -364,6 +364,7 @@ void ApplicationManager::handleSpoolDetected(const AppMessage& msg) {
         else if (strcmp(s.tag_format, "TigerTag") == 0) spool.tagType = 2;
         else if (strcmp(s.tag_format, "OpenTag3D") == 0) spool.tagType = 3;
         else if (strcmp(s.tag_format, "BambuTag") == 0) spool.tagType = 4;
+        else if (strcmp(s.tag_format, "OpenSpool") == 0) spool.tagType = 6;
         else spool.tagType = 0;
         display_->showSpool(spool);
     } else if (display_) {

src/ConfigHTML.h

@@ -49,6 +49,7 @@ const char CONFIG_HTML[] PROGMEM = R"rawliteral(
       <a href="/writer/openprinttag">OpenPrintTag</a>
       <a href="/writer/tigertag">TigerTag</a>
       <a href="/writer/opentag3d">OpenTag3D</a>
+      <a href="/writer/openspool">OpenSpool</a>
       <a href="/register/uid">NFC+</a>
       <a href="/update">Update</a>
       <a href="/troubleshooting">Troubleshooting</a>

src/DisplayI.h

@@ -9,7 +9,7 @@ struct DisplaySpoolData {
     char colorHex[8];        // "RRGGBB" no leading #
     float remainingWeight;   // grams
     float totalWeight;       // grams
-    uint8_t tagType;         // 0=unknown, 1=OpenPrintTag, 2=TigerTag, 3=OpenTag3D, 4=Bambu, 5=NFC+
+    uint8_t tagType;         // 0=unknown, 1=OpenPrintTag, 2=TigerTag, 3=OpenTag3D, 4=Bambu, 5=NFC+, 6=OpenSpool
 };
 
 // Display interface — implemented by LCDManager and TFTManager.

src/LandingHTML.h

@@ -21,6 +21,7 @@ const char LANDING_HTML[] PROGMEM = R"rawliteral(
       <a href="/writer/openprinttag">OpenPrintTag</a>
       <a href="/writer/tigertag">TigerTag</a>
       <a href="/writer/opentag3d">OpenTag3D</a>
+      <a href="/writer/openspool">OpenSpool</a>
       <a href="/register/uid">NFC+</a>
       <a href="/update">Update</a>
       <a href="/troubleshooting">Troubleshooting</a>
@@ -71,6 +72,12 @@ const char LANDING_HTML[] PROGMEM = R"rawliteral(
         <div class="tool-desc">Write filament data to NTAG215/216 tags using the OpenTag3D format.</div>
       </a>
 
+      <a href="/writer/openspool" class="tool-card">
+        <img src="/img/openspool.png" alt="OpenSpool" style="height:48px;border-radius:6px" />
+        <div class="tool-name">OpenSpool Writer</div>
+        <div class="tool-desc">Write filament data to NTAG215/216 tags using the OpenSpool format.</div>
+      </a>
+
       <a href="/register/uid" class="tool-card">
         <div class="tool-icon">&#128179;</div>
         <div class="tool-name">NFC+ Registration</div>

src/NFCManager.cpp

@@ -1,6 +1,7 @@
 #include "NFCManager.h"
 #include "ConversionUtils.h"
 #include "TigerTagParser.h"
+#include "OpenSpoolParser.h"
 #ifndef NATIVE_TEST
   #include "ApplicationManager.h"
   #include "HardwareNFCConnection.h"
@@ -112,6 +113,15 @@ bool NFCManager::getLastOpenTag3DData(opentag3d_t& out) {
     return valid;
 }
 
+bool NFCManager::getLastOpenSpoolData(OpenSpoolData& out) {
+    if (tagMutex == nullptr) return false;
+    if (xSemaphoreTake(tagMutex, pdMS_TO_TICKS(50)) != pdTRUE) return false;
+    bool valid = lastOpenSpoolValid_;
+    if (valid) out = lastOpenSpool_;
+    xSemaphoreGive(tagMutex);
+    return valid;
+}
+
 void NFCManager::setGenericTagSpoolInfo(const GenericTagSpoolInfo& info) {
     if (tagMutex && xSemaphoreTake(tagMutex, pdMS_TO_TICKS(50)) == pdTRUE) {
         lastGenericTagSpoolInfo_ = info;
@@ -310,10 +320,12 @@ void NFCManager::scanLoop() {
                     Serial.printf("NFCManager: Bambu Lab tag — UID=%s (encrypted, no data access)\n", scan.uid_hex);
                     sendGenericTagMessage();
                 } else if (scan.kind == TagKind::GenericUidTag) {
-                    // ISO14443A tag — try TigerTag, then OpenTag3D, fall back to UID-only
+                    // ISO14443A tag — try TigerTag, then OpenTag3D, then OpenSpool, fall back to UID-only
                     bool isTigerTag = false;
                     bool isOpenTag3D = false;
+                    bool isOpenSpool = false;
                     TigerTagData tigerData;
+                    OpenSpoolData openSpoolData;
                     opentag3d_t ot3dData;
                     memset(&tigerData, 0, sizeof(tigerData));
                     memset(&ot3dData, 0, sizeof(ot3dData));
@@ -414,6 +426,51 @@ void NFCManager::scanLoop() {
                                                 }
                                             }
                                         }
+
+                                        // Check for OpenSpool (application/json + "protocol":"openspool")
+                                        if (!isOpenTag3D) {
+                                            const char* jsonMime = "application/json";
+                                            size_t jsonMimeLen = strlen(jsonMime);
+                                            if (typeLen == jsonMimeLen &&
+                                                memcmp(pageData + ndefStart + headerSize, jsonMime, jsonMimeLen) == 0) {
+                                                uint32_t osPayloadLen = 0;
+                                                if (sr) {
+                                                    osPayloadLen = pageData[ndefStart + 2];
+                                                } else {
+                                                    osPayloadLen = ((uint32_t)pageData[ndefStart + 2] << 24) |
+                                                                   ((uint32_t)pageData[ndefStart + 3] << 16) |
+                                                                   ((uint32_t)pageData[ndefStart + 4] << 8) |
+                                                                   pageData[ndefStart + 5];
+                                                }
+                                                uint16_t osOffset = ndefStart + headerSize + typeLen;
+                                                uint8_t osPayload[256] = {0};
+                                                uint16_t osBytes = 0;
+
+                                                if (osOffset + osPayloadLen <= bytesRead) {
+                                                    osBytes = (uint16_t)osPayloadLen;
+                                                    if (osBytes > sizeof(osPayload)) osBytes = sizeof(osPayload);
+                                                    memcpy(osPayload, pageData + osOffset, osBytes);
+                                                } else {
+                                                    uint8_t osStartPage = 4 + (osOffset / 4);
+                                                    uint16_t osPagesNeeded = (uint16_t)((osPayloadLen + 3) / 4) + 1;
+                                                    if (osPagesNeeded > 50) osPagesNeeded = 50;
+                                                    uint8_t osExtData[256] = {0};
+                                                    uint16_t osExtRead = connection_->readISO14443Pages(
+                                                        osStartPage, (uint8_t)osPagesNeeded, osExtData, sizeof(osExtData));
+                                                    uint16_t osOffInPage = osOffset % 4;
+                                                    if (osExtRead > osOffInPage) {
+                                                        osBytes = osExtRead - osOffInPage;
+                                                        if (osBytes > osPayloadLen) osBytes = (uint16_t)osPayloadLen;
+                                                        if (osBytes > sizeof(osPayload)) osBytes = sizeof(osPayload);
+                                                        memcpy(osPayload, osExtData + osOffInPage, osBytes);
+                                                    }
+                                                }
+
+                                                if (osBytes > 0 && parseOpenSpool(osPayload, osBytes, openSpoolData)) {
+                                                    isOpenSpool = true;
+                                                }
+                                            }
+                                        }
                                     }
                                 }
                                 break;
@@ -449,14 +506,26 @@ void NFCManager::scanLoop() {
                             lastOpenTag3D_ = ot3dData;
                             lastOpenTag3DValid_ = true;
                             lastTigerTagValid_ = false;
+                            lastOpenSpoolValid_ = false;
                             Serial.printf("NFCManager: OpenTag3D detected — %s %s %.2fmm %ug\n",
                                           ot3dData.manufacturer, ot3dData.base_material,
                                           opentag3d_diameter_mm(&ot3dData), ot3dData.target_weight_g);
+                        } else if (isOpenSpool) {
+                            currentSpool.kind = TagKind::OpenSpoolTag;
+                            currentSpool.tag_data_valid = false;
+                            lastOpenSpool_ = openSpoolData;
+                            lastOpenSpoolValid_ = true;
+                            lastTigerTagValid_ = false;
+                            lastOpenTag3DValid_ = false;
+                            Serial.printf("NFCManager: OpenSpool detected — %s %s #%s\n",
+                                          openSpoolData.brand, openSpoolData.material,
+                                          openSpoolData.color_hex);
                         } else {
                             currentSpool.kind = TagKind::GenericUidTag;
                             currentSpool.tag_data_valid = false;
                             lastTigerTagValid_ = false;
                             lastOpenTag3DValid_ = false;
+                            lastOpenSpoolValid_ = false;
                         }
                         xSemaphoreGive(tagMutex);
                     } else {
@@ -467,6 +536,8 @@ void NFCManager::scanLoop() {
                         sendTigerTagMessage(tigerData);
                     } else if (isOpenTag3D) {
                         sendOpenTag3DMessage(ot3dData);
+                    } else if (isOpenSpool) {
+                        sendOpenSpoolMessage(currentSpool.spool_id, openSpoolData);
                     } else {
                         sendGenericTagMessage();
                     }
@@ -1093,6 +1164,56 @@ void NFCManager::sendOpenTag3DMessage(const opentag3d_t& ot3d) {
     ApplicationManager::getInstance().sendMessage(msg);
 }
 
+void NFCManager::sendOpenSpoolMessage(const char* uid, const OpenSpoolData& os) {
+    AppMessage msg;
+    msg.type = AppMessageType::SPOOL_DETECTED;
+    auto& s = msg.payload.spoolDetected;
+    memset(&s, 0, sizeof(s));
+
+    strncpy(s.spool_id, uid, sizeof(s.spool_id) - 1);
+    strncpy(s.manufacturer, os.brand, sizeof(s.manufacturer) - 1);
+    strncpy(s.material_name, os.material, sizeof(s.material_name) - 1);
+
+    // Material type lookup
+    s.material_type = 0;
+    if (strcasecmp(os.material, "PLA") == 0) s.material_type = OPT_MATERIAL_TYPE_PLA;
+    else if (strcasecmp(os.material, "PETG") == 0) s.material_type = OPT_MATERIAL_TYPE_PETG;
+    else if (strcasecmp(os.material, "ABS") == 0) s.material_type = OPT_MATERIAL_TYPE_ABS;
+    else if (strcasecmp(os.material, "ASA") == 0) s.material_type = OPT_MATERIAL_TYPE_ASA;
+    else if (strcasecmp(os.material, "TPU") == 0) s.material_type = OPT_MATERIAL_TYPE_TPU;
+    else if (strcasecmp(os.material, "PA") == 0 || strcasecmp(os.material, "Nylon") == 0) s.material_type = OPT_MATERIAL_TYPE_PA6;
+    else if (strcasecmp(os.material, "PC") == 0) s.material_type = OPT_MATERIAL_TYPE_PC;
+
+    // Parse color hex to RGB
+    if (strlen(os.color_hex) == 6) {
+        unsigned int r, g, b;
+        if (sscanf(os.color_hex, "%02x%02x%02x", &r, &g, &b) == 3) {
+            s.primary_color[0] = (uint8_t)r;
+            s.primary_color[1] = (uint8_t)g;
+            s.primary_color[2] = (uint8_t)b;
+            s.primary_color[3] = 255;
+            s.has_color = true;
+        }
+    }
+
+    s.min_print_temp = os.min_temp;
+    s.max_print_temp = os.max_temp;
+
+    strncpy(s.tag_format, "OpenSpool", sizeof(s.tag_format) - 1);
+    s.spoolman_id = -1;
+
+    Serial.println("--- OpenSpool SpoolDetected payload ---");
+    Serial.printf("  uid:          %s\n", s.spool_id);
+    Serial.printf("  brand:        %s\n", s.manufacturer);
+    Serial.printf("  material:     %s\n", s.material_name);
+    Serial.printf("  color:        #%s\n", os.color_hex);
+    Serial.printf("  nozzle:       %d-%d°C\n", s.min_print_temp, s.max_print_temp);
+    Serial.printf("  version:      %s\n", os.version);
+    Serial.println("---------------------------------------");
+
+    ApplicationManager::getInstance().sendMessage(msg);
+}
+
 TagScanResult NFCManager::classifyTag(const uint8_t* uid, uint8_t uid_length) {
     TagScanResult result;
     result.present = true;
@@ -1651,6 +1772,91 @@ bool NFCManager::executeWrite(const NFCWriteRequest& request) {
         return ok;
     }
 
+    // Handle WRITE_OPENSPOOL — write NDEF-wrapped JSON payload to NTAG pages
+    if (request.type == NFCWriteType::WRITE_OPENSPOOL) {
+        if (xSemaphoreTake(tagMutex, pdMS_TO_TICKS(100)) != pdTRUE) {
+            Serial.println("NFCManager: WRITE_OPENSPOOL - could not acquire tagMutex");
+            return false;
+        }
+        if (request.expected_spool_id[0] != '\0' &&
+            strcmp(currentSpool.spool_id, request.expected_spool_id) != 0) {
+            xSemaphoreGive(tagMutex);
+            Serial.println("NFCManager: WRITE_OPENSPOOL rejected - UID mismatch");
+            return false;
+        }
+        xSemaphoreGive(tagMutex);
+
+        if (!rawWritePending_ || rawWriteBufferSize_ == 0) {
+            Serial.println("NFCManager: WRITE_OPENSPOOL - no raw data available");
+            return false;
+        }
+
+        const uint8_t* jsonPayload = rawWriteBuffer_;
+        uint16_t payloadLen = (uint16_t)rawWriteBufferSize_;
+        rawWritePending_ = false;
+
+        const char* mime = "application/json";
+        uint8_t mimeLen = (uint8_t)strlen(mime);
+        bool sr = (payloadLen <= 255);
+        uint8_t ndefHeaderSize = 2 + (sr ? 1 : 4);
+        uint16_t ndefRecordLen = ndefHeaderSize + mimeLen + payloadLen;
+
+        bool longTlv = (ndefRecordLen > 254);
+        uint16_t tlvHeaderSize = 1 + (longTlv ? 3 : 1);
+        uint16_t totalSize = tlvHeaderSize + ndefRecordLen + 1;
+
+        uint8_t ndefBuf[256];
+        if (totalSize > sizeof(ndefBuf)) {
+            Serial.printf("NFCManager: WRITE_OPENSPOOL - NDEF too large (%u bytes)\n", totalSize);
+            return false;
+        }
+
+        uint16_t idx = 0;
+        ndefBuf[idx++] = 0x03;
+        if (longTlv) {
+            ndefBuf[idx++] = 0xFF;
+            ndefBuf[idx++] = (uint8_t)(ndefRecordLen >> 8);
+            ndefBuf[idx++] = (uint8_t)(ndefRecordLen & 0xFF);
+        } else {
+            ndefBuf[idx++] = (uint8_t)ndefRecordLen;
+        }
+
+        uint8_t ndefFlags = 0xC0 | 0x02;
+        if (sr) ndefFlags |= 0x10;
+        ndefBuf[idx++] = ndefFlags;
+        ndefBuf[idx++] = mimeLen;
+        if (sr) {
+            ndefBuf[idx++] = (uint8_t)payloadLen;
+        } else {
+            ndefBuf[idx++] = (uint8_t)((payloadLen >> 24) & 0xFF);
+            ndefBuf[idx++] = (uint8_t)((payloadLen >> 16) & 0xFF);
+            ndefBuf[idx++] = (uint8_t)((payloadLen >> 8) & 0xFF);
+            ndefBuf[idx++] = (uint8_t)(payloadLen & 0xFF);
+        }
+
+        memcpy(ndefBuf + idx, mime, mimeLen);
+        idx += mimeLen;
+        memcpy(ndefBuf + idx, jsonPayload, payloadLen);
+        idx += payloadLen;
+        ndefBuf[idx++] = 0xFE;
+
+        while (idx % 4 != 0) ndefBuf[idx++] = 0x00;
+
+        uint8_t pagesNeeded = (uint8_t)(idx / 4);
+        Serial.printf("NFCManager: WRITE_OPENSPOOL - writing %u bytes (%u pages)\n", idx, pagesNeeded);
+        bool ok = connection_->writeISO14443Pages(4, pagesNeeded, ndefBuf, idx);
+        if (ok) {
+            Serial.printf("NFCManager: WRITE_OPENSPOOL succeeded (%u bytes, %u pages)\n", idx, pagesNeeded);
+            if (xSemaphoreTake(tagMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
+                currentSpool.present = false;
+                xSemaphoreGive(tagMutex);
+            }
+        } else {
+            Serial.println("NFCManager: WRITE_OPENSPOOL failed");
+        }
+        return ok;
+    }
+
     // Handle WRITE_ATOMIC — build complete CBOR map from sidecar fields, write once
     if (request.type == NFCWriteType::WRITE_ATOMIC) {
         if (!atomicWriteFields_.pending) {

src/NFCManager.h

@@ -12,6 +12,7 @@
 #include "NFCTypes.h"
 #include "NFCConnectionI.h"
 #include "TigerTagParser.h"
+#include "OpenSpoolParser.h"
 #include "opentag3d_lib.h"
 
 // Sidecar for WRITE_ATOMIC: filled by HTTP handler, consumed by scan task.
@@ -75,6 +76,7 @@ class NFCManager {
     bool getCurrentSpoolState(CurrentSpoolState& out);
     bool getLastTigerTagData(TigerTagData& out);
     bool getLastOpenTag3DData(opentag3d_t& out);
+    bool getLastOpenSpoolData(OpenSpoolData& out);
     // Returns reader identification string (e.g. "PN5180 v3.4", "PN532 v1.6")
     bool getNfcReaderInfo(char* buf, size_t len) const;
     void pauseScanTask();
@@ -123,6 +125,7 @@ class NFCManager {
     void sendGenericTagMessage();
     void sendTigerTagMessage(const TigerTagData& tt);
     void sendOpenTag3DMessage(const opentag3d_t& ot3d);
+    void sendOpenSpoolMessage(const char* uid, const OpenSpoolData& data);
     void sendTagRemovedMessage();
     void processWriteQueue();
     bool executeWrite(const NFCWriteRequest& request);
@@ -153,6 +156,8 @@ class NFCManager {
     // Last parsed OpenTag3D data (retained for /api/status)
     opentag3d_t lastOpenTag3D_;
     bool lastOpenTag3DValid_ = false;
+    OpenSpoolData lastOpenSpool_;
+    bool lastOpenSpoolValid_ = false;
 
     // Resolved Spoolman data for the current generic UID tag
     GenericTagSpoolInfo lastGenericTagSpoolInfo_ = {};

src/NFCTypes.h

@@ -18,6 +18,7 @@ enum class TagKind : uint8_t {
     OpenTag3D,      // OpenTag3D format — ISO14443A
     TigerTag,       // TigerTag format — ISO14443A (NTAG213/215/216)
     BambuTag,       // Bambu Lab spool — MIFARE Classic (encrypted, UID-only)
+    OpenSpoolTag,   // OpenSpool format — ISO14443A (NTAG215/216, NDEF JSON)
     BlankTag,
     Unsupported
 };

src/NFCWriteTypes.h

@@ -26,6 +26,7 @@ enum class NFCWriteType : uint8_t {
     SET_MAX_BED_TEMP,     // Set maximum bed temperature (°C)
     WRITE_TIGERTAG,       // Write 40-byte TigerTag binary to NTAG pages 4-13
     WRITE_OPENTAG3D,      // Write NDEF-wrapped OpenTag3D payload to NTAG pages
+    WRITE_OPENSPOOL,      // Write NDEF-wrapped OpenSpool JSON payload to NTAG pages
     WRITE_ATOMIC,         // Atomic single-pass write: build complete CBOR map, write once
 };
 

src/OpenPrintTagWriterHTML.h

@@ -25,6 +25,7 @@ const char OPENPRINTTAG_WRITER_HTML[] PROGMEM = R"rawliteral(
       <a href="/writer/openprinttag">OpenPrintTag</a>
       <a href="/writer/tigertag">TigerTag</a>
       <a href="/writer/opentag3d">OpenTag3D</a>
+      <a href="/writer/openspool">OpenSpool</a>
       <a href="/register/uid">NFC+</a>
       <a href="/update">Update</a>
       <a href="/troubleshooting">Troubleshooting</a>