mbed official / UbloxUSBModem

u-blox USB modems (GSM and CDMA)

Dependencies:   CellularUSBModem

Dependents:   C027_CANInterfaceComm C027_ModemTransparentUSBCDC_revb UbloxModemHTTPClientTest C027_HTTPClientTest ... more

Legacy Networking Libray

This is an mbed 2 networking library. For an mbed OS 5 compatible library, please see:

Import libraryC027Interface

Socket interface for C027Interface. Implements the NetworkSocketAPI

Last commit 20 Apr 2017 by NetworkSocketAPI

UbloxModem.cpp@9:71550cccbe73, 2014-03-04 (annotated)

Committer:
mbed_official
Date:
Tue Mar 04 13:51:49 2014 +0000
Revision:
9:71550cccbe73
Parent:
8:45f5433cfa96 
Use latest version of CellularUSBModem

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 5:60b48a013e86 1 /* UbloxModem.cpp */
mbed_official 5:60b48a013e86 2 /* Copyright (C) 2012 mbed.org, MIT License
mbed_official 5:60b48a013e86 3 *
mbed_official 5:60b48a013e86 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
mbed_official 5:60b48a013e86 5 * and associated documentation files (the "Software"), to deal in the Software without restriction,
mbed_official 5:60b48a013e86 6 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
mbed_official 5:60b48a013e86 7 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
mbed_official 5:60b48a013e86 8 * furnished to do so, subject to the following conditions:
mbed_official 5:60b48a013e86 9 *
mbed_official 5:60b48a013e86 10 * The above copyright notice and this permission notice shall be included in all copies or
mbed_official 5:60b48a013e86 11 * substantial portions of the Software.
mbed_official 5:60b48a013e86 12 *
mbed_official 5:60b48a013e86 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
mbed_official 5:60b48a013e86 14 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
mbed_official 5:60b48a013e86 15 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
mbed_official 5:60b48a013e86 16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
mbed_official 5:60b48a013e86 17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
mbed_official 5:60b48a013e86 18 */
mbed_official 5:60b48a013e86 19
mbed_official 5:60b48a013e86 20 #define __DEBUG__ 3
mbed_official 5:60b48a013e86 21 #ifndef __MODULE__
mbed_official 5:60b48a013e86 22 #define __MODULE__ "UbloxModem.cpp"
mbed_official 5:60b48a013e86 23 #endif
mbed_official 5:60b48a013e86 24
mbed_official 5:60b48a013e86 25 #include "core/fwk.h"
mbed_official 5:60b48a013e86 26 #include "sms/GSMSMSInterface.h"
mbed_official 5:60b48a013e86 27 #include "sms/CDMASMSInterface.h"
mbed_official 5:60b48a013e86 28
mbed_official 5:60b48a013e86 29 #include "UbloxModem.h"
mbed_official 5:60b48a013e86 30
mbed_official 5:60b48a013e86 31 UbloxModem::UbloxModem(IOStream* atStream, IOStream* pppStream) :
mbed_official 5:60b48a013e86 32 m_at(atStream), // Construct ATCommandsInterface with the AT serial channel
mbed_official 5:60b48a013e86 33 m_CdmaSms(&m_at), // Construct SMSInterface with the ATCommandsInterface
mbed_official 5:60b48a013e86 34 m_GsmSms(&m_at), // Construct SMSInterface with the ATCommandsInterface
mbed_official 5:60b48a013e86 35 m_ussd(&m_at), // Construct USSDInterface with the ATCommandsInterface
mbed_official 5:60b48a013e86 36 m_linkMonitor(&m_at), // Construct LinkMonitor with the ATCommandsInterface
mbed_official 5:60b48a013e86 37 m_ppp(pppStream ? pppStream : atStream), // Construct PPPIPInterface with the PPP serial channel
mbed_official 5:60b48a013e86 38 m_ipInit(false), // PPIPInterface connection is initially down
mbed_official 5:60b48a013e86 39 m_smsInit(false), // SMSInterface starts un-initialised
mbed_official 5:60b48a013e86 40 m_ussdInit(false), // USSDInterface starts un-initialised
mbed_official 5:60b48a013e86 41 m_linkMonitorInit(false), // LinkMonitor subsystem starts un-initialised
mbed_official 5:60b48a013e86 42 m_atOpen(false), // ATCommandsInterface starts in a closed state
mbed_official 5:60b48a013e86 43 m_onePort(pppStream == NULL),
mbed_official 8:45f5433cfa96 44 m_type(UNKNOWN)
mbed_official 5:60b48a013e86 45 {
mbed_official 5:60b48a013e86 46 }
mbed_official 5:60b48a013e86 47
mbed_official 6:5a1583d0e6cd 48
mbed_official 8:45f5433cfa96 49 genericAtProcessor::genericAtProcessor()
mbed_official 8:45f5433cfa96 50 {
mbed_official 6:5a1583d0e6cd 51 i = 0;
mbed_official 6:5a1583d0e6cd 52 str[0] = '\0';
mbed_official 8:45f5433cfa96 53 }
mbed_official 8:45f5433cfa96 54
mbed_official 8:45f5433cfa96 55 const char* genericAtProcessor::getResponse(void)
mbed_official 8:45f5433cfa96 56 {
mbed_official 8:45f5433cfa96 57 return str;
mbed_official 8:45f5433cfa96 58 }
mbed_official 8:45f5433cfa96 59
mbed_official 8:45f5433cfa96 60 int genericAtProcessor::onNewATResponseLine(ATCommandsInterface* pInst, const char* line)
mbed_official 8:45f5433cfa96 61 {
mbed_official 6:5a1583d0e6cd 62 int l = strlen(line);
mbed_official 6:5a1583d0e6cd 63 if (i + l + 2 > sizeof(str))
mbed_official 6:5a1583d0e6cd 64 return NET_OVERFLOW;
mbed_official 6:5a1583d0e6cd 65 if (i) str[i++] = ',';
mbed_official 6:5a1583d0e6cd 66 strcat(&str[i], line);
mbed_official 6:5a1583d0e6cd 67 i += l;
mbed_official 6:5a1583d0e6cd 68 return OK;
mbed_official 8:45f5433cfa96 69 }
mbed_official 8:45f5433cfa96 70
mbed_official 8:45f5433cfa96 71 int genericAtProcessor::onNewEntryPrompt(ATCommandsInterface* pInst)
mbed_official 8:45f5433cfa96 72 {
mbed_official 6:5a1583d0e6cd 73 return OK;
mbed_official 8:45f5433cfa96 74 }
mbed_official 6:5a1583d0e6cd 75
mbed_official 5:60b48a013e86 76 class CREGProcessor : public IATCommandsProcessor
mbed_official 5:60b48a013e86 77 {
mbed_official 5:60b48a013e86 78 public:
mbed_official 5:60b48a013e86 79 CREGProcessor(bool gsm) : status(STATUS_REGISTERING)
mbed_official 5:60b48a013e86 80 {
mbed_official 5:60b48a013e86 81 m_gsm = gsm;
mbed_official 5:60b48a013e86 82 }
mbed_official 5:60b48a013e86 83 enum REGISTERING_STATUS { STATUS_REGISTERING, STATUS_OK, STATUS_FAILED };
mbed_official 5:60b48a013e86 84 REGISTERING_STATUS getStatus()
mbed_official 5:60b48a013e86 85 {
mbed_official 5:60b48a013e86 86 return status;
mbed_official 5:60b48a013e86 87 }
mbed_official 5:60b48a013e86 88 const char* getAtCommand()
mbed_official 5:60b48a013e86 89 {
mbed_official 5:60b48a013e86 90 return m_gsm ? "AT+CREG?" : "AT+CSS?";
mbed_official 5:60b48a013e86 91 }
mbed_official 5:60b48a013e86 92 private:
mbed_official 5:60b48a013e86 93 virtual int onNewATResponseLine(ATCommandsInterface* pInst, const char* line)
mbed_official 5:60b48a013e86 94 {
mbed_official 5:60b48a013e86 95 int r;
mbed_official 5:60b48a013e86 96 if (m_gsm)
mbed_official 5:60b48a013e86 97 {
mbed_official 5:60b48a013e86 98 if( sscanf(line, "+CREG: %*d,%d", &r) == 1 )
mbed_official 5:60b48a013e86 99 {
mbed_official 5:60b48a013e86 100 status = (r == 1 || r == 5) ? STATUS_OK :
mbed_official 5:60b48a013e86 101 (r == 0 || r == 2) ? STATUS_REGISTERING :
mbed_official 5:60b48a013e86 102 // (r == 3) ? STATUS_FAILED :
mbed_official 5:60b48a013e86 103 STATUS_FAILED;
mbed_official 5:60b48a013e86 104 }
mbed_official 5:60b48a013e86 105 }
mbed_official 5:60b48a013e86 106 else
mbed_official 5:60b48a013e86 107 {
mbed_official 5:60b48a013e86 108 char bc[3] = "";
mbed_official 5:60b48a013e86 109 if(sscanf(line, "%*s %*c,%2s,%*d",bc)==1)
mbed_official 5:60b48a013e86 110 {
mbed_official 5:60b48a013e86 111 status = (strcmp("Z", bc) == 0) ? STATUS_REGISTERING : STATUS_OK;
mbed_official 5:60b48a013e86 112 }
mbed_official 5:60b48a013e86 113 }
mbed_official 5:60b48a013e86 114 return OK;
mbed_official 5:60b48a013e86 115 }
mbed_official 5:60b48a013e86 116 virtual int onNewEntryPrompt(ATCommandsInterface* pInst)
mbed_official 5:60b48a013e86 117 {
mbed_official 5:60b48a013e86 118 return OK;
mbed_official 5:60b48a013e86 119 }
mbed_official 5:60b48a013e86 120 volatile REGISTERING_STATUS status;
mbed_official 5:60b48a013e86 121 bool m_gsm;
mbed_official 5:60b48a013e86 122 };
mbed_official 5:60b48a013e86 123
mbed_official 5:60b48a013e86 124 int UbloxModem::connect(const char* apn, const char* user, const char* password)
mbed_official 5:60b48a013e86 125 {
mbed_official 5:60b48a013e86 126 if( !m_ipInit )
mbed_official 5:60b48a013e86 127 {
mbed_official 5:60b48a013e86 128 m_ipInit = true;
mbed_official 5:60b48a013e86 129 m_ppp.init();
mbed_official 5:60b48a013e86 130 }
mbed_official 8:45f5433cfa96 131 m_ppp.setup(user, password, (m_type != LISA_C200) ? DEFAULT_MSISDN_GSM : DEFAULT_MSISDN_CDMA);
mbed_official 5:60b48a013e86 132
mbed_official 5:60b48a013e86 133 int ret = init();
mbed_official 5:60b48a013e86 134 if(ret)
mbed_official 5:60b48a013e86 135 {
mbed_official 5:60b48a013e86 136 return ret;
mbed_official 5:60b48a013e86 137 }
mbed_official 5:60b48a013e86 138
mbed_official 5:60b48a013e86 139 if (m_onePort)
mbed_official 5:60b48a013e86 140 {
mbed_official 5:60b48a013e86 141 m_smsInit = false; //SMS status reset
mbed_official 5:60b48a013e86 142 m_ussdInit = false; //USSD status reset
mbed_official 5:60b48a013e86 143 m_linkMonitorInit = false; //Link monitor status reset
mbed_official 5:60b48a013e86 144 }
mbed_official 5:60b48a013e86 145
mbed_official 5:60b48a013e86 146 ATCommandsInterface::ATResult result;
mbed_official 5:60b48a013e86 147
mbed_official 5:60b48a013e86 148 if(apn != NULL)
mbed_official 5:60b48a013e86 149 {
mbed_official 5:60b48a013e86 150 char cmd[48];
mbed_official 5:60b48a013e86 151 int tries = 30;
mbed_official 5:60b48a013e86 152 sprintf(cmd, "AT+CGDCONT=1,\"IP\",\"%s\"", apn);
mbed_official 5:60b48a013e86 153 do //Try 30 times because for some reasons it can fail *a lot* with the K3772-Z dongle
mbed_official 5:60b48a013e86 154 {
mbed_official 5:60b48a013e86 155 ret = m_at.executeSimple(cmd, &result);
mbed_official 5:60b48a013e86 156 DBG("Result of command: Err code=%d", ret);
mbed_official 5:60b48a013e86 157 if(ret)
mbed_official 5:60b48a013e86 158 {
mbed_official 5:60b48a013e86 159 Thread::wait(500);
mbed_official 5:60b48a013e86 160 }
mbed_official 5:60b48a013e86 161 } while(ret && --tries);
mbed_official 5:60b48a013e86 162 DBG("ATResult: AT return=%d (code %d)", result.result, result.code);
mbed_official 5:60b48a013e86 163 DBG("APN set to %s", apn);
mbed_official 5:60b48a013e86 164 }
mbed_official 5:60b48a013e86 165
mbed_official 5:60b48a013e86 166 //Connect
mbed_official 5:60b48a013e86 167 DBG("Connecting");
mbed_official 5:60b48a013e86 168 if (m_onePort)
mbed_official 5:60b48a013e86 169 {
mbed_official 5:60b48a013e86 170 m_at.close(); // Closing AT parser
mbed_official 5:60b48a013e86 171 m_atOpen = false; //Will need to be reinitialized afterwards
mbed_official 5:60b48a013e86 172 }
mbed_official 5:60b48a013e86 173
mbed_official 5:60b48a013e86 174 DBG("Connecting PPP");
mbed_official 5:60b48a013e86 175
mbed_official 5:60b48a013e86 176 ret = m_ppp.connect();
mbed_official 5:60b48a013e86 177 DBG("Result of connect: Err code=%d", ret);
mbed_official 5:60b48a013e86 178 return ret;
mbed_official 5:60b48a013e86 179 }
mbed_official 5:60b48a013e86 180
mbed_official 5:60b48a013e86 181
mbed_official 5:60b48a013e86 182 int UbloxModem::disconnect()
mbed_official 5:60b48a013e86 183 {
mbed_official 5:60b48a013e86 184 DBG("Disconnecting from PPP");
mbed_official 5:60b48a013e86 185 int ret = m_ppp.disconnect();
mbed_official 5:60b48a013e86 186 if(ret)
mbed_official 5:60b48a013e86 187 {
mbed_official 5:60b48a013e86 188 ERR("Disconnect returned %d, still trying to disconnect", ret);
mbed_official 5:60b48a013e86 189 }
mbed_official 5:60b48a013e86 190
mbed_official 5:60b48a013e86 191 //Ugly but leave dongle time to recover
mbed_official 5:60b48a013e86 192 Thread::wait(500);
mbed_official 5:60b48a013e86 193
mbed_official 5:60b48a013e86 194 if (m_onePort)
mbed_official 5:60b48a013e86 195 {
mbed_official 5:60b48a013e86 196 //ATCommandsInterface::ATResult result;
mbed_official 5:60b48a013e86 197 DBG("Starting AT thread");
mbed_official 5:60b48a013e86 198 ret = m_at.open();
mbed_official 5:60b48a013e86 199 if(ret)
mbed_official 5:60b48a013e86 200 {
mbed_official 5:60b48a013e86 201 return ret;
mbed_official 5:60b48a013e86 202 }
mbed_official 5:60b48a013e86 203 }
mbed_official 5:60b48a013e86 204
mbed_official 5:60b48a013e86 205 DBG("Trying to hangup");
mbed_official 5:60b48a013e86 206
mbed_official 5:60b48a013e86 207 if (m_onePort)
mbed_official 5:60b48a013e86 208 {
mbed_official 5:60b48a013e86 209 //Reinit AT parser
mbed_official 5:60b48a013e86 210 ret = m_at.init(false);
mbed_official 5:60b48a013e86 211 DBG("Result of command: Err code=%d\n", ret);
mbed_official 5:60b48a013e86 212 if(ret)
mbed_official 5:60b48a013e86 213 {
mbed_official 5:60b48a013e86 214 m_at.close(); // Closing AT parser
mbed_official 5:60b48a013e86 215 DBG("AT Parser closed, could not complete disconnection");
mbed_official 5:60b48a013e86 216 return NET_TIMEOUT;
mbed_official 5:60b48a013e86 217 }
mbed_official 5:60b48a013e86 218
mbed_official 5:60b48a013e86 219 }
mbed_official 5:60b48a013e86 220 return OK;
mbed_official 5:60b48a013e86 221 }
mbed_official 5:60b48a013e86 222
mbed_official 5:60b48a013e86 223 int UbloxModem::sendSM(const char* number, const char* message)
mbed_official 5:60b48a013e86 224 {
mbed_official 5:60b48a013e86 225 int ret = init();
mbed_official 5:60b48a013e86 226 if(ret)
mbed_official 5:60b48a013e86 227 {
mbed_official 5:60b48a013e86 228 return ret;
mbed_official 5:60b48a013e86 229 }
mbed_official 5:60b48a013e86 230
mbed_official 5:60b48a013e86 231 ISMSInterface* sms;
mbed_official 8:45f5433cfa96 232 if (m_type == LISA_C200) sms = &m_CdmaSms;
mbed_official 8:45f5433cfa96 233 else sms = &m_GsmSms;
mbed_official 5:60b48a013e86 234 if(!m_smsInit)
mbed_official 5:60b48a013e86 235 {
mbed_official 5:60b48a013e86 236 ret = sms->init();
mbed_official 5:60b48a013e86 237 if(ret)
mbed_official 5:60b48a013e86 238 {
mbed_official 5:60b48a013e86 239 return ret;
mbed_official 5:60b48a013e86 240 }
mbed_official 5:60b48a013e86 241 m_smsInit = true;
mbed_official 5:60b48a013e86 242 }
mbed_official 5:60b48a013e86 243
mbed_official 5:60b48a013e86 244 ret = sms->send(number, message);
mbed_official 5:60b48a013e86 245 if(ret)
mbed_official 5:60b48a013e86 246 {
mbed_official 5:60b48a013e86 247 return ret;
mbed_official 5:60b48a013e86 248 }
mbed_official 5:60b48a013e86 249
mbed_official 5:60b48a013e86 250 return OK;
mbed_official 5:60b48a013e86 251 }
mbed_official 5:60b48a013e86 252
mbed_official 5:60b48a013e86 253 int UbloxModem::getSM(char* number, char* message, size_t maxLength)
mbed_official 5:60b48a013e86 254 {
mbed_official 5:60b48a013e86 255 int ret = init();
mbed_official 5:60b48a013e86 256 if(ret)
mbed_official 5:60b48a013e86 257 {
mbed_official 5:60b48a013e86 258 return ret;
mbed_official 5:60b48a013e86 259 }
mbed_official 5:60b48a013e86 260
mbed_official 5:60b48a013e86 261 ISMSInterface* sms;
mbed_official 8:45f5433cfa96 262 if (m_type == LISA_C200) sms = &m_CdmaSms;
mbed_official 8:45f5433cfa96 263 else sms = &m_GsmSms;
mbed_official 5:60b48a013e86 264 if(!m_smsInit)
mbed_official 5:60b48a013e86 265 {
mbed_official 5:60b48a013e86 266 ret = sms->init();
mbed_official 5:60b48a013e86 267 if(ret)
mbed_official 5:60b48a013e86 268 {
mbed_official 5:60b48a013e86 269 return ret;
mbed_official 5:60b48a013e86 270 }
mbed_official 5:60b48a013e86 271 m_smsInit = true;
mbed_official 5:60b48a013e86 272 }
mbed_official 5:60b48a013e86 273
mbed_official 5:60b48a013e86 274 ret = sms->get(number, message, maxLength);
mbed_official 5:60b48a013e86 275 if(ret)
mbed_official 5:60b48a013e86 276 {
mbed_official 5:60b48a013e86 277 return ret;
mbed_official 5:60b48a013e86 278 }
mbed_official 5:60b48a013e86 279
mbed_official 5:60b48a013e86 280 return OK;
mbed_official 5:60b48a013e86 281 }
mbed_official 5:60b48a013e86 282
mbed_official 5:60b48a013e86 283 int UbloxModem::getSMCount(size_t* pCount)
mbed_official 5:60b48a013e86 284 {
mbed_official 5:60b48a013e86 285 int ret = init();
mbed_official 5:60b48a013e86 286 if(ret)
mbed_official 5:60b48a013e86 287 {
mbed_official 5:60b48a013e86 288 return ret;
mbed_official 5:60b48a013e86 289 }
mbed_official 5:60b48a013e86 290
mbed_official 5:60b48a013e86 291 ISMSInterface* sms;
mbed_official 8:45f5433cfa96 292 if (m_type == LISA_C200) sms = &m_CdmaSms;
mbed_official 8:45f5433cfa96 293 else sms = &m_GsmSms;
mbed_official 5:60b48a013e86 294 if(!m_smsInit)
mbed_official 5:60b48a013e86 295 {
mbed_official 5:60b48a013e86 296 ret = sms->init();
mbed_official 5:60b48a013e86 297 if(ret)
mbed_official 5:60b48a013e86 298 {
mbed_official 5:60b48a013e86 299 return ret;
mbed_official 5:60b48a013e86 300 }
mbed_official 5:60b48a013e86 301 m_smsInit = true;
mbed_official 5:60b48a013e86 302 }
mbed_official 5:60b48a013e86 303
mbed_official 5:60b48a013e86 304 ret = sms->getCount(pCount);
mbed_official 5:60b48a013e86 305 if(ret)
mbed_official 5:60b48a013e86 306 {
mbed_official 5:60b48a013e86 307 return ret;
mbed_official 5:60b48a013e86 308 }
mbed_official 5:60b48a013e86 309
mbed_official 5:60b48a013e86 310 return OK;
mbed_official 5:60b48a013e86 311 }
mbed_official 5:60b48a013e86 312
mbed_official 5:60b48a013e86 313 ATCommandsInterface* UbloxModem::getATCommandsInterface()
mbed_official 5:60b48a013e86 314 {
mbed_official 5:60b48a013e86 315 return &m_at;
mbed_official 5:60b48a013e86 316 }
mbed_official 5:60b48a013e86 317
mbed_official 5:60b48a013e86 318 int UbloxModem::init()
mbed_official 5:60b48a013e86 319 {
mbed_official 5:60b48a013e86 320 if(m_atOpen)
mbed_official 5:60b48a013e86 321 {
mbed_official 5:60b48a013e86 322 return OK;
mbed_official 5:60b48a013e86 323 }
mbed_official 5:60b48a013e86 324
mbed_official 5:60b48a013e86 325 DBG("Starting AT thread if needed");
mbed_official 5:60b48a013e86 326 int ret = m_at.open();
mbed_official 5:60b48a013e86 327 if(ret)
mbed_official 5:60b48a013e86 328 {
mbed_official 5:60b48a013e86 329 return ret;
mbed_official 5:60b48a013e86 330 }
mbed_official 5:60b48a013e86 331
mbed_official 5:60b48a013e86 332 DBG("Sending initialisation commands");
mbed_official 5:60b48a013e86 333 ret = m_at.init(false);
mbed_official 5:60b48a013e86 334 if(ret)
mbed_official 5:60b48a013e86 335 {
mbed_official 5:60b48a013e86 336 return ret;
mbed_official 5:60b48a013e86 337 }
mbed_official 8:45f5433cfa96 338
mbed_official 8:45f5433cfa96 339
mbed_official 5:60b48a013e86 340 ATCommandsInterface::ATResult result;
mbed_official 8:45f5433cfa96 341 genericAtProcessor atiProcessor;
mbed_official 8:45f5433cfa96 342 ret = m_at.execute("ATI", &atiProcessor, &result);
mbed_official 8:45f5433cfa96 343 if (OK != ret)
mbed_official 8:45f5433cfa96 344 return ret;
mbed_official 8:45f5433cfa96 345 const char* info = atiProcessor.getResponse();
mbed_official 8:45f5433cfa96 346 INFO("Modem Identification [%s]", info);
mbed_official 8:45f5433cfa96 347 if (strstr(info, "LISA-C200")) {
mbed_official 8:45f5433cfa96 348 m_type = LISA_C200;
mbed_official 8:45f5433cfa96 349 m_onePort = true; // force use of only one port
mbed_official 6:5a1583d0e6cd 350 }
mbed_official 8:45f5433cfa96 351 else if (strstr(info, "LISA-U200")) {
mbed_official 8:45f5433cfa96 352 m_type = LISA_U200;
mbed_official 8:45f5433cfa96 353 }
mbed_official 8:45f5433cfa96 354 else if (strstr(info, "SARA-G350")) {
mbed_official 8:45f5433cfa96 355 m_type = SARA_G350;
mbed_official 6:5a1583d0e6cd 356 }
mbed_official 6:5a1583d0e6cd 357
mbed_official 8:45f5433cfa96 358 // enable the network indicator
mbed_official 8:45f5433cfa96 359 if (m_type == SARA_G350) {
mbed_official 8:45f5433cfa96 360 m_at.executeSimple("AT+UGPIOC=16,2", &result);
mbed_official 8:45f5433cfa96 361 }
mbed_official 8:45f5433cfa96 362 else if (m_type == LISA_U200) {
mbed_official 8:45f5433cfa96 363 m_at.executeSimple("AT+UGPIOC=20,2", &result);
mbed_official 8:45f5433cfa96 364 }
mbed_official 8:45f5433cfa96 365 else if (m_type == LISA_C200) {
mbed_official 8:45f5433cfa96 366 // LISA-C200 02S/22S : GPIO1 do not support network status indication
mbed_official 8:45f5433cfa96 367 // m_at.executeSimple("AT+UGPIOC=20,2", &result);
mbed_official 8:45f5433cfa96 368 }
mbed_official 8:45f5433cfa96 369 INFO("Modem Identification [%s]", info);
mbed_official 8:45f5433cfa96 370
mbed_official 8:45f5433cfa96 371 CREGProcessor cregProcessor(m_type != LISA_C200);
mbed_official 5:60b48a013e86 372 //Wait for network registration
mbed_official 5:60b48a013e86 373 do
mbed_official 5:60b48a013e86 374 {
mbed_official 5:60b48a013e86 375 DBG("Waiting for network registration");
mbed_official 5:60b48a013e86 376 ret = m_at.execute(cregProcessor.getAtCommand(), &cregProcessor, &result);
mbed_official 5:60b48a013e86 377 DBG("Result of command: Err code=%d\n", ret);
mbed_official 5:60b48a013e86 378 DBG("ATResult: AT return=%d (code %d)\n", result.result, result.code);
mbed_official 5:60b48a013e86 379 if(cregProcessor.getStatus() == CREGProcessor::STATUS_REGISTERING)
mbed_official 5:60b48a013e86 380 {
mbed_official 5:60b48a013e86 381 Thread::wait(3000);
mbed_official 5:60b48a013e86 382 }
mbed_official 5:60b48a013e86 383 } while(cregProcessor.getStatus() == CREGProcessor::STATUS_REGISTERING);
mbed_official 5:60b48a013e86 384 if(cregProcessor.getStatus() == CREGProcessor::STATUS_FAILED)
mbed_official 5:60b48a013e86 385 {
mbed_official 5:60b48a013e86 386 ERR("Registration denied");
mbed_official 5:60b48a013e86 387 return NET_AUTH;
mbed_official 5:60b48a013e86 388 }
mbed_official 5:60b48a013e86 389
mbed_official 5:60b48a013e86 390 m_atOpen = true;
mbed_official 5:60b48a013e86 391
mbed_official 5:60b48a013e86 392 return OK;
mbed_official 5:60b48a013e86 393 }
mbed_official 5:60b48a013e86 394
mbed_official 5:60b48a013e86 395 int UbloxModem::cleanup()
mbed_official 5:60b48a013e86 396 {
mbed_official 5:60b48a013e86 397 if(m_ppp.isConnected())
mbed_official 5:60b48a013e86 398 {
mbed_official 5:60b48a013e86 399 WARN("Data connection is still open"); //Try to encourage good behaviour from the user
mbed_official 5:60b48a013e86 400 m_ppp.disconnect();
mbed_official 5:60b48a013e86 401 }
mbed_official 5:60b48a013e86 402
mbed_official 5:60b48a013e86 403 m_smsInit = false;
mbed_official 5:60b48a013e86 404 m_ussdInit = false;
mbed_official 5:60b48a013e86 405 m_linkMonitorInit = false;
mbed_official 5:60b48a013e86 406 //We don't reset m_ipInit as PPPIPInterface::init() only needs to be called once
mbed_official 5:60b48a013e86 407
mbed_official 5:60b48a013e86 408 if(m_atOpen)
mbed_official 5:60b48a013e86 409 {
mbed_official 5:60b48a013e86 410 m_at.close();
mbed_official 5:60b48a013e86 411 m_atOpen = false;
mbed_official 5:60b48a013e86 412 }
mbed_official 5:60b48a013e86 413
mbed_official 5:60b48a013e86 414 return OK;
mbed_official 5:60b48a013e86 415 }
mbed_official 5:60b48a013e86 416
mbed_official 5:60b48a013e86 417 int UbloxModem::sendUSSD(const char* command, char* result, size_t maxLength)
mbed_official 5:60b48a013e86 418 {
mbed_official 5:60b48a013e86 419 int ret = init();
mbed_official 5:60b48a013e86 420 if(ret)
mbed_official 5:60b48a013e86 421 {
mbed_official 5:60b48a013e86 422 return ret;
mbed_official 5:60b48a013e86 423 }
mbed_official 5:60b48a013e86 424
mbed_official 5:60b48a013e86 425 if(!m_ussdInit)
mbed_official 5:60b48a013e86 426 {
mbed_official 5:60b48a013e86 427 ret = m_ussd.init();
mbed_official 5:60b48a013e86 428 if(ret)
mbed_official 5:60b48a013e86 429 {
mbed_official 5:60b48a013e86 430 return ret;
mbed_official 5:60b48a013e86 431 }
mbed_official 5:60b48a013e86 432 m_ussdInit = true;
mbed_official 5:60b48a013e86 433 }
mbed_official 5:60b48a013e86 434
mbed_official 5:60b48a013e86 435 ret = m_ussd.send(command, result, maxLength);
mbed_official 5:60b48a013e86 436 if(ret)
mbed_official 5:60b48a013e86 437 {
mbed_official 5:60b48a013e86 438 return ret;
mbed_official 5:60b48a013e86 439 }
mbed_official 5:60b48a013e86 440
mbed_official 5:60b48a013e86 441 return OK;
mbed_official 5:60b48a013e86 442 }
mbed_official 5:60b48a013e86 443
mbed_official 5:60b48a013e86 444 int UbloxModem::getLinkState(int* pRssi, LinkMonitor::REGISTRATION_STATE* pRegistrationState, LinkMonitor::BEARER* pBearer)
mbed_official 5:60b48a013e86 445 {
mbed_official 5:60b48a013e86 446 int ret = init();
mbed_official 5:60b48a013e86 447 if(ret)
mbed_official 5:60b48a013e86 448 {
mbed_official 5:60b48a013e86 449 return ret;
mbed_official 5:60b48a013e86 450 }
mbed_official 5:60b48a013e86 451
mbed_official 5:60b48a013e86 452 if(!m_linkMonitorInit)
mbed_official 5:60b48a013e86 453 {
mbed_official 8:45f5433cfa96 454 ret = m_linkMonitor.init(m_type != LISA_C200);
mbed_official 5:60b48a013e86 455 if(ret)
mbed_official 5:60b48a013e86 456 {
mbed_official 5:60b48a013e86 457 return ret;
mbed_official 5:60b48a013e86 458 }
mbed_official 5:60b48a013e86 459 m_linkMonitorInit = true;
mbed_official 5:60b48a013e86 460 }
mbed_official 5:60b48a013e86 461
mbed_official 5:60b48a013e86 462 ret = m_linkMonitor.getState(pRssi, pRegistrationState, pBearer);
mbed_official 5:60b48a013e86 463 if(ret)
mbed_official 5:60b48a013e86 464 {
mbed_official 5:60b48a013e86 465 return ret;
mbed_official 5:60b48a013e86 466 }
mbed_official 5:60b48a013e86 467
mbed_official 5:60b48a013e86 468 return OK;
mbed_official 5:60b48a013e86 469 }
mbed_official 5:60b48a013e86 470
mbed_official 8:45f5433cfa96 471 int UbloxModem::getPhoneNumber(char* phoneNumber)
mbed_official 8:45f5433cfa96 472 {
mbed_official 8:45f5433cfa96 473 int ret = init();
mbed_official 8:45f5433cfa96 474 if(ret)
mbed_official 8:45f5433cfa96 475 {
mbed_official 8:45f5433cfa96 476 return ret;
mbed_official 8:45f5433cfa96 477 }
mbed_official 8:45f5433cfa96 478
mbed_official 8:45f5433cfa96 479 if(!m_linkMonitorInit)
mbed_official 8:45f5433cfa96 480 {
mbed_official 8:45f5433cfa96 481 ret = m_linkMonitor.init(m_type != LISA_C200);
mbed_official 8:45f5433cfa96 482 if(ret)
mbed_official 8:45f5433cfa96 483 {
mbed_official 8:45f5433cfa96 484 return ret;
mbed_official 8:45f5433cfa96 485 }
mbed_official 8:45f5433cfa96 486 m_linkMonitorInit = true;
mbed_official 8:45f5433cfa96 487 }
mbed_official 8:45f5433cfa96 488
mbed_official 8:45f5433cfa96 489 ret = m_linkMonitor.getPhoneNumber(phoneNumber);
mbed_official 8:45f5433cfa96 490 if(ret)
mbed_official 8:45f5433cfa96 491 {
mbed_official 8:45f5433cfa96 492 return ret;
mbed_official 8:45f5433cfa96 493 }
mbed_official 8:45f5433cfa96 494
mbed_official 8:45f5433cfa96 495 return OK;
mbed_official 8:45f5433cfa96 496 }
mbed_official 8:45f5433cfa96 497
mbed_official 5:60b48a013e86 498 #include "USBHost.h"
mbed_official 5:60b48a013e86 499 #include "UbloxGSMModemInitializer.h"
mbed_official 5:60b48a013e86 500 #include "UbloxCDMAModemInitializer.h"
mbed_official 5:60b48a013e86 501
mbed_official 5:60b48a013e86 502 UbloxUSBModem::UbloxUSBModem() :
mbed_official 5:60b48a013e86 503 UbloxModem(&m_atStream, &m_pppStream),
mbed_official 5:60b48a013e86 504 m_dongle(), // Construct WANDongle: USB interface with two serial channels to the modem (USBSerialStream objects)
mbed_official 5:60b48a013e86 505 m_atStream(m_dongle.getSerial(1)), // AT commands are sent down one serial channel.
mbed_official 5:60b48a013e86 506 m_pppStream(m_dongle.getSerial(0)), // PPP connections are managed via another serial channel.
mbed_official 5:60b48a013e86 507 m_dongleConnected(false) // Dongle is initially not ready for anything
mbed_official 5:60b48a013e86 508 {
mbed_official 5:60b48a013e86 509 USBHost* host = USBHost::getHostInst();
mbed_official 5:60b48a013e86 510 m_dongle.addInitializer(new UbloxGSMModemInitializer(host));
mbed_official 5:60b48a013e86 511 m_dongle.addInitializer(new UbloxCDMAModemInitializer(host));
mbed_official 5:60b48a013e86 512 }
mbed_official 5:60b48a013e86 513
mbed_official 5:60b48a013e86 514 int UbloxUSBModem::init()
mbed_official 5:60b48a013e86 515 {
mbed_official 5:60b48a013e86 516 if( !m_dongleConnected )
mbed_official 5:60b48a013e86 517 {
mbed_official 5:60b48a013e86 518 m_dongleConnected = true;
mbed_official 5:60b48a013e86 519 while( !m_dongle.connected() )
mbed_official 5:60b48a013e86 520 {
mbed_official 5:60b48a013e86 521 m_dongle.tryConnect();
mbed_official 5:60b48a013e86 522 Thread::wait(10);
mbed_official 5:60b48a013e86 523 }
mbed_official 5:60b48a013e86 524 if(m_dongle.getDongleType() == WAN_DONGLE_TYPE_UBLOX_LISAU200)
mbed_official 5:60b48a013e86 525 {
mbed_official 5:60b48a013e86 526 INFO("Using a u-blox LISA-U200 3G/WCDMA Modem");
mbed_official 8:45f5433cfa96 527 m_type = LISA_U200;
mbed_official 5:60b48a013e86 528 }
mbed_official 5:60b48a013e86 529 else if(m_dongle.getDongleType() == WAN_DONGLE_TYPE_UBLOX_LISAC200)
mbed_official 5:60b48a013e86 530 {
mbed_official 5:60b48a013e86 531 INFO("Using a u-blox LISA-C200 CDMA Modem");
mbed_official 8:45f5433cfa96 532 m_type = LISA_C200;
mbed_official 5:60b48a013e86 533 m_onePort = true;
mbed_official 5:60b48a013e86 534 }
mbed_official 5:60b48a013e86 535 else
mbed_official 5:60b48a013e86 536 {
mbed_official 5:60b48a013e86 537 WARN("Using an Unknown Dongle");
mbed_official 5:60b48a013e86 538 }
mbed_official 5:60b48a013e86 539 }
mbed_official 5:60b48a013e86 540 return UbloxModem::init();
mbed_official 5:60b48a013e86 541 }
mbed_official 5:60b48a013e86 542
mbed_official 5:60b48a013e86 543 int UbloxUSBModem::cleanup()
mbed_official 5:60b48a013e86 544 {
mbed_official 5:60b48a013e86 545 UbloxModem::cleanup();
mbed_official 5:60b48a013e86 546 m_dongle.disconnect();
mbed_official 5:60b48a013e86 547 m_dongleConnected = false;
mbed_official 5:60b48a013e86 548 return OK;
mbed_official 5:60b48a013e86 549 }
mbed_official 5:60b48a013e86 550
mbed_official 5:60b48a013e86 551 UbloxSerModem::UbloxSerModem() :
mbed_official 5:60b48a013e86 552 UbloxModem(&m_atStream, NULL),
mbed_official 8:45f5433cfa96 553 m_Serial(P0_15/*MDMTXD*/,P0_16/*MDMRXD*/),
mbed_official 5:60b48a013e86 554 m_atStream(m_Serial)
mbed_official 5:60b48a013e86 555 {
mbed_official 8:45f5433cfa96 556 m_Serial.baud(115200/*MDMBAUD*/);
mbed_official 8:45f5433cfa96 557 m_Serial.set_flow_control(SerialBase::RTSCTS, P0_22/*MDMRTS*/, P0_17/*MDMCTS*/);
mbed_official 5:60b48a013e86 558 }
mbed_official 5:60b48a013e86 559