UBLOX Tool Lahore
Retry
Fork of
ublox-at-cellular-interface
by 
u-blox
Embed:
(wiki syntax)
Show/hide line numbers
main.cpp
00001 #include "UbloxATCellularInterface.h" 00002 #include "greentea-client/test_env.h" 00003 #include "unity.h" 00004 #include "utest.h" 00005 #include "UDPSocket.h" 00006 #ifdef FEATURE_COMMON_PAL 00007 #include "mbed_trace.h" 00008 #define TRACE_GROUP "TEST" 00009 #else 00010 #define tr_debug(format, ...) debug(format "\n", ## __VA_ARGS__) 00011 #define tr_info(format, ...) debug(format "\n", ## __VA_ARGS__) 00012 #define tr_warn(format, ...) debug(format "\n", ## __VA_ARGS__) 00013 #define tr_error(format, ...) debug(format "\n", ## __VA_ARGS__) 00014 #endif 00015 00016 using namespace utest::v1; 00017 00018 // IMPORTANT!!! if you make a change to the tests here you should 00019 // check whether the same change should be made to the tests under 00020 // the PPP interface. 00021 00022 // NOTE: these test are only as reliable as UDP across the internet 00023 // over a radio link. The tests expect an NTP server to respond 00024 // to UDP packets and, if configured, an echo server to respond 00025 // to UDP packets. This simply may not happen. Please be patient. 00026 00027 // ---------------------------------------------------------------- 00028 // COMPILE-TIME MACROS 00029 // ---------------------------------------------------------------- 00030 00031 // These macros can be overridden with an mbed_app.json file and 00032 // contents of the following form: 00033 // 00034 //{ 00035 // "config": { 00036 // "default-pin": { 00037 // "value": "\"1234\"" 00038 // } 00039 //} 00040 // 00041 // See the template_mbed_app.txt in this directory for a fuller example. 00042 00043 // Whether debug trace is on 00044 #ifndef MBED_CONF_APP_DEBUG_ON 00045 # define MBED_CONF_APP_DEBUG_ON false 00046 #endif 00047 00048 // Run the SIM change tests, which require the DEFAULT_PIN 00049 // above to be correct for the board on which the test 00050 // is being run (and the SIM PIN to be disabled before tests run). 00051 #ifndef MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS 00052 # define MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS 0 00053 #endif 00054 00055 #if MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS 00056 # ifndef MBED_CONF_APP_DEFAULT_PIN 00057 # error "MBED_CONF_APP_DEFAULT_PIN must be defined to run the SIM tests" 00058 # endif 00059 # ifndef MBED_CONF_APP_ALT_PIN 00060 # error "MBED_CONF_APP_ALT_PIN must be defined to run the SIM tests" 00061 # endif 00062 # ifndef MBED_CONF_APP_INCORRECT_PIN 00063 # error "MBED_CONF_APP_INCORRECT_PIN must be defined to run the SIM tests" 00064 # endif 00065 #endif 00066 00067 // The credentials of the SIM in the board. 00068 #ifndef MBED_CONF_APP_DEFAULT_PIN 00069 // Note: if PIN is enabled on your SIM, or you wish to run the SIM PIN change 00070 // tests, you must define the PIN for your SIM (see note above on using 00071 // mbed_app.json to do so). 00072 # define MBED_CONF_APP_DEFAULT_PIN "0000" 00073 #endif 00074 #ifndef MBED_CONF_APP_APN 00075 # define MBED_CONF_APP_APN NULL 00076 #endif 00077 #ifndef MBED_CONF_APP_USERNAME 00078 # define MBED_CONF_APP_USERNAME NULL 00079 #endif 00080 #ifndef MBED_CONF_APP_PASSWORD 00081 # define MBED_CONF_APP_PASSWORD NULL 00082 #endif 00083 00084 // Alternate PIN to use during pin change testing 00085 #ifndef MBED_CONF_APP_ALT_PIN 00086 # define MBED_CONF_APP_ALT_PIN "9876" 00087 #endif 00088 00089 // A PIN that is definitely incorrect 00090 #ifndef MBED_CONF_APP_INCORRECT_PIN 00091 # define MBED_CONF_APP_INCORRECT_PIN "1530" 00092 #endif 00093 00094 // Servers and ports 00095 #ifdef MBED_CONF_APP_ECHO_SERVER 00096 # ifndef MBED_CONF_APP_ECHO_UDP_PORT 00097 # error "MBED_CONF_APP_ECHO_UDP_PORT (the port on which your echo server echoes UDP packets) must be defined" 00098 # endif 00099 # ifndef MBED_CONF_APP_ECHO_TCP_PORT 00100 # error "MBED_CONF_APP_ECHO_TCP_PORT (the port on which your echo server echoes TCP packets) must be defined" 00101 # endif 00102 #endif 00103 00104 #ifndef MBED_CONF_APP_NTP_SERVER 00105 # define MBED_CONF_APP_NTP_SERVER "2.pool.ntp.org" 00106 #else 00107 # ifndef MBED_CONF_APP_NTP_PORT 00108 # error "MBED_CONF_APP_NTP_PORT must be defined if MBED_CONF_APP_NTP_SERVER is defined" 00109 # endif 00110 #endif 00111 #ifndef MBED_CONF_APP_NTP_PORT 00112 # define MBED_CONF_APP_NTP_PORT 123 00113 #endif 00114 00115 #ifndef MBED_CONF_APP_LOCAL_PORT 00116 # define MBED_CONF_APP_LOCAL_PORT 15 00117 #endif 00118 00119 // UDP packet size limit for testing 00120 #ifndef MBED_CONF_APP_UDP_MAX_PACKET_SIZE 00121 # define MBED_CONF_APP_UDP_MAX_PACKET_SIZE 1024 00122 #endif 00123 00124 // The maximum size of UDP data fragmented across 00125 // multiple packets 00126 #ifndef MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE 00127 # define MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE 1500 00128 #endif 00129 00130 // TCP packet size limit for testing 00131 #ifndef MBED_CONF_APP_MBED_CONF_APP_TCP_MAX_PACKET_SIZE 00132 # define MBED_CONF_APP_TCP_MAX_PACKET_SIZE 1500 00133 #endif 00134 00135 // The number of retries for UDP exchanges 00136 #define NUM_UDP_RETRIES 5 00137 00138 // How long to wait for stuff to travel in the async echo tests 00139 #define ASYNC_TEST_WAIT_TIME 10000 00140 00141 // The maximum number of sockets that can be open at one time 00142 #define MAX_NUM_SOCKETS 7 00143 00144 // ---------------------------------------------------------------- 00145 // PRIVATE VARIABLES 00146 // ---------------------------------------------------------------- 00147 00148 #ifdef FEATURE_COMMON_PAL 00149 // Lock for debug prints 00150 static Mutex mtx; 00151 #endif 00152 00153 // An instance of the cellular interface 00154 static UbloxATCellularInterface *interface = 00155 new UbloxATCellularInterface(MDMTXD, MDMRXD, 00156 MBED_CONF_UBLOX_CELL_BAUD_RATE, 00157 MBED_CONF_APP_DEBUG_ON); 00158 00159 // Connection flag 00160 static bool connection_has_gone_down = false; 00161 00162 // Data to exchange 00163 static const char send_data[] = "_____0000:0123456789012345678901234567890123456789" 00164 "01234567890123456789012345678901234567890123456789" 00165 "_____0100:0123456789012345678901234567890123456789" 00166 "01234567890123456789012345678901234567890123456789" 00167 "_____0200:0123456789012345678901234567890123456789" 00168 "01234567890123456789012345678901234567890123456789" 00169 "_____0300:0123456789012345678901234567890123456789" 00170 "01234567890123456789012345678901234567890123456789" 00171 "_____0400:0123456789012345678901234567890123456789" 00172 "01234567890123456789012345678901234567890123456789" 00173 "_____0500:0123456789012345678901234567890123456789" 00174 "01234567890123456789012345678901234567890123456789" 00175 "_____0600:0123456789012345678901234567890123456789" 00176 "01234567890123456789012345678901234567890123456789" 00177 "_____0700:0123456789012345678901234567890123456789" 00178 "01234567890123456789012345678901234567890123456789" 00179 "_____0800:0123456789012345678901234567890123456789" 00180 "01234567890123456789012345678901234567890123456789" 00181 "_____0900:0123456789012345678901234567890123456789" 00182 "01234567890123456789012345678901234567890123456789" 00183 "_____1000:0123456789012345678901234567890123456789" 00184 "01234567890123456789012345678901234567890123456789" 00185 "_____1100:0123456789012345678901234567890123456789" 00186 "01234567890123456789012345678901234567890123456789" 00187 "_____1200:0123456789012345678901234567890123456789" 00188 "01234567890123456789012345678901234567890123456789" 00189 "_____1300:0123456789012345678901234567890123456789" 00190 "01234567890123456789012345678901234567890123456789" 00191 "_____1400:0123456789012345678901234567890123456789" 00192 "01234567890123456789012345678901234567890123456789" 00193 "_____1500:0123456789012345678901234567890123456789" 00194 "01234567890123456789012345678901234567890123456789" 00195 "_____1600:0123456789012345678901234567890123456789" 00196 "01234567890123456789012345678901234567890123456789" 00197 "_____1700:0123456789012345678901234567890123456789" 00198 "01234567890123456789012345678901234567890123456789" 00199 "_____1800:0123456789012345678901234567890123456789" 00200 "01234567890123456789012345678901234567890123456789" 00201 "_____1900:0123456789012345678901234567890123456789" 00202 "01234567890123456789012345678901234567890123456789" 00203 "_____2000:0123456789012345678901234567890123456789" 00204 "01234567890123456789012345678901234567890123456789"; 00205 00206 // ---------------------------------------------------------------- 00207 // PRIVATE FUNCTIONS 00208 // ---------------------------------------------------------------- 00209 00210 #ifdef FEATURE_COMMON_PAL 00211 // Locks for debug prints 00212 static void lock() 00213 { 00214 mtx.lock(); 00215 } 00216 00217 static void unlock() 00218 { 00219 mtx.unlock(); 00220 } 00221 #endif 00222 00223 // Callback in case the connection goes down 00224 static void connection_down_cb(nsapi_error_t err) 00225 { 00226 connection_has_gone_down = true; 00227 } 00228 00229 #ifdef MBED_CONF_APP_ECHO_SERVER 00230 // Make sure that size is greater than 0 and no more than limit, 00231 // useful since, when moduloing a very large number number, 00232 // compilers sometimes screw up and produce a small *negative* 00233 // number. Who knew? For example, GCC decided that 00234 // 492318453 (0x1d582ef5) modulo 508 was -47 (0xffffffd1). 00235 static int fix (int size, int limit) 00236 { 00237 if (size <= 0) { 00238 size = limit / 2; // better than 1 00239 } else if (size > limit) { 00240 size = limit; 00241 } 00242 00243 return size; 00244 } 00245 00246 // Do a UDP socket echo test to a given host of a given packet size 00247 static void do_udp_echo(UDPSocket *sock, SocketAddress *host_address, int size) 00248 { 00249 bool success = false; 00250 void * recv_data = malloc (size); 00251 SocketAddress sender_address; 00252 TEST_ASSERT(recv_data != NULL); 00253 00254 // Retry this a few times, don't want to fail due to a flaky link 00255 for (int x = 0; !success && (x < NUM_UDP_RETRIES); x++) { 00256 tr_debug("Echo testing UDP packet size %d byte(s), try %d.", size, x + 1); 00257 if ((sock->sendto(*host_address, (void*) send_data, size) == size) && 00258 (sock->recvfrom(&sender_address, recv_data, size) == size)) { 00259 TEST_ASSERT (memcmp(send_data, recv_data, size) == 0); 00260 TEST_ASSERT (strcmp(sender_address.get_ip_address(), host_address->get_ip_address()) == 0); 00261 TEST_ASSERT (sender_address.get_port() == host_address->get_port()); 00262 success = true; 00263 } 00264 } 00265 TEST_ASSERT (success); 00266 TEST_ASSERT(!connection_has_gone_down); 00267 00268 free (recv_data); 00269 } 00270 00271 // The asynchronous callback 00272 static void async_cb(bool *callback_triggered) 00273 { 00274 00275 TEST_ASSERT (callback_triggered != NULL); 00276 *callback_triggered = true; 00277 } 00278 00279 // Do a UDP echo but using the asynchronous interface; we can exchange 00280 // packets longer in size than one UDP packet this way 00281 static void do_udp_echo_async(UDPSocket *sock, SocketAddress *host_address, 00282 int size, bool *callback_triggered) 00283 { 00284 void * recv_data = malloc (size); 00285 int recv_size = 0; 00286 SocketAddress sender_address; 00287 Timer timer; 00288 int x, y, z; 00289 TEST_ASSERT(recv_data != NULL); 00290 00291 *callback_triggered = false; 00292 for (y = 0; (recv_size < size) && (y < NUM_UDP_RETRIES); y++) { 00293 tr_debug("Echo testing UDP packet size %d byte(s) async, try %d.", size, y + 1); 00294 recv_size = 0; 00295 // Retry this a few times, don't want to fail due to a flaky link 00296 if (sock->sendto(*host_address, (void *) send_data, size) == size) { 00297 // Wait for all the echoed data to arrive 00298 timer.start(); 00299 while ((recv_size < size) && (timer.read_ms() < ASYNC_TEST_WAIT_TIME)) { 00300 if (*callback_triggered) { 00301 *callback_triggered = false; 00302 x = sock->recvfrom(&sender_address, (char *) recv_data + recv_size, size); 00303 if (x > 0) { 00304 recv_size += x; 00305 } 00306 tr_debug("%d byte(s) echoed back so far, %d to go.", recv_size, size - recv_size); 00307 TEST_ASSERT(strcmp(sender_address.get_ip_address(), host_address->get_ip_address()) == 0); 00308 TEST_ASSERT(sender_address.get_port() == host_address->get_port()); 00309 } 00310 wait_ms(10); 00311 } 00312 timer.stop(); 00313 timer.reset(); 00314 00315 // If everything arrived back, check it's the same as we sent 00316 if (recv_size == size) { 00317 z = memcmp(send_data, recv_data, size); 00318 if (z != 0) { 00319 tr_debug("WARNING: mismatch, retrying"); 00320 tr_debug("Sent %d, |%*.*s|", size, size, size, send_data); 00321 tr_debug("Rcvd %d, |%*.*s|", size, size, size, (char *) recv_data); 00322 // If things don't match, it could be due to data loss (this is UDP 00323 // you know...), so set recv_size to 0 to cause another try 00324 recv_size = 0; 00325 } 00326 } 00327 } 00328 } 00329 00330 TEST_ASSERT(recv_size == size); 00331 TEST_ASSERT(!connection_has_gone_down); 00332 00333 free (recv_data); 00334 } 00335 00336 // Send an entire TCP data buffer until done 00337 static int sendAll(TCPSocket *sock, const char *data, int size) 00338 { 00339 int x; 00340 int count = 0; 00341 Timer timer; 00342 00343 timer.start(); 00344 while ((count < size) && (timer.read_ms() < 10000)) { 00345 x = sock->send(data + count, size - count); 00346 if (x > 0) { 00347 count += x; 00348 tr_debug("%d byte(s) sent, %d left to send.", count, size - count); 00349 } 00350 wait_ms(10); 00351 } 00352 timer.stop(); 00353 00354 return count; 00355 } 00356 00357 // Do a TCP echo but using the asynchronous interface 00358 static void do_tcp_echo_async(TCPSocket *sock, int size, bool *callback_triggered) 00359 { 00360 void * recv_data = malloc (size); 00361 int recv_size = 0; 00362 int x, y; 00363 Timer timer; 00364 TEST_ASSERT(recv_data != NULL); 00365 00366 *callback_triggered = false; 00367 tr_debug("Echo testing TCP packet size %d byte(s) async.", size); 00368 TEST_ASSERT (sendAll(sock, send_data, size) == size); 00369 00370 // Wait for all the echoed data to arrive 00371 timer.start(); 00372 while ((recv_size < size) && (timer.read_ms() < ASYNC_TEST_WAIT_TIME)) { 00373 if (*callback_triggered) { 00374 *callback_triggered = false; 00375 x = sock->recv((char *) recv_data + recv_size, size); 00376 TEST_ASSERT(x > 0); 00377 recv_size += x; 00378 tr_debug("%d byte(s) echoed back so far, %d to go.", recv_size, size - recv_size); 00379 } 00380 wait_ms(10); 00381 } 00382 TEST_ASSERT(recv_size == size); 00383 y = memcmp(send_data, recv_data, size); 00384 if (y != 0) { 00385 tr_debug("Sent %d, |%*.*s|", size, size, size, send_data); 00386 tr_debug("Rcvd %d, |%*.*s|", size, size, size, (char *) recv_data); 00387 TEST_ASSERT(false); 00388 } 00389 timer.stop(); 00390 00391 TEST_ASSERT(!connection_has_gone_down); 00392 00393 free (recv_data); 00394 } 00395 #endif 00396 00397 // Get NTP time from a socket 00398 static void do_ntp_sock (UDPSocket *sock, SocketAddress ntp_address) 00399 { 00400 char ntp_values[48] = { 0 }; 00401 time_t timestamp = 0; 00402 struct tm *localTime; 00403 char timeString[25]; 00404 time_t TIME1970 = 2208988800U; 00405 int len; 00406 bool comms_done = false; 00407 00408 ntp_values[0] = '\x1b'; 00409 00410 // Retry this a few times, don't want to fail due to a flaky link 00411 for (unsigned int x = 0; !comms_done && (x < NUM_UDP_RETRIES); x++) { 00412 sock->sendto(ntp_address, (void*) ntp_values, sizeof(ntp_values)); 00413 len = sock->recvfrom(&ntp_address, (void*) ntp_values, sizeof(ntp_values)); 00414 if (len > 0) { 00415 comms_done = true; 00416 } 00417 } 00418 TEST_ASSERT (comms_done); 00419 00420 tr_debug("UDP: %d byte(s) returned by NTP server.", len); 00421 if (len >= 43) { 00422 timestamp |= ((int) *(ntp_values + 40)) << 24; 00423 timestamp |= ((int) *(ntp_values + 41)) << 16; 00424 timestamp |= ((int) *(ntp_values + 42)) << 8; 00425 timestamp |= ((int) *(ntp_values + 43)); 00426 timestamp -= TIME1970; 00427 srand (timestamp); 00428 tr_debug("srand() called"); 00429 localTime = localtime(×tamp); 00430 if (localTime) { 00431 if (strftime(timeString, sizeof(timeString), "%a %b %d %H:%M:%S %Y", localTime) > 0) { 00432 printf("NTP timestamp is %s.\n", timeString); 00433 } 00434 } 00435 } 00436 } 00437 00438 // Get NTP time 00439 static void do_ntp(UbloxATCellularInterface *interface) 00440 { 00441 UDPSocket sock; 00442 SocketAddress host_address; 00443 00444 TEST_ASSERT(sock.open(interface) == 0) 00445 00446 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_NTP_SERVER, &host_address) == 0); 00447 host_address.set_port(MBED_CONF_APP_NTP_PORT); 00448 00449 tr_debug("UDP: NIST server %s address: %s on port %d.", MBED_CONF_APP_NTP_SERVER, 00450 host_address.get_ip_address(), host_address.get_port()); 00451 00452 sock.set_timeout(10000); 00453 00454 do_ntp_sock(&sock, host_address); 00455 00456 sock.close(); 00457 } 00458 00459 // Use a connection, checking that it is good 00460 static void use_connection(UbloxATCellularInterface *interface) 00461 { 00462 const char * ip_address = interface->get_ip_address(); 00463 const char * net_mask = interface->get_netmask(); 00464 const char * gateway = interface->get_gateway(); 00465 00466 TEST_ASSERT(interface->is_connected()); 00467 00468 TEST_ASSERT(ip_address != NULL); 00469 tr_debug ("IP address %s.", ip_address); 00470 TEST_ASSERT(net_mask == NULL); 00471 tr_debug ("Net mask %s.", net_mask); 00472 TEST_ASSERT(gateway != NULL); 00473 tr_debug ("Gateway %s.", gateway); 00474 00475 do_ntp(interface); 00476 TEST_ASSERT(!connection_has_gone_down); 00477 } 00478 00479 // Drop a connection and check that it has dropped 00480 static void drop_connection(UbloxATCellularInterface *interface) 00481 { 00482 TEST_ASSERT(interface->disconnect() == 0); 00483 TEST_ASSERT(connection_has_gone_down); 00484 connection_has_gone_down = false; 00485 TEST_ASSERT(!interface->is_connected()); 00486 } 00487 00488 // ---------------------------------------------------------------- 00489 // TESTS 00490 // ---------------------------------------------------------------- 00491 00492 // Call srand() using the NTP server 00493 void test_set_randomise() { 00494 UDPSocket sock; 00495 SocketAddress host_address; 00496 00497 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00498 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00499 do_ntp(interface); 00500 TEST_ASSERT(!connection_has_gone_down); 00501 drop_connection(interface); 00502 } 00503 00504 #ifdef MBED_CONF_APP_ECHO_SERVER 00505 00506 // Test UDP data exchange 00507 void test_udp_echo() { 00508 UDPSocket sock; 00509 SocketAddress host_address; 00510 SocketAddress local_address; 00511 int x; 00512 int size; 00513 00514 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00515 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00516 00517 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); 00518 host_address.set_port(MBED_CONF_APP_ECHO_UDP_PORT); 00519 00520 tr_debug("UDP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, 00521 host_address.get_ip_address(), host_address.get_port()); 00522 00523 TEST_ASSERT(sock.open(interface) == 0) 00524 00525 // Do a bind, just for the helluvit 00526 local_address.set_port(MBED_CONF_APP_LOCAL_PORT); 00527 TEST_ASSERT(sock.bind(local_address) == 0); 00528 00529 sock.set_timeout(10000); 00530 00531 // Test min, max, and some random sizes in-between 00532 do_udp_echo(&sock, &host_address, 1); 00533 do_udp_echo(&sock, &host_address, MBED_CONF_APP_UDP_MAX_PACKET_SIZE); 00534 for (x = 0; x < 10; x++) { 00535 size = (rand() % MBED_CONF_APP_UDP_MAX_PACKET_SIZE) + 1; 00536 size = fix(size, MBED_CONF_APP_UDP_MAX_PACKET_SIZE); 00537 do_udp_echo(&sock, &host_address, size); 00538 } 00539 00540 sock.close(); 00541 drop_connection(interface); 00542 tr_debug("%d UDP packets of size up to %d byte(s) echoed successfully.", 00543 x, MBED_CONF_APP_UDP_MAX_PACKET_SIZE); 00544 } 00545 00546 // Test many different sizes of UDP data arriving at once 00547 void test_udp_echo_recv_sizes() { 00548 UDPSocket sock; 00549 SocketAddress host_address; 00550 int x, y, z; 00551 int size; 00552 int tries = 0; 00553 unsigned int offset; 00554 char * recv_data; 00555 bool packetLoss; 00556 bool sendSuccess; 00557 Timer timer; 00558 00559 interface->deinit(); 00560 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00561 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00562 00563 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); 00564 host_address.set_port(MBED_CONF_APP_ECHO_UDP_PORT); 00565 00566 tr_debug("UDP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, 00567 host_address.get_ip_address(), host_address.get_port()); 00568 00569 TEST_ASSERT(sock.open(interface) == 0) 00570 00571 do { 00572 tr_debug("--- UDP packet size test, test try %d, flushing input buffers", tries + 1); 00573 // First of all, clear any junk from the socket 00574 sock.set_timeout(1000); 00575 recv_data = (char *) malloc (MBED_CONF_APP_UDP_MAX_PACKET_SIZE); 00576 TEST_ASSERT(recv_data != NULL); 00577 while (sock.recvfrom(&host_address, (void *) recv_data, MBED_CONF_APP_UDP_MAX_PACKET_SIZE) > 0) { 00578 // Throw it away 00579 } 00580 free (recv_data); 00581 00582 sock.set_timeout(10000); 00583 00584 // Throw random sized UDP packets up... 00585 x = 0; 00586 offset = 0; 00587 while (offset < sizeof (send_data)) { 00588 size = (rand() % (MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2)) + 1; 00589 size = fix(size, MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2); 00590 if (offset + size > sizeof (send_data)) { 00591 size = sizeof (send_data) - offset; 00592 } 00593 sendSuccess = false; 00594 for (y = 0; !sendSuccess && (y < NUM_UDP_RETRIES); y++) { 00595 tr_debug("Sending UDP packet number %d, size %d byte(s), send try %d.", x + 1, size, y + 1); 00596 if (sock.sendto(host_address, (void *) (send_data + offset), size) == size) { 00597 sendSuccess = true; 00598 offset += size; 00599 } 00600 } 00601 TEST_ASSERT(sendSuccess); 00602 x++; 00603 } 00604 tr_debug("--- All UDP packets sent"); 00605 00606 // ...and capture them all again afterwards 00607 recv_data = (char *) malloc (sizeof (send_data)); 00608 TEST_ASSERT(recv_data != NULL); 00609 memset (recv_data, 0, sizeof (send_data)); 00610 size = 0; 00611 y = 0; 00612 packetLoss = false; 00613 timer.start(); 00614 while ((size < (int) sizeof (send_data)) && (timer.read_ms() < 10000)) { 00615 y = sock.recvfrom(&host_address, (void *) (recv_data + size), sizeof (send_data) - size); 00616 if (y > 0) { 00617 size += y; 00618 } 00619 } 00620 timer.stop(); 00621 timer.reset(); 00622 tr_debug( "--- Either received everything back or timed out waiting"); 00623 00624 // Check that we reassembled everything correctly 00625 if (size == sizeof (send_data)) { 00626 for (x = 0; ((*(recv_data + x) == *(send_data + x))) && (x < (int) sizeof (send_data)); x++) { 00627 } 00628 if (x != sizeof (send_data)) { 00629 y = x - 5; 00630 if (y < 0) { 00631 y = 0; 00632 } 00633 z = 10; 00634 if (y + z > (int) sizeof (send_data)) { 00635 z = sizeof(send_data) - y; 00636 } 00637 tr_debug(" --- Difference at character %d (send \"%*.*s\", recv \"%*.*s\")", 00638 x + 1, z, z, send_data + y, z, z, recv_data + y); 00639 packetLoss = true; 00640 } 00641 } else { 00642 tr_debug(" --- %d bytes missing (%d bytes received when %d were expected))", 00643 sizeof (send_data) - size, size, sizeof (send_data)); 00644 packetLoss = true; 00645 } 00646 free (recv_data); 00647 tries++; 00648 } while (packetLoss && (tries < NUM_UDP_RETRIES)); 00649 00650 TEST_ASSERT(!packetLoss); 00651 TEST_ASSERT(!connection_has_gone_down); 00652 sock.close(); 00653 drop_connection(interface); 00654 } 00655 00656 // Test UDP data exchange via the asynchronous sigio() mechanism 00657 void test_udp_echo_async() { 00658 UDPSocket sock; 00659 SocketAddress host_address; 00660 SocketAddress local_address; 00661 bool callback_triggered = false; 00662 int x; 00663 int size; 00664 00665 interface->deinit(); 00666 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00667 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00668 00669 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); 00670 host_address.set_port(MBED_CONF_APP_ECHO_UDP_PORT); 00671 00672 tr_debug("UDP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, 00673 host_address.get_ip_address(), host_address.get_port()); 00674 00675 TEST_ASSERT(sock.open(interface) == 0) 00676 00677 // Set up the async callback and set the timeout to zero 00678 sock.sigio(callback(async_cb, &callback_triggered)); 00679 sock.set_timeout(0); 00680 00681 // Test min, max, and some random sizes in-between 00682 // and this time allow the UDP packets to be fragmented 00683 do_udp_echo_async(&sock, &host_address, 1, &callback_triggered); 00684 do_udp_echo_async(&sock, &host_address, MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE, 00685 &callback_triggered); 00686 for (x = 0; x < 10; x++) { 00687 size = (rand() % MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE) + 1; 00688 size = fix(size, MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE); 00689 do_udp_echo_async(&sock, &host_address, size, &callback_triggered); 00690 } 00691 00692 sock.close(); 00693 00694 drop_connection(interface); 00695 00696 tr_debug("%d UDP packets of size up to %d byte(s) echoed asynchronously and successfully.", 00697 x, MBED_CONF_APP_UDP_MAX_FRAG_PACKET_SIZE); 00698 } 00699 00700 // Test many different sizes of TCP data arriving at once 00701 void test_tcp_echo_recv_sizes() { 00702 TCPSocket sock; 00703 SocketAddress host_address; 00704 int x, y, z; 00705 int size; 00706 unsigned int offset; 00707 char * recv_data; 00708 Timer timer; 00709 00710 interface->deinit(); 00711 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00712 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00713 00714 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); 00715 host_address.set_port(MBED_CONF_APP_ECHO_TCP_PORT); 00716 00717 tr_debug("TCP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, 00718 host_address.get_ip_address(), host_address.get_port()); 00719 00720 TEST_ASSERT(sock.open(interface) == 0) 00721 00722 TEST_ASSERT(sock.connect(host_address) == 0); 00723 00724 sock.set_timeout(10000); 00725 00726 // Throw random sized TCP packets up... 00727 x = 0; 00728 offset = 0; 00729 while (offset < sizeof (send_data)) { 00730 size = (rand() % (MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2)) + 1; 00731 size = fix(size, MBED_CONF_APP_UDP_MAX_PACKET_SIZE / 2); 00732 if (offset + size > sizeof (send_data)) { 00733 size = sizeof (send_data) - offset; 00734 } 00735 tr_debug("Sending TCP packet number %d, size %d byte(s).", x + 1, size); 00736 TEST_ASSERT(sendAll(&sock, (send_data + offset), size) == size); 00737 offset += size; 00738 x++; 00739 } 00740 00741 // ...and capture them all again afterwards 00742 recv_data = (char *) malloc (sizeof (send_data)); 00743 TEST_ASSERT(recv_data != NULL); 00744 memset (recv_data, 0, sizeof (send_data)); 00745 size = 0; 00746 x = 0; 00747 timer.start(); 00748 while ((size < (int) sizeof (send_data)) && (timer.read_ms() < 30000)) { 00749 y = sock.recv((void *) (recv_data + size), sizeof (send_data) - size); 00750 tr_debug("Received TCP packet number %d, size %d byte(s).", x, y); 00751 size += y; 00752 x++; 00753 } 00754 timer.stop(); 00755 timer.reset(); 00756 00757 // Check that we reassembled everything correctly 00758 for (x = 0; ((*(recv_data + x) == *(send_data + x))) && (x < (int) sizeof (send_data)); x++) { 00759 } 00760 if (x != sizeof (send_data)) { 00761 y = x - 5; 00762 if (y < 0) { 00763 y = 0; 00764 } 00765 z = 10; 00766 if (y + z > (int) sizeof (send_data)) { 00767 z = sizeof(send_data) - y; 00768 } 00769 tr_debug("Difference at character %d (send \"%*.*s\", recv \"%*.*s\")", 00770 x + 1, z, z, send_data + y, z, z, recv_data + y); 00771 TEST_ASSERT(false); 00772 } 00773 free (recv_data); 00774 00775 TEST_ASSERT(!connection_has_gone_down); 00776 sock.close(); 00777 drop_connection(interface); 00778 } 00779 00780 // Test TCP data exchange via the asynchronous sigio() mechanism 00781 void test_tcp_echo_async() { 00782 TCPSocket sock; 00783 SocketAddress host_address; 00784 bool callback_triggered = false; 00785 int x; 00786 int size; 00787 00788 interface->deinit(); 00789 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00790 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00791 00792 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_ECHO_SERVER, &host_address) == 0); 00793 host_address.set_port(MBED_CONF_APP_ECHO_TCP_PORT); 00794 00795 tr_debug("TCP: Server %s address: %s on port %d.", MBED_CONF_APP_ECHO_SERVER, 00796 host_address.get_ip_address(), host_address.get_port()); 00797 00798 TEST_ASSERT(sock.open(interface) == 0) 00799 00800 // Set up the async callback and set the timeout to zero 00801 sock.sigio(callback(async_cb, &callback_triggered)); 00802 sock.set_timeout(0); 00803 00804 TEST_ASSERT(sock.connect(host_address) == 0); 00805 // Test min, max, and some random sizes in-between 00806 do_tcp_echo_async(&sock, 1, &callback_triggered); 00807 do_tcp_echo_async(&sock, MBED_CONF_APP_TCP_MAX_PACKET_SIZE, &callback_triggered); 00808 for (x = 0; x < 10; x++) { 00809 size = (rand() % MBED_CONF_APP_TCP_MAX_PACKET_SIZE) + 1; 00810 size = fix(size, MBED_CONF_APP_TCP_MAX_PACKET_SIZE); 00811 do_tcp_echo_async(&sock, size, &callback_triggered); 00812 } 00813 00814 sock.close(); 00815 00816 drop_connection(interface); 00817 00818 tr_debug("%d TCP packets of size up to %d byte(s) echoed asynchronously and successfully.", 00819 x, MBED_CONF_APP_TCP_MAX_PACKET_SIZE); 00820 } 00821 #endif 00822 00823 // Allocate max sockets 00824 void test_max_sockets() { 00825 UDPSocket sock[MAX_NUM_SOCKETS]; 00826 UDPSocket sockNone; 00827 SocketAddress host_address; 00828 00829 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00830 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00831 00832 TEST_ASSERT(interface->gethostbyname(MBED_CONF_APP_NTP_SERVER, &host_address) == 0); 00833 host_address.set_port(MBED_CONF_APP_NTP_PORT); 00834 00835 // Open the first socket and use it 00836 TEST_ASSERT(sock[0].open(interface) == 0) 00837 sock[0].set_timeout(10000); 00838 do_ntp_sock(&sock[0], host_address); 00839 00840 // Check that we stop being able to get sockets at the max number 00841 for (int x = 1; x < (int) (sizeof (sock) / sizeof (sock[0])); x++) { 00842 TEST_ASSERT(sock[x].open(interface) == 0) 00843 } 00844 TEST_ASSERT(sockNone.open(interface) < 0); 00845 00846 // Now use the last one 00847 sock[sizeof (sock) / sizeof (sock[0]) - 1].set_timeout(10000); 00848 do_ntp_sock(&sock[sizeof (sock) / sizeof (sock[0]) - 1], host_address); 00849 00850 // Close all of the sockets 00851 for (int x = 0; x < (int) (sizeof (sock) / sizeof (sock[0])); x++) { 00852 TEST_ASSERT(sock[x].close() == 0); 00853 } 00854 00855 drop_connection(interface); 00856 } 00857 00858 // Connect with credentials included in the connect request 00859 void test_connect_credentials() { 00860 00861 interface->deinit(); 00862 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00863 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00864 use_connection(interface); 00865 drop_connection(interface); 00866 } 00867 00868 // Test with credentials preset 00869 void test_connect_preset_credentials() { 00870 00871 interface->deinit(); 00872 TEST_ASSERT(interface->init(MBED_CONF_APP_DEFAULT_PIN)); 00873 interface->set_credentials(MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, 00874 MBED_CONF_APP_PASSWORD); 00875 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN) == 0); 00876 use_connection(interface); 00877 drop_connection(interface); 00878 } 00879 00880 // Test adding and using a SIM pin, then removing it, using the pending 00881 // mechanism where the change doesn't occur until connect() is called 00882 void test_check_sim_pin_pending() { 00883 00884 interface->deinit(); 00885 00886 // Enable PIN checking (which will use the current PIN) 00887 // and also flag that the PIN should be changed to MBED_CONF_APP_ALT_PIN, 00888 // then try connecting 00889 interface->set_sim_pin_check(true); 00890 interface->set_new_sim_pin(MBED_CONF_APP_ALT_PIN); 00891 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00892 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00893 use_connection(interface); 00894 drop_connection(interface); 00895 interface->deinit(); 00896 00897 // Now change the PIN back to what it was before 00898 interface->set_new_sim_pin(MBED_CONF_APP_DEFAULT_PIN); 00899 TEST_ASSERT(interface->connect(MBED_CONF_APP_ALT_PIN, MBED_CONF_APP_APN, 00900 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00901 use_connection(interface); 00902 drop_connection(interface); 00903 interface->deinit(); 00904 00905 // Check that it was changed back, and this time 00906 // use the other way of entering the PIN 00907 interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); 00908 TEST_ASSERT(interface->connect(NULL, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, 00909 MBED_CONF_APP_PASSWORD) == 0); 00910 use_connection(interface); 00911 drop_connection(interface); 00912 interface->deinit(); 00913 00914 // Remove PIN checking again and check that it no 00915 // longer matters what the PIN is 00916 interface->set_sim_pin_check(false); 00917 TEST_ASSERT(interface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00918 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00919 use_connection(interface); 00920 drop_connection(interface); 00921 interface->deinit(); 00922 TEST_ASSERT(interface->init(NULL)); 00923 TEST_ASSERT(interface->connect(MBED_CONF_APP_INCORRECT_PIN, MBED_CONF_APP_APN, 00924 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00925 use_connection(interface); 00926 drop_connection(interface); 00927 00928 // Put the SIM pin back to the correct value for any subsequent tests 00929 interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); 00930 } 00931 00932 // Test adding and using a SIM pin, then removing it, using the immediate 00933 // mechanism 00934 void test_check_sim_pin_immediate() { 00935 00936 interface->deinit(); 00937 interface->connection_status_cb(connection_down_cb); 00938 00939 // Enable PIN checking (which will use the current PIN), change 00940 // the PIN to MBED_CONF_APP_ALT_PIN, then try connecting after powering on and 00941 // off the modem 00942 interface->set_sim_pin_check(true, true, MBED_CONF_APP_DEFAULT_PIN); 00943 interface->set_new_sim_pin(MBED_CONF_APP_ALT_PIN, true); 00944 interface->deinit(); 00945 TEST_ASSERT(interface->init(NULL)); 00946 TEST_ASSERT(interface->connect(MBED_CONF_APP_ALT_PIN, MBED_CONF_APP_APN, 00947 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00948 use_connection(interface); 00949 drop_connection(interface); 00950 00951 interface->connection_status_cb(connection_down_cb); 00952 00953 // Now change the PIN back to what it was before 00954 interface->set_new_sim_pin(MBED_CONF_APP_DEFAULT_PIN, true); 00955 interface->deinit(); 00956 interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); 00957 TEST_ASSERT(interface->init(NULL)); 00958 TEST_ASSERT(interface->connect(NULL, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, 00959 MBED_CONF_APP_PASSWORD) == 0); 00960 use_connection(interface); 00961 drop_connection(interface); 00962 00963 interface->connection_status_cb(connection_down_cb); 00964 00965 // Remove PIN checking again and check that it no 00966 // longer matters what the PIN is 00967 interface->set_sim_pin_check(false, true); 00968 interface->deinit(); 00969 TEST_ASSERT(interface->init(MBED_CONF_APP_INCORRECT_PIN)); 00970 TEST_ASSERT(interface->connect(NULL, MBED_CONF_APP_APN, MBED_CONF_APP_USERNAME, 00971 MBED_CONF_APP_PASSWORD) == 0); 00972 use_connection(interface); 00973 drop_connection(interface); 00974 00975 // Put the SIM pin back to the correct value for any subsequent tests 00976 interface->set_sim_pin(MBED_CONF_APP_DEFAULT_PIN); 00977 } 00978 00979 // Test being able to connect with a local instance of the interface 00980 // NOTE: since this local instance will fiddle with bits of HW that the 00981 // static instance thought it owned, the static instance will no longer 00982 // work afterwards, hence this must be run as the last test in the list 00983 void test_connect_local_instance_last_test() { 00984 00985 UbloxATCellularInterface *pLocalInterface = NULL; 00986 00987 pLocalInterface = new UbloxATCellularInterface(MDMTXD, MDMRXD, 00988 MBED_CONF_UBLOX_CELL_BAUD_RATE, 00989 MBED_CONF_APP_DEBUG_ON); 00990 pLocalInterface->connection_status_cb(connection_down_cb); 00991 00992 TEST_ASSERT(pLocalInterface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 00993 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 00994 use_connection(pLocalInterface); 00995 drop_connection(pLocalInterface); 00996 delete pLocalInterface; 00997 00998 pLocalInterface = new UbloxATCellularInterface(MDMTXD, MDMRXD, 00999 MBED_CONF_UBLOX_CELL_BAUD_RATE, 01000 MBED_CONF_APP_DEBUG_ON); 01001 pLocalInterface->connection_status_cb(connection_down_cb); 01002 01003 TEST_ASSERT(pLocalInterface->connect(MBED_CONF_APP_DEFAULT_PIN, MBED_CONF_APP_APN, 01004 MBED_CONF_APP_USERNAME, MBED_CONF_APP_PASSWORD) == 0); 01005 use_connection(pLocalInterface); 01006 drop_connection(pLocalInterface); 01007 delete pLocalInterface; 01008 } 01009 01010 // ---------------------------------------------------------------- 01011 // TEST ENVIRONMENT 01012 // ---------------------------------------------------------------- 01013 01014 // Setup the test environment 01015 utest::v1::status_t test_setup(const size_t number_of_cases) { 01016 // Setup Greentea with a timeout 01017 GREENTEA_SETUP(960, "default_auto"); 01018 return verbose_test_setup_handler(number_of_cases); 01019 } 01020 01021 // IMPORTANT!!! if you make a change to the tests here you should 01022 // check whether the same change should be made to the tests under 01023 // the PPP interface. 01024 01025 // Test cases 01026 Case cases[] = { 01027 Case("Set randomise", test_set_randomise), 01028 #ifdef MBED_CONF_APP_ECHO_SERVER 01029 Case("UDP echo test", test_udp_echo), 01030 # ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 to run this test 01031 Case("UDP recv sizes", test_udp_echo_recv_sizes), 01032 # endif 01033 Case("UDP async echo test", test_udp_echo_async), 01034 # ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 to run this test 01035 Case("TCP recv sizes", test_tcp_echo_recv_sizes), 01036 # endif 01037 Case("TCP async echo test", test_tcp_echo_async), 01038 #endif 01039 #ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 to run this test 01040 Case("Alloc max sockets", test_max_sockets), 01041 #endif 01042 Case("Connect with credentials", test_connect_credentials), 01043 Case("Connect with preset credentials", test_connect_preset_credentials), 01044 #if MBED_CONF_APP_RUN_SIM_PIN_CHANGE_TESTS 01045 Case("Check SIM pin, pending", test_check_sim_pin_pending), 01046 Case("Check SIM pin, immediate", test_check_sim_pin_immediate), 01047 #endif 01048 #ifndef TARGET_UBLOX_C027 // Not enough RAM on little 'ole C027 for this 01049 Case("Connect using local instance, must be last test", test_connect_local_instance_last_test) 01050 #endif 01051 }; 01052 01053 Specification specification(test_setup, cases); 01054 01055 // ---------------------------------------------------------------- 01056 // MAIN 01057 // ---------------------------------------------------------------- 01058 01059 int main() { 01060 01061 #ifdef FEATURE_COMMON_PAL 01062 mbed_trace_init(); 01063 01064 mbed_trace_mutex_wait_function_set(lock); 01065 mbed_trace_mutex_release_function_set(unlock); 01066 #endif 01067 01068 interface->connection_status_cb(connection_down_cb); 01069 01070 // Run tests 01071 return !Harness::run(specification); 01072 } 01073 01074 // End Of File 01075
Generated on Fri Jul 15 2022 01:47:11 by
1.7.2