cpp refactored, refactor the python next

Author: ConradBraam

TEST_APPS/device/nfcapp/main.cpp

@@ -35,35 +35,36 @@ using mbed::nfc::NFCEEPROMDriver;
 
 #endif // MBED_CONF_NFCEEPROM
 
+const char *errorcodes = // descriptions from nfc/stack/nfc_errors.h
+    " 0 NFC_OK\r\n"
+    " 1 NFC_ERR_UNKNOWN\r\n"
+    " 2 NFC_ERR_LENGTH\r\n"
+    " 3 NFC_ERR_NOT_FOUND\r\n"
+    " 4 NFC_ERR_UNSUPPORTED\r\n"
+    " 5 NFC_ERR_PARAMS\r\n"
+    " 6 NFC_ERR_BUFFER_TOO_SMALL\r\n"
+    " 7 NFC_ERR_TIMEOUT\r\n"
+    " 8 NFC_ERR_CRC\r\n"
+    " 9 NFC_ERR_NOPEER\r\n"
+    "10 NFC_ERR_PARITY\r\n"
+    "11 NFC_ERR_FIELD\r\n"
+    "12 NFC_ERR_COLLISION\r\n"
+    "13 NFC_ERR_WRONG_COMM\r\n"
+    "14 NFC_ERR_PROTOCOL\r\n"
+    "15 NFC_ERR_BUSY\r\n"
+    "16 NFC_ERR_CONTROLLER\r\n"
+    "17 NFC_ERR_HALTED\r\n"
+    "18 NFC_ERR_MAC\r\n"
+    "19 NFC_ERR_UNDERFLOW\r\n"
+    "20 NFC_ERR_DISCONNECTED\r\n"
+    "21 NFC_ERR_ABORTED\r\n";
+
 
 void wrap_printf(const char *f, va_list a)
 {
     vprintf(f, a);
 }
 
-const char *errorcodes = // descriptions from nfc/stack/nfc_errors.h
-    " 0 NFC_OK \n"
-    " 1 NFC_ERR_UNKNOWN\n"
-    " 2 NFC_ERR_LENGTH \n"
-    " 3 NFC_ERR_NOT_FOUND\n"
-    " 4 NFC_ERR_UNSUPPORTED\n"
-    " 5 NFC_ERR_PARAMS \n"
-    " 6 NFC_ERR_BUFFER_TOO_SMALL\n"
-    " 7 NFC_ERR_TIMEOUT\n"
-    " 8 NFC_ERR_CRC\n"
-    " 9 NFC_ERR_NOPEER \n"
-    "10 NFC_ERR_PARITY \n"
-    "11 NFC_ERR_FIELD\n"
-    "12 NFC_ERR_COLLISION\n"
-    "13 NFC_ERR_WRONG_COMM \n"
-    "14 NFC_ERR_PROTOCOL \n"
-    "15 NFC_ERR_BUSY \n"
-    "16 NFC_ERR_CONTROLLER \n"
-    "17 NFC_ERR_HALTED \n"
-    "18 NFC_ERR_MAC\n"
-    "19 NFC_ERR_UNDERFLOW\n"
-    "20 NFC_ERR_DISCONNECTED \n"
-    "21 NFC_ERR_ABORTED\n";
 
 /** Disables VT100 etc. for easy manual UI interaction */
 int seteasy(int argc, char *argv[])
@@ -75,6 +76,7 @@ int seteasy(int argc, char *argv[])
     }
     return (CMDLINE_RETCODE_SUCCESS);
 }
+
 /**
  * This test app can be used standalone interactively with at 115200 baud terminal. It is designed to work with the
  * IceTea test framework https://os.mbed.com/docs/latest/tools/icetea-testing-applications.html . This app does
@@ -88,7 +90,7 @@ int seteasy(int argc, char *argv[])
  * If using an NFC EEPROM, an extra library is needed. Please see the documentation in the README.MD for instructions
  * on how to modify this test for new drivers/targets, and the steps to run this test suite.
  */
