Mudassar Hussain
ublox-at-cellular-interface
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 active = 0; 00253 int at_timeout = _at_timeout; 00254 SocketAddress address; 00255 00256 // Set up the APN 00257 if (*apn) { 00258 success = _at->send("AT+UPSD=" PROFILE ",1,\"%s\"", apn) && _at->recv("OK"); 00259 } 00260 if (success && *username) { 00261 success = _at->send("AT+UPSD=" PROFILE ",2,\"%s\"", username) && _at->recv("OK"); 00262 } 00263 if (success && *password) { 00264 success = _at->send("AT+UPSD=" PROFILE ",3,\"%s\"", password) && _at->recv("OK"); 00265 } 00266 00267 if (success) { 00268 // Set up dynamic IP address assignment. 00269 success = _at->send("AT+UPSD=" PROFILE ",7,\"0.0.0.0\"") && _at->recv("OK"); 00270 // Set up the authentication protocol 00271 // 0 = none 00272 // 1 = PAP (Password Authentication Protocol) 00273 // 2 = CHAP (Challenge Handshake Authentication Protocol) 00274 for (int protocol = nsapi_security_to_modem_security(NSAPI_SECURITY_NONE); 00275 success && (protocol <= nsapi_security_to_modem_security(NSAPI_SECURITY_CHAP)); protocol++) { 00276 if ((_auth == NSAPI_SECURITY_UNKNOWN) || (nsapi_security_to_modem_security(_auth) == protocol)) { 00277 if (_at->send("AT+UPSD=" PROFILE ",6,%d", protocol) && _at->recv("OK")) { 00278 at_set_timeout(3*60*1000); 00279 _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK"); 00280 at_set_timeout(at_timeout); 00281 } 00282 } 00283 } 00284 00285 Timer timer; 00286 timer.start(); 00287 while (timer.read() < 180) { 00288 if (_at->send("AT+UPSND=" PROFILE ",8") && _at->recv("+UPSND: %*d,%*d,%d\n", &active) && 00289 _at->recv("OK")) { 00290 if (active == 1) { 00291 tr_debug("Profile activated successfully"); 00292 activated = true; 00293 break; 00294 } else { 00295 tr_error("Profile still inactive"); 00296 rtos::ThisThread::sleep_for(5000); //Wait for 5 seconds and then try again 00297 } 00298 } 00299 } 00300 timer.stop(); 00301 } 00302 00303 return activated; 00304 } 00305 00306 // Activate a profile by reusing an external PDP context. 00307 // Note: the AT interface should be locked before this is called. 00308 bool UbloxATCellularInterface::activate_profile_reuse_external(void) 00309 { 00310 bool success = false; 00311 int cid = -1; 00312 SocketAddress address; 00313 int t; 00314 int at_timeout = _at_timeout; 00315 00316 //+CGDCONT: <cid>,"IP","<apn name>","<ip adr>",0,0,0,0,0,0 00317 if (_at->send("AT+CGDCONT?")) { 00318 char ip[NSAPI_IP_SIZE]; 00319 if (_at->recv("+CGDCONT: %d,\"IP\",\"%*[^\"]\",\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\",%*d,%*d,%*d,%*d,%*d,%*d", 00320 &t, ip) && 00321 _at->recv("OK")) { 00322 // Check if the IP address is valid 00323 if (address.set_ip_address(ip)) { 00324 cid = t; 00325 } 00326 } 00327 } 00328 00329 // If a context has been found, use it 00330 if ((cid != -1) && (_at->send("AT+UPSD=" PROFILE ",100,%d", cid) && _at->recv("OK"))) { 00331 // Activate, waiting 30 seconds for the connection to be made 00332 at_set_timeout(30000); 00333 success = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK"); 00334 at_set_timeout(at_timeout); 00335 } 00336 00337 return success; 00338 } 00339 00340 // Activate a profile by context ID. 00341 // Note: the AT interface should be locked before this is called. 00342 bool UbloxATCellularInterface::activate_profile_by_cid(int cid, 00343 const char* apn, 00344 const char* username, 00345 const char* password, 00346 nsapi_security_t auth) 00347 { 00348 bool success = false; 00349 00350 #ifndef TARGET_UBLOX_C030_R41XM 00351 int at_timeout = _at_timeout; 00352 00353 if (_at->send("AT+CGDCONT=%d,\"IP\",\"%s\"", cid, apn) && _at->recv("OK") && 00354 _at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, nsapi_security_to_modem_security(auth), 00355 username, password) && _at->recv("OK") && 00356 _at->send("AT+UPSD=" PROFILE ",100,%d", cid) && _at->recv("OK")) { 00357 00358 // Wait 30 seconds for the connection to be made 00359 at_set_timeout(30000); 00360 // Activate the protocol 00361 success = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK"); 00362 at_set_timeout(at_timeout); 00363 } 00364 #else 00365 int modem_security = nsapi_security_to_modem_security(auth); 00366 if (_at->send("AT+CGDCONT=%d,\"IP\",\"%s\"", cid, apn) && _at->recv("OK")) { 00367 if ( modem_security == NSAPI_SECURITY_CHAP) { 00368 if (_at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, modem_security, 00369 password, username) && _at->recv("OK")) { 00370 success = true; 00371 } 00372 } else if (modem_security == NSAPI_SECURITY_NONE) { 00373 if (_at->send("AT+UAUTHREQ=%d,%d", cid, modem_security) && _at->recv("OK")) { 00374 success = true; 00375 } 00376 } else { 00377 if (_at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, modem_security, 00378 username, password) && _at->recv("OK")) { 00379 success = true; 00380 } 00381 } 00382 } 00383 #endif 00384 00385 return success; 00386 } 00387 00388 #ifdef TARGET_UBLOX_C030_R41XM 00389 //define PDP context for R412M 00390 bool UbloxATCellularInterface::define_context() 00391 { 00392 bool success = false; 00393 const char * config = NULL; 00394 LOCK(); 00395 00396 // If the caller hasn't entered an APN, try to find it 00397 if (_apn == NULL) { 00398 config = apnconfig(_dev_info.imsi); 00399 } 00400 00401 // Attempt to connect 00402 do { 00403 // Set up APN and IP protocol for PDP context 00404 get_next_credentials(&config); 00405 _auth = (*_uname && *_pwd) ? _auth : NSAPI_SECURITY_NONE; 00406 if (activate_profile_by_cid(1, _apn, _uname, _pwd, _auth)) { 00407 success = true; 00408 } 00409 } while (!success && config && *config); 00410 00411 if (!success) { 00412 tr_error("Failed to connect, check your APN/username/password"); 00413 } 00414 00415 UNLOCK(); 00416 return success; 00417 } 00418 bool UbloxATCellularInterface::activate_context() 00419 { 00420 bool status = false; 00421 int at_timeout; 00422 LOCK(); 00423 00424 at_timeout = _at_timeout; // Has to be inside LOCK()s 00425 at_set_timeout(150000); 00426 if (_at->send("AT+CGACT=1,1") && _at->recv("OK")) { 00427 status = true; 00428 } 00429 00430 at_set_timeout(at_timeout); 00431 00432 UNLOCK(); 00433 return status; 00434 } 00435 00436 bool UbloxATCellularInterface::is_context_active() 00437 { 00438 bool status = false; 00439 int at_timeout; 00440 int active = 0; 00441 LOCK(); 00442 00443 at_timeout = _at_timeout; // Has to be inside LOCK()s 00444 at_set_timeout(150000); 00445 if (_at->send("AT+CGACT?") && _at->recv("+CGACT: %*d,%d\n", &active) && 00446 _at->recv("OK")) { 00447 if (active == 1) { 00448 status = true; 00449 } 00450 } 00451 at_set_timeout(at_timeout); 00452 00453 UNLOCK(); 00454 return status; 00455 } 00456 #endif 00457 00458 // Connect the on board IP stack of the modem. 00459 bool UbloxATCellularInterface::connect_modem_stack() 00460 { 00461 bool success = false; 00462 int active = 0; 00463 const char * config = NULL; 00464 LOCK(); 00465 00466 // Check the profile 00467 if (_at->send("AT+UPSND=" PROFILE ",8") && _at->recv("+UPSND: %*d,%*d,%d\n", &active) && 00468 _at->recv("OK")) { 00469 if (active == 0) { 00470 // If the caller hasn't entered an APN, try to find it 00471 if (_apn == NULL) { 00472 config = apnconfig(_dev_info.imsi); 00473 } 00474 00475 // Attempt to connect 00476 do { 00477 // Set up APN and IP protocol for PDP context 00478 get_next_credentials(&config); 00479 _auth = (*_uname && *_pwd) ? _auth : NSAPI_SECURITY_NONE; 00480 if ((_dev_info.dev != DEV_TOBY_L2) && (_dev_info.dev != DEV_MPCI_L2)) { 00481 success = activate_profile(_apn, _uname, _pwd, _auth); 00482 } else { 00483 success = activate_profile_reuse_external(); 00484 if (success) { 00485 tr_debug("Reusing external context"); 00486 } else { 00487 success = activate_profile_by_cid(1, _apn, _uname, _pwd, _auth); 00488 } 00489 } 00490 } while (!success && config && *config); 00491 } else { 00492 // If the profile is already active, we're good 00493 success = true; 00494 } 00495 } 00496 00497 if (!success) { 00498 tr_error("Failed to connect, check your APN/username/password"); 00499 } 00500 00501 UNLOCK(); 00502 return success; 00503 } 00504 00505 // Disconnect the on board IP stack of the modem. 00506 bool UbloxATCellularInterface::disconnect_modem_stack() 00507 { 00508 bool success = false; 00509 int active; 00510 Timer t1; 00511 LOCK(); 00512 00513 if (get_ip_address () != NULL) { 00514 if (_at->send("AT+UPSDA=" PROFILE ",4") && _at->recv("OK")) { 00515 success = true; 00516 if (_connection_status_cb) { 00517 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST); 00518 } 00519 } 00520 } 00521 t1.start(); 00522 while (!(t1.read() >= 180)) { 00523 if (_at->send("AT+UPSND=" PROFILE ",8") && _at->recv("+UPSND: %*d,%*d,%d\n", &active) && _at->recv("OK")) { 00524 00525 if (active == 0) { //If context is deactivated, exit while loop and return status 00526 tr_debug("Profile deactivated successfully"); 00527 break; 00528 } 00529 else { 00530 tr_error("Profile still active"); 00531 rtos::ThisThread::sleep_for(5000); //Wait for 5 seconds and then try again 00532 } 00533 } 00534 } 00535 t1.stop(); 00536 00537 UNLOCK(); 00538 return success; 00539 } 00540 00541 /********************************************************************** 00542 * PROTECTED METHODS: NETWORK INTERFACE and SOCKETS 00543 **********************************************************************/ 00544 00545 // Gain access to us. 00546 NetworkStack *UbloxATCellularInterface::get_stack() 00547 { 00548 return this; 00549 } 00550 00551 // Create a socket. 00552 nsapi_error_t UbloxATCellularInterface::socket_open(nsapi_socket_t *handle, 00553 nsapi_protocol_t proto) 00554 { 00555 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00556 int modem_handle; 00557 SockCtrl *socket; 00558 LOCK(); 00559 00560 // Find a free socket 00561 socket = find_socket(); 00562 tr_debug("socket_open(%d)", proto); 00563 00564 if (socket != NULL) { 00565 bool success = false; 00566 if (proto == NSAPI_UDP) { 00567 success = _at->send("AT+USOCR=17"); 00568 } else if (proto == NSAPI_TCP) { 00569 success = _at->send("AT+USOCR=6"); 00570 } else { 00571 nsapi_error = NSAPI_ERROR_UNSUPPORTED; 00572 } 00573 00574 if (success) { 00575 nsapi_error = NSAPI_ERROR_NO_SOCKET; 00576 if (_at->recv("+USOCR: %d\n", &modem_handle) && (modem_handle != SOCKET_UNUSED) && 00577 _at->recv("OK")) { 00578 tr_debug("Socket 0x%8x: handle %d was created", (unsigned int) socket, modem_handle); 00579 clear_socket(socket); 00580 socket->modem_handle = modem_handle; 00581 *handle = (nsapi_socket_t) socket; 00582 nsapi_error = NSAPI_ERROR_OK; 00583 } 00584 } 00585 } else { 00586 nsapi_error = NSAPI_ERROR_NO_MEMORY; 00587 } 00588 00589 UNLOCK(); 00590 return nsapi_error; 00591 } 00592 00593 // Close a socket. 00594 nsapi_error_t UbloxATCellularInterface::socket_close(nsapi_socket_t handle) 00595 { 00596 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00597 SockCtrl *socket = (SockCtrl *) handle; 00598 LOCK(); 00599 00600 tr_debug("socket_close(0x%08x)", (unsigned int) handle); 00601 00602 MBED_ASSERT (check_socket(socket)); 00603 00604 if (_at->send("AT+USOCL=%d", socket->modem_handle) && 00605 _at->recv("OK")) { 00606 clear_socket(socket); 00607 nsapi_error = NSAPI_ERROR_OK; 00608 } 00609 00610 UNLOCK(); 00611 return nsapi_error; 00612 } 00613 00614 // Bind a local port to a socket. 00615 nsapi_error_t UbloxATCellularInterface::socket_bind(nsapi_socket_t handle, 00616 const SocketAddress &address) 00617 { 00618 nsapi_error_t nsapi_error = NSAPI_ERROR_NO_SOCKET; 00619 int proto; 00620 int modem_handle; 00621 SockCtrl savedSocket; 00622 SockCtrl *socket = (SockCtrl *) handle; 00623 LOCK(); 00624 00625 tr_debug("socket_bind(0x%08x, :%d)", (unsigned int) handle, address.get_port()); 00626 00627 MBED_ASSERT (check_socket(socket)); 00628 00629 // Query the socket type 00630 if (_at->send("AT+USOCTL=%d,0", socket->modem_handle) && 00631 _at->recv("+USOCTL: %*d,0,%d\n", &proto) && 00632 _at->recv("OK")) { 00633 savedSocket = *socket; 00634 nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00635 // Now close the socket and re-open it with the binding given 00636 if (_at->send("AT+USOCL=%d", socket->modem_handle) && 00637 _at->recv("OK")) { 00638 clear_socket(socket); 00639 nsapi_error = NSAPI_ERROR_CONNECTION_LOST; 00640 if (_at->send("AT+USOCR=%d,%d", proto, address.get_port()) && 00641 _at->recv("+USOCR: %d\n", &modem_handle) && (modem_handle != SOCKET_UNUSED) && 00642 _at->recv("OK")) { 00643 *socket = savedSocket; 00644 nsapi_error = NSAPI_ERROR_OK; 00645 } 00646 } 00647 } 00648 00649 UNLOCK(); 00650 return nsapi_error; 00651 } 00652 00653 // Connect to a socket 00654 nsapi_error_t UbloxATCellularInterface::socket_connect(nsapi_socket_t handle, 00655 const SocketAddress &address) 00656 { 00657 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 00658 SockCtrl *socket = (SockCtrl *) handle; 00659 LOCK(); 00660 00661 tr_debug("socket_connect(0x%08x, %s(:%d))", (unsigned int) handle, 00662 address.get_ip_address(), address.get_port()); 00663 00664 MBED_ASSERT (check_socket(socket)); 00665 00666 if (_at->send("AT+USOCO=%d,\"%s\",%d", socket->modem_handle, 00667 address.get_ip_address(), address.get_port()) && 00668 _at->recv("OK")) { 00669 nsapi_error = NSAPI_ERROR_OK; 00670 } 00671 00672 UNLOCK(); 00673 return nsapi_error; 00674 } 00675 00676 // Send to a socket. 00677 nsapi_size_or_error_t UbloxATCellularInterface::socket_send(nsapi_socket_t handle, 00678 const void *data, 00679 nsapi_size_t size) 00680 { 00681 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00682 bool success = true; 00683 const char *buf = (const char *) data; 00684 nsapi_size_t blk = MAX_WRITE_SIZE; 00685 nsapi_size_t count = size; 00686 SockCtrl *socket = (SockCtrl *) handle; 00687 00688 tr_debug("socket_send(0x%08x, 0x%08x, %d)", (unsigned int) handle, (unsigned int) data, size); 00689 00690 MBED_ASSERT (check_socket(socket)); 00691 00692 if (socket->modem_handle == SOCKET_UNUSED) { 00693 tr_debug("socket_send: socket closed"); 00694 return NSAPI_ERROR_NO_SOCKET; 00695 } 00696 00697 while ((count > 0) && success) { 00698 if (count < blk) { 00699 blk = count; 00700 } 00701 LOCK(); 00702 00703 if (_at->send("AT+USOWR=%d,%d", socket->modem_handle, blk) && _at->recv("@")) { 00704 ThisThread::sleep_for(50); 00705 if ((_at->write(buf, blk) < (int) blk) || 00706 !_at->recv("OK")) { 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_send: %d \"%*.*s\"", size, size, size, (char *) data); 00722 } 00723 } 00724 00725 return nsapi_error_size; 00726 } 00727 00728 // Send to an IP address. 00729 nsapi_size_or_error_t UbloxATCellularInterface::socket_sendto(nsapi_socket_t handle, 00730 const SocketAddress &address, 00731 const void *data, 00732 nsapi_size_t size) 00733 { 00734 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00735 bool success = true; 00736 const char *buf = (const char *) data; 00737 nsapi_size_t blk = MAX_WRITE_SIZE; 00738 nsapi_size_t count = size; 00739 SockCtrl *socket = (SockCtrl *) handle; 00740 00741 tr_debug("socket_sendto(0x%8x, %s(:%d), 0x%08x, %d)", (unsigned int) handle, 00742 address.get_ip_address(), address.get_port(), (unsigned int) data, size); 00743 00744 MBED_ASSERT (check_socket(socket)); 00745 00746 if (size > MAX_WRITE_SIZE) { 00747 tr_warn("WARNING: packet length %d is too big for one UDP packet (max %d), will be fragmented.", size, MAX_WRITE_SIZE); 00748 } 00749 00750 while ((count > 0) && success) { 00751 if (count < blk) { 00752 blk = count; 00753 } 00754 LOCK(); 00755 00756 if (_at->send("AT+USOST=%d,\"%s\",%d,%d", socket->modem_handle, 00757 address.get_ip_address(), address.get_port(), blk) && 00758 _at->recv("@")) { 00759 ThisThread::sleep_for(50); 00760 if ((_at->write(buf, blk) >= (int) blk) && 00761 _at->recv("OK")) { 00762 } else { 00763 success = false; 00764 } 00765 } else { 00766 success = false; 00767 } 00768 00769 UNLOCK(); 00770 buf += blk; 00771 count -= blk; 00772 } 00773 00774 if (success) { 00775 nsapi_error_size = size - count; 00776 if (_debug_trace_on) { 00777 tr_debug("socket_sendto: %d \"%*.*s\"", size, size, size, (char *) data); 00778 } 00779 } 00780 00781 return nsapi_error_size; 00782 } 00783 00784 // Receive from a socket, TCP style. 00785 nsapi_size_or_error_t UbloxATCellularInterface::socket_recv(nsapi_socket_t handle, 00786 void *data, 00787 nsapi_size_t size) 00788 { 00789 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00790 bool success = true; 00791 char *buf = (char *) data; 00792 nsapi_size_t read_blk; 00793 nsapi_size_t count = 0; 00794 unsigned int usord_sz; 00795 int read_sz; 00796 Timer timer; 00797 SockCtrl *socket = (SockCtrl *) handle; 00798 00799 00800 tr_debug("socket_recv(0x%08x, 0x%08x, %d)", 00801 (unsigned int) handle, (unsigned int) data, size); 00802 00803 MBED_ASSERT (check_socket(socket)); 00804 00805 if (socket->modem_handle == SOCKET_UNUSED) { 00806 tr_debug("socket_recv: socket closed"); 00807 return NSAPI_ERROR_NO_SOCKET; 00808 } 00809 00810 timer.start(); 00811 00812 while (success && (size > 0)) { 00813 int at_timeout; 00814 LOCK(); 00815 at_timeout = _at_timeout; 00816 at_set_timeout(1000); 00817 00818 read_blk = MAX_READ_SIZE; 00819 if (read_blk > size) { 00820 read_blk = size; 00821 } 00822 if (socket->pending > 0) { 00823 tr_debug("Socket 0x%08x: modem handle %d has %d byte(s) pending", 00824 (unsigned int) socket, socket->modem_handle, socket->pending); 00825 _at->debug_on(false); // ABSOLUTELY no time for debug here if you want to 00826 // be able to read packets of any size without 00827 // losing characters in UARTSerial 00828 if (_at->send("AT+USORD=%d,%d", socket->modem_handle, read_blk) && 00829 _at->recv("+USORD: %*d,%d,\"", &usord_sz)) { 00830 // Must use what +USORD returns here as it may be less or more than we asked for 00831 if (usord_sz > socket->pending) { 00832 socket->pending = 0; 00833 } else { 00834 socket->pending -= usord_sz; 00835 } 00836 // Note: insert no debug between _at->recv() and _at->read(), no time... 00837 if (usord_sz > size) { 00838 usord_sz = size; 00839 } 00840 read_sz = _at->read(buf, usord_sz); 00841 if (read_sz > 0) { 00842 tr_debug("...read %d byte(s) from modem handle %d...", read_sz, 00843 socket->modem_handle); 00844 if (_debug_trace_on) { 00845 tr_debug("Read returned %d, |%*.*s|", read_sz, read_sz, read_sz, buf); 00846 } 00847 count += read_sz; 00848 buf += read_sz; 00849 size -= read_sz; 00850 } else { 00851 // read() should not fail 00852 success = false; 00853 } 00854 tr_debug("Socket 0x%08x: modem handle %d now has only %d byte(s) pending", 00855 (unsigned int) socket, socket->modem_handle, socket->pending); 00856 // Wait for the "OK" before continuing 00857 _at->recv("OK"); 00858 } else { 00859 // Should never fail to do _at->send()/_at->recv() 00860 success = false; 00861 } 00862 _at->debug_on(_debug_trace_on); 00863 } else if (timer.read_ms() < SOCKET_TIMEOUT) { 00864 // Wait for URCs 00865 _at->recv(UNNATURAL_STRING); 00866 } else { 00867 if (count == 0) { 00868 // Timeout with nothing received 00869 nsapi_error_size = NSAPI_ERROR_WOULD_BLOCK; 00870 success = false; 00871 } 00872 size = 0; // This simply to cause an exit 00873 } 00874 00875 at_set_timeout(at_timeout); 00876 UNLOCK(); 00877 } 00878 timer.stop(); 00879 00880 if (success) { 00881 nsapi_error_size = count; 00882 } 00883 00884 if (_debug_trace_on) { 00885 tr_debug("socket_recv: %d \"%*.*s\"", count, count, count, buf - count); 00886 } else { 00887 tr_debug("socket_recv: received %d byte(s)", count); 00888 } 00889 00890 return nsapi_error_size; 00891 } 00892 00893 // Receive a packet over a UDP socket. 00894 nsapi_size_or_error_t UbloxATCellularInterface::socket_recvfrom(nsapi_socket_t handle, 00895 SocketAddress *address, 00896 void *data, 00897 nsapi_size_t size) 00898 { 00899 nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR; 00900 bool success = true; 00901 char *buf = (char *) data; 00902 nsapi_size_t read_blk; 00903 nsapi_size_t count = 0; 00904 char ipAddress[NSAPI_IP_SIZE]; 00905 int port; 00906 unsigned int usorf_sz; 00907 int read_sz; 00908 Timer timer; 00909 SockCtrl *socket = (SockCtrl *) handle; 00910 00911 tr_debug("socket_recvfrom(0x%08x, 0x%08x, %d)", 00912 (unsigned int) handle, (unsigned int) data, size); 00913 00914 MBED_ASSERT (check_socket(socket)); 00915 00916 timer.start(); 00917 00918 while (success && (size > 0)) { 00919 int at_timeout; 00920 LOCK(); 00921 at_timeout = _at_timeout; 00922 at_set_timeout(1000); 00923 00924 read_blk = MAX_READ_SIZE; 00925 if (read_blk > size) { 00926 read_blk = size; 00927 } 00928 if (socket->pending > 0) { 00929 tr_debug("Socket 0x%08x: modem handle %d has %d byte(s) pending", 00930 (unsigned int) socket, socket->modem_handle, socket->pending); 00931 memset (ipAddress, 0, sizeof (ipAddress)); // Ensure terminator 00932 00933 // Note: the maximum length of UDP packet we can receive comes from 00934 // fitting all of the following into one buffer: 00935 // 00936 // +USORF: xx,"max.len.ip.address.ipv4.or.ipv6",yyyyy,wwww,"the_data"\r\n 00937 // 00938 // where xx is the handle, max.len.ip.address.ipv4.or.ipv6 is NSAPI_IP_SIZE, 00939 // yyyyy is the port number (max 65536), wwww is the length of the data and 00940 // the_data is binary data. I make that 29 + 48 + len(the_data), 00941 // so the overhead is 77 bytes. 00942 00943 _at->debug_on(false); // ABSOLUTELY no time for debug here if you want to 00944 // be able to read packets of any size without 00945 // losing characters in UARTSerial 00946 if (_at->send("AT+USORF=%d,%d", socket->modem_handle, read_blk) && 00947 _at->recv("+USORF: %*d,\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\",%d,%d,\"", 00948 ipAddress, &port, &usorf_sz)) { 00949 // Must use what +USORF returns here as it may be less or more than we asked for 00950 if (usorf_sz > socket->pending) { 00951 socket->pending = 0; 00952 } else { 00953 socket->pending -= usorf_sz; 00954 } 00955 // Note: insert no debug between _at->recv() and _at->read(), no time... 00956 if (usorf_sz > size) { 00957 usorf_sz = size; 00958 } 00959 read_sz = _at->read(buf, usorf_sz); 00960 if (read_sz > 0) { 00961 address->set_ip_address(ipAddress); 00962 address->set_port(port); 00963 tr_debug("...read %d byte(s) from modem handle %d...", read_sz, 00964 socket->modem_handle); 00965 if (_debug_trace_on) { 00966 tr_debug("Read returned %d, |%*.*s|", read_sz, read_sz, read_sz, buf); 00967 } 00968 count += read_sz; 00969 buf += read_sz; 00970 size -= read_sz; 00971 if ((usorf_sz < read_blk) || (usorf_sz == MAX_READ_SIZE)) { 00972 size = 0; // If we've received less than we asked for, or 00973 // the max size, then a whole UDP packet has arrived and 00974 // this means DONE. 00975 } 00976 } else { 00977 // read() should not fail 00978 success = false; 00979 } 00980 tr_debug("Socket 0x%08x: modem handle %d now has only %d byte(s) pending", 00981 (unsigned int) socket, socket->modem_handle, socket->pending); 00982 // Wait for the "OK" before continuing 00983 _at->recv("OK"); 00984 } else { 00985 // Should never fail to do _at->send()/_at->recv() 00986 success = false; 00987 } 00988 _at->debug_on(_debug_trace_on); 00989 } else if (timer.read_ms() < SOCKET_TIMEOUT) { 00990 // Wait for URCs 00991 _at->recv(UNNATURAL_STRING); 00992 } else { 00993 if (count == 0) { 00994 // Timeout with nothing received 00995 nsapi_error_size = NSAPI_ERROR_WOULD_BLOCK; 00996 success = false; 00997 } 00998 size = 0; // This simply to cause an exit 00999 } 01000 01001 at_set_timeout(at_timeout); 01002 UNLOCK(); 01003 } 01004 timer.stop(); 01005 01006 if (success) { 01007 nsapi_error_size = count; 01008 } 01009 01010 if (_debug_trace_on) { 01011 tr_debug("socket_recvfrom: %d \"%*.*s\"", count, count, count, buf - count); 01012 } else { 01013 tr_debug("socket_recvfrom: received %d byte(s)", count); 01014 } 01015 01016 return nsapi_error_size; 01017 } 01018 01019 // Attach an event callback to a socket, required for asynchronous 01020 // data reception 01021 void UbloxATCellularInterface::socket_attach(nsapi_socket_t handle, 01022 void (*callback)(void *), 01023 void *data) 01024 { 01025 SockCtrl *socket = (SockCtrl *) handle; 01026 01027 MBED_ASSERT (check_socket(socket)); 01028 01029 socket->callback = callback; 01030 socket->data = data; 01031 } 01032 01033 // Unsupported TCP server functions. 01034 nsapi_error_t UbloxATCellularInterface::socket_listen(nsapi_socket_t handle, 01035 int backlog) 01036 { 01037 return NSAPI_ERROR_UNSUPPORTED; 01038 } 01039 nsapi_error_t UbloxATCellularInterface::socket_accept(nsapi_socket_t server, 01040 nsapi_socket_t *handle, 01041 SocketAddress *address) 01042 { 01043 return NSAPI_ERROR_UNSUPPORTED; 01044 } 01045 01046 // Unsupported option functions. 01047 nsapi_error_t UbloxATCellularInterface::setsockopt(nsapi_socket_t handle, 01048 int level, int optname, 01049 const void *optval, 01050 unsigned optlen) 01051 { 01052 return NSAPI_ERROR_UNSUPPORTED; 01053 } 01054 nsapi_error_t UbloxATCellularInterface::getsockopt(nsapi_socket_t handle, 01055 int level, int optname, 01056 void *optval, 01057 unsigned *optlen) 01058 { 01059 return NSAPI_ERROR_UNSUPPORTED; 01060 } 01061 01062 /********************************************************************** 01063 * PUBLIC METHODS 01064 **********************************************************************/ 01065 01066 // Constructor. 01067 UbloxATCellularInterface::UbloxATCellularInterface(PinName tx, 01068 PinName rx, 01069 int baud, 01070 bool debug_on, 01071 osPriority priority) 01072 { 01073 _sim_pin_check_change_pending = false; 01074 _sim_pin_check_change_pending_enabled_value = false; 01075 _sim_pin_change_pending = false; 01076 _sim_pin_change_pending_new_pin_value = NULL; 01077 _run_event_thread = true; 01078 _apn = NULL; 01079 _uname = NULL; 01080 _pwd = NULL; 01081 01082 01083 01084 01085 // Initialise sockets storage 01086 memset(_sockets, 0, sizeof(_sockets)); 01087 for (unsigned int socket = 0; socket < sizeof(_sockets) / sizeof(_sockets[0]); socket++) { 01088 _sockets[socket].modem_handle = SOCKET_UNUSED; 01089 _sockets[socket].callback = NULL; 01090 _sockets[socket].data = NULL; 01091 } 01092 01093 // The authentication to use 01094 _auth = NSAPI_SECURITY_UNKNOWN; 01095 01096 // Nullify the temporary IP address storage 01097 _ip = NULL; 01098 _connection_status_cb = NULL; 01099 01100 01101 // Initialise the base class, which starts the AT parser 01102 baseClassInit(tx, rx, baud, debug_on); 01103 01104 // Start the event handler thread for Rx data 01105 event_thread.start(callback(this, &UbloxATCellularInterface::handle_event)); 01106 event_thread.set_priority(priority); 01107 01108 // URC handlers for sockets 01109 _at->oob("+UUSORD", callback(this, &UbloxATCellularInterface::UUSORD_URC)); 01110 _at->oob("+UUSORF", callback(this, &UbloxATCellularInterface::UUSORF_URC)); 01111 _at->oob("+UUSOCL", callback(this, &UbloxATCellularInterface::UUSOCL_URC)); 01112 _at->oob("+UUPSDD", callback(this, &UbloxATCellularInterface::UUPSDD_URC)); 01113 } 01114 01115 // Destructor. 01116 UbloxATCellularInterface::~UbloxATCellularInterface() 01117 { 01118 // Let the event thread shut down tidily 01119 _run_event_thread = false; 01120 event_thread.join(); 01121 01122 // Free _ip if it was ever allocated 01123 free(_ip); 01124 } 01125 01126 // Set the authentication scheme. 01127 void UbloxATCellularInterface::set_authentication(nsapi_security_t auth) 01128 { 01129 _auth = auth; 01130 } 01131 01132 // Set APN, user name and password. 01133 void UbloxATCellularInterface::set_credentials(const char *apn, 01134 const char *uname, 01135 const char *pwd) 01136 { 01137 _apn = apn; 01138 _uname = uname; 01139 _pwd = pwd; 01140 } 01141 01142 // Set PIN. 01143 void UbloxATCellularInterface::set_sim_pin(const char *pin) 01144 { 01145 set_pin(pin); 01146 } 01147 01148 // Get the IP address of a host. 01149 nsapi_error_t UbloxATCellularInterface::gethostbyname(const char *host, 01150 SocketAddress *address, 01151 nsapi_version_t version) 01152 { 01153 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01154 01155 01156 if (address->set_ip_address(host)) { 01157 nsapi_error = NSAPI_ERROR_OK; 01158 } else { 01159 int at_timeout; 01160 char ipAddress[NSAPI_IP_SIZE]; 01161 LOCK(); 01162 // This interrogation can sometimes take longer than the usual 8 seconds 01163 at_timeout = _at_timeout; 01164 at_set_timeout(60000); 01165 memset (ipAddress, 0, sizeof (ipAddress)); // Ensure terminator 01166 if (_at->send("AT+UDNSRN=0,\"%s\"", host) && 01167 _at->recv("+UDNSRN: \"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\"", ipAddress) && 01168 _at->recv("OK")) { 01169 if (address->set_ip_address(ipAddress)) { 01170 nsapi_error = NSAPI_ERROR_OK; 01171 } 01172 } 01173 at_set_timeout(at_timeout); 01174 UNLOCK(); 01175 } 01176 01177 return nsapi_error; 01178 } 01179 01180 // Make a cellular connection 01181 nsapi_error_t UbloxATCellularInterface::connect(const char *sim_pin, 01182 const char *apn, 01183 const char *uname, 01184 const char *pwd) 01185 { 01186 nsapi_error_t nsapi_error; 01187 01188 if (sim_pin != NULL) { 01189 _pin = sim_pin; 01190 } 01191 01192 if (apn != NULL) { 01193 _apn = apn; 01194 } 01195 01196 if ((uname != NULL) && (pwd != NULL)) { 01197 _uname = uname; 01198 _pwd = pwd; 01199 } else { 01200 _uname = NULL; 01201 _pwd = NULL; 01202 } 01203 01204 nsapi_error = connect(); 01205 01206 return nsapi_error; 01207 } 01208 01209 // Make a cellular connection using the IP stack on board the cellular modem 01210 nsapi_error_t UbloxATCellularInterface::connect() 01211 { 01212 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01213 bool registered = false; 01214 01215 // Set up modem and then register with the network 01216 if (init()) { 01217 nsapi_error = NSAPI_ERROR_NO_CONNECTION; 01218 // Perform any pending SIM actions 01219 if (_sim_pin_check_change_pending) { 01220 if (!sim_pin_check_enable(_sim_pin_check_change_pending_enabled_value)) { 01221 nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01222 } 01223 _sim_pin_check_change_pending = false; 01224 } 01225 if (_sim_pin_change_pending) { 01226 if (!change_sim_pin(_sim_pin_change_pending_new_pin_value)) { 01227 nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01228 } 01229 _sim_pin_change_pending = false; 01230 } 01231 #ifdef TARGET_UBLOX_C030_R41XM 01232 define_context(); 01233 #endif 01234 if (nsapi_error == NSAPI_ERROR_NO_CONNECTION) { 01235 for (int retries = 0; !registered && (retries < 3); retries++) { 01236 if (nwk_registration()) { 01237 registered = true; 01238 #ifdef TARGET_UBLOX_C030_R41XM 01239 if (is_context_active()) { 01240 nsapi_error = NSAPI_ERROR_OK; 01241 tr_info("Context is already active\r\n"); 01242 } else { 01243 tr_info("Context is not active, activating it.\r\n"); 01244 if (activate_context()) { 01245 nsapi_error = NSAPI_ERROR_OK; 01246 } 01247 } 01248 #endif 01249 } 01250 } 01251 } 01252 } 01253 #ifndef TARGET_UBLOX_C030_R41XM 01254 // Attempt to establish a connection 01255 if (registered && connect_modem_stack()) { 01256 nsapi_error = NSAPI_ERROR_OK; 01257 } 01258 #endif 01259 return nsapi_error; 01260 } 01261 01262 // User initiated disconnect. 01263 nsapi_error_t UbloxATCellularInterface::disconnect() 01264 { 01265 nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01266 #ifdef TARGET_UBLOX_C030_R41XM 01267 if (nwk_deregistration()) { 01268 if (_connection_status_cb) { 01269 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST); 01270 } 01271 #else 01272 if (disconnect_modem_stack() && nwk_deregistration()) { 01273 #endif 01274 nsapi_error = NSAPI_ERROR_OK; 01275 } 01276 01277 return nsapi_error; 01278 } 01279 01280 // Enable or disable SIM PIN check lock. 01281 nsapi_error_t UbloxATCellularInterface::set_sim_pin_check(bool set, 01282 bool immediate, 01283 const char *sim_pin) 01284 { 01285 nsapi_error_t nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01286 01287 if (sim_pin != NULL) { 01288 _pin = sim_pin; 01289 } 01290 01291 if (immediate) { 01292 if (init()) { 01293 if (sim_pin_check_enable(set)) { 01294 nsapi_error = NSAPI_ERROR_OK; 01295 } 01296 } else { 01297 nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01298 } 01299 } else { 01300 nsapi_error = NSAPI_ERROR_OK; 01301 _sim_pin_check_change_pending = true; 01302 _sim_pin_check_change_pending_enabled_value = set; 01303 } 01304 01305 return nsapi_error; 01306 } 01307 01308 // Change the PIN code for the SIM card. 01309 nsapi_error_t UbloxATCellularInterface::set_new_sim_pin(const char *new_pin, 01310 bool immediate, 01311 const char *old_pin) 01312 { 01313 nsapi_error_t nsapi_error = NSAPI_ERROR_AUTH_FAILURE; 01314 01315 if (old_pin != NULL) { 01316 _pin = old_pin; 01317 } 01318 01319 if (immediate) { 01320 if (init()) { 01321 if (change_sim_pin(new_pin)) { 01322 nsapi_error = NSAPI_ERROR_OK; 01323 } 01324 } else { 01325 nsapi_error = NSAPI_ERROR_DEVICE_ERROR; 01326 } 01327 } else { 01328 nsapi_error = NSAPI_ERROR_OK; 01329 _sim_pin_change_pending = true; 01330 _sim_pin_change_pending_new_pin_value = new_pin; 01331 } 01332 01333 return nsapi_error; 01334 } 01335 01336 // Determine if the connection is up. 01337 bool UbloxATCellularInterface::is_connected() 01338 { 01339 return get_ip_address () != NULL; 01340 } 01341 01342 // Get the IP address of the on-board modem IP stack. 01343 const char * UbloxATCellularInterface::get_ip_address () 01344 { 01345 SocketAddress address; 01346 LOCK(); 01347 01348 if (_ip == NULL) { 01349 // Temporary storage for an IP address string with terminator 01350 _ip = (char *) malloc(NSAPI_IP_SIZE); 01351 } 01352 01353 if (_ip != NULL) { 01354 memset(_ip, 0, NSAPI_IP_SIZE); // Ensure a terminator 01355 // +UPSND=<profile_id>,<param_tag>[,<dynamic_param_val>] 01356 // If we get back a quoted "w.x.y.z" then we have an IP address, 01357 // otherwise we don't. 01358 #ifdef TARGET_UBLOX_C030_R41XM 01359 if (!_at->send("AT+CGPADDR=1") || 01360 !_at->recv("+CGPADDR: 1,%" u_stringify(NSAPI_IP_SIZE) "[^\n]\nOK\n", _ip) || 01361 !address.set_ip_address(_ip) || // Return NULL if the address is not a valid one 01362 !address) { // Return null if the address is zero 01363 free (_ip); 01364 _ip = NULL; 01365 } 01366 #else 01367 if (!_at->send("AT+UPSND=" PROFILE ",0") || 01368 !_at->recv("+UPSND: " PROFILE ",0,\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\"", _ip) || 01369 !_at->recv("OK") || 01370 !address.set_ip_address(_ip) || // Return NULL if the address is not a valid one 01371 !address) { // Return null if the address is zero 01372 free (_ip); 01373 _ip = NULL; 01374 } 01375 #endif 01376 } 01377 01378 UNLOCK(); 01379 return _ip; 01380 } 01381 01382 // Get the IP address of the on-board modem IP stack. 01383 nsapi_error_t UbloxATCellularInterface::get_ip_address (SocketAddress *address) 01384 { 01385 address->set_ip_address(this->get_ip_address ()); 01386 01387 return NSAPI_ERROR_OK; 01388 } 01389 01390 nsapi_error_t UbloxATCellularInterface::get_netmask (SocketAddress *address) 01391 { 01392 address->set_ip_address(""); 01393 01394 return NSAPI_ERROR_OK; 01395 } 01396 01397 nsapi_error_t UbloxATCellularInterface::get_gateway (SocketAddress *address) 01398 { 01399 address->set_ip_address(this->get_ip_address ()); 01400 01401 return NSAPI_ERROR_OK; 01402 } 01403 01404 // Get the local network mask. 01405 const char *UbloxATCellularInterface::get_netmask () 01406 { 01407 // Not implemented. 01408 return NULL; 01409 } 01410 01411 // Get the local gateways. 01412 const char *UbloxATCellularInterface::get_gateway () 01413 { 01414 return get_ip_address (); 01415 } 01416 01417 // Callback in case the connection is lost. 01418 void UbloxATCellularInterface::connection_status_cb(Callback<void(nsapi_error_t)> cb) 01419 { 01420 _connection_status_cb = cb; 01421 } 01422 01423 void UbloxATCellularInterface::set_plmn(const char *plmn) { 01424 01425 } 01426 01427 // End of file 01428
Generated on Sat Jul 23 2022 05:31:40 by
1.7.2