Wajahat Abbas
changes for R412M test cases
Embed:
(wiki syntax)
Show/hide line numbers
UbloxATCellularInterface.cpp
00001 /* Copyright (c) 2017 ublox Limited 00002 * 00003 * Licensed under the Apache License, Version 2.0 (the "License"); 00004 * you may not use this file except in compliance with the License. 00005 * You may obtain a copy of the License at 00006 * 00007 * http://www.apache.org/licenses/LICENSE-2.0 00008 * 00009 * Unless required by applicable law or agreed to in writing, software 00010 * distributed under the License is distributed on an "AS IS" BASIS, 00011 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00012 * See the License for the specific language governing permissions and 00013 * limitations under the License. 00014 */ 00015 00016 #include "UbloxATCellularInterface.h" 00017 #include "mbed_poll.h" 00018 #include "nsapi.h" 00019 #include "APN_db.h" 00020 #ifdef FEATURE_COMMON_PAL 00021 #include "mbed_trace.h" 00022 #define TRACE_GROUP "UACI" 00023 #else 00024 #define tr_debug(format, ...) debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__) 00025 #define tr_info(format, ...) debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__) 00026 #define tr_warn(format, ...) debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__) 00027 #define tr_error(format, ...) debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__) 00028 #endif 00029 00030 /********************************************************************** 00031 * PRIVATE METHODS 00032 **********************************************************************/ 00033 00034 // Event thread for asynchronous received data handling. 00035 void UbloxATCellularInterface::handle_event(){ 00036 pollfh fhs; 00037 int at_timeout; 00038 fhs.fh = _fh; 00039 fhs.events = POLLIN; 00040 00041 while (_run_event_thread) { 00042 int count; 00043 count = poll(&fhs, 1, 1000); 00044 if (count > 0 && (fhs.revents & POLLIN)) { 00045 LOCK(); 00046 at_timeout = _at_timeout; 00047 at_set_timeout(10); // Avoid blocking but also make sure we don't 00048 // time out if we get ahead of the serial port 00049 _at->debug_on(false); // Debug here screws with the test output 00050 // Let the URCs run 00051 _at->recv(UNNATURAL_STRING); 00052 _at->debug_on(_debug_trace_on); 00053 at_set_timeout(at_timeout); 00054 UNLOCK(); 00055 } 00056 } 00057 } 00058 00059 // Find or create a socket from the list. 00060 UbloxATCellularInterface::SockCtrl * UbloxATCellularInterface::find_socket(int modem_handle) 00061 { 00062 UbloxATCellularInterface::SockCtrl *socket = NULL; 00063 00064 for (unsigned int x = 0; (socket == NULL) && (x < sizeof(_sockets) / sizeof(_sockets[0])); x++) { 00065 if (_sockets[x].modem_handle == modem_handle) { 00066 socket = &(_sockets[x]); 00067 } 00068 } 00069 00070 return socket; 00071 } 00072 00073 // Clear out the storage for a socket 00074 void UbloxATCellularInterface::clear_socket(UbloxATCellularInterface::SockCtrl * socket) 00075 { 00076 if (socket != NULL) { 00077 socket->modem_handle = SOCKET_UNUSED; 00078 socket->pending = 0; 00079 socket->callback = NULL; 00080 socket->data = NULL; 00081 } 00082 } 00083 00084 // Check that a socket pointer is valid 00085 bool UbloxATCellularInterface::check_socket(SockCtrl * socket) 00086 { 00087 bool success = false; 00088 00089 if (socket != NULL) { 00090 for (unsigned int x = 0; !success && (x < sizeof(_sockets) / sizeof(_sockets[0])); x++) { 00091 if (socket == &(_sockets[x])) { 00092 success = true; 00093 } 00094 } 00095 } 00096 00097 return success; 00098 } 00099 00100 // Convert nsapi_security_t to the modem security numbers 00101 int UbloxATCellularInterface::nsapi_security_to_modem_security(nsapi_security_t nsapi_security) 00102 { 00103 int modem_security = 3; 00104 00105 switch (nsapi_security) 00106 { 00107 case NSAPI_SECURITY_NONE: 00108 modem_security = 0; 00109 break; 00110 case NSAPI_SECURITY_PAP: 00111 modem_security = 1; 00112 break; 00113 case NSAPI_SECURITY_CHAP: 00114 modem_security = 2; 00115 break; 00116 #ifndef TARGET_UBLOX_C030_R41XM 00117 case NSAPI_SECURITY_UNKNOWN: 00118 modem_security = 3; 00119 break; 00120 default: 00121 modem_security = 3; 00122 break; 00123 #else 00124 default: 00125 modem_security = 0; 00126 break; 00127 #endif 00128 } 00129 00130 return modem_security; 00131 } 00132 00133 // Callback for Socket Read URC. 00134 void UbloxATCellularInterface::UUSORD_URC() 00135 { 00136 int a; 00137 int b; 00138 char buf[32]; 00139 // Note: not calling _at->recv() from here as we're 00140 // already in an _at->recv() 00141 // +UUSORD: <socket>,<length> 00142 if (read_at_to_char(buf, sizeof (buf), '\n') > 0) { 00143 00144 if (sscanf(buf, ": %d,%d", &a, &b) == 2) { 00145 SockCtrl *socket; 00146 socket = find_socket(a); 00147 if (socket != NULL) { 00148 socket->pending = b; 00149 // No debug prints here as they can affect timing 00150 // and cause data loss in UARTSerial 00151 if (socket->callback != NULL) { 00152 socket->callback(socket->data); 00153 } 00154 } 00155 } 00156 } 00157 } 00158 00159 // Callback for Socket Read From URC. 00160 void UbloxATCellularInterface::UUSORF_URC() 00161 { 00162 int a; 00163 int b; 00164 char buf[32]; 00165 // Note: not calling _at->recv() from here as we're 00166 // already in an _at->recv() 00167 // +UUSORF: <socket>,<length> 00168 if (read_at_to_char(buf, sizeof (buf), '\n') > 0) { 00169 if (sscanf(buf, ": %d,%d", &a, &b) == 2) { 00170 SockCtrl *socket; 00171 socket = find_socket(a); 00172 if (socket != NULL) { 00173 socket->pending = b; 00174 // No debug prints here as they can affect timing 00175 // and cause data loss in UARTSerial 00176 if (socket->callback != NULL) { 00177 socket->callback(socket->data); 00178 } 00179 } 00180 } 00181 } 00182 } 00183 00184 // Callback for Socket Close URC. 00185 void UbloxATCellularInterface::UUSOCL_URC() 00186 { 00187 int a; 00188 char buf[32]; 00189 // Note: not calling _at->recv() from here as we're 00190 // already in an _at->recv() 00191 // +UUSOCL: <socket> 00192 if (read_at_to_char(buf, sizeof (buf), '\n') > 0) { 00193 if (sscanf(buf, ": %d", &a) == 1) { 00194 SockCtrl *socket; 00195 socket = find_socket(a); 00196 tr_debug("Socket 0x%08x: handle %d closed by remote host", 00197 (unsigned int) socket, a); 00198 clear_socket(socket); 00199 } 00200 } 00201 } 00202 00203 // Callback for UUPSDD. 00204 void UbloxATCellularInterface::UUPSDD_URC() 00205 { 00206 int a; 00207 char buf[32]; 00208 // Note: not calling _at->recv() from here as we're 00209 // already in an _at->recv() 00210 // +UUPSDD: <socket> 00211 if (read_at_to_char(buf, sizeof (buf), '\n') > 0) { 00212 if (sscanf(buf, ": %d", &a) == 1) { 00213 SockCtrl *socket; 00214 socket = find_socket(a); 00215 tr_debug("Socket 0x%08x: handle %d connection lost", 00216 (unsigned int) socket, a); 00217 clear_socket(socket); 00218 if (_connection_status_cb) { 00219 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST); 00220 } 00221 } 00222 } 00223 } 00224 00225 /********************************************************************** 00226 * PROTECTED METHODS: GENERAL 00227 **********************************************************************/ 00228 00229 // Get the next set of credentials, based on IMSI. 00230 void UbloxATCellularInterface::get_next_credentials(const char ** config) 00231 { 00232 if (*config) { 00233 _apn = _APN_GET(*config); 00234 _uname = _APN_GET(*config); 00235 _pwd = _APN_GET(*config); 00236 } 00237 00238 _apn = _apn ? _apn : ""; 00239 _uname = _uname ? _uname : ""; 00240 _pwd = _pwd ? _pwd : ""; 00241 } 00242 00243 // Active a connection profile on board the modem. 00244 // Note: the AT interface should be locked before this is called. 00245 bool UbloxATCellularInterface::activate_profile(const char* apn, 00246 const char* username, 00247 const char* password, 00248 nsapi_security_t auth) 00249 { 00250 bool activated = false; 00251 bool success = false; 00252 int at_timeout = _at_timeout; 00253 SocketAddress address; 00254 00255 // Set up the APN 00256 if (*apn) { 00257 success = _at->send("AT+UPSD=" PROFILE ",1,\"%s\"", apn) && _at->recv("OK"); 00258 } 00259 if (success && *username) { 00260 success = _at->send("AT+UPSD=" PROFILE ",2,\"%s\"", username) && _at->recv("OK"); 00261 } 00262 if (success && *password) { 00263 success = _at->send("AT+UPSD=" PROFILE ",3,\"%s\"", password) && _at->recv("OK"); 00264 } 00265 00266 if (success) { 00267 // Set up dynamic IP address assignment. 00268 success = _at->send("AT+UPSD=" PROFILE ",7,\"0.0.0.0\"") && _at->recv("OK"); 00269 // Set up the authentication protocol 00270 // 0 = none 00271 // 1 = PAP (Password Authentication Protocol) 00272 // 2 = CHAP (Challenge Handshake Authentication Protocol) 00273 for (int protocol = nsapi_security_to_modem_security(NSAPI_SECURITY_NONE); 00274 success && (protocol <= nsapi_security_to_modem_security(NSAPI_SECURITY_CHAP)); protocol++) { 00275 if ((_auth == NSAPI_SECURITY_UNKNOWN) || (nsapi_security_to_modem_security(_auth) == protocol)) { 00276 if (_at->send("AT+UPSD=" PROFILE ",6,%d", protocol) && _at->recv("OK")) { 00277 // Activate, waiting 30 seconds for the connection to be made 00278 at_set_timeout(30000); 00279 activated = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK"); 00280 at_set_timeout(at_timeout); 00281 } 00282 } 00283 } 00284 } 00285 00286 return activated; 00287 } 00288 00289 // Activate a profile by reusing an external PDP context. 00290 // Note: the AT interface should be locked before this is called. 00291 bool UbloxATCellularInterface::activate_profile_reuse_external(void) 00292 { 00293 bool success = false; 00294 int cid = -1; 00295 SocketAddress address; 00296 int t; 00297 int at_timeout = _at_timeout; 00298 00299 //+CGDCONT: <cid>,"IP","<apn name>","<ip adr>",0,0,0,0,0,0 00300 if (_at->send("AT+CGDCONT?")) { 00301 char ip[NSAPI_IP_SIZE]; 00302 if (_at->recv("+CGDCONT: %d,\"IP\",\"%*[^\"]\",\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\",%*d,%*d,%*d,%*d,%*d,%*d", 00303 &t, ip) && 00304 _at->recv("OK")) { 00305 // Check if the IP address is valid 00306 if (address.set_ip_address(ip)) { 00307 cid = t; 00308 } 00309 } 00310 } 00311 00312 // If a context has been found, use it 00313 if ((cid != -1) && (_at->send("AT+UPSD=" PROFILE ",100,%d", cid) && _at->recv("OK"))) { 00314 // Activate, waiting 30 seconds for the connection to be made 00315 at_set_timeout(30000); 00316 success = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK"); 00317 at_set_timeout(at_timeout); 00318 } 00319 00320 return success; 00321 } 00322 00323 // Activate a profile by context ID. 00324 // Note: the AT interface should be locked before this is called. 00325 bool UbloxATCellularInterface::activate_profile_by_cid(int cid, 00326 const char* apn, 00327 const char* username, 00328 const char* password, 00329 nsapi_security_t auth) 00330 { 00331 bool success = false; 00332 int at_timeout = _at_timeout; 00333 00334 #ifndef TARGET_UBLOX_C030_R41XM 00335 if (_at->send("AT+CGDCONT=%d,\"IP\",\"%s\"", cid, apn) && _at->recv("OK") && 00336 _at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, nsapi_security_to_modem_security(auth), 00337 username, password) && _at->recv("OK") && 00338 _at->send("AT+UPSD=" PROFILE ",100,%d", cid) && _at->recv("OK")) { 00339 00340 // Wait 30 seconds for the connection to be made 00341 at_set_timeout(30000); 00342 // Activate the protocol 00343 success = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK"); 00344 at_set_timeout(at_timeout); 00345 } 00346 #else 00347 int modem_security = nsapi_security_to_modem_security(auth); 00348 if (_at->send("AT+CGDCONT=%d,\"IP\",\"%s\"", cid, apn) && _at->recv("OK")) { 00349 if ( modem_security == NSAPI_SECURITY_CHAP) { 00350 if (_at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, modem_security, 00351 password, username) && _at->recv("OK")) { 00352 success = true; 00353 } 00354 } else if (modem_security == NSAPI_SECURITY_NONE) { 00355 if (_at->send("AT+UAUTHREQ=%d,%d", cid, modem_security) && _at->recv("OK")) { 00356 success = true; 00357 } 00358 } else { 00359 if (_at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, modem_security, 00360 username, password) && _at->recv("OK")) { 00361 success = true; 00362 } 00363 } 00364 } 00365 #endif 00366 00367 return success; 00368 } 00369 00370 #ifdef TARGET_UBLOX_C030_R41XM 00371 //define PDP context for R412M 00372 bool UbloxATCellularInterface::define_context() 00373 { 00374 bool success = false; 00375 const char * config = NULL; 00376 LOCK(); 00377 00378 // If the caller hasn't entered an APN, try to find it 00379 if (_apn == NULL) { 00380 config = apnconfig(_dev_info.imsi); 00381 } 00382 00383 // Attempt to connect 00384 do { 00385 // Set up APN and IP protocol for PDP context 00386 get_next_credentials(&config); 00387 _auth = (*_uname && *_pwd) ? _auth : NSAPI_SECURITY_NONE; 00388 if (activate_profile_by_cid(1, _apn, _uname, _pwd, _auth)) { 00389 success = true; 00390 } 00391 } while (!success && config && *config); 00392 00393 if (!success) { 00394 tr_error("Failed to connect, check your APN/username/password"); 00395 } 00396 00397 UNLOCK(); 00398 return success; 00399 } 00400 bool UbloxATCellularInterface::activate_context() 00401 { 00402 bool status = false; 00403 int at_timeout; 00404 LOCK(); 00405 00406 at_timeout = _at_timeout; // Has to be inside LOCK()s 00407 at_set_timeout(150000); 00408 if (_at->send("AT+CGACT=1,1") && _at->recv("OK")) { 00409 status = true; 00410 } 00411 00412 at_set_timeout(at_timeout); 00413 00414 UNLOCK(); 00415 return status; 00416 } 00417 #endif 00418 00419 // Connect the on board IP stack of the modem. 00420 bool UbloxATCellularInterface::connect_modem_stack() 00421 { 00422 bool success = false; 00423 int active = 0; 00424 const char * config = NULL; 00425 LOCK(); 00426 00427 // Check the profile 00428 if (_at->send("AT+UPSND=" PROFILE ",8") && _at->recv("+UPSND: %*d,%*d,%d\n", &active) && 00429 _at->recv("OK")) { 00430 if (active == 0) { 00431 // If the caller hasn't entered an APN, try to find it 00432 if (_apn == NULL) { 00433 config = apnconfig(_dev_info.imsi); 00434 } 00435 00436 // Attempt to connect 00437 do { 00438 // Set up APN and IP protocol for PDP context 00439 get_next_credentials(&config); 00440 _auth = (*_uname && *_pwd) ? _auth : NSAPI_SECURITY_NONE; 00441 if ((_dev_info.dev != DEV_TOBY_L2) && (_dev_info.dev != DEV_MPCI_L2)) { 00442 success = activate_profile(_apn, _uname, _pwd, _auth); 00443 } else { 00444 success = activate_profile_reuse_external(); 00445 if (success) { 00446 tr_debug("Reusing external context"); 00447 } else { 00448 success = activate_profile_by_cid(1, _apn, _uname, _pwd, _auth); 00449 } 00450 } 00451 } while (!success && config && *config); 00452 } else { 00453 // If the profile is already active, we're good 00454 success = true; 00455 } 00456 } 00457 00458 if (!success) { 00459 tr_error("Failed to connect, check your APN/username/password"); 00460 } 00461 00462 UNLOCK(); 00463 return success; 00464 } 00465 00466 // Disconnect the on board IP stack of the modem. 00467 bool UbloxATCellularInterface::disconnect_modem_stack() 00468 { 00469 bool success = false; 00470 LOCK(); 00471 00472 if (get_ip_address() != NULL) { 00473 if (_at->send("AT+UPSDA=" PROFILE ",4") && _at->recv("OK")) { 00474 success = true; 00475 if (_connection_status_cb) { 00476 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST); 00477 } 00478 } 00479 } 00480 00481 UNLOCK(); 00482 return success; 00483 } 00484 00485 /********************************************************************** 00486 * PROTECTED METHODS: NETWORK INTERFACE and SOCKETS 00487 **********************************************************************/ 00488 00489 // Gain access to us. 00490 NetworkStack *UbloxATCellularInterface::get_stack() 00491 { 00492 return this; 00493 } 00494 00495 // Create a socket. 00496 nsapi_error_t UbloxATCellularInterface::socket_open(nsapi_socket_t *handle, 00497 nsapi_protocol_t proto) 00498 { 00499 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00500 int modem_handle; 00501 SockCtrl *socket; 00502 LOCK(); 00503 00504 // Find a free socket 00505 socket = find_socket(); 00506 tr_debug("socket_open(%d)", proto); 00507 00508 if (socket != NULL) { 00509 bool success = false; 00510 if (proto == NSAPI_UDP) { 00511 success = _at->send("AT+USOCR=17"); 00512 } else if (proto == NSAPI_TCP) { 00513 success = _at->send("AT+USOCR=6"); 00514 } else { 00515 nsapi_error = NSAPI_ERROR_UNSUPPORTED; 00516 } 00517 00518 if (success) { 00519 nsapi_error = NSAPI_ERROR_NO_SOCKET; 00520 if (_at->recv("+USOCR: %d\n", &modem_handle) && (modem_handle != SOCKET_UNUSED) && 00521 _at->recv("OK")) { 00522 tr_debug("Socket 0x%8x: handle %d was created", (unsigned int) socket, modem_handle); 00523 clear_socket(socket); 00524 socket->modem_handle = modem_handle; 00525 *handle = (nsapi_socket_t) socket; 00526 nsapi_error = NSAPI_ERROR_OK; 00527 } 00528 } 00529 } else { 00530 nsapi_error = NSAPI_ERROR_NO_MEMORY; 00531 } 00532 00533 UNLOCK(); 00534 return nsapi_error; 00535 } 00536 00537 // Close a socket. 00538 nsapi_error_t UbloxATCellularInterface::socket_close(nsapi_socket_t handle) 00539 { 00540 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00541 SockCtrl *socket = (SockCtrl *) handle; 00542 LOCK(); 00543 00544 tr_debug("socket_close(0x%08x)", (unsigned int) handle); 00545 00546 MBED_ASSERT (check_socket(socket)); 00547 00548 if (_at->send("AT+USOCL=%d", socket->modem_handle) && 00549 _at->recv("OK")) { 00550 clear_socket(socket); 00551 nsapi_error = NSAPI_ERROR_OK; 00552 } 00553 00554 UNLOCK(); 00555 return nsapi_error; 00556 } 00557 00558 // Bind a local port to a socket. 00559 nsapi_error_t UbloxATCellularInterface::socket_bind(nsapi_socket_t handle, 00560 const SocketAddress &address) 00561 { 00562 nsapi_error_t nsapi_error = NSAPI_ERROR_NO_SOCKET; 00563 int proto; 00564 int modem_handle; 00565 SockCtrl savedSocket; 00566 SockCtrl *socket = (SockCtrl *) handle; 00567 LOCK(); 00568 00569 tr_debug("socket_bind(0x%08x, :%d)", (unsigned int) handle, address.get_port()); 00570 00571 MBED_ASSERT (check_socket(socket)); 00572 00573 // Query the socket type 00574 if (_at->send("AT+USOCTL=%d,0", socket->modem_handle) && 00575 _at->recv("+USOCTL: %*d,0,%d\n", &proto) && 00576 _at->recv("OK")) { 00577 savedSocket = *socket; 00578 nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00579 // Now close the socket and re-open it with the binding given 00580 if (_at->send("AT+USOCL=%d", socket->modem_handle) && 00581 _at->recv("OK")) { 00582 clear_socket(socket); 00583 nsapi_error = NSAPI_ERROR_CONNECTION_LOST; 00584 if (_at->send("AT+USOCR=%d,%d", proto, address.get_port()) && 00585 _at->recv("+USOCR: %d\n", &modem_handle) && (modem_handle != SOCKET_UNUSED) && 00586 _at->recv("OK")) { 00587 *socket = savedSocket; 00588 nsapi_error = NSAPI_ERROR_OK; 00589 } 00590 } 00591 } 00592 00593 UNLOCK(); 00594 return nsapi_error; 00595 } 00596 00597 // Connect to a socket 00598 nsapi_error_t UbloxATCellularInterface::socket_connect(nsapi_socket_t handle, 00599 const SocketAddress &address) 00600 { 00601 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00602 SockCtrl *socket = (SockCtrl *) handle; 00603 LOCK(); 00604 00605 tr_debug("socket_connect(0x%08x, %s(:%d))", (unsigned int) handle, 00606 address.get_ip_address(), address.get_port()); 00607 00608 MBED_ASSERT (check_socket(socket)); 00609 00610 if (_at->send("AT+USOCO=%d,\"%s\",%d", socket->modem_handle, 00611 address.get_ip_address(), address.get_port()) && 00612 _at->recv("OK")) { 00613 nsapi_error = NSAPI_ERROR_OK; 00614 } 00615 00616 UNLOCK(); 00617 return nsapi_error; 00618 } 00619 00620 // Send to a socket. 00621 nsapi_size_or_error_t UbloxATCellularInterface::socket_send(nsapi_socket_t handle, 00622 const void *data, 00623 nsapi_size_t size) 00624 { 00625 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00626 bool success = true; 00627 const char *buf = (const char *) data; 00628 nsapi_size_t blk = MAX_WRITE_SIZE; 00629 nsapi_size_t count = size; 00630 SockCtrl *socket = (SockCtrl *) handle; 00631 00632 tr_debug("socket_send(0x%08x, 0x%08x, %d)", (unsigned int) handle, (unsigned int) data, size); 00633 00634 MBED_ASSERT (check_socket(socket)); 00635 00636 if (socket->modem_handle == SOCKET_UNUSED) { 00637 tr_debug("socket_send: socket closed"); 00638 return NSAPI_ERROR_NO_SOCKET; 00639 } 00640 00641 while ((count > 0) && success) { 00642 if (count < blk) { 00643 blk = count; 00644 } 00645 LOCK(); 00646 00647 if (_at->send("AT+USOWR=%d,%d", socket->modem_handle, blk) && _at->recv("@")) { 00648 wait_ms(50); 00649 if ((_at->write(buf, blk) < (int) blk) || 00650 !_at->recv("OK")) { 00651 success = false; 00652 } 00653 } else { 00654 success = false; 00655 } 00656 00657 UNLOCK(); 00658 buf += blk; 00659 count -= blk; 00660 } 00661 00662 if (success) { 00663 nsapi_error_size = size - count; 00664 if (_debug_trace_on) { 00665 tr_debug("socket_send: %d \"%*.*s\"", size, size, size, (char *) data); 00666 } 00667 } 00668 00669 return nsapi_error_size; 00670 } 00671 00672 // Send to an IP address. 00673 nsapi_size_or_error_t UbloxATCellularInterface::socket_sendto(nsapi_socket_t handle, 00674 const SocketAddress &address, 00675 const void *data, 00676 nsapi_size_t size) 00677 { 00678 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00679 bool success = true; 00680 const char *buf = (const char *) data; 00681 nsapi_size_t blk = MAX_WRITE_SIZE; 00682 nsapi_size_t count = size; 00683 SockCtrl *socket = (SockCtrl *) handle; 00684 00685 tr_debug("socket_sendto(0x%8x, %s(:%d), 0x%08x, %d)", (unsigned int) handle, 00686 address.get_ip_address(), address.get_port(), (unsigned int) data, size); 00687 00688 MBED_ASSERT (check_socket(socket)); 00689 00690 if (size > MAX_WRITE_SIZE) { 00691 tr_warn("WARNING: packet length %d is too big for one UDP packet (max %d), will be fragmented.", size, MAX_WRITE_SIZE); 00692 } 00693 00694 while ((count > 0) && success) { 00695 if (count < blk) { 00696 blk = count; 00697 } 00698 LOCK(); 00699 00700 if (_at->send("AT+USOST=%d,\"%s\",%d,%d", socket->modem_handle, 00701 address.get_ip_address(), address.get_port(), blk) && 00702 _at->recv("@")) { 00703 wait_ms(50); 00704 if ((_at->write(buf, blk) >= (int) blk) && 00705 _at->recv("OK")) { 00706 } else { 00707 success = false; 00708 } 00709 } else { 00710 success = false; 00711 } 00712 00713 UNLOCK(); 00714 buf += blk; 00715 count -= blk; 00716 } 00717 00718 if (success) { 00719 nsapi_error_size = size - count; 00720 if (_debug_trace_on) { 00721 tr_debug("socket_sendto: %d \"%*.*s\"", size, size, size, (char *) data); 00722 } 00723 } 00724 00725 return nsapi_error_size; 00726 } 00727 00728 // Receive from a socket, TCP style. 00729 nsapi_size_or_error_t UbloxATCellularInterface::socket_recv(nsapi_socket_t handle, 00730 void *data, 00731 nsapi_size_t size) 00732 { 00733 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00734 bool success = true; 00735 char *buf = (char *) data; 00736 nsapi_size_t read_blk; 00737 nsapi_size_t count = 0; 00738 unsigned int usord_sz; 00739 int read_sz; 00740 Timer timer; 00741 SockCtrl *socket = (SockCtrl *) handle; 00742 00743 00744 tr_debug("socket_recv(0x%08x, 0x%08x, %d)", 00745 (unsigned int) handle, (unsigned int) data, size); 00746 00747 MBED_ASSERT (check_socket(socket)); 00748 00749 if (socket->modem_handle == SOCKET_UNUSED) { 00750 tr_debug("socket_recv: socket closed"); 00751 return NSAPI_ERROR_NO_SOCKET; 00752 } 00753 00754 timer.start(); 00755 00756 while (success && (size > 0)) { 00757 int at_timeout; 00758 LOCK(); 00759 at_timeout = _at_timeout; 00760 at_set_timeout(1000); 00761 00762 read_blk = MAX_READ_SIZE; 00763 if (read_blk > size) { 00764 read_blk = size; 00765 } 00766 if (socket->pending > 0) { 00767 tr_debug("Socket 0x%08x: modem handle %d has %d byte(s) pending", 00768 (unsigned int) socket, socket->modem_handle, socket->pending); 00769 _at->debug_on(false); // ABSOLUTELY no time for debug here if you want to 00770 // be able to read packets of any size without 00771 // losing characters in UARTSerial 00772 if (_at->send("AT+USORD=%d,%d", socket->modem_handle, read_blk) && 00773 _at->recv("+USORD: %*d,%d,\"", &usord_sz)) { 00774 // Must use what +USORD returns here as it may be less or more than we asked for 00775 if (usord_sz > socket->pending) { 00776 socket->pending = 0; 00777 } else { 00778 socket->pending -= usord_sz; 00779 } 00780 // Note: insert no debug between _at->recv() and _at->read(), no time... 00781 if (usord_sz > size) { 00782 usord_sz = size; 00783 } 00784 read_sz = _at->read(buf, usord_sz); 00785 if (read_sz > 0) { 00786 tr_debug("...read %d byte(s) from modem handle %d...", read_sz, 00787 socket->modem_handle); 00788 if (_debug_trace_on) { 00789 tr_debug("Read returned %d, |%*.*s|", read_sz, read_sz, read_sz, buf); 00790 } 00791 count += read_sz; 00792 buf += read_sz; 00793 size -= read_sz; 00794 } else { 00795 // read() should not fail 00796 success = false; 00797 } 00798 tr_debug("Socket 0x%08x: modem handle %d now has only %d byte(s) pending", 00799 (unsigned int) socket, socket->modem_handle, socket->pending); 00800 // Wait for the "OK" before continuing 00801 _at->recv("OK"); 00802 } else { 00803 // Should never fail to do _at->send()/_at->recv() 00804 success = false; 00805 } 00806 _at->debug_on(_debug_trace_on); 00807 } else if (timer.read_ms() < SOCKET_TIMEOUT) { 00808 // Wait for URCs 00809 _at->recv(UNNATURAL_STRING); 00810 } else { 00811 if (count == 0) { 00812 // Timeout with nothing received 00813 nsapi_error_size = NSAPI_ERROR_WOULD_BLOCK; 00814 success = false; 00815 } 00816 size = 0; // This simply to cause an exit 00817 } 00818 00819 at_set_timeout(at_timeout); 00820 UNLOCK(); 00821 } 00822 timer.stop(); 00823 00824 if (success) { 00825 nsapi_error_size = count; 00826 } 00827 00828 if (_debug_trace_on) { 00829 tr_debug("socket_recv: %d \"%*.*s\"", count, count, count, buf - count); 00830 } else { 00831 tr_debug("socket_recv: received %d byte(s)", count); 00832 } 00833 00834 return nsapi_error_size; 00835 } 00836 00837 // Receive a packet over a UDP socket. 00838 nsapi_size_or_error_t UbloxATCellularInterface::socket_recvfrom(nsapi_socket_t handle, 00839 SocketAddress *address, 00840 void *data, 00841 nsapi_size_t size) 00842 { 00843 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00844 bool success = true; 00845 char *buf = (char *) data; 00846 nsapi_size_t read_blk; 00847 nsapi_size_t count = 0; 00848 char ipAddress[NSAPI_IP_SIZE]; 00849 int port; 00850 unsigned int usorf_sz; 00851 int read_sz; 00852 Timer timer; 00853 SockCtrl *socket = (SockCtrl *) handle; 00854 00855 tr_debug("socket_recvfrom(0x%08x, 0x%08x, %d)", 00856 (unsigned int) handle, (unsigned int) data, size); 00857 00858 MBED_ASSERT (check_socket(socket)); 00859 00860 timer.start(); 00861 00862 while (success && (size > 0)) { 00863 int at_timeout; 00864 LOCK(); 00865 at_timeout = _at_timeout; 00866 at_set_timeout(1000); 00867 00868 read_blk = MAX_READ_SIZE; 00869 if (read_blk > size) { 00870 read_blk = size; 00871 } 00872 if (socket->pending > 0) { 00873 tr_debug("Socket 0x%08x: modem handle %d has %d byte(s) pending", 00874 (unsigned int) socket, socket->modem_handle, socket->pending); 00875 memset (ipAddress, 0, sizeof (ipAddress)); // Ensure terminator 00876 00877 // Note: the maximum length of UDP packet we can receive comes from 00878 // fitting all of the following into one buffer: 00879 // 00880 // +USORF: xx,"max.len.ip.address.ipv4.or.ipv6",yyyyy,wwww,"the_data"\r\n 00881 // 00882 // where xx is the handle, max.len.ip.address.ipv4.or.ipv6 is NSAPI_IP_SIZE, 00883 // yyyyy is the port number (max 65536), wwww is the length of the data and 00884 // the_data is binary data. I make that 29 + 48 + len(the_data), 00885 // so the overhead is 77 bytes. 00886 00887 _at->debug_on(false); // ABSOLUTELY no time for debug here if you want to 00888 // be able to read packets of any size without 00889 // losing characters in UARTSerial 00890 if (_at->send("AT+USORF=%d,%d", socket->modem_handle, read_blk) && 00891 _at->recv("+USORF: %*d,\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\",%d,%d,\"", 00892 ipAddress, &port, &usorf_sz)) { 00893 // Must use what +USORF returns here as it may be less or more than we asked for 00894 if (usorf_sz > socket->pending) { 00895 socket->pending = 0; 00896 } else { 00897 socket->pending -= usorf_sz; 00898 } 00899 // Note: insert no debug between _at->recv() and _at->read(), no time... 00900 if (usorf_sz > size) { 00901 usorf_sz = size; 00902 } 00903 read_sz = _at->read(buf, usorf_sz); 00904 if (read_sz > 0) { 00905 address->set_ip_address(ipAddress); 00906 address->set_port(port); 00907 tr_debug("...read %d byte(s) from modem handle %d...", read_sz, 00908 socket->modem_handle); 00909 if (_debug_trace_on) { 00910 tr_debug("Read returned %d, |%*.*s|", read_sz, read_sz, read_sz, buf); 00911 } 00912 count += read_sz; 00913 buf += read_sz; 00914 size -= read_sz; 00915 if ((usorf_sz < read_blk) || (usorf_sz == MAX_READ_SIZE)) { 00916 size = 0; // If we've received less than we asked for, or 00917 // the max size, then a whole UDP packet has arrived and 00918 // this means DONE. 00919 } 00920 } else { 00921 // read() should not fail 00922 success = false; 00923 } 00924 tr_debug("Socket 0x%08x: modem handle %d now has only %d byte(s) pending", 00925 (unsigned int) socket, socket->modem_handle, socket->pending); 00926 // Wait for the "OK" before continuing 00927 _at->recv("OK"); 00928 } else { 00929 // Should never fail to do _at->send()/_at->recv() 00930 success = false; 00931 } 00932 _at->debug_on(_debug_trace_on); 00933 } else if (timer.read_ms() < SOCKET_TIMEOUT) { 00934 // Wait for URCs 00935 _at->recv(UNNATURAL_STRING); 00936 } else { 00937 if (count == 0) { 00938 // Timeout with nothing received 00939 nsapi_error_size = NSAPI_ERROR_WOULD_BLOCK; 00940 success = false; 00941 } 00942 size = 0; // This simply to cause an exit 00943 } 00944 00945 at_set_timeout(at_timeout); 00946 UNLOCK(); 00947 } 00948 timer.stop(); 00949 00950 if (success) { 00951 nsapi_error_size = count; 00952 } 00953 00954 if (_debug_trace_on) { 00955 tr_debug("socket_recvfrom: %d \"%*.*s\"", count, count, count, buf - count); 00956 } else { 00957 tr_debug("socket_recvfrom: received %d byte(s)", count); 00958 } 00959 00960 return nsapi_error_size; 00961 } 00962 00963 // Attach an event callback to a socket, required for asynchronous 00964 // data reception 00965 void UbloxATCellularInterface::socket_attach(nsapi_socket_t handle, 00966 void (*callback)(void *), 00967 void *data) 00968 { 00969 SockCtrl *socket = (SockCtrl *) handle; 00970 00971 MBED_ASSERT (check_socket(socket)); 00972 00973 socket->callback = callback; 00974 socket->data = data; 00975 } 00976 00977 // Unsupported TCP server functions. 00978 nsapi_error_t UbloxATCellularInterface::socket_listen(nsapi_socket_t handle, 00979 int backlog) 00980 { 00981 return NSAPI_ERROR_UNSUPPORTED; 00982 } 00983 nsapi_error_t UbloxATCellularInterface::socket_accept(nsapi_socket_t server, 00984 nsapi_socket_t *handle, 00985 SocketAddress *address) 00986 { 00987 return NSAPI_ERROR_UNSUPPORTED; 00988 } 00989 00990 // Unsupported option functions. 00991 nsapi_error_t UbloxATCellularInterface::setsockopt(nsapi_socket_t handle, 00992 int level, int optname, 00993 const void *optval, 00994 unsigned optlen) 00995 { 00996 return NSAPI_ERROR_UNSUPPORTED; 00997 } 00998 nsapi_error_t UbloxATCellularInterface::getsockopt(nsapi_socket_t handle, 00999 int level, int optname, 01000 void *optval, 01001 unsigned *optlen) 01002 { 01003 return NSAPI_ERROR_UNSUPPORTED; 01004 } 01005 01006 /********************************************************************** 01007 * PUBLIC METHODS 01008 **********************************************************************/ 01009 01010 // Constructor. 01011 UbloxATCellularInterface::UbloxATCellularInterface(PinName tx, 01012 PinName rx, 01013 int baud, 01014 bool debug_on, 01015 osPriority priority) 01016 { 01017 _sim_pin_check_change_pending = false; 01018 _sim_pin_check_change_pending_enabled_value = false; 01019 _sim_pin_change_pending = false; 01020 _sim_pin_change_pending_new_pin_value = NULL; 01021 _run_event_thread = true; 01022 _apn = NULL; 01023 _uname = NULL; 01024 _pwd = NULL; 01025 01026 01027 01028 01029 // Initialise sockets storage 01030 memset(_sockets, 0, sizeof(_sockets)); 01031 for (unsigned int socket = 0; socket < sizeof(_sockets) / sizeof(_sockets[0]); socket++) { 01032 _sockets[socket].modem_handle = SOCKET_UNUSED; 01033 _sockets[socket].callback = NULL; 01034 _sockets[socket].data = NULL; 01035 } 01036 01037 // The authentication to use 01038 _auth = NSAPI_SECURITY_UNKNOWN; 01039 01040 // Nullify the temporary IP address storage 01041 _ip = NULL; 01042 _connection_status_cb = NULL; 01043 01044 01045 // Initialise the base class, which starts the AT parser 01046 baseClassInit(tx, rx, baud, debug_on); 01047 01048 // Start the event handler thread for Rx data 01049 event_thread.start(callback(this, &UbloxATCellularInterface::handle_event)); 01050 event_thread.set_priority(priority); 01051 01052 // URC handlers for sockets 01053 _at->oob("+UUSORD", callback(this, &UbloxATCellularInterface::UUSORD_URC)); 01054 _at->oob("+UUSORF", callback(this, &UbloxATCellularInterface::UUSORF_URC)); 01055 _at->oob("+UUSOCL", callback(this, &UbloxATCellularInterface::UUSOCL_URC)); 01056 _at->oob("+UUPSDD", callback(this, &UbloxATCellularInterface::UUPSDD_URC)); 01057 } 01058 01059 // Destructor. 01060 UbloxATCellularInterface::~UbloxATCellularInterface() 01061 { 01062 // Let the event thread shut down tidily 01063 _run_event_thread = false; 01064 event_thread.join(); 01065 01066 // Free _ip if it was ever allocated 01067 free(_ip); 01068 } 01069 01070 // Set the authentication scheme. 01071 void UbloxATCellularInterface::set_authentication(nsapi_security_t auth) 01072 { 01073 _auth = auth; 01074 } 01075 01076 // Set APN, user name and password. 01077 void UbloxATCellularInterface::set_credentials(const char *apn, 01078 const char *uname, 01079 const char *pwd) 01080 { 01081 _apn = apn; 01082 _uname = uname; 01083 _pwd = pwd; 01084 } 01085 01086 // Set PIN. 01087 void UbloxATCellularInterface::set_sim_pin(const char *pin) 01088 { 01089 set_pin(pin); 01090 } 01091 01092 // Get the IP address of a host. 01093 nsapi_error_t UbloxATCellularInterface::gethostbyname(const char *host, 01094 SocketAddress *address, 01095 nsapi_version_t version) 01096 { 01097 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01098 01099 01100 if (address->set_ip_address(host)) { 01101 nsapi_error = NSAPI_ERROR_OK; 01102 } else { 01103 int at_timeout; 01104 char ipAddress[NSAPI_IP_SIZE]; 01105 LOCK(); 01106 // This interrogation can sometimes take longer than the usual 8 seconds 01107 at_timeout = _at_timeout; 01108 at_set_timeout(60000); 01109 memset (ipAddress, 0, sizeof (ipAddress)); // Ensure terminator 01110 if (_at->send("AT+UDNSRN=0,\"%s\"", host) && 01111 _at->recv("+UDNSRN: \"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\"", ipAddress) && 01112 _at->recv("OK")) { 01113 if (address->set_ip_address(ipAddress)) { 01114 nsapi_error = NSAPI_ERROR_OK; 01115 } 01116 } 01117 at_set_timeout(at_timeout); 01118 UNLOCK(); 01119 } 01120 01121 return nsapi_error; 01122 } 01123 01124 // Make a cellular connection 01125 nsapi_error_t UbloxATCellularInterface::connect(const char *sim_pin, 01126 const char *apn, 01127 const char *uname, 01128 const char *pwd) 01129 { 01130 nsapi_error_t nsapi_error; 01131 01132 if (sim_pin != NULL) { 01133 _pin = sim_pin; 01134 } 01135 01136 if (apn != NULL) { 01137 _apn = apn; 01138 } 01139 01140 if ((uname != NULL) && (pwd != NULL)) { 01141 _uname = uname; 01142 _pwd = pwd; 01143 } else { 01144 _uname = NULL; 01145 _pwd = NULL; 01146 } 01147 01148 nsapi_error = connect(); 01149 01150 return nsapi_error; 01151 } 01152 01153 // Make a cellular connection using the IP stack on board the cellular modem 01154 nsapi_error_t UbloxATCellularInterface::connect() 01155 { 01156 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01157 bool registered = false; 01158 01159 // Set up modem and then register with the network 01160 if (init()) { 01161 nsapi_error = NSAPI_ERROR_NO_CONNECTION; 01162 // Perform any pending SIM actions 01163 if (_sim_pin_check_change_pending) { 01164 if (!sim_pin_check_enable(_sim_pin_check_change_pending_enabled_value)) { 01165 nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01166 } 01167 _sim_pin_check_change_pending = false; 01168 } 01169 if (_sim_pin_change_pending) { 01170 if (!change_sim_pin(_sim_pin_change_pending_new_pin_value)) { 01171 nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01172 } 01173 _sim_pin_change_pending = false; 01174 } 01175 #ifdef TARGET_UBLOX_C030_R41XM 01176 define_context(); 01177 #endif 01178 if (nsapi_error == NSAPI_ERROR_NO_CONNECTION) { 01179 for (int retries = 0; !registered && (retries < 3); retries++) { 01180 if (nwk_registration()) { 01181 registered = true; 01182 #ifdef TARGET_UBLOX_C030_R41XM 01183 if (activate_context()) { 01184 nsapi_error = NSAPI_ERROR_OK; 01185 } 01186 #endif 01187 } 01188 } 01189 } 01190 } 01191 #ifndef TARGET_UBLOX_C030_R41XM 01192 // Attempt to establish a connection 01193 if (registered && connect_modem_stack()) { 01194 nsapi_error = NSAPI_ERROR_OK; 01195 } 01196 #endif 01197 return nsapi_error; 01198 } 01199 01200 // User initiated disconnect. 01201 nsapi_error_t UbloxATCellularInterface::disconnect() 01202 { 01203 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01204 #ifdef TARGET_UBLOX_C030_R41XM 01205 if (nwk_deregistration()) { 01206 if (_connection_status_cb) { 01207 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST); 01208 } 01209 #else 01210 if (disconnect_modem_stack() && nwk_deregistration()) { 01211 #endif 01212 nsapi_error = NSAPI_ERROR_OK; 01213 } 01214 01215 return nsapi_error; 01216 } 01217 01218 // Enable or disable SIM PIN check lock. 01219 nsapi_error_t UbloxATCellularInterface::set_sim_pin_check(bool set, 01220 bool immediate, 01221 const char *sim_pin) 01222 { 01223 nsapi_error_t nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01224 01225 if (sim_pin != NULL) { 01226 _pin = sim_pin; 01227 } 01228 01229 if (immediate) { 01230 if (init()) { 01231 if (sim_pin_check_enable(set)) { 01232 nsapi_error = NSAPI_ERROR_OK; 01233 } 01234 } else { 01235 nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01236 } 01237 } else { 01238 nsapi_error = NSAPI_ERROR_OK; 01239 _sim_pin_check_change_pending = true; 01240 _sim_pin_check_change_pending_enabled_value = set; 01241 } 01242 01243 return nsapi_error; 01244 } 01245 01246 // Change the PIN code for the SIM card. 01247 nsapi_error_t UbloxATCellularInterface::set_new_sim_pin(const char *new_pin, 01248 bool immediate, 01249 const char *old_pin) 01250 { 01251 nsapi_error_t nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01252 01253 if (old_pin != NULL) { 01254 _pin = old_pin; 01255 } 01256 01257 if (immediate) { 01258 if (init()) { 01259 if (change_sim_pin(new_pin)) { 01260 nsapi_error = NSAPI_ERROR_OK; 01261 } 01262 } else { 01263 nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01264 } 01265 } else { 01266 nsapi_error = NSAPI_ERROR_OK; 01267 _sim_pin_change_pending = true; 01268 _sim_pin_change_pending_new_pin_value = new_pin; 01269 } 01270 01271 return nsapi_error; 01272 } 01273 01274 // Determine if the connection is up. 01275 bool UbloxATCellularInterface::is_connected() 01276 { 01277 return get_ip_address() != NULL; 01278 } 01279 01280 // Get the IP address of the on-board modem IP stack. 01281 const char * UbloxATCellularInterface::get_ip_address() 01282 { 01283 SocketAddress address; 01284 LOCK(); 01285 01286 if (_ip == NULL) { 01287 // Temporary storage for an IP address string with terminator 01288 _ip = (char *) malloc(NSAPI_IP_SIZE); 01289 } 01290 01291 if (_ip != NULL) { 01292 memset(_ip, 0, NSAPI_IP_SIZE); // Ensure a terminator 01293 // +UPSND=<profile_id>,<param_tag>[,<dynamic_param_val>] 01294 // If we get back a quoted "w.x.y.z" then we have an IP address, 01295 // otherwise we don't. 01296 #ifdef TARGET_UBLOX_C030_R41XM 01297 if (!_at->send("AT+CGPADDR=1") || 01298 !_at->recv("+CGPADDR: 1,%" u_stringify(NSAPI_IP_SIZE) "[^\n]\nOK\n", _ip) || 01299 !address.set_ip_address(_ip) || // Return NULL if the address is not a valid one 01300 !address) { // Return null if the address is zero 01301 free (_ip); 01302 _ip = NULL; 01303 } 01304 #else 01305 if (!_at->send("AT+UPSND=" PROFILE ",0") || 01306 !_at->recv("+UPSND: " PROFILE ",0,\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\"", _ip) || 01307 !_at->recv("OK") || 01308 !address.set_ip_address(_ip) || // Return NULL if the address is not a valid one 01309 !address) { // Return null if the address is zero 01310 free (_ip); 01311 _ip = NULL; 01312 } 01313 #endif 01314 } 01315 01316 UNLOCK(); 01317 return _ip; 01318 } 01319 01320 // Get the local network mask. 01321 const char *UbloxATCellularInterface::get_netmask() 01322 { 01323 // Not implemented. 01324 return NULL; 01325 } 01326 01327 // Get the local gateways. 01328 const char *UbloxATCellularInterface::get_gateway() 01329 { 01330 return get_ip_address(); 01331 } 01332 01333 // Callback in case the connection is lost. 01334 void UbloxATCellularInterface::connection_status_cb(Callback<void(nsapi_error_t)> cb) 01335 { 01336 _connection_status_cb = cb; 01337 } 01338 01339 void UbloxATCellularInterface::set_plmn(const char *plmn) { 01340 01341 } 01342 01343 // End of file 01344
Generated on Mon Jul 18 2022 17:55:35 by
1.7.2