Merge pull request #9184 from ConradBraam/master

Adds an NFC System Test suite

Author: 0xc0170

TEST_APPS/device/nfcapp/NFCCommands.cpp

@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) 2018 ARM Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <string>
+#include <vector>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "mbed_events.h"
+#include "mbed-client-cli/ns_cmdline.h"
+#include "rtos/Thread.h"
+#include "NFCTestShim.h"
+#include "NFCCommands.h"
+
+#if MBED_CONF_NFCEEPROM
+#include "NFCEEPROMDriver.h"
+#include "NFCProcessEEPROM.h"
+#endif
+
+using mbed::nfc::nfc_rf_protocols_bitmask_t;
+
+events::EventQueue HandleTestCommand::_nfcQueue;
+
+rtos::Thread nfcThread;
+bool human_trace_enabled = true;
+
+NFCTestShim *HandleTestCommand::new_testshim()
+{
+#if MBED_CONF_NFCEEPROM
+    mbed::nfc::NFCEEPROMDriver &eeprom_driver = get_eeprom_driver(_nfcQueue);
+
+    return ((NFCTestShim *)(new NFCProcessEEPROM(_nfcQueue, eeprom_driver)));
+#else
+    return ((NFCTestShim *)(new NFCProcessController(_nfcQueue)));
+#endif // EEPROM
+
+}
+
+void HandleTestCommand::nfc_routine()
+{
+    _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(&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);
+    }
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+
+int HandleTestCommand::cmd_get_max_ndef(int argc, char *argv[])
+{
+    if (pNFC_Test_Shim) {
+        _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_get_max_ndef);
+        return CMDLINE_RETCODE_EXCUTING_CONTINUE;
+    }
+    return CMDLINE_RETCODE_FAIL;
+}
+
+
+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);
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+int HandleTestCommand::cmd_read_message(int argc, char *argv[])
+{
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_read_nfc_contents);
+
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+int HandleTestCommand::cmd_set_smartposter(int argc, char *argv[])
+{
+    // args are "setsmartposter", "<uri>"
+    if (argc <= 1) {
+        cmd_printf("setlastnfcerror() invalid parameter(s)\r\n");
+        return (CMDLINE_RETCODE_INVALID_PARAMETERS);
+    } else {
+        // parse arg and queue it up
+        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
+        } else {
+            cmd_printf("WARN out of memory!\r\n");
+            return (CMDLINE_RETCODE_FAIL);
+        }
+    }
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+int HandleTestCommand::cmd_erase(int argc, char *argv[])
+{
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_erase);
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+int HandleTestCommand::cmd_write_long_ndef_message(int argc, char *argv[])
+{
+    size_t length, idx, sourceLength;
+    static const char alphabet[] = "thequickbrownfoxjumpedoverthelazydog";
+    char *data;
+    const char *sourceMessage;
+
+    // expect 2 or 3 args "<cmd> <length> [optional-text]"
+    if (argc < 2) {
+        cmd_printf("supply length of message\r\n");
+        return (CMDLINE_RETCODE_INVALID_PARAMETERS);
+    }
+
+    int converted = sscanf(argv[1], "%d", &length);
+    if (1 != converted) {
+        cmd_printf("Cannot convert value to int\r\n");
+        return (CMDLINE_RETCODE_INVALID_PARAMETERS);
+    }
+    // check that it would not overflow
+    if (length > MBED_CONF_APP_TEST_NDEF_MSG_MAX) {
+        cmd_printf("Buffer length may not exceed %d !\r\n", (int)MBED_CONF_APP_TEST_NDEF_MSG_MAX);
+        return (CMDLINE_RETCODE_FAIL);
+    }
+
+    data = (char *) malloc(length + 1);
+    if (!data) {
+        cmd_printf("WARN out of memory!\r\n");
+        return (CMDLINE_RETCODE_FAIL);
+    }
+    if (argc > 2) {
+        // user provided text to copy into text NDEF record
+        sourceMessage = argv[2];
+    } else {
+        // use our internal default message to copy into the text NDEF
+        sourceMessage = alphabet;
+    }
+    sourceLength = strlen(sourceMessage);
+    for (idx = 0; idx < length; idx++) {
+        data[idx] = sourceMessage[idx % sourceLength];
+    }
+    data[length] = '\0';
+
+    // method must release buffer
+    _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"))) {
+        trace_printf("User must restart discovery manually()\r\n");
+        _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_start_discovery, false);
+    } else {
+        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);
+    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);
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+
+bool HandleTestCommand::set_protocol_target(
+    nfc_rf_protocols_bitmask_t &bitmask, const char *protocolName)
+{
+    bool parsed = false;
+    if (0 == strcmp(protocolName, "t1t")) {
+        parsed = bitmask.target_t1t = true;
+    }
+    if (0 == strcmp(protocolName, "t2t")) {
+        parsed = bitmask.target_t2t = true;
+    }
+    if (0 == strcmp(protocolName, "t3t")) {
+        parsed = bitmask.target_t3t = true;
+    }
+    if (0 == strcmp(protocolName, "t5t")) {
+        parsed = bitmask.target_t5t = true;
+    }
+    if (0 == strcmp(protocolName, "isodep")) {
+        parsed = bitmask.target_iso_dep = true;
+    }
+    if (0 == strcmp(protocolName, "nfcdep")) {
+        parsed = bitmask.target_nfc_dep = true;
+    }
+    return (parsed);
+}
+
+int HandleTestCommand::cmd_configure_rf_protocols(int argc, char *argv[])
+{
+    nfc_rf_protocols_bitmask_t protocols = { 0 };
+
+    int argindex = argc;
+    while (argindex > 1) {
+        if (!set_protocol_target(protocols, argv[argindex - 1])) {
+            cmd_printf("Unknown protocol %s", argv[argindex - 1]);
+            return (CMDLINE_RETCODE_INVALID_PARAMETERS);
+        }
+        argindex--;
+    }
+    _nfcQueue.call(pNFC_Test_Shim, &NFCTestShim::cmd_configure_rf_protocols,
+                   protocols);
+    return (CMDLINE_RETCODE_EXCUTING_CONTINUE);
+}
+