Dump a range of a bank and size the write example from the tag

Author: GOB52

examples/UnitUnified/UHF/ReadWrite/main/ReadWrite.cpp

@@ -12,6 +12,7 @@
 #include <M5UnitUnifiedRFID.h>
 #include <M5Utility.h>
 #include <wiring/m5_unit_unified_wiring.hpp>
+#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -81,19 +82,12 @@ std::string to_hex(const std::vector<uint8_t>& data)
 //! @brief Words the short write test replaces and then puts back
 constexpr uint16_t WRITE_TEST_WORDS{2};
 /*!
-  @brief Words the long write test replaces and then puts back
-  @details The most a single Write command carries. The module programs the words into the tag
-  one at a time and waits out the tag's write time for each, so this is the longest a single
-  command legitimately takes. Monza 4QT holds exactly this much user memory
+  @brief The most a single Write command carries
+  @details The module programs the words into the tag one at a time and waits out the tag's
+  write time for each, so a write of this many words is the longest a single command
+  legitimately takes. Anything longer is split by writeBank into several
  */
 constexpr uint16_t WRITE_TEST_MAX_WORDS{32};
-/*!
-  @brief Words the whole-bank write test replaces and then puts back
-  @details The full User bank of an Alien Higgs 9, 688 bits of it. More than a single Write
-  command carries, so writeBank splits it, which is the thing worth exercising here. A tag with
-  less user memory than this answers with a memory overrun and nothing is written
- */
-constexpr uint16_t WRITE_TEST_BANK_WORDS{43};
 
 /*!
   Write a stretch of User memory, read it back and put the original contents back.
@@ -128,7 +122,9 @@ void write_roundtrip(const m5::uhf::Tag& detected, const uint16_t words)
     const unsigned long read_began = m5::utility::millis();
     std::vector<uint8_t> original{};
     if (!uhf.readBank(original, m5::uhf::Bank::User, 0, words)) {
-        M5_LOGE("write %u words: this tag has no User memory to write to, or not that much of it", words);
+        // The caller sized this from what the tag holds, so a refusal here is not the bank being
+        // too small; it is the read itself failing
+        M5_LOGE("write %u words: could not read what is there now, so nothing is written", words);
         uhf.deselect();
         return;
     }
@@ -158,6 +154,7 @@ void write_roundtrip(const m5::uhf::Tag& detected, const uint16_t words)
     M5_LOGI("write %2u words: read %lums, write %lums, read back %s", words, read_took, took,
             readback == pattern ? "matches" : "MISMATCH");
     lcd.printf("%2u words %lums %s\n", words, took, readback == pattern ? "ok" : "NG");
+    uhf.dump(m5::uhf::Bank::User, 0, words);
 
     // Put it back the way it was, and say so loudly if that does not work: the tag is left
     // holding the pattern in that case
@@ -170,6 +167,7 @@ void write_roundtrip(const m5::uhf::Tag& detected, const uint16_t words)
     if (uhf.readBank(restored, m5::uhf::Bank::User, 0, words)) {
         M5_LOGI("write %2u words: restored %s", words, restored == original ? "matches" : "MISMATCH");
     }
+    uhf.dump(m5::uhf::Bank::User, 0, words);
     uhf.deselect();
 }
 }  // namespace
@@ -193,15 +191,48 @@ void loop()
     if (M5.BtnA.wasClicked()) {
         lcd.fillScreen(TFT_DARKGREEN);
         lcd.setCursor(0, 0);
+        m5::uhf::Tag detected{};
+        if (!detect_one(detected)) {
+            return;
+        }
+        // How much user memory there is decides what is worth writing, and only the TID says
+        // which chip this is
+        if (!uhf.select(detected)) {
+            M5_LOGE("Failed to select the tag");
+            lcd.println("select: failed");
+            return;
+        }
         m5::uhf::Tag tag{};
-        if (!detect_one(tag)) {
+        const bool identified = uhf.identify(tag);
+        uhf.deselect();
+        if (!identified) {
+            M5_LOGE("Failed to identify the tag");
+            lcd.println("identify: failed");
             return;
         }
-        // Two words to see it work, then the most a single command carries, then more than that
-        // so writeBank has to split it across two
+
+        const uint16_t bank = static_cast<uint16_t>(tag.user_memory_bits / 16);
+        M5_LOGI("%s: user memory %s", tag.chipAsString().c_str(),
+                bank ? m5::utility::formatString("%u words", bank).c_str()
+                     : (m5::uhf::pcUserMemoryIndicator(tag.pc) ? "size not known" : "none"));
+        lcd.printf("%s\n", tag.chipAsString().c_str());
+
+        if (bank == 0 && !m5::uhf::pcUserMemoryIndicator(tag.pc)) {
+            M5_LOGI("Nothing to write to on this tag");
+            lcd.println("no user memory");
+            return;
+        }
+
+        // Two words to see it work at all
         write_roundtrip(tag, WRITE_TEST_WORDS);
-        write_roundtrip(tag, WRITE_TEST_MAX_WORDS);
-        write_roundtrip(tag, WRITE_TEST_BANK_WORDS);
+        // Then the most a single command carries, or the whole bank if that is smaller
+        write_roundtrip(tag, bank ? std::min<uint16_t>(WRITE_TEST_MAX_WORDS, bank) : WRITE_TEST_MAX_WORDS);
+        // Then the whole bank, which only tells us anything when it takes more than one command
+        if (bank > WRITE_TEST_MAX_WORDS) {
+            write_roundtrip(tag, bank);
+        } else if (bank) {
+            M5_LOGI("The whole bank fits in one command, so there is no split to exercise");
+        }
     }
 }
 

src/uhf/uhf_layer.cpp

@@ -271,7 +271,7 @@ uint16_t UHFLayer::bank_words(const Bank bank)
     }
 }
 
-bool UHFLayer::dump_words(const char* what, const Bank bank, const uint16_t words)
+bool UHFLayer::dump_words(const char* what, const Bank bank, const uint16_t word_address, const uint16_t words)
 {
     printf("== %s ==\n", what);
     if (words == 0) {
@@ -282,8 +282,9 @@ bool UHFLayer::dump_words(const char* what, const Bank bank, const uint16_t word
 
     // Eight words to a line, which is the sixteen bytes the sister NFC dump puts on one
     constexpr uint16_t PER_LINE{8};
-    for (uint16_t at = 0; at < words; at += PER_LINE) {
-        const uint16_t n = std::min<uint16_t>(PER_LINE, words - at);
+    for (uint16_t off = 0; off < words; off += PER_LINE) {
+        const uint16_t at = static_cast<uint16_t>(word_address + off);
+        const uint16_t n  = std::min<uint16_t>(PER_LINE, words - off);
         std::vector<uint8_t> data{};
         if (!readBank(data, bank, at, n)) {
             printf("[%03u/%03X] ERROR\n", at, at);
@@ -298,14 +299,19 @@ bool UHFLayer::dump_words(const char* what, const Bank bank, const uint16_t word
     return true;
 }
 
-bool UHFLayer::dump(const Bank bank)
+bool UHFLayer::dump(const Bank bank, const uint16_t word_address, const uint16_t words)
 {
     if (!_has_selection) {
         M5_LIB_LOGE("dump needs a tag to have been selected");
         return false;
     }
     static const char* names[] = {"Reserved", "EPC", "TID", "User"};
-    return dump_words(names[static_cast<uint8_t>(bank) & 0x03], bank, bank_words(bank));
+    return dump_words(names[static_cast<uint8_t>(bank) & 0x03], bank, word_address, words);
+}
+
+bool UHFLayer::dump(const Bank bank)
+{
+    return dump(bank, 0, bank_words(bank));
 }
 
 bool UHFLayer::dump()

src/uhf/uhf_layer.hpp

@@ -131,6 +131,15 @@ class UHFLayer {
       @pre A tag must have been selected
      */
     bool dump(const Bank bank);
+    /*!
+      @brief Dump part of one memory bank
+      @param bank Memory bank
+      @param word_address Start address in 16-bit words
+      @param words Number of 16-bit words
+      @return True if successful
+      @pre A tag must have been selected
+     */
+    bool dump(const Bank bank, const uint16_t word_address, const uint16_t words);
     ///@}
 
     ///@name Tag memory, addressed to the selected tag
@@ -186,8 +195,8 @@ class UHFLayer {
     bool verify_selection();
     //! @brief How many words of a bank there are to read, 0 when that is not known
     uint16_t bank_words(const Bank bank);
-    //! @brief Print one bank's worth of words, sixteen bytes to a line
-    bool dump_words(const char* what, const Bank bank, const uint16_t words);
+    //! @brief Print a stretch of one bank, sixteen bytes to a line
+    bool dump_words(const char* what, const Bank bank, const uint16_t word_address, const uint16_t words);
     /*!
       @brief Stop polling for as long as a tag is being addressed
       @details An inventory round leaves every tag it saw flagged as already counted, and a tag

src/unit/unit_JRD4035.cpp

@@ -353,7 +353,10 @@ void UnitJRD4035::route_frame(const Frame& f)
         if (is_no_tag(code) && !awaiting_inventory) {
             return;
         }
-        M5_LIB_LOGW("Error frame %02X", code);
+        // Whether this matters is not known here: most of them are retried and succeed on the
+        // next attempt. Saying so is left to succeeded(), which is reached only once the
+        // operation has actually given up
+        M5_LIB_LOGD("Error frame %02X", code);
         if (_response_pending) {
             _response         = f;
             _response_pending = false;