Merge pull request ARMmbed#5 from yennster/cc3220sf-uart

Added initial stubs for Serial/UART API

TESTS/mbed_drivers/timeout/timeout_tests.h

@@ -305,14 +305,19 @@ void test_deepsleep(void)
  LowPowerTimer timer;
 
  /*
- * Since deepsleep() may shut down the UART peripheral, we wait for 10ms
+ * Since deepsleep() may shut down the UART peripheral, we wait for 20ms
  * to allow for hardware serial buffers to completely flush.
+ *
+ * Take NUMAKER_PFM_NUC472 as an example:
+ * Its UART peripheral has 16-byte Tx FIFO. With baud rate set to 9600, flush
+ * Tx FIFO would take: 16 * 8 * 1000 / 9600 = 13.3 (ms). So set wait time to
+ * 20ms here for safe.
 
  * This should be replaced with a better function that checks if the
  * hardware buffers are empty. However, such an API does not exist now,
  * so we'll use the wait_ms() function for now.
  */
- wait_ms(10);
+ wait_ms(20);
 
  timer.start();
  timeout.attach_callback(mbed::callback(sem_callback, &sem), delay_us);

features/cellular/TESTS/api/cellular_power/main.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates.
+ * 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.
+ */
+
+
+#if !defined(MBED_CONF_NSAPI_PRESENT)
+#error [NOT_SUPPORTED] A json configuration file is needed. Skipping this build.
+#endif
+
+#include "CellularUtil.h" // for CELLULAR_ helper macros
+#include "CellularTargets.h"
+
+#ifndef CELLULAR_DEVICE
+#error [NOT_SUPPORTED] CELLULAR_DEVICE must be defined
+#endif
+
+#ifndef MBED_CONF_APP_CELLULAR_SIM_PIN
+#error [NOT_SUPPORTED] SIM pin code is needed. Skipping this build.
+#endif
+
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+#include "mbed.h"
+
+#include "CellularDevice.h"
+#include "../../cellular_tests_common.h"
+#include CELLULAR_STRINGIFY(CELLULAR_DEVICE.h)
+
+#define NETWORK_TIMEOUT (180*1000)
+
+static UARTSerial cellular_serial(MDMTXD, MDMRXD, MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
+static CELLULAR_DEVICE* cellular_device;
+static EventQueue queue(2 * EVENTS_EVENT_SIZE);
+
+static void urc_callback()
+{
+}
+
+static void wait_for_power(CellularPower* pwr)
+{
+ nsapi_error_t err = pwr->set_device_ready_urc_cb(&urc_callback);
+ MBED_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+
+ int sanity_count = 0;
+ while (pwr->is_device_ready() != NSAPI_ERROR_OK) {
+ sanity_count++;
+ wait(1);
+ MBED_ASSERT(sanity_count < 20);
+ }
+
+ err = pwr->set_at_mode();
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+
+ pwr->remove_device_ready_urc_cb(&urc_callback);
+}
+
+static void test_power_interface()
+{
+ cellular_device = new CELLULAR_DEVICE(queue);
+ CellularPower* pwr = cellular_device->open_power(&cellular_serial);
+
+ nsapi_error_t err = pwr->on();
+ MBED_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+ wait_for_power(pwr);
+
+ MBED_ASSERT(pwr->set_power_level(1,0) == NSAPI_ERROR_OK);
+
+ err = pwr->reset();
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+ wait_for_power(pwr);
+
+ err = pwr->off();
+ MBED_ASSERT(err == NSAPI_ERROR_OK || err == NSAPI_ERROR_UNSUPPORTED);
+}
+
+using namespace utest::v1;
+
+static utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
+{
+ greentea_case_failure_abort_handler(source, reason);
+ return STATUS_ABORT;
+}
+
+static Case cases[] = {
+ Case("CellularPower test interface", test_power_interface, greentea_failure_handler)
+};
+
+static utest::v1::status_t test_setup(const size_t number_of_cases)
+{
+ GREENTEA_SETUP(10*60, "default_auto");
+ return verbose_test_setup_handler(number_of_cases);
+}
+
+static Specification specification(test_setup, cases);
+
+int main()
+{
+#if MBED_CONF_MBED_TRACE_ENABLE
+ trace_open();
+#endif
+ int ret = Harness::run(specification);
+#if MBED_CONF_MBED_TRACE_ENABLE
+ trace_close();
+#endif
+ return ret;
+}

features/cellular/TESTS/api/cellular_sim/main.cpp

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates.
+ * 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.
+ */
+
+
+#if !defined(MBED_CONF_NSAPI_PRESENT)
+#error [NOT_SUPPORTED] A json configuration file is needed. Skipping this build.
+#endif
+
+#include "CellularUtil.h" // for CELLULAR_ helper macros
+#include "CellularTargets.h"
+
+#ifndef CELLULAR_DEVICE
+#error [NOT_SUPPORTED] CELLULAR_DEVICE must be defined
+#endif
+
+#ifndef MBED_CONF_APP_CELLULAR_SIM_PIN
+#error [NOT_SUPPORTED] SIM pin code is needed. Skipping this build.
+#endif
+
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+#include "mbed.h"
+
+#include "CellularConnectionFSM.h"
+#include "CellularDevice.h"
+#include "../../cellular_tests_common.h"
+#include CELLULAR_STRINGIFY(CELLULAR_DEVICE.h)
+
+#define NETWORK_TIMEOUT (180*1000)
+
+static UARTSerial cellular_serial(MDMTXD, MDMRXD, MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
+static EventQueue queue(8 * EVENTS_EVENT_SIZE);
+static rtos::Semaphore network_semaphore(0);
+static CellularConnectionFSM cellular;
+static CellularConnectionFSM::CellularState cellular_target_state;
+
+static char *get_rand_string(char *str, size_t size)
+{
+ const char charset[] = "0123456789";
+ if (size) {
+ --size;
+ for (size_t n = 0; n < size; n++) {
+ int key = rand() % (int) (sizeof charset - 1);
+ str[n] = charset[key];
+ }
+ str[size] = '\0';
+ }
+ return str;
+}
+
+static bool fsm_callback(int state, int next_state)
+{
+ if (next_state == CellularConnectionFSM::STATE_SIM_PIN) {
+ MBED_ASSERT(network_semaphore.release() == osOK);
+ return false;
+ }
+ return true;
+}
+
+static void init_to_sim_state()
+{
+ cellular.set_serial(&cellular_serial);
+ TEST_ASSERT(cellular.init() == NSAPI_ERROR_OK);
+#if defined (MDMRTS) && defined (MDMCTS)
+ cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
+#endif
+ cellular.set_callback(&fsm_callback);
+ TEST_ASSERT(cellular.start_dispatch() == NSAPI_ERROR_OK);
+ cellular_target_state = CellularConnectionFSM::STATE_SIM_PIN;
+ TEST_ASSERT(cellular.continue_to_state(cellular_target_state) == NSAPI_ERROR_OK);
+ TEST_ASSERT(network_semaphore.wait(NETWORK_TIMEOUT) == 1);
+}
+
+static void test_sim_interface()
+{
+ CellularSIM *sim = cellular.get_sim();
+ TEST_ASSERT(sim != NULL);
+
+ // 1. test set_pin
+ nsapi_error_t err = sim->set_pin(MBED_CONF_APP_CELLULAR_SIM_PIN);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+
+ // 2. test change pin
+ char pin[5];
+ int sanity_count = 0;
+ while (strcmp(get_rand_string(pin, 5), MBED_CONF_APP_CELLULAR_SIM_PIN) == 0) {
+ sanity_count++;
+ TEST_ASSERT(sanity_count < 50);
+ };
+
+ // change pin and change it back
+ err = sim->change_pin(MBED_CONF_APP_CELLULAR_SIM_PIN, pin);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+ err = sim->change_pin(pin, MBED_CONF_APP_CELLULAR_SIM_PIN);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+
+ // 3. test set_pin_query
+ err = sim->set_pin_query(MBED_CONF_APP_CELLULAR_SIM_PIN, false);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+ err = sim->set_pin_query(MBED_CONF_APP_CELLULAR_SIM_PIN, true);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+
+ // 4. test get_sim_state
+ CellularSIM::SimState state;
+ err = sim->get_sim_state(state);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+ MBED_ASSERT(state == CellularSIM::SimStateReady);
+
+ // 5. test get_imsi
+ char imsi[16] = {0};
+ err = sim->get_imsi(imsi);
+ MBED_ASSERT(err == NSAPI_ERROR_OK);
+ MBED_ASSERT(strlen(imsi) > 0);
+}
+
+using namespace utest::v1;
+
+static utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
+{
+ greentea_case_failure_abort_handler(source, reason);
+ return STATUS_ABORT;
+}
+
+static Case cases[] = {
+ Case("CellularSIM init", init_to_sim_state, greentea_failure_handler),
+ Case("CellularSIM test interface", test_sim_interface, greentea_failure_handler)
+};
+
+static utest::v1::status_t test_setup(const size_t number_of_cases)
+{
+ GREENTEA_SETUP(10*60, "default_auto");
+ return verbose_test_setup_handler(number_of_cases);
+}
+
+static Specification specification(test_setup, cases);
+
+int main()
+{
+#if MBED_CONF_MBED_TRACE_ENABLE
+ trace_open();
+#endif
+ int ret = Harness::run(specification);
+#if MBED_CONF_MBED_TRACE_ENABLE
+ trace_close();
+#endif
+ return ret;
+}

features/cellular/TESTS/cellular_tests_common.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2018, Arm Limited and affiliates.
+ * 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.
+ */
+#ifndef CELLULAR_TESTS_COMMON_H_
+#define CELLULAR_TESTS_COMMON_H_
+
+#include "CellularLog.h"
+
+#if MBED_CONF_MBED_TRACE_ENABLE
+
+static rtos::Mutex trace_mutex;
+
+void trace_wait()
+{
+ trace_mutex.lock();
+}
+
+void trace_release()
+{
+ trace_mutex.unlock();
+}
+
+static char time_st[sizeof("[12345678]") + 1];
+
+static char *trace_time(size_t ss)
+{
+ snprintf(time_st, sizeof("[12345678]"), "[%08llu]", rtos::Kernel::get_ms_count());
+ return time_st;
+}
+
+static void trace_open()
+{
+ mbed_trace_init();
+ mbed_trace_prefix_function_set(&trace_time);
+ mbed_trace_mutex_wait_function_set(trace_wait);
+ mbed_trace_mutex_release_function_set(trace_release);
+
+ mbed_cellular_trace::mutex_wait_function_set(trace_wait);
+ mbed_cellular_trace::mutex_release_function_set(trace_release);
+}
+
+static void trace_close()
+{
+ mbed_cellular_trace::mutex_wait_function_set(NULL);
+ mbed_cellular_trace::mutex_release_function_set(NULL);
+
+ mbed_trace_free();
+}
+
+#endif // MBED_CONF_MBED_TRACE_ENABLE
+
+
+#endif /* CELLULAR_TESTS_COMMON_H_ */