Implementation of the CellularInterface for u-blox C027 and C030 (non-N2xx flavour) modems that uses the IP stack on-board the cellular modem, hence not requiring LWIP (and so less RAM) and allowing any AT command exchanges to be carried out at the same time as data transfers (since the modem remains in AT mode all the time). This library may be used from mbed 5.5 onwards. If you need to use SMS, USSD or access the modem file system at the same time as using the CellularInterface then use ublox-at-cellular-interface-ext instead.
Dependents: example-ublox-cellular-interface example-ublox-cellular-interface_r410M example-ublox-mbed-client example-ublox-cellular-interface ... more
TESTS/unit_tests/default/main.cpp
- Committer:
- mudassar0121
- Date:
- 2020-01-06
- Revision:
- 42:98808477a691
- Parent:
- 40:9299d6d117f1
File content as of revision 42:98808477a691:
#include "UbloxATCellularInterface.h" #include "greentea-client/test_env.h" #include "unity.h" #include "utest.h" #include "UDPSocket.h" #ifdef FEATURE_COMMON_PAL #include "mbed_trace.h" #define TRACE_GROUP "TEST" #else #define tr_debug(format, ...) debug(format "\n", ## __VA_ARGS__) #define tr_info(format, ...) debug(format "\n", ## __VA_ARGS__) #define tr_warn(format, ...) debug(format "\n", ## __VA_ARGS__) #define tr_error(format, ...) debug(format "\n", ## __VA_ARGS__) #endif using namespace utest::v1; // IMPORTANT!!! if you make a change to the tests here you should // check whether the same change should be made to the tests under // the PPP interface. // NOTE: these test are only as reliable as UDP across the internet // over a radio link. The tests expect an NTP server to respond // to UDP packets and, if configured, an echo server to respond // to UDP packets. This simply may not happen. Please be patient. // ---------------------------------------------------------------- // COMPILE-TIME MACROS // ---------------------------------------------------------------- // These macros can be overridden with an mbed_app.json file and // contents of the following form: // //{ // "config": { // "default-pin": { // "value": "\"1234\"" // } //} // // See the template_mbed_app.txt in this directory for a fuller example. // Whether debug trace is on #ifndef MBED_CONF_APP_DEBUG_ON # define MBED_CONF_APP_DEBUG_ON false #endif // Run the SIM change tests, which require the DEFAULT_PIN // above to be correct for the board on which the test // is being run (and the SIM PIN to be disabled before tests run). #ifndef MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS # define MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS 0 #endif #if MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS # ifndef MBED_CONF_APP_DEFAULT_PIN # error "MBED_CONF_APP_DEFAULT_PIN must be defined to run the SIM tests" # endif # ifndef MBED_CONF_APP_ALT_PIN # error "MBED_CONF_APP_ALT_PIN must be defined to run the SIM tests" # endif # ifndef MBED_CONF_APP_INCORRECT_PIN # error "MBED_CONF_APP_INCORRECT_PIN must be defined to run the SIM tests" # endif #endif // The credentials of the SIM in the board. #ifndef MBED_CONF_APP_DEFAULT_PIN // Note: if PIN is enabled on your SIM, or you wish to run the SIM PIN change // tests, you must define the PIN for your SIM (see note above on using // mbed_app.json to do so). # define MBED_CONF_APP_DEFAULT_PIN "0000" #endif #ifndef MBED_CONF_APP_APN # define MBED_CONF_APP_APN NULL #endif #ifndef MBED_CONF_APP_USERNAME # define MBED_CONF_APP_USERNAME NULL #endif #ifndef MBED_CONF_APP_PASSWORD # define MBED_CONF_APP_PASSWORD NULL #endif // Alternate PIN to use during pin change testing #ifndef MBED_CONF_APP_ALT_PIN # define MBED_CONF_APP_ALT_PIN "9876" #endif // A PIN that is definitely incorrect #ifndef MBED_CONF_APP_INCORRECT_PIN # define MBED_CONF_APP_INCORRECT_PIN "1530" #endif // Servers and ports #ifdef MBED_CONF_APP_ECHO_SERVER # ifndef MBED_CONF_APP_ECHO_UDP_PORT # error "MBED_CONF_APP_ECHO_UDP_PORT (the port on which your echo server echoes UDP packets) must be defined" # endif # ifndef MBED_CONF_APP_ECHO_TCP_PORT # error "MBED_CONF_APP_ECHO_TCP_PORT (the port on which your echo server echoes TCP packets) must be defined" # endif #endif #ifndef MBED_CONF_APP_NTP_SERVER # define MBED_CONF_APP_NTP_SERVER "2.pool.ntp.org" #else # ifndef MBED_CONF_APP_NTP_PORT # error "MBED_CONF_APP_NTP_PORT must be defined if MBED_CONF_APP_NTP_SERVER is defined" # endif #endif #ifndef MBED_CONF_APP_NTP_PORT # define MBED_CONF_APP_NTP_PORT 123 #endif #ifndef MBED_CONF_APP_LOCAL_PORT # define MBED_CONF_APP_LOCAL_PORT 15 #endif // UDP packet size limit for testing #ifndef MBED_CONF_APP_UDP_MAX_PACKET_SIZE # define MBED_CONF_APP_UDP_MAX_PACKET_SIZE 1024 #endif // The maximum size of UDP data fragmented across // multiple packets #ifndef MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE # define MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE 1500 #endif // TCP packet size limit for testing #ifndef MBED_CONF_APP_MBED_CONF_APP_TCP_MAX_PACKET_SIZE # define MBED_CONF_APP_TCP_MAX_PACKET_SIZE 1500 #endif // The number of retries for UDP exchanges #define NUM_UDP_RETRIES 5 // How long to wait for stuff to travel in the async echo tests #define ASYNC_TEST_WAIT_TIME 10000 // The maximum number of sockets that can be open at one time #define MAX_NUM_SOCKETS 7 int previousSelectedRat = -1, previousPreferredRat = -1, previousSecondPreferredRat = -1; // ---------------------------------------------------------------- // PRIVATE VARIABLES // ---------------------------------------------------------------- #ifdef FEATURE_COMMON_PAL // Lock for debug prints static Mutex mtx; #endif // An instance of the cellular interface static UbloxATCellularInterface *interface = new UbloxATCellularInterface(MDMTXD, MDMRXD, MBED_CONF_UBLOX_CELL_BAUD_RATE, MBED_CONF_APP_DEBUG_ON); // Connection flag static bool connection_has_gone_down = false; #ifdef MBED_CONF_APP_ECHO_SERVER // Data to exchange static const char send_data[] = "_____0000:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0100:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0200:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0300:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0400:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0500:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0600:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0700:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0800:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____0900:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1000:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1100:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1200:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1300:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1400:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1500:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1600:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1700:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1800:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____1900:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789" "_____2000:0123456789012345678901234567890123456789" "01234567890123456789012345678901234567890123456789"; #endif // ---------------------------------------------------------------- // PRIVATE FUNCTIONS // ---------------------------------------------------------------- #ifdef FEATURE_COMMON_PAL // Locks for debug prints static void lock() { mtx.lock(); } static void unlock() { mtx.unlock(); } #endif // Callback in case the connection goes down static void connection_down_cb(nsapi_error_t err) { connection_has_gone_down = true; } #ifdef MBED_CONF_APP_ECHO_SERVER // Make sure that size is greater than 0 and no more than limit, // useful since, when moduloing a very large number number, // compilers sometimes screw up and produce a small *negative* // number. Who knew? For example, GCC decided that // 492318453 (0x1d582ef5) modulo 508 was -47 (0xffffffd1). static int fix (int size, int limit) { if (size <= 0) { size = limit / 2; // better than 1 } else if (size > limit) { size = limit; } return size; } // Do a UDP socket echo test to a given host of a given packet size static void do_udp_echo(UDPSocket *sock, SocketAddress *host_address, int size) { bool success = false; void * recv_data = malloc (size); SocketAddress sender_address; TEST_ASSERT(recv_data != NULL); // Retry this a few times, don't want to fail due to a flaky link for (int x = 0; !success && (x < NUM_UDP_RETRIES); x++) { tr_debug("Echo testing UDP packet size %d byte(s), try %d.", size, x + 1); if ((sock->sendto(*host_address, (void*) send_data, size) == size) && (sock->recvfrom(&sender_address, recv_data, size) == size)) { TEST_ASSERT (memcmp(send_data, recv_data, size) == 0); TEST_ASSERT (strcmp(sender_address.get_ip_address(), host_address->get_ip_address()) == 0); TEST_ASSERT (sender_address.get_port() == host_address->get_port()); success = true; } } TEST_ASSERT (success); TEST_ASSERT(!connection_has_gone_down); free (recv_data); } // The asynchronous callback static void async_cb(bool *callback_triggered) { TEST_ASSERT (callback_triggered != NULL); *callback_triggered = true; } // Do a UDP echo but using the asynchronous interface; we can exchange // packets longer in size than one UDP packet this way static void do_udp_echo_async(UDPSocket *sock, SocketAddress *host_address, int size, bool *callback_triggered) { void * recv_data = malloc (size); int recv_size = 0; SocketAddress sender_address; Timer timer; int x, y, z; TEST_ASSERT(recv_data != NULL); *callback_triggered = false; for (y = 0; (recv_size < size) && (y < NUM_UDP_RETRIES); y++) { tr_debug("Echo testing UDP packet size %d byte(s) async, try %d.", size, y + 1); recv_size = 0; // Retry this a few times, don't want to fail due to a flaky link if (sock->sendto(*host_address, (void *) send_data, size) == size) { // Wait for all the echoed data to arrive timer.start(); while ((recv_size < size) && (timer.read_ms() < ASYNC_TEST_WAIT_TIME)) { if (*callback_triggered) { *callback_triggered = false; x = sock->recvfrom(&sender_address, (char *) recv_data + recv_size, size); if (x > 0) { recv_size += x; } tr_debug("%d byte(s) echoed back so far, %d to go.", recv_size, size - recv_size); TEST_ASSERT(strcmp(sender_address.get_ip_address(), host_address->get_ip_address()) == 0); TEST_ASSERT(sender_address.get_port() == host_address->get_port()); } ThisThread::sleep_for(10); } timer.stop(); timer.reset(); // If everything arrived back, check it's the same as we sent if (recv_size == size) { z = memcmp(send_data, recv_data, size); if (z != 0) { tr_debug("WARNING: mismatch, retrying"); tr_debug("Sent %d, |%*.*s|", size, size, size, send_data); tr_debug("Rcvd %d, |%*.*s|", size, size, size, (char *) recv_data); // If things don't match, it could be due to data loss (this is UDP // you know...), so set recv_size to 0 to cause another try recv_size = 0; } } } } TEST_ASSERT(recv_size == size); TEST_ASSERT(!connection_has_gone_down); free (recv_data); } // Send an entire TCP data buffer until done static int sendAll(TCPSocket *sock, const char *data, int size) { int x; int count = 0; Timer timer; timer.start(); while ((count < size) && (timer.read_ms() < 10000)) { x = sock->send(data + count, size - count); if (x > 0) { count += x; tr_debug("%d byte(s) sent, %d left to send.", count, size - count); } ThisThread::sleep_for(10); } timer.stop(); return count; } // Do a TCP echo but using the asynchronous interface static void do_tcp_echo_async(TCPSocket *sock, int size, bool *callback_triggered) { void * recv_data = malloc (size); int recv_size = 0; int x, y; Timer timer; TEST_ASSERT(recv_data != NULL); *callback_triggered = false; tr_debug("Echo testing TCP packet size %d byte(s) async.", size); TEST_ASSERT (sendAll(sock, send_data, size) == size); // Wait for all the echoed data to arrive timer.start(); while ((recv_size < size) && (timer.read_ms() < ASYNC_TEST_WAIT_TIME)) { if (*callback_triggered) { *callback_triggered = false; x = sock->recv((char *) recv_data + recv_size, size); TEST_ASSERT(x > 0); recv_size += x; tr_debug("%d byte(s) echoed back so far, %d to go.", recv_size, size - recv_size); } ThisThread::sleep_for(10); } TEST_ASSERT(recv_size == size); y = memcmp(send_data, recv_data, size); if (y != 0) { tr_debug("Sent %d, |%*.*s|", size, size, size, send_data); tr_debug("Rcvd %d, |%*.*s|", size, size, size, (char *) recv_data); TEST_ASSERT(false); } timer.stop(); TEST_ASSERT(!connection_has_gone_down); free (recv_data); } #endif // Get NTP time from a socket static void do_ntp_sock (UDPSocket *sock, SocketAddress ntp_address) { char ntp_values[48] = { 0 }; time_t timestamp = 0; int len; bool comms_done = false; ntp_values[0] = '\x1b'; // Retry this a few times, don't want to fail due to a flaky link for (unsigned int x = 0; !comms_done && (x < NUM_UDP_RETRIES); x++) { sock->sendto(ntp_address, (void*) ntp_values, sizeof(ntp_values)); len = sock->recvfrom(&ntp_address, (void*) ntp_values, sizeof(ntp_values)); if (len > 0) { comms_done = true; } } TEST_ASSERT (comms_done); tr_debug("UDP: %d byte(s) returned by NTP server.", len); if (len >= 43) { struct tm *localTime; time_t TIME1970 = 2208988800U; timestamp |= ((int) *(ntp_values + 40)) << 24; timestamp |= ((int) *(ntp_values + 41)) << 16; timestamp |= ((int) *(ntp_values + 42)) << 8; timestamp |= ((int) *(ntp_values + 43)); timestamp -= TIME1970; srand (timestamp); tr_debug("srand() called"); localTime = localtime(×tamp); if (localTime) { char timeString[25]; if (strftime(timeString, sizeof(timeString), "%a %b %d %H:%M:%S %Y", localTime) > 0) { printf("NTP timestamp is %s.\n", timeString); } } } } // Get NTP time static void do_ntp(UbloxATCellularInterface *interface) { UDPSocket sock; SocketAddress host_address; TEST_ASSERT(sock.open(interface) == 0) TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_NTP_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_NTP_PORT); tr_debug("UDP: NIST server %s address: %s on port %d.", MBED_CONF_APP_NTP_SERVER, host_address.get_ip_address(), host_address.get_port()); sock.set_timeout(10000); do_ntp_sock(&sock, host_address); sock.close(); } // Use a connection, checking that it is good static void use_connection(UbloxATCellularInterface *interface) { const char * ip_address = interface->get_ip_address(); const char * net_mask = interface->get_netmask(); const char * gateway = interface->get_gateway(); TEST_ASSERT(interface->is_connected()); TEST_ASSERT(ip_address != NULL); tr_debug ("IP address %s.", ip_address); TEST_ASSERT(net_mask == NULL); tr_debug ("Net mask %s.", net_mask); TEST_ASSERT(gateway != NULL); tr_debug ("Gateway %s.", gateway); do_ntp(interface); TEST_ASSERT(!connection_has_gone_down); } // Drop a connection and check that it has dropped static void drop_connection(UbloxATCellularInterface *interface) { TEST_ASSERT(interface->disconnect() == 0); TEST_ASSERT(connection_has_gone_down); connection_has_gone_down = false; TEST_ASSERT(!interface->is_connected()); } // ---------------------------------------------------------------- // TESTS // ---------------------------------------------------------------- // Tests of stuff in the base class void test_base_class() { const char *imei; const char *meid; const char *imsi; const char *iccid; int rssi; // Power-up the modem interface->init(); // Check all of the IMEI, MEID, IMSI and ICCID calls imei = interface->imei(); if (imei != NULL) { tr_debug("IMEI is %s.", imei); } else { TEST_ASSERT(false); } meid = interface->meid(); if (meid != NULL) { tr_debug("MEID is %s.", meid); } else { TEST_ASSERT(false); } imsi = interface->imsi(); if (imsi != NULL) { tr_debug("IMSI is %s.", imsi); } else { TEST_ASSERT(false); } iccid = interface->iccid(); if (iccid != NULL) { tr_debug("ICCID is %s.", iccid); } else { TEST_ASSERT(false); } // Check the RSSI call at least doesn't assert rssi = interface->rssi(); tr_debug("RSSI is %d dBm.", rssi); // Now connect and check that the answers for the // static fields are the same while connected TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(strcmp(imei, interface->imei()) == 0); TEST_ASSERT(strcmp(meid, interface->meid()) == 0); TEST_ASSERT(strcmp(imsi, interface->imsi()) == 0); TEST_ASSERT(strcmp(iccid, interface->iccid()) == 0); // Check that the RSSI call still doesn't assert rssi = interface->rssi(); tr_debug("RSSI is %d dBm.", rssi); } // Call srand() using the NTP server void test_set_randomise() { UDPSocket sock; SocketAddress host_address; TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); do_ntp(interface); TEST_ASSERT(!connection_has_gone_down); drop_connection(interface); interface->deinit(); } #ifdef MBED_CONF_APP_ECHO_SERVER // Test UDP data exchange void test_udp_echo() { UDPSocket sock; SocketAddress host_address; SocketAddress local_address; int x; int size; TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_ECHO_UDP_PORT); tr_debug("UDP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, host_address.get_ip_address(), host_address.get_port()); TEST_ASSERT(sock.open(interface) == 0) // Do a bind, just for the helluvit local_address.set_port(MBED_CONF_APP_LOCAL_PORT); TEST_ASSERT(sock.bind(local_address) == 0); sock.set_timeout(10000); // Test min, max, and some random sizes in-between do_udp_echo(&sock, &host_address, 1); do_udp_echo(&sock, &host_address, MBED_CONF_APP_UDP_MAX_PACKET_SIZE); for (x = 0; x < 10; x++) { size = (rand() % MBED_CONF_APP_UDP_MAX_PACKET_SIZE) + 1; size = fix(size, MBED_CONF_APP_UDP_MAX_PACKET_SIZE); do_udp_echo(&sock, &host_address, size); } sock.close(); drop_connection(interface); interface->deinit(); tr_debug("%d UDP packets of size up to %d byte(s) echoed successfully.", x, MBED_CONF_APP_UDP_MAX_PACKET_SIZE); } // Test many different sizes of UDP data arriving at once void test_udp_echo_recv_sizes() { UDPSocket sock; SocketAddress host_address; int x, y, z; int size; int tries = 0; unsigned int offset; char * recv_data; bool packetLoss; bool sendSuccess; Timer timer; interface->deinit(); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_ECHO_UDP_PORT); tr_debug("UDP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, host_address.get_ip_address(), host_address.get_port()); TEST_ASSERT(sock.open(interface) == 0) do { tr_debug("--- UDP packet size test, test try %d, flushing input buffers", tries + 1); // First of all, clear any junk from the socket sock.set_timeout(1000); recv_data = (char *) malloc (MBED_CONF_APP_UDP_MAX_PACKET_SIZE); TEST_ASSERT(recv_data != NULL); while (sock.recvfrom(&host_address, (void *) recv_data, MBED_CONF_APP_UDP_MAX_PACKET_SIZE) > 0) { // Throw it away } free (recv_data); sock.set_timeout(10000); // Throw random sized UDP packets up... x = 0; offset = 0; while (offset < sizeof (send_data)) { size = (rand() % (MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2)) + 1; size = fix(size, MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2); if (offset + size > sizeof (send_data)) { size = sizeof (send_data) - offset; } sendSuccess = false; for (y = 0; !sendSuccess && (y < NUM_UDP_RETRIES); y++) { tr_debug("Sending UDP packet number %d, size %d byte(s), send try %d.", x + 1, size, y + 1); if (sock.sendto(host_address, (void *) (send_data + offset), size) == size) { sendSuccess = true; offset += size; } } TEST_ASSERT(sendSuccess); x++; } tr_debug("--- All UDP packets sent"); // ...and capture them all again afterwards recv_data = (char *) malloc (sizeof (send_data)); TEST_ASSERT(recv_data != NULL); memset (recv_data, 0, sizeof (send_data)); size = 0; y = 0; packetLoss = false; timer.start(); while ((size < (int) sizeof (send_data)) && (timer.read_ms() < 10000)) { y = sock.recvfrom(&host_address, (void *) (recv_data + size), sizeof (send_data) - size); if (y > 0) { size += y; } } timer.stop(); timer.reset(); tr_debug( "--- Either received everything back or timed out waiting"); // Check that we reassembled everything correctly if (size == sizeof (send_data)) { for (x = 0; ((*(recv_data + x) == *(send_data + x))) && (x < (int) sizeof (send_data)); x++) { } if (x != sizeof (send_data)) { y = x - 5; if (y < 0) { y = 0; } z = 10; if (y + z > (int) sizeof (send_data)) { z = sizeof(send_data) - y; } tr_debug(" --- Difference at character %d (send \"%*.*s\", recv \"%*.*s\")", x + 1, z, z, send_data + y, z, z, recv_data + y); packetLoss = true; } } else { tr_debug(" --- %d bytes missing (%d bytes received when %d were expected))", sizeof (send_data) - size, size, sizeof (send_data)); packetLoss = true; } free (recv_data); tries++; } while (packetLoss && (tries < NUM_UDP_RETRIES)); TEST_ASSERT(!packetLoss); TEST_ASSERT(!connection_has_gone_down); sock.close(); drop_connection(interface); interface->deinit(); } // Test UDP data exchange via the asynchronous sigio() mechanism void test_udp_echo_async() { UDPSocket sock; SocketAddress host_address; SocketAddress local_address; bool callback_triggered = false; int x; int size; interface->deinit(); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_ECHO_UDP_PORT); tr_debug("UDP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, host_address.get_ip_address(), host_address.get_port()); TEST_ASSERT(sock.open(interface) == 0) // Set up the async callback and set the timeout to zero sock.sigio(callback(async_cb, &callback_triggered)); sock.set_timeout(0); // Test min, max, and some random sizes in-between // and this time allow the UDP packets to be fragmented do_udp_echo_async(&sock, &host_address, 1, &callback_triggered); do_udp_echo_async(&sock, &host_address, MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE, &callback_triggered); for (x = 0; x < 10; x++) { size = (rand() % MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE) + 1; size = fix(size, MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE); do_udp_echo_async(&sock, &host_address, size, &callback_triggered); } sock.close(); drop_connection(interface); interface->deinit(); tr_debug("%d UDP packets of size up to %d byte(s) echoed asynchronously and successfully.", x, MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE); } // Test many different sizes of TCP data arriving at once void test_tcp_echo_recv_sizes() { TCPSocket sock; SocketAddress host_address; int x, y, z; int size; unsigned int offset; char * recv_data; Timer timer; interface->deinit(); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_ECHO_TCP_PORT); tr_debug("TCP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, host_address.get_ip_address(), host_address.get_port()); TEST_ASSERT(sock.open(interface) == 0) TEST_ASSERT(sock.connect(host_address) == 0); sock.set_timeout(10000); // Throw random sized TCP packets up... x = 0; offset = 0; while (offset < sizeof (send_data)) { size = (rand() % (MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2)) + 1; size = fix(size, MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2); if (offset + size > sizeof (send_data)) { size = sizeof (send_data) - offset; } tr_debug("Sending TCP packet number %d, size %d byte(s).", x + 1, size); TEST_ASSERT(sendAll(&sock, (send_data + offset), size) == size); offset += size; x++; } // ...and capture them all again afterwards recv_data = (char *) malloc (sizeof (send_data)); TEST_ASSERT(recv_data != NULL); memset (recv_data, 0, sizeof (send_data)); size = 0; x = 0; timer.start(); while ((size < (int) sizeof (send_data)) && (timer.read_ms() < 30000)) { y = sock.recv((void *) (recv_data + size), sizeof (send_data) - size); tr_debug("Received TCP packet number %d, size %d byte(s).", x, y); size += y; x++; } timer.stop(); timer.reset(); // Check that we reassembled everything correctly for (x = 0; ((*(recv_data + x) == *(send_data + x))) && (x < (int) sizeof (send_data)); x++) { } if (x != sizeof (send_data)) { y = x - 5; if (y < 0) { y = 0; } z = 10; if (y + z > (int) sizeof (send_data)) { z = sizeof(send_data) - y; } tr_debug("Difference at character %d (send \"%*.*s\", recv \"%*.*s\")", x + 1, z, z, send_data + y, z, z, recv_data + y); TEST_ASSERT(false); } free (recv_data); TEST_ASSERT(!connection_has_gone_down); sock.close(); drop_connection(interface); interface->deinit(); } // Test TCP data exchange via the asynchronous sigio() mechanism void test_tcp_echo_async() { TCPSocket sock; SocketAddress host_address; bool callback_triggered = false; int x; int size; interface->deinit(); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_ECHO_TCP_PORT); tr_debug("TCP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, host_address.get_ip_address(), host_address.get_port()); TEST_ASSERT(sock.open(interface) == 0) // Set up the async callback and set the timeout to zero sock.sigio(callback(async_cb, &callback_triggered)); sock.set_timeout(0); TEST_ASSERT(sock.connect(host_address) == 0); // Test min, max, and some random sizes in-between do_tcp_echo_async(&sock, 1, &callback_triggered); do_tcp_echo_async(&sock, MBED_CONF_APP_TCP_MAX_PACKET_SIZE, &callback_triggered); for (x = 0; x < 10; x++) { size = (rand() % MBED_CONF_APP_TCP_MAX_PACKET_SIZE) + 1; size = fix(size, MBED_CONF_APP_TCP_MAX_PACKET_SIZE); do_tcp_echo_async(&sock, size, &callback_triggered); } sock.close(); drop_connection(interface); interface->deinit(); tr_debug("%d TCP packets of size up to %d byte(s) echoed asynchronously and successfully.", x, MBED_CONF_APP_TCP_MAX_PACKET_SIZE); } #endif // Allocate max sockets void test_max_sockets() { UDPSocket sock[MAX_NUM_SOCKETS]; UDPSocket sockNone; SocketAddress host_address; TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_NTP_SERVER, &host_address) == 0); host_address.set_port(MBED_CONF_APP_NTP_PORT); // Open the first socket and use it TEST_ASSERT(sock[0].open(interface) == 0) sock[0].set_timeout(10000); do_ntp_sock(&sock[0], host_address); // Check that we stop being able to get sockets at the max number for (int x = 1; x < (int) (sizeof (sock) / sizeof (sock[0])); x++) { TEST_ASSERT(sock[x].open(interface) == 0) } TEST_ASSERT(sockNone.open(interface) < 0); // Now use the last one sock[sizeof (sock) / sizeof (sock[0]) - 1].set_timeout(10000); do_ntp_sock(&sock[sizeof (sock) / sizeof (sock[0]) - 1], host_address); // Close all of the sockets for (int x = 0; x < (int) (sizeof (sock) / sizeof (sock[0])); x++) { TEST_ASSERT(sock[x].close() == 0); } drop_connection(interface); interface->deinit(); } // Connect with credentials included in the connect request void test_connect_credentials() { interface->deinit(); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->deinit(); } // Test with credentials preset void test_connect_preset_credentials() { interface->deinit(); TEST_ASSERT(interface->init(MBED_CONF_APP_DEFAULT_PIN)); interface->set_credentials(MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN) == 0); use_connection(interface); drop_connection(interface); interface->deinit(); } // Test adding and using a SIM pin, then removing it, using the pending // mechanism where the change doesn't occur until connect() is called void test_check_sim_pin_pending() { interface->deinit(); // Enable PIN checking (which will use the current PIN) // and also flag that the PIN should be changed to MBED_CONF_APP_ALT_PIN, // then try connecting interface->set_sim_pin_check(true); interface->set_new_sim_pin(MBED_CONF_APP_ALT_PIN); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->deinit(); // Now change the PIN back to what it was before interface->set_new_sim_pin(MBED_CONF_APP_DEFAULT_PIN); TEST_ASSERT(interface->connect(MBED_CONF_APP_ALT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->deinit(); // Check that it was changed back, and this time // use the other way of entering the PIN interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); TEST_ASSERT(interface->connect(NULL, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->deinit(); // Remove PIN checking again and check that it no // longer matters what the PIN is interface->set_sim_pin_check(false); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->deinit(); TEST_ASSERT(interface->init(NULL)); TEST_ASSERT(interface->connect(MBED_CONF_APP_INCORRECT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); // Put the SIM pin back to the correct value for any subsequent tests interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); interface->deinit(); } // Test adding and using a SIM pin, then removing it, using the immediate // mechanism void test_check_sim_pin_immediate() { interface->deinit(); interface->connection_status_cb(connection_down_cb); // Enable PIN checking (which will use the current PIN), change // the PIN to MBED_CONF_APP_ALT_PIN, then try connecting after powering on and // off the modem interface->set_sim_pin_check(true, true, MBED_CONF_APP_DEFAULT_PIN); interface->set_new_sim_pin(MBED_CONF_APP_ALT_PIN, true); interface->deinit(); TEST_ASSERT(interface->init(NULL)); TEST_ASSERT(interface->connect(MBED_CONF_APP_ALT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->connection_status_cb(connection_down_cb); // Now change the PIN back to what it was before interface->set_new_sim_pin(MBED_CONF_APP_DEFAULT_PIN, true); interface->deinit(); interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); TEST_ASSERT(interface->init(NULL)); TEST_ASSERT(interface->connect(NULL, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); interface->connection_status_cb(connection_down_cb); // Remove PIN checking again and check that it no // longer matters what the PIN is interface->set_sim_pin_check(false, true); interface->deinit(); TEST_ASSERT(interface->init(MBED_CONF_APP_INCORRECT_PIN)); TEST_ASSERT(interface->connect(NULL, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(interface); drop_connection(interface); // Put the SIM pin back to the correct value for any subsequent tests interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); interface->deinit(); } // Test being able to connect with a local instance of the interface // NOTE: since this local instance will fiddle with bits of HW that the // static instance thought it owned, the static instance will no longer // work afterwards, hence this must be run as the last test in the list void test_connect_local_instance_last_test() { UbloxATCellularInterface *pLocalInterface = NULL; pLocalInterface = new UbloxATCellularInterface(MDMTXD, MDMRXD, MBED_CONF_UBLOX_CELL_BAUD_RATE, MBED_CONF_APP_DEBUG_ON); pLocalInterface->connection_status_cb(connection_down_cb); TEST_ASSERT(pLocalInterface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); use_connection(pLocalInterface); drop_connection(pLocalInterface); delete pLocalInterface; } #if defined (TARGET_UBLOX_C030_U201) || defined (TARGET_UBLOX_C030_R412M) void test_set_new_rat() { int currentSelectedRat = -1, currentPreferredRat = -1, currentSecondPreferredRat = -1; // Power-up the modem TEST_ASSERT(interface->init()); interface->set_functionality_mode(UbloxCellularBase::FUNC_FULL); // Check if modem is registered with network if (interface->is_registered_csd() || interface->is_registered_psd() || interface->is_registered_eps()) { tr_error("RAT should only be set in detached state"); // Deregister from Network drop_connection(interface); } // Get and store initial RAT set on modem TEST_ASSERT(interface->get_modem_rat(&previousSelectedRat, &previousPreferredRat, &previousSecondPreferredRat)); tr_debug("previous selected RAT: %d\nprevious preferred RAT: %d\nprevious second preferred RAT: %d\n", previousSelectedRat, previousPreferredRat, previousSecondPreferredRat); #ifdef TARGET_UBLOX_C030_U201 // Set new RAT TEST_ASSERT(interface->set_modem_rat(UbloxATCellularInterface::GSM_UMTS, UbloxATCellularInterface::UMTS)); tr_debug("RAT configured\n"); // Get latest set RAT on modem TEST_ASSERT(interface->get_modem_rat(¤tSelectedRat, ¤tPreferredRat, ¤tSecondPreferredRat)); tr_debug("new selected RAT: %d\nnew preferred RAT: %d\nnew second preferred RAT: %d\n", currentSelectedRat, currentPreferredRat, currentSecondPreferredRat); // Check RAT configured correctly TEST_ASSERT((currentSelectedRat == UbloxATCellularInterface::GSM_UMTS) && (currentPreferredRat == UbloxATCellularInterface::UMTS)); #elif TARGET_UBLOX_C030_R412M // Set new RAT TEST_ASSERT(interface->set_modem_rat(UbloxATCellularInterface::LTE_CATM1, UbloxATCellularInterface::LTE_CATNB1, UbloxATCellularInterface::GPRS_EGPRS)); tr_debug("RAT configured\n"); // Get latest set RAT on modem TEST_ASSERT(interface->get_modem_rat(¤tSelectedRat, ¤tPreferredRat, ¤tSecondPreferredRat)); tr_debug("new selected RAT: %d\nnew preferred RAT: %d\nnew second preferred RAT: %d\n", currentSelectedRat, currentPreferredRat, currentSecondPreferredRat); // Check RAT configured correctly TEST_ASSERT((currentSelectedRat == UbloxATCellularInterface::LTE_CATM1) && (currentPreferredRat == UbloxATCellularInterface::LTE_CATNB1)); #endif } void test_reboot() { // Rebooting modem for settings to take effect TEST_ASSERT(interface->reboot_modem()); } void test_registration() { TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); drop_connection(interface); } void test_set_previous_rat() { int currentSelectedRat = -1, currentPreferredRat = -1, currentSecondPreferredRat = -1; // Restore RAT to previous settings TEST_ASSERT(interface->set_modem_rat((UbloxATCellularInterface::RAT)previousSelectedRat, (UbloxATCellularInterface::RAT)previousPreferredRat, (UbloxATCellularInterface::RAT)previousSecondPreferredRat)); tr_debug("RAT configured\n"); TEST_ASSERT(interface->get_modem_rat(¤tSelectedRat, ¤tPreferredRat, ¤tSecondPreferredRat)); tr_debug("current selected RAT: %d\ncurrent preferred RAT: %d\ncurrent second preferred RAT: %d\n", currentSelectedRat, currentPreferredRat, currentSecondPreferredRat); // Check RAT configured correctly TEST_ASSERT((currentSelectedRat == previousSelectedRat) && (currentPreferredRat == previousPreferredRat)); // Rebooting modem for settings to take effect TEST_ASSERT(interface->reboot_modem()); } #endif #ifdef TARGET_UBLOX_C030_R41XM void test_mno_profile() { int previous_profile, current_profile; // Power-up the modem interface->init(MBED_CONF_APP_DEFAULT_PIN); //init can return false if profile set is SW_DEFAULT // Check if modem is registered with network if (interface->is_registered_csd() || interface->is_registered_psd() || interface->is_registered_eps()) { tr_error("MNO profile should only be set in detached state"); // Deregister from Network drop_connection(interface); } // Getting current mno profile TEST_ASSERT(interface->get_mno_profile(&previous_profile)); tr_debug("Previous MNO profile is: %d\n", previous_profile); // Set MNO profile TEST_ASSERT(interface->set_mno_profile(UbloxATCellularInterface::STANDARD_EU)); tr_debug("MNO configured\n"); // Rebooting modem for settings to take effect TEST_ASSERT(interface->reboot_modem()); tr_debug("Reboot successful\n"); ThisThread::sleep_for(5000); TEST_ASSERT(interface->init(MBED_CONF_APP_DEFAULT_PIN)); // Check MNO profile configured correctly TEST_ASSERT(interface->get_mno_profile(¤t_profile)); tr_debug("New MNO profile is: %d\n", current_profile); TEST_ASSERT(interface->disable_power_saving_mode()); TEST_ASSERT((UbloxATCellularInterface::MNOProfile)current_profile == UbloxATCellularInterface::STANDARD_EU); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); drop_connection(interface); interface->deinit(); } void test_edrx() { const int c_edrx_value = 2; // Power-up the modem TEST_ASSERT(interface->init(MBED_CONF_APP_DEFAULT_PIN)); // Check if modem is registered with network if (interface->is_registered_csd() || interface->is_registered_psd() || interface->is_registered_eps()) { tr_error("set edrx in detached state"); // Deregister from Network drop_connection(interface); } //disable edrx interface->set_receive_period(3, UbloxCellularBase::EDRXEUTRAN_WB_S1_mode); interface->set_receive_period(3, UbloxCellularBase::EDRXEUTRAN_NB_S1_mode); //set edrx interface->set_receive_period(2, UbloxCellularBase::EDRXEUTRAN_WB_S1_mode, c_edrx_value); interface->set_receive_period(2, UbloxCellularBase::EDRXEUTRAN_NB_S1_mode, c_edrx_value); TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); TEST_ASSERT(interface->get_receive_period() == c_edrx_value); drop_connection(interface); //re-apply default mno profile TEST_ASSERT(interface->set_mno_profile(UbloxATCellularInterface::STANDARD_EU)); TEST_ASSERT(interface->reboot_modem()); ThisThread::sleep_for(5000); TEST_ASSERT(interface->init(MBED_CONF_APP_DEFAULT_PIN)); TEST_ASSERT(interface->disable_power_saving_mode()); } #endif // ---------------------------------------------------------------- // TEST ENVIRONMENT // ---------------------------------------------------------------- // Setup the test environment utest::v1::status_t test_setup(const size_t number_of_cases) { // Setup Greentea with a timeout GREENTEA_SETUP(960, "default_auto"); return verbose_test_setup_handler(number_of_cases); } // IMPORTANT!!! if you make a change to the tests here you should // check whether the same change should be made to the tests under // the PPP interface. // Test cases Case cases[] = { #ifdef TARGET_UBLOX_C030_R41XM Case("MNO profile test", test_mno_profile), Case("edrx test", test_edrx), #endif Case("Base class tests", test_base_class), Case("Set randomise", test_set_randomise), #ifdef MBED_CONF_APP_ECHO_SERVER Case("UDP echo test", test_udp_echo), # ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 to run this test Case("UDP recv sizes", test_udp_echo_recv_sizes), # endif Case("UDP async echo test", test_udp_echo_async), # ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 to run this test Case("TCP recv sizes", test_tcp_echo_recv_sizes), # endif Case("TCP async echo test", test_tcp_echo_async), #endif #ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 to run this test Case("Alloc max sockets", test_max_sockets), #endif Case("Connect with credentials", test_connect_credentials), Case("Connect with preset credentials", test_connect_preset_credentials), #if MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS Case("Check SIM pin, pending", test_check_sim_pin_pending), Case("Check SIM pin, immediate", test_check_sim_pin_immediate), #endif #if defined (TARGET_UBLOX_C030_U201) || defined (TARGET_UBLOX_C030_R412M) Case("Set RAT test", test_set_new_rat), Case("Reboot test", test_reboot), Case("Register with network test", test_registration), Case("Set previous RAT test", test_set_previous_rat), #endif #ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 for this Case("Connect using local instance, must be last test", test_connect_local_instance_last_test) #endif }; Specification specification(test_setup, cases); // ---------------------------------------------------------------- // MAIN // ---------------------------------------------------------------- int main() { #ifdef FEATURE_COMMON_PAL mbed_trace_init(); mbed_trace_mutex_wait_function_set(lock); mbed_trace_mutex_release_function_set(unlock); #endif interface->connection_status_cb(connection_down_cb); // Run tests return !Harness::run(specification); } // End Of File