Say why an operation on a tag did not go through

Author: GOB52

examples/UnitUnified/UHF/Kill/main/Kill.cpp

@@ -195,8 +195,9 @@ void dry_run(m5::uhf::Tag& detected)
     }
     M5_LOGI("Killing with the zero password it holds: %s",
             uhf.kill(detected, stored) ? "sent, which it should not be" : "refused before sending");
+    const auto probed = uhf.kill(detected, PROBE_PASSWORD);
     M5_LOGI("Killing with a password it does not hold: %s",
-            uhf.kill(detected, PROBE_PASSWORD) ? "the tag accepted it" : "the tag refused it");
+            probed ? "the tag accepted it" : m5::uhf::reasonAsString(probed.error()));
     uhf.deselect();
     lcd.println("refused, as it should");
 }
@@ -222,9 +223,14 @@ void kill_for_good(m5::uhf::Tag& detected)
     const std::vector<uint8_t> password{static_cast<uint8_t>(KILL_PASSWORD >> 24),
                                         static_cast<uint8_t>(KILL_PASSWORD >> 16),
                                         static_cast<uint8_t>(KILL_PASSWORD >> 8), static_cast<uint8_t>(KILL_PASSWORD)};
-    if (!uhf.writeBank(m5::uhf::Bank::Reserved, KILL_PASSWORD_WORD, password.data(),
-                       static_cast<uint16_t>(password.size()))) {
-        M5_LOGE("Could not write the kill password; the tag is untouched");
+    const auto stored_password = uhf.writeBank(m5::uhf::Bank::Reserved, KILL_PASSWORD_WORD, password.data(),
+                                               static_cast<uint16_t>(password.size()));
+    if (!stored_password) {
+        // A tag that answered has not been written to; one that said nothing may hold a
+        // password nobody knows, which is a tag nobody can kill
+        M5_LOGE("Could not write the kill password: %s. The tag is %s",
+                m5::uhf::reasonAsString(stored_password.error()),
+                m5::uhf::tagUnchanged(stored_password.error()) ? "untouched" : "in a state that cannot be told");
         lcd.println("password: not written");
         uhf.deselect();
         return;
@@ -240,9 +246,9 @@ void kill_for_good(m5::uhf::Tag& detected)
     }
     M5_LOGW("Kill password written and read back. The tag can now be killed");
 
-    const bool killed = uhf.kill(detected, KILL_PASSWORD);
+    const auto killed = uhf.kill(detected, KILL_PASSWORD);
     uhf.deselect();
-    M5_LOGW("Kill: %s", killed ? "the tag carried it out" : "failed");
+    M5_LOGW("Kill: %s", killed ? "the tag carried it out" : m5::uhf::reasonAsString(killed.error()));
 
     // The answer to a kill can go missing on the way back, and a tag that did die cannot say so.
     // Asking the field is the only way to tell those two apart

examples/UnitUnified/UHF/Lock/main/Lock.cpp

@@ -145,20 +145,24 @@ void write_probe(const char* when)
     constexpr uint32_t RESTORE_INTERVAL_MS{20};
 
     const std::vector<uint8_t> pattern{0x5A, 0xA5};
-    const bool wrote = uhf.writeBank(m5::uhf::Bank::User, 0, pattern.data(), static_cast<uint16_t>(pattern.size()));
-    M5_LOGI("Writing one word %s: %s", when, wrote ? "allowed" : "refused");
-    lcd.printf("write %s: %s\n", when, wrote ? "ok" : "no");
+    const auto wrote = uhf.writeBank(m5::uhf::Bank::User, 0, pattern.data(), static_cast<uint16_t>(pattern.size()));
+    // A tag that says no has not been written to; one that says nothing may have been, which is
+    // a different thing to be told and the reason is what tells them apart
+    M5_LOGI("Writing one word %s: %s", when, wrote ? "allowed" : m5::uhf::reasonAsString(wrote.error()));
+    lcd.printf("write %s: %s\n", when, wrote ? "ok" : m5::uhf::tagUnchanged(wrote.error()) ? "no" : "?");
     if (!wrote) {
         return;
     }
     const std::vector<uint8_t> zero{0x00, 0x00};
+    m5::uhf::Result restored{m5::stl::unexpected<m5::uhf::Reason>{m5::uhf::Reason::NoAnswer}};
     for (uint8_t i = 0; i < RESTORE_ATTEMPTS; ++i) {
-        if (uhf.writeBank(m5::uhf::Bank::User, 0, zero.data(), static_cast<uint16_t>(zero.size()))) {
+        restored = uhf.writeBank(m5::uhf::Bank::User, 0, zero.data(), static_cast<uint16_t>(zero.size()));
+        if (restored) {
             return;
         }
         m5::utility::delay(RESTORE_INTERVAL_MS);
     }
-    M5_LOGE("FAILED TO RESTORE the word; the tag still holds 5AA5");
+    M5_LOGE("FAILED TO RESTORE the word (%s); the tag still holds 5AA5", m5::uhf::reasonAsString(restored.error()));
 }
 
 //! @brief Address the tag again with a password, since that is what decides the state it is in
@@ -183,9 +187,10 @@ bool set_access_password(const m5::uhf::Tag& tag, const uint32_t password)
 {
     const std::vector<uint8_t> data{static_cast<uint8_t>(password >> 24), static_cast<uint8_t>(password >> 16),
                                     static_cast<uint8_t>(password >> 8), static_cast<uint8_t>(password)};
-    if (!uhf.writeBank(m5::uhf::Bank::Reserved, ACCESS_PASSWORD_WORD, data.data(),
-                       static_cast<uint16_t>(data.size()))) {
-        M5_LOGE("Failed to store the access password %08X", password);
+    const auto stored =
+        uhf.writeBank(m5::uhf::Bank::Reserved, ACCESS_PASSWORD_WORD, data.data(), static_cast<uint16_t>(data.size()));
+    if (!stored) {
+        M5_LOGE("Failed to store the access password %08X: %s", password, m5::uhf::reasonAsString(stored.error()));
         lcd.println("password: failed");
         return false;
     }
@@ -215,10 +220,11 @@ bool set_access_password(const m5::uhf::Tag& tag, const uint32_t password)
 bool set_lock(const m5::uhf::LockTarget target, const m5::uhf::LockAction action, const char* what)
 {
     const std::vector<m5::uhf::LockSetting> settings{m5::uhf::LockSetting(target, action)};
-    const bool ok = uhf.lock(settings);
-    M5_LOGI("%s: %s", what, ok ? "the tag carried it out" : "failed");
-    lcd.printf("%s: %s\n", what, ok ? "ok" : "NG");
-    return ok;
+    const auto result = uhf.lock(settings);
+    // EPC Gen2 gives no way to read a tag's lock bits, so what the reader says is all there is
+    M5_LOGI("%s: %s", what, result ? "the tag carried it out" : m5::uhf::reasonAsString(result.error()));
+    lcd.printf("%s: %s\n", what, result ? "ok" : "NG");
+    return static_cast<bool>(result);
 }
 
 void lock_and_open(m5::uhf::Tag& tag)

examples/UnitUnified/UHF/MonzaQT/main/MonzaQT.cpp

@@ -123,8 +123,9 @@ bool look(m5::uhf::Tag& tag, m5::uhf::QTParameters& qt)
                     (base[1] & 0x80) ? 1 : 0);
         }
     }