-int main(int argc, char *argv[])
+int main()
 {
     cmd_init(&wrap_printf);
     cmd_add("getlastnfcerror", HandleTestCommand::cmd_get_last_nfc_error,
@@ -127,6 +129,8 @@ int main(int argc, char *argv[])
             "set rf protocols", "-p [t1t]/[t2t]/[t3t]/[isodep]/[nfcdep]/[t5t]");
     cmd_add("easy", seteasy, "Use human readable terminal output",
             "echo off,vt100 off,return-codes visible");
+    cmd_add("trace", HandleTestCommand::cmd_set_trace, "detailed tracing on/off, ",
+            "Defaults to enabled; values like 'on','true','1' all turn it on, anything else turns off detailed tracing.");
 
 #if MBED_CONF_NFCEEPROM
     cmd_printf("MBED NFC EEPROM defined\r\n");
@@ -135,16 +139,17 @@ int main(int argc, char *argv[])
 #endif
 
 #ifdef TARGET_M24SR
-    cmd_printf("Using driver:M24SR\r\n");
+    cmd_printf("Using driver: M24SR\r\n");
 #endif
 #ifdef TARGET_PN512
-    cmd_printf("Using driver:PN512\r\n");
+    cmd_printf("Using driver: PN512\r\n");
 #endif
-
-    int c;
-    HandleTestCommand handleCommands; // starts handling nfc messages
-    while ((c = getc(stdin)) != EOF) {
-        cmd_char_input(c);
+    {
+        int c;
+        HandleTestCommand handleCommands; // For handling test commands and set nfc message queue
+        while ((c = getc(stdin)) != EOF) {
+            cmd_char_input(c);
+        }
     }
     return 0;
 }

TEST_APPS/device/nfcapp/nfccommands.cpp

@@ -15,6 +15,7 @@
  */
 #include <string>
 #include <vector>
+#include <stdarg.h>
 #include <stdlib.h>
 #include "mbed_events.h"
 #include "mbed-client-cli/ns_cmdline.h"
@@ -29,41 +30,89 @@
 
 using mbed::nfc::nfc_rf_protocols_bitmask_t;
 
-events::EventQueue nfcQueue;
+events::EventQueue HandleTestCommand::_nfcQueue;
+
 rtos::Thread nfcThread;
-NFCTestShim *pNFC_Test_Shim = NULL;
+bool human_trace_enabled = true;
 
-NFCTestShim *new_testshim()
+NFCTestShim *HandleTestCommand::new_testshim()
 {
 #if MBED_CONF_NFCEEPROM
-    mbed::nfc::NFCEEPROMDriver &eeprom_driver = get_eeprom_driver(nfcQueue);
+    mbed::nfc::NFCEEPROMDriver &eeprom_driver = get_eeprom_driver(_nfcQueue);
 
-    return ((NFCTestShim *)(new NFCProcessEEPROM(nfcQueue, eeprom_driver)));
+    return ((NFCTestShim *)(new NFCProcessEEPROM(_nfcQueue, eeprom_driver)));
 #else
-    return ((NFCTestShim *)(new NFCProcessController(nfcQueue)));
+    return ((NFCTestShim *)(new NFCProcessController(_nfcQueue)));
 #endif // EEPROM
 
 }
 
-void nfcRoutine()
+void HandleTestCommand::nfc_routine()
 {
-    nfcQueue.dispatch_forever();
+    _nfcQueue.dispatch_forever();
+}
+
+void trace_printf(const char *fmt, ...)
+{
+    if (human_trace_enabled) {
+        va_list ap;
+        va_start(ap, fmt);
+        cmd_vprintf(fmt, ap);
+        va_end(ap);
+    }
 }
 
 HandleTestCommand::HandleTestCommand()
 {
-    osStatus status = nfcThread.start(mbed::callback(&nfcRoutine));
+    osStatus status = nfcThread.start(mbed::callback(&HandleTestCommand::nfc_routine));
     MBED_ASSERT(status == osOK);
 }
 
+int HandleTestCommand::cmd_get_last_nfc_error(int argc, char *argv[])
+{
+    _nfcQueue.call(NFCTestShim::cmd_get_last_nfc_error);
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+/** returns compile time flag if NFC EEPROM was compiled */
+int HandleTestCommand::cmd_get_conf_nfceeprom(int argc, char *argv[])
+{
+    _nfcQueue.call(NFCTestShim::cmd_get_conf_nfceeprom);
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+
+
+int HandleTestCommand::cmd_set_trace(int argc, char *argv[])
+{
+    human_trace_enabled = false;
+    if (argc > 1) {
+        static char buffer[7];
+        char *p_buffer = buffer;
+        strncpy(buffer, argv[1], sizeof(buffer) - 1);
+        buffer[sizeof(buffer) - 1] = 0;
+        while (*p_buffer) {
+            *p_buffer = toupper(*p_buffer);
+            p_buffer++;
+        }
+        cmd_printf(buffer);
+        human_trace_enabled = (0 == strcmp(buffer, "TRUE")) || (0 == strcmp(buffer, "1")) || (0 == strcmp(buffer, "ON"));
+    }
+    cmd_printf("set trace '%s'", (human_trace_enabled ? "true" : "false"));
+    return (CMDLINE_RETCODE_SUCCESS);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+
 int HandleTestCommand::cmd_set_last_nfc_error(int argc, char *argv[])
 {
     if (argc <= 1) {
         cmd_printf("setlastnfcerror() invalid parameter(s)\r\n");
         return (CMDLINE_RETCODE_INVALID_PARAMETERS);
     } else {
         int value = strtol(argv[1], NULL, 10);
-        nfcQueue.call(NFCTestShim::cmd_set_last_nfc_error, value);
+        _nfcQueue.call(NFCTestShim::cmd_set_last_nfc_error, value);
     }
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
@@ -72,7 +121,7 @@ int HandleTestCommand::cmd_set_last_nfc_error(int argc, char *argv[])
 int HandleTestCommand::cmd_get_max_ndef(int argc, char *argv[])
 {
     if (pNFC_Test_Shim) {
-        nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_get_max_ndef);
+        _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_get_max_ndef);
         return CMDLINE_RETCODE_EXCUTING_CONTINUE;
     }
     return CMDLINE_RETCODE_FAIL;
@@ -81,19 +130,18 @@ int HandleTestCommand::cmd_get_max_ndef(int argc, char *argv[])
 
 int HandleTestCommand::cmd_init_nfc(int argc, char *argv[])
 {
-
     if (pNFC_Test_Shim) {
         cmd_printf("WARN init called again!\r\n"); // only legal here, if eeprom driver stops talking
     } else {
         pNFC_Test_Shim = new_testshim();
     }
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_init);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_init);
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
 int HandleTestCommand::cmd_read_message(int argc, char *argv[])
 {
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_read_nfc_contents);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_read_nfc_contents);
 
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
@@ -109,8 +157,8 @@ int HandleTestCommand::cmd_set_smartposter(int argc, char *argv[])
         char *uri = (char *) malloc(strlen(argv[1]) + 1);
         if (uri) {
             strcpy(uri, argv[1]);
-            nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_set_smartposter,
-                          uri); // called thread must free
+            _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_set_smartposter,
+                           uri); // called thread must free
         } else {
             cmd_printf("WARN out of memory!\r\n");
             return (CMDLINE_RETCODE_FAIL);
@@ -119,10 +167,9 @@ int HandleTestCommand::cmd_set_smartposter(int argc, char *argv[])
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
-// todo: jira IOTPAN-295
 int HandleTestCommand::cmd_erase(int argc, char *argv[])
 {
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_erase);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_erase);
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
@@ -169,31 +216,31 @@ int HandleTestCommand::cmd_write_long_ndef_message(int argc, char *argv[])
     data[length] = '\0';
 
     // method must release buffer
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_write_long, data);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_write_long, data);
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
 int HandleTestCommand::cmd_start_discovery(int argc, char *argv[])
 {
     if ((argc > 1) && (0 == strcmp(argv[1], "man"))) {
-        cmd_printf("User must restart discovery manually()\r\n");
-        nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_start_discovery, false);
+        trace_printf("User must restart discovery manually()\r\n");
+        _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_start_discovery, false);
     } else {
-        cmd_printf("App will restart discovery loop on auto()\r\n");
-        nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_start_discovery, true);
+        trace_printf("App will restart discovery loop on auto()\r\n");
+        _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_start_discovery, true);
     }
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
 int HandleTestCommand::cmd_stop_discovery(int argc, char *argv[])
 {
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_stop_discovery);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_stop_discovery);
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
 int HandleTestCommand::cmd_get_supported_rf_protocols(int argc, char *argv[])
 {
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_get_rf_protocols);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_get_rf_protocols);
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
@@ -234,38 +281,8 @@ int HandleTestCommand::cmd_configure_rf_protocols(int argc, char *argv[])
         }
         argindex--;
     }
-    nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_configure_rf_protocols,
-                  protocols);
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_configure_rf_protocols,
+                   protocols);
     return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
 }
 
-// todo: implement
-int cmd_start_stop_discovery_wait_tag(int argc, char *argv[])
-{
-
-    return (CMDLINE_RETCODE_COMMAND_NOT_IMPLEMENTED);
-}
-
-/////////////////////////////////////////////////////////////////////
-// boilerplate only
-
-int cmd_is_iso7816_supported(int argc, char *argv[])
-{
-    return (CMDLINE_RETCODE_COMMAND_NOT_IMPLEMENTED);
-}
-
-int cmd_add_iso7816_application(int argc, char *argv[])
-{
-    return (CMDLINE_RETCODE_COMMAND_NOT_IMPLEMENTED);
-}
-
-int cmd_set_tagtype(int argc, char *argv[])
-{
-    return (CMDLINE_RETCODE_COMMAND_NOT_IMPLEMENTED);
-}
-
-int cmd_get_tagtype(int argc, char *argv[])
-{
-    return (CMDLINE_RETCODE_COMMAND_NOT_IMPLEMENTED);
-}
-