-    if (!uhf.readQTParameters(qt)) {
-        M5_LOGE("The tag did not answer the QT command; is it a Monza 4QT?");
+    const auto read = uhf.readQTParameters(qt);
+    if (!read) {
+        M5_LOGE("The QT command did not go through (%s); is it a Monza 4QT?", m5::uhf::reasonAsString(read.error()));
         lcd.println("QT: no answer");
         uhf.deselect();
         return false;
@@ -153,8 +154,9 @@ void switch_map(const bool keep)
     M5_LOGI("Switching to the %s map", wanted.public_memory ? "public" : "private");
     lcd.printf("-> %s\n", wanted.public_memory ? "public" : "private");
     // Written to stay: a volatile switch would be gone before the tag is looked for again
-    if (!uhf.writeQTParameters(wanted, true)) {
-        M5_LOGE("Failed to switch the map");
+    const auto switched = uhf.writeQTParameters(wanted, true);
+    if (!switched) {
+        M5_LOGE("Failed to switch the map: %s", m5::uhf::reasonAsString(switched.error()));
         lcd.println("switch: failed");
         uhf.deselect();
         return;
@@ -180,8 +182,10 @@ void switch_map(const bool keep)
     }
     // Whichever way it went, the tag is put back the way it was found
     M5_LOGI("Switching back to the %s map", qt.public_memory ? "public" : "private");
-    if (!uhf.writeQTParameters(qt, true)) {
-        M5_LOGE("Failed to switch it back; it is showing its %s map", qt_after.public_memory ? "public" : "private");
+    const auto back = uhf.writeQTParameters(qt, true);
+    if (!back) {
+        M5_LOGE("Failed to switch it back (%s); it is showing its %s map", m5::uhf::reasonAsString(back.error()),
+                qt_after.public_memory ? "public" : "private");
         lcd.println("NOT switched back");
         uhf.deselect();
         return;

examples/UnitUnified/UHF/NxpG2X/main/NxpG2X.cpp

@@ -148,8 +148,10 @@ bool look(m5::uhf::Tag& tag, uint16_t& word)
     if (uhf.identify(tag)) {
         M5_LOGI("Chip: %s", tag.chipAsString().c_str());
     }
-    if (!uhf.readNxpConfigWord(word)) {
-        M5_LOGE("The Config-Word could not be read");
+    const auto read = uhf.readNxpConfigWord(word);
+    if (!read) {
+        // A chip that never had the command is a different answer from one that did not reply
+        M5_LOGE("The Config-Word could not be read: %s", m5::uhf::reasonAsString(read.error()));
         lcd.println("no Config-Word");
         uhf.deselect();
         return false;
@@ -182,8 +184,9 @@ bool set_access_password(const m5::uhf::Tag& tag, const uint32_t password)
 {
     const uint8_t data[]{static_cast<uint8_t>(password >> 24), static_cast<uint8_t>(password >> 16),
                          static_cast<uint8_t>(password >> 8), static_cast<uint8_t>(password)};
-    if (!uhf.writeBank(m5::uhf::Bank::Reserved, ACCESS_PASSWORD_WORD, data, sizeof(data))) {
-        M5_LOGE("Failed to store the access password %08X", password);
+    const auto stored = uhf.writeBank(m5::uhf::Bank::Reserved, ACCESS_PASSWORD_WORD, data, sizeof(data));
+    if (!stored) {
+        M5_LOGE("Failed to store the access password %08X: %s", password, m5::uhf::reasonAsString(stored.error()));
         return false;
     }
     // The write changed the very password the selection carries, so the tag is addressed again
@@ -216,8 +219,10 @@ void restore_tag(const m5::uhf::Tag& tag, const bool was_raised)
     }
     uint16_t word{};
     if (uhf.readNxpConfigWord(word) && m5::uhf::decodeNxpConfigWord(word).psf_alarm != was_raised) {
-        if (!uhf.writeNxpEAS(was_raised)) {
-            M5_LOGE("THE FLAG IS STILL %s; hold the button again", was_raised ? "DOWN" : "UP");
+        const auto put_back = uhf.writeNxpEAS(was_raised);
+        if (!put_back) {
+            M5_LOGE("THE FLAG IS STILL %s (%s); hold the button again", was_raised ? "DOWN" : "UP",
+                    m5::uhf::reasonAsString(put_back.error()));
             lcd.println("flag left");
         }
     }
@@ -249,8 +254,9 @@ void flag_and_unflag()
         restore_tag(tag, was_raised);
         return;
     }
-    if (!uhf.writeNxpEAS(!was_raised)) {
-        M5_LOGE("Failed to change the flag");
+    const auto changed = uhf.writeNxpEAS(!was_raised);
+    if (!changed) {
+        M5_LOGE("Failed to change the flag: %s", m5::uhf::reasonAsString(changed.error()));
         lcd.println("EAS: failed");
         restore_tag(tag, was_raised);
         return;

examples/UnitUnified/UHF/NxpReadProtect/main/NxpReadProtect.cpp

@@ -158,8 +158,16 @@ bool look(m5::uhf::Tag& tag, uint16_t& word)
         lcd.println("select: failed");
         return false;
     }
-    if (!uhf.readNxpConfigWord(word)) {
-        M5_LOGE("The Config-Word could not be read");
+    // Which chip this is comes from the TID, and what a chip is decides whether it can have
+    // the command at all. Asking a chip that cannot costs a round trip and comes back saying
+    // nothing answered, which is not the same as being told it was never there to answer
+    if (uhf.identify(tag)) {
+        M5_LOGI("Chip: %s", tag.chipAsString().c_str());
+    }
+    const auto read = uhf.readNxpConfigWord(word);
+    if (!read) {
+        // A chip that never had the command is a different answer from one that did not reply
+        M5_LOGE("The Config-Word could not be read: %s", m5::uhf::reasonAsString(read.error()));
         lcd.println("no Config-Word");
         uhf.deselect();
         return false;
@@ -189,8 +197,9 @@ bool set_access_password(const m5::uhf::Tag& tag, const uint32_t password)
 {
     const uint8_t data[]{static_cast<uint8_t>(password >> 24), static_cast<uint8_t>(password >> 16),
                          static_cast<uint8_t>(password >> 8), static_cast<uint8_t>(password)};
-    if (!uhf.writeBank(m5::uhf::Bank::Reserved, ACCESS_PASSWORD_WORD, data, sizeof(data))) {
-        M5_LOGE("Failed to store the access password %08X", password);
+    const auto stored = uhf.writeBank(m5::uhf::Bank::Reserved, ACCESS_PASSWORD_WORD, data, sizeof(data));
+    if (!stored) {
+        M5_LOGE("Failed to store the access password %08X: %s", password, m5::uhf::reasonAsString(stored.error()));
         return false;
     }
     // The write changed the very password the selection carries, so the tag is addressed again
@@ -247,8 +256,10 @@ void restore_tag()
             undo |= m5::uhf::NXP_CONFIG_PROTECT_TID;
         }
         if (undo != 0) {
-            if (!uhf.toggleNxpConfigWord(word, undo)) {
-                M5_LOGE("THE TAG IS STILL PROTECTED; hold the button again");
+            const auto undone = uhf.toggleNxpConfigWord(word, undo);
+            if (!undone) {
+                M5_LOGE("THE TAG IS STILL PROTECTED (%s); hold the button again",
+                        m5::uhf::reasonAsString(undone.error()));
                 lcd.println("still protected");
                 return;
             }
@@ -297,8 +308,9 @@ void protect_and_release()
     // Inverting both at once, which is what ReadProtect would have done to them
     constexpr uint16_t BOTH{m5::uhf::NXP_CONFIG_PROTECT_EPC | m5::uhf::NXP_CONFIG_PROTECT_TID};
     uint16_t now{};
-    if (!uhf.toggleNxpConfigWord(now, BOTH)) {
-        M5_LOGE("Failed to protect the tag");
+    const auto protect = uhf.toggleNxpConfigWord(now, BOTH);
+    if (!protect) {
+        M5_LOGE("Failed to protect the tag: %s", m5::uhf::reasonAsString(protect.error()));
         lcd.println("protect: failed");
         restore_tag();
         return;