Rob Meades / C027_Support_N

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of C027_Support by u-blox

MDM.cpp@120:4f4aaf0c9521, 2015-03-12 (annotated)

Committer:
RobMeades
Date:
Thu Mar 12 13:40:55 2015 +0000
Revision:
120:4f4aaf0c9521
Parent:
119:d62a42409280
Child:
121:2ec1046f7251
Remove unnecessary AT commands.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mazgch 18:e5697801df29 1 #include "mbed.h"
mazgch 18:e5697801df29 2 #include "MDM.h"
mazgch 74:208e3e32d263 3 #ifdef TARGET_UBLOX_C027
mazgch 74:208e3e32d263 4 #include "C027_api.h"
mazgch 74:208e3e32d263 5 #endif
mazgch 85:dd8f4f0d0ca9 6 #include "MDMAPN.h"
mazgch 84:a05edb010176 7
mazgch 74:208e3e32d263 8 #define PROFILE "0" //!< this is the psd profile used
mazgch 74:208e3e32d263 9 #define MAX_SIZE 128 //!< max expected messages
mazgch 103:197fa7920ad8 10 // num sockets
mazgch 104:c64ba749a422 11 #define NUMSOCKETS (sizeof(_sockets)/sizeof(*_sockets))
mazgch 104:c64ba749a422 12 //! test if it is a socket is ok to use
mazgch 104:c64ba749a422 13 #define ISSOCKET(s) (((s) >= 0) && ((s) < NUMSOCKETS) && (_sockets[s].handle != SOCKET_ERROR))
mazgch 75:ce6e12067d0c 14 //! check for timeout
mazgch 75:ce6e12067d0c 15 #define TIMEOUT(t, ms) ((ms != TIMEOUT_BLOCKING) && (ms < t.read_ms()))
mazgch 80:34985b4d821e 16 //! registration ok check helper
mazgch 79:291df065e345 17 #define REG_OK(r) ((r == REG_HOME) || (r == REG_ROAMING))
mazgch 80:34985b4d821e 18 //! registration done check helper (no need to poll further)
mazgch 79:291df065e345 19 #define REG_DONE(r) ((r == REG_HOME) || (r == REG_ROAMING) || (r == REG_DENIED))
mazgch 95:8282dbbe1492 20 //! helper to make sure that lock unlock pair is always balaced
mazgch 95:8282dbbe1492 21 #define LOCK() { lock()
mazgch 95:8282dbbe1492 22 //! helper to make sure that lock unlock pair is always balaced
mazgch 95:8282dbbe1492 23 #define UNLOCK() } unlock()
mazgch 79:291df065e345 24
mazgch 74:208e3e32d263 25 #ifdef MDM_DEBUG
mazgch 95:8282dbbe1492 26 #if 1 // colored terminal output using ANSI escape sequences
mazgch 95:8282dbbe1492 27 #define COL(c) "\033[" c
mazgch 95:8282dbbe1492 28 #else
mazgch 95:8282dbbe1492 29 #define COL(c)
mazgch 95:8282dbbe1492 30 #endif
mazgch 95:8282dbbe1492 31 #define DEF COL("39m")
mazgch 95:8282dbbe1492 32 #define BLA COL("30m")
mazgch 95:8282dbbe1492 33 #define RED COL("31m")
mazgch 95:8282dbbe1492 34 #define GRE COL("32m")
mazgch 95:8282dbbe1492 35 #define YEL COL("33m")
mazgch 95:8282dbbe1492 36 #define BLU COL("34m")
mazgch 95:8282dbbe1492 37 #define MAG COL("35m")
mazgch 95:8282dbbe1492 38 #define CYA COL("36m")
mazgch 95:8282dbbe1492 39 #define WHY COL("37m")
mazgch 95:8282dbbe1492 40
mazgch 74:208e3e32d263 41 void dumpAtCmd(const char* buf, int len)
mazgch 21:c4d64830bf02 42 {
mazgch 75:ce6e12067d0c 43 ::printf(" %3d \"", len);
mazgch 21:c4d64830bf02 44 while (len --) {
mazgch 21:c4d64830bf02 45 char ch = *buf++;
mazgch 75:ce6e12067d0c 46 if ((ch > 0x1F) && (ch != 0x7F)) { // is printable
mazgch 75:ce6e12067d0c 47 if (ch == '%') ::printf("%%");
mazgch 75:ce6e12067d0c 48 else if (ch == '"') ::printf("\\\"");
mazgch 75:ce6e12067d0c 49 else if (ch == '\\') ::printf("\\\\");
mazgch 75:ce6e12067d0c 50 else putchar(ch);
mazgch 75:ce6e12067d0c 51 } else {
mazgch 75:ce6e12067d0c 52 if (ch == '\a') ::printf("\\a"); // BEL (0x07)
mazgch 75:ce6e12067d0c 53 else if (ch == '\b') ::printf("\\b"); // Backspace (0x08)
mazgch 75:ce6e12067d0c 54 else if (ch == '\t') ::printf("\\t"); // Horizontal Tab (0x09)
mazgch 75:ce6e12067d0c 55 else if (ch == '\n') ::printf("\\n"); // Linefeed (0x0A)
mazgch 75:ce6e12067d0c 56 else if (ch == '\v') ::printf("\\v"); // Vertical Tab (0x0B)
mazgch 75:ce6e12067d0c 57 else if (ch == '\f') ::printf("\\f"); // Formfeed (0x0C)
mazgch 75:ce6e12067d0c 58 else if (ch == '\r') ::printf("\\r"); // Carriage Return (0x0D)
mazgch 76:f7c3dd568dae 59 else ::printf("\\x%02x", (unsigned char)ch);
mazgch 75:ce6e12067d0c 60 }
mazgch 21:c4d64830bf02 61 }
mazgch 75:ce6e12067d0c 62 ::printf("\"\r\n");
mazgch 21:c4d64830bf02 63 }
mazgch 74:208e3e32d263 64
mazgch 117:74e4e0109a9e 65 void MDMParser::_debugPrint(int level, const char* color, const char* format, ...)
mazgch 117:74e4e0109a9e 66 {
mazgch 117:74e4e0109a9e 67 if (_debugLevel >= level)
mazgch 117:74e4e0109a9e 68 {
mazgch 117:74e4e0109a9e 69 ::printf("_debugPrint %d %d\r\n", _debugLevel, level);
mazgch 117:74e4e0109a9e 70 va_list args;
mazgch 117:74e4e0109a9e 71 va_start (args, format);
mazgch 117:74e4e0109a9e 72 if (color) ::printf(color);
mazgch 117:74e4e0109a9e 73 ::vprintf(format, args);
mazgch 117:74e4e0109a9e 74 if (color) ::printf(DEF);
mazgch 117:74e4e0109a9e 75 va_end (args);
mazgch 117:74e4e0109a9e 76 }
mazgch 117:74e4e0109a9e 77 }
mazgch 117:74e4e0109a9e 78
mazgch 117:74e4e0109a9e 79 #define ERROR(...) _debugPrint(0, RED, __VA_ARGS__)
mazgch 117:74e4e0109a9e 80 #define INFO(...) _debugPrint(1, GRE, __VA_ARGS__)
mazgch 117:74e4e0109a9e 81 #define TRACE(...) _debugPrint(2, DEF, __VA_ARGS__)
mazgch 117:74e4e0109a9e 82 #define TEST(...) _debugPrint(3, CYA, __VA_ARGS__)
mazgch 74:208e3e32d263 83
mazgch 74:208e3e32d263 84 #else
mazgch 74:208e3e32d263 85
mazgch 75:ce6e12067d0c 86 #define ERROR(...) (void)0 // no tracing
mazgch 95:8282dbbe1492 87 #define TEST(...) (void)0 // no tracing
mazgch 74:208e3e32d263 88 #define INFO(...) (void)0 // no tracing
mazgch 74:208e3e32d263 89 #define TRACE(...) (void)0 // no tracing
mazgch 74:208e3e32d263 90
mazgch 31:a0bed6c1e05d 91 #endif
mazgch 21:c4d64830bf02 92
mazgch 44:9d12223b78ff 93 MDMParser* MDMParser::inst;
mazgch 44:9d12223b78ff 94
mazgch 21:c4d64830bf02 95 MDMParser::MDMParser(void)
mazgch 21:c4d64830bf02 96 {
mazgch 44:9d12223b78ff 97 inst = this;
mazgch 31:a0bed6c1e05d 98 memset(&_dev, 0, sizeof(_dev));
mazgch 31:a0bed6c1e05d 99 memset(&_net, 0, sizeof(_net));
mazgch 54:7ba8e4c218e2 100 _net.lac = 0xFFFF;
mazgch 54:7ba8e4c218e2 101 _net.ci = 0xFFFFFFFF;
mazgch 35:9275215a3a5b 102 _ip = NOIP;
mazgch 76:f7c3dd568dae 103 _init = false;
mazgch 31:a0bed6c1e05d 104 memset(_sockets, 0, sizeof(_sockets));
mazgch 104:c64ba749a422 105 for (int socket = 0; socket < NUMSOCKETS; socket ++)
mazgch 103:197fa7920ad8 106 _sockets[socket].handle = SOCKET_ERROR;
RobMeades 118:f3fd6c30dc19 107 _outstandingNMI = 0;
mazgch 74:208e3e32d263 108 #ifdef MDM_DEBUG
mazgch 76:f7c3dd568dae 109 _debugLevel = 1;
mazgch 74:208e3e32d263 110 _debugTime.start();
mazgch 74:208e3e32d263 111 #endif
mazgch 74:208e3e32d263 112 }
mazgch 74:208e3e32d263 113
mazgch 18:e5697801df29 114 int MDMParser::send(const char* buf, int len)
mazgch 18:e5697801df29 115 {
mazgch 74:208e3e32d263 116 #ifdef MDM_DEBUG
mazgch 74:208e3e32d263 117 if (_debugLevel >= 3) {
mazgch 75:ce6e12067d0c 118 ::printf("%10.3f AT send ", _debugTime.read_ms()*0.001);
mazgch 74:208e3e32d263 119 dumpAtCmd(buf,len);
mazgch 74:208e3e32d263 120 }
mazgch 21:c4d64830bf02 121 #endif
mazgch 18:e5697801df29 122 return _send(buf, len);
mazgch 18:e5697801df29 123 }
mazgch 18:e5697801df29 124
mazgch 21:c4d64830bf02 125 int MDMParser::sendFormated(const char* format, ...) {
mazgch 21:c4d64830bf02 126 char buf[MAX_SIZE];
mazgch 21:c4d64830bf02 127 va_list args;
mazgch 21:c4d64830bf02 128 va_start(args, format);
mazgch 21:c4d64830bf02 129 int len = vsnprintf(buf,sizeof(buf), format, args);
mazgch 21:c4d64830bf02 130 va_end(args);
mazgch 21:c4d64830bf02 131 return send(buf, len);
mazgch 21:c4d64830bf02 132 }
mazgch 21:c4d64830bf02 133
mazgch 26:07be5faf8925 134 int MDMParser::waitFinalResp(_CALLBACKPTR cb /* = NULL*/,
mazgch 26:07be5faf8925 135 void* param /* = NULL*/,
mazgch 26:07be5faf8925 136 int timeout_ms /*= 5000*/)
mazgch 26:07be5faf8925 137 {
mazgch 69:4d6fa520dfca 138 char buf[MAX_SIZE + 64 /* add some more space for framing */];
mazgch 21:c4d64830bf02 139 Timer timer;
mazgch 21:c4d64830bf02 140 timer.start();
mazgch 21:c4d64830bf02 141 do {
mazgch 21:c4d64830bf02 142 int ret = getLine(buf, sizeof(buf));
mazgch 74:208e3e32d263 143 #ifdef MDM_DEBUG
mazgch 74:208e3e32d263 144 if ((_debugLevel >= 3) && (ret != WAIT) && (ret != NOT_FOUND))
mazgch 21:c4d64830bf02 145 {
mazgch 31:a0bed6c1e05d 146 int len = LENGTH(ret);
mazgch 31:a0bed6c1e05d 147 int type = TYPE(ret);
mazgch 95:8282dbbe1492 148 const char* s = (type == TYPE_UNKNOWN)? YEL "UNK" DEF :
mazgch 95:8282dbbe1492 149 (type == TYPE_TEXT) ? MAG "TXT" DEF :
mazgch 95:8282dbbe1492 150 (type == TYPE_OK ) ? GRE "OK " DEF :
mazgch 95:8282dbbe1492 151 (type == TYPE_ERROR) ? RED "ERR" DEF :
mazgch 95:8282dbbe1492 152 (type == TYPE_PLUS) ? CYA " + " DEF :
mazgch 95:8282dbbe1492 153 (type == TYPE_PROMPT) ? BLU " > " DEF :
mazgch 95:8282dbbe1492 154 "..." ;
mazgch 75:ce6e12067d0c 155 ::printf("%10.3f AT read %s", _debugTime.read_ms()*0.001, s);
mazgch 74:208e3e32d263 156 dumpAtCmd(buf, len);
mazgch 21:c4d64830bf02 157 }
mazgch 21:c4d64830bf02 158 #endif
mazgch 21:c4d64830bf02 159 if ((ret != WAIT) && (ret != NOT_FOUND))
mazgch 18:e5697801df29 160 {
mazgch 21:c4d64830bf02 161 int type = TYPE(ret);
mazgch 21:c4d64830bf02 162 // handle unsolicited commands here
mazgch 21:c4d64830bf02 163 if (type == TYPE_PLUS) {
mazgch 21:c4d64830bf02 164 const char* cmd = buf+3;
mazgch 54:7ba8e4c218e2 165 int a, b, c, d, r;
mazgch 23:05a1aeeb5fd9 166 char s[32];
mazgch 21:c4d64830bf02 167
mazgch 31:a0bed6c1e05d 168 // SMS Command ---------------------------------
mazgch 31:a0bed6c1e05d 169 // +CNMI: <mem>,<index>
mazgch 31:a0bed6c1e05d 170 if (sscanf(cmd, "CMTI: \"%*[^\"]\",%d", &a) == 1) {
mazgch 31:a0bed6c1e05d 171 TRACE("New SMS at index %d\r\n", a);
mazgch 21:c4d64830bf02 172 // Socket Specific Command ---------------------------------
mazgch 21:c4d64830bf02 173 // +UUSORD: <socket>,<length>
mazgch 103:197fa7920ad8 174 } else if ((sscanf(cmd, "UUSORD: %d,%d", &a, &b) == 2)) {
mazgch 103:197fa7920ad8 175 int socket = _findSocket(a);
mazgch 103:197fa7920ad8 176 TRACE("Socket %d: handle %d has %d bytes pending\r\n", socket, a, b);
mazgch 103:197fa7920ad8 177 if (socket != SOCKET_ERROR)
mazgch 103:197fa7920ad8 178 _sockets[socket].pending = b;
mazgch 69:4d6fa520dfca 179 // +UUSORF: <socket>,<length>
mazgch 103:197fa7920ad8 180 } else if ((sscanf(cmd, "UUSORF: %d,%d", &a, &b) == 2)) {
mazgch 103:197fa7920ad8 181 int socket = _findSocket(a);
mazgch 103:197fa7920ad8 182 TRACE("Socket %d: handle %d has %d bytes pending\r\n", socket, a, b);
mazgch 103:197fa7920ad8 183 if (socket != SOCKET_ERROR)
mazgch 103:197fa7920ad8 184 _sockets[socket].pending = b;
mazgch 21:c4d64830bf02 185 // +UUSOCL: <socket>
mazgch 103:197fa7920ad8 186 } else if ((sscanf(cmd, "UUSOCL: %d", &a) == 1)) {
mazgch 103:197fa7920ad8 187 int socket = _findSocket(a);
mazgch 103:197fa7920ad8 188 TRACE("Socket %d: handle %d closed by remote host\r\n", socket, a);
mazgch 103:197fa7920ad8 189 if ((socket != SOCKET_ERROR) && _sockets[socket].connected)
mazgch 103:197fa7920ad8 190 _sockets[socket].connected = false;
mazgch 103:197fa7920ad8 191 }
mazgch 32:8f12ac182bbb 192 if (_dev.dev == DEV_LISA_C200) {
mazgch 21:c4d64830bf02 193 // CDMA Specific -------------------------------------------
mazgch 21:c4d64830bf02 194 // +CREG: <n><SID>,<NID>,<stat>
mazgch 54:7ba8e4c218e2 195 if (sscanf(cmd, "CREG: %*d,%d,%d,%d",&a,&b,&c) == 3) {
mazgch 54:7ba8e4c218e2 196 // _net.sid = a;
mazgch 54:7ba8e4c218e2 197 // _net.nid = b;
mazgch 79:291df065e345 198 if (c == 0) _net.csd = REG_NONE; // not registered, home network
mazgch 79:291df065e345 199 else if (c == 1) _net.csd = REG_HOME; // registered, home network
mazgch 79:291df065e345 200 else if (c == 2) _net.csd = REG_NONE; // not registered, but MT is currently searching a new operator to register to
mazgch 79:291df065e345 201 else if (c == 3) _net.csd = REG_DENIED; // registration denied
mazgch 79:291df065e345 202 else if (c == 5) _net.csd = REG_ROAMING; // registered, roaming
mazgch 79:291df065e345 203 _net.psd = _net.csd; // fake PSD registration (CDMA is always registered)
mazgch 31:a0bed6c1e05d 204 _net.act = ACT_CDMA;
mazgch 84:a05edb010176 205 // +CSS: <mode>[,<format>,<oper>[,<AcT>]]
mazgch 21:c4d64830bf02 206 } else if (sscanf(cmd, "CSS %*c,%2s,%*d",s) == 1) {
mazgch 31:a0bed6c1e05d 207 //_net.reg = (strcmp("Z", s) == 0) ? REG_UNKNOWN : REG_HOME;
mazgch 21:c4d64830bf02 208 }
RobMeades 118:f3fd6c30dc19 209 } else if (_dev.dev == DEV_LISA_N101) {
RobMeades 118:f3fd6c30dc19 210 // Neul unsolicited responses ----------------------------
RobMeades 118:f3fd6c30dc19 211 // New Message Indication
RobMeades 118:f3fd6c30dc19 212 // +NMI:<length>,<data>
RobMeades 118:f3fd6c30dc19 213 if (sscanf(buf, "\r\n+NMI:%d,%s", &a, s) == 2) {
RobMeades 118:f3fd6c30dc19 214 _outstandingNMI++;
RobMeades 118:f3fd6c30dc19 215 TRACE("New Message Indication, length: %d\r\n", a);
RobMeades 118:f3fd6c30dc19 216 }
RobMeades 118:f3fd6c30dc19 217 // Send Message Indication
RobMeades 118:f3fd6c30dc19 218 // +SMI:<status>
RobMeades 118:f3fd6c30dc19 219 if (sscanf(cmd, "SMI:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 220 TRACE("Send message status: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 221 }
RobMeades 118:f3fd6c30dc19 222 // +GSN:<UUID>
RobMeades 118:f3fd6c30dc19 223 if (sscanf(cmd, "GSN:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 224 TRACE("Serial number is: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 225 }
RobMeades 118:f3fd6c30dc19 226 // +MGS:<status>
RobMeades 118:f3fd6c30dc19 227 if (sscanf(cmd, "MGS:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 228 TRACE("Message Send returned: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 229 }
RobMeades 118:f3fd6c30dc19 230 // +MGR:<length>,<data>
RobMeades 118:f3fd6c30dc19 231 if (sscanf(cmd, "MGR:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 232 TRACE("Message Receive returned: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 233 }
RobMeades 118:f3fd6c30dc19 234 // +RAS:<status>
RobMeades 118:f3fd6c30dc19 235 if (sscanf(cmd, "RAS:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 236 TRACE("Radio Activity Status returned: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 237 }
RobMeades 118:f3fd6c30dc19 238 // +QMGR:<status>
RobMeades 118:f3fd6c30dc19 239 if (sscanf(cmd, "QMGR:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 240 TRACE("Query Messages Received returned: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 241 }
RobMeades 118:f3fd6c30dc19 242 // +QMGS:<status>
RobMeades 118:f3fd6c30dc19 243 if (sscanf(cmd, "QMGS:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 244 TRACE("Query Messages Sent returned: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 245 }
RobMeades 118:f3fd6c30dc19 246 // +RB:<status>
RobMeades 118:f3fd6c30dc19 247 if (sscanf(cmd, "RB:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 248 TRACE("Rebooting returned: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 249 }
RobMeades 118:f3fd6c30dc19 250 // +CSQ: <0-255>
RobMeades 118:f3fd6c30dc19 251 if (sscanf(cmd, "CSQ: %d", &a) == 1) {
RobMeades 118:f3fd6c30dc19 252 TRACE("Signal strength is: %d\r\n", a);
RobMeades 118:f3fd6c30dc19 253 }
RobMeades 118:f3fd6c30dc19 254 // +LAC:<commandname>
RobMeades 118:f3fd6c30dc19 255 if (sscanf(cmd, "LAC:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 256 TRACE("An available command is: %s\r\n", s);
RobMeades 118:f3fd6c30dc19 257 }
RobMeades 118:f3fd6c30dc19 258 // +DI:<string>
RobMeades 118:f3fd6c30dc19 259 if (sscanf(cmd, "DI:%s", s) == 1) {
RobMeades 118:f3fd6c30dc19 260 // Do nothing, this will be spat out when debug is on anyway
RobMeades 118:f3fd6c30dc19 261 }
mazgch 21:c4d64830bf02 262 } else {
mazgch 21:c4d64830bf02 263 // GSM/UMTS Specific -------------------------------------------
mazgch 79:291df065e345 264 // +UUPSDD: <profile_id>
mazgch 79:291df065e345 265 if (sscanf(cmd, "UUPSDD: %d",&a) == 1) {
mazgch 79:291df065e345 266 if (*PROFILE == a) _ip = NOIP;
mazgch 79:291df065e345 267 } else {
mazgch 79:291df065e345 268 // +CREG|CGREG: <n>,<stat>[,<lac>,<ci>[,AcT[,<rac>]]] // reply to AT+CREG|AT+CGREG
mazgch 79:291df065e345 269 // +CREG|CGREG: <stat>[,<lac>,<ci>[,AcT[,<rac>]]] // URC
mazgch 79:291df065e345 270 b = 0xFFFF; c = 0xFFFFFFFF; d = -1;
mazgch 79:291df065e345 271 r = sscanf(cmd, "%s %*d,%d,\"%X\",\"%X\",%d",s,&a,&b,&c,&d);
mazgch 79:291df065e345 272 if (r <= 1)
mazgch 79:291df065e345 273 r = sscanf(cmd, "%s %d,\"%X\",\"%X\",%d",s,&a,&b,&c,&d);
mazgch 79:291df065e345 274 if (r >= 2) {
mazgch 79:291df065e345 275 Reg *reg = !strcmp(s, "CREG:") ? &_net.csd :
mazgch 79:291df065e345 276 !strcmp(s, "CGREG:") ? &_net.psd : NULL;
mazgch 79:291df065e345 277 if (reg) {
mazgch 79:291df065e345 278 // network status
mazgch 79:291df065e345 279 if (a == 0) *reg = REG_NONE; // 0: not registered, home network
mazgch 79:291df065e345 280 else if (a == 1) *reg = REG_HOME; // 1: registered, home network
mazgch 79:291df065e345 281 else if (a == 2) *reg = REG_NONE; // 2: not registered, but MT is currently searching a new operator to register to
mazgch 79:291df065e345 282 else if (a == 3) *reg = REG_DENIED; // 3: registration denied
mazgch 79:291df065e345 283 else if (a == 4) *reg = REG_UNKNOWN; // 4: unknown
mazgch 79:291df065e345 284 else if (a == 5) *reg = REG_ROAMING; // 5: registered, roaming
mazgch 79:291df065e345 285 if ((r >= 3) && (b != 0xFFFF)) _net.lac = b; // location area code
mazgch 79:291df065e345 286 if ((r >= 4) && (c != 0xFFFFFFFF)) _net.ci = c; // cell ID
mazgch 79:291df065e345 287 // access technology
mazgch 79:291df065e345 288 if (r >= 5) {
mazgch 79:291df065e345 289 if (d == 0) _net.act = ACT_GSM; // 0: GSM
mazgch 79:291df065e345 290 else if (d == 1) _net.act = ACT_GSM; // 1: GSM COMPACT
mazgch 79:291df065e345 291 else if (d == 2) _net.act = ACT_UTRAN; // 2: UTRAN
mazgch 79:291df065e345 292 else if (d == 3) _net.act = ACT_EDGE; // 3: GSM with EDGE availability
mazgch 79:291df065e345 293 else if (d == 4) _net.act = ACT_UTRAN; // 4: UTRAN with HSDPA availability
mazgch 79:291df065e345 294 else if (d == 5) _net.act = ACT_UTRAN; // 5: UTRAN with HSUPA availability
mazgch 79:291df065e345 295 else if (d == 6) _net.act = ACT_UTRAN; // 6: UTRAN with HSDPA and HSUPA availability
mazgch 79:291df065e345 296 }
mazgch 79:291df065e345 297 }
mazgch 54:7ba8e4c218e2 298 }
mazgch 21:c4d64830bf02 299 }
mazgch 21:c4d64830bf02 300 }
mazgch 21:c4d64830bf02 301 }
mazgch 21:c4d64830bf02 302 if (cb) {
mazgch 21:c4d64830bf02 303 int len = LENGTH(ret);
mazgch 21:c4d64830bf02 304 int ret = cb(type, buf, len, param);
mazgch 21:c4d64830bf02 305 if (WAIT != ret)
mazgch 21:c4d64830bf02 306 return ret;
mazgch 21:c4d64830bf02 307 }
mazgch 95:8282dbbe1492 308 if (type == TYPE_OK)
mazgch 95:8282dbbe1492 309 return RESP_OK;
mazgch 95:8282dbbe1492 310 if (type == TYPE_ERROR)
mazgch 95:8282dbbe1492 311 return RESP_ERROR;
mazgch 95:8282dbbe1492 312 if (type == TYPE_PROMPT)
mazgch 95:8282dbbe1492 313 return RESP_PROMPT;
mazgch 21:c4d64830bf02 314 }
mazgch 21:c4d64830bf02 315 // relax a bit
mazgch 95:8282dbbe1492 316 wait_ms(10);
mazgch 21:c4d64830bf02 317 }
mazgch 75:ce6e12067d0c 318 while (!TIMEOUT(timer, timeout_ms));
mazgch 21:c4d64830bf02 319 return WAIT;
mazgch 21:c4d64830bf02 320 }
mazgch 21:c4d64830bf02 321
mazgch 31:a0bed6c1e05d 322 int MDMParser::_cbString(int type, const char* buf, int len, char* str)
mazgch 21:c4d64830bf02 323 {
mazgch 37:cc3433329d66 324 if (str && (type == TYPE_UNKNOWN)) {
mazgch 31:a0bed6c1e05d 325 if (sscanf(buf, "\r\n%s\r\n", str) == 1)
mazgch 31:a0bed6c1e05d 326 /*nothing*/;
mazgch 21:c4d64830bf02 327 }
mazgch 21:c4d64830bf02 328 return WAIT;
mazgch 21:c4d64830bf02 329 }
mazgch 21:c4d64830bf02 330
mazgch 31:a0bed6c1e05d 331 int MDMParser::_cbInt(int type, const char* buf, int len, int* val)
mazgch 31:a0bed6c1e05d 332 {
mazgch 37:cc3433329d66 333 if (val && (type == TYPE_UNKNOWN)) {
mazgch 31:a0bed6c1e05d 334 if (sscanf(buf, "\r\n%d\r\n", val) == 1)
mazgch 31:a0bed6c1e05d 335 /*nothing*/;
mazgch 31:a0bed6c1e05d 336 }
mazgch 31:a0bed6c1e05d 337 return WAIT;
mazgch 31:a0bed6c1e05d 338 }
mazgch 31:a0bed6c1e05d 339
RobMeades 118:f3fd6c30dc19 340 // Neul modem flavour of manufacturer ID string
RobMeades 118:f3fd6c30dc19 341 int MDMParser::_cbGmiString(int type, const char* buf, int len, char* str)
RobMeades 118:f3fd6c30dc19 342 {
RobMeades 118:f3fd6c30dc19 343 if (str && (type == TYPE_PLUS)) {
RobMeades 118:f3fd6c30dc19 344 if (sscanf(buf, "\r\n+GMI:%s\r\n", str) == 1)
RobMeades 118:f3fd6c30dc19 345 /*nothing*/;
RobMeades 118:f3fd6c30dc19 346 }
RobMeades 118:f3fd6c30dc19 347 return WAIT;
RobMeades 118:f3fd6c30dc19 348 }
RobMeades 118:f3fd6c30dc19 349
RobMeades 118:f3fd6c30dc19 350 // Neul modem flavour of manufacturer model string
RobMeades 118:f3fd6c30dc19 351 int MDMParser::_cbGmmString(int type, const char* buf, int len, char* str)
RobMeades 118:f3fd6c30dc19 352 {
RobMeades 118:f3fd6c30dc19 353 if (str && (type == TYPE_PLUS)) {
RobMeades 118:f3fd6c30dc19 354 if (sscanf(buf, "\r\n+GMM:%s\r\n", str) == 1)
RobMeades 118:f3fd6c30dc19 355 /*nothing*/;
RobMeades 118:f3fd6c30dc19 356 }
RobMeades 118:f3fd6c30dc19 357 return WAIT;
RobMeades 118:f3fd6c30dc19 358 }
RobMeades 118:f3fd6c30dc19 359
RobMeades 118:f3fd6c30dc19 360 // Neul modem flavour of manufacturer revision string
RobMeades 118:f3fd6c30dc19 361 int MDMParser::_cbGmrString(int type, const char* buf, int len, char* str)
RobMeades 118:f3fd6c30dc19 362 {
RobMeades 118:f3fd6c30dc19 363 if (str && (type == TYPE_PLUS)) {
RobMeades 118:f3fd6c30dc19 364 if (sscanf(buf, "\r\n+GMR:%s\r\n", str) == 1)
RobMeades 118:f3fd6c30dc19 365 /*nothing*/;
RobMeades 118:f3fd6c30dc19 366 }
RobMeades 118:f3fd6c30dc19 367 return WAIT;
RobMeades 118:f3fd6c30dc19 368 }
RobMeades 118:f3fd6c30dc19 369
mazgch 31:a0bed6c1e05d 370 // ----------------------------------------------------------------
mazgch 31:a0bed6c1e05d 371
mazgch 57:869bd35f44cc 372 bool MDMParser::connect(
mazgch 57:869bd35f44cc 373 const char* simpin,
mazgch 80:34985b4d821e 374 const char* apn, const char* username,
mazgch 80:34985b4d821e 375 const char* password, Auth auth,
mazgch 74:208e3e32d263 376 PinName pn)
mazgch 57:869bd35f44cc 377 {
mazgch 75:ce6e12067d0c 378 bool ok = init(simpin, NULL, pn);
mazgch 74:208e3e32d263 379 #ifdef MDM_DEBUG
mazgch 75:ce6e12067d0c 380 if (_debugLevel >= 1) dumpDevStatus(&_dev);
mazgch 74:208e3e32d263 381 #endif
mazgch 75:ce6e12067d0c 382 if (!ok)
mazgch 57:869bd35f44cc 383 return false;
mazgch 75:ce6e12067d0c 384 ok = registerNet();
mazgch 74:208e3e32d263 385 #ifdef MDM_DEBUG
mazgch 75:ce6e12067d0c 386 if (_debugLevel >= 1) dumpNetStatus(&_net);
mazgch 74:208e3e32d263 387 #endif
mazgch 75:ce6e12067d0c 388 if (!ok)
mazgch 57:869bd35f44cc 389 return false;
mazgch 80:34985b4d821e 390 IP ip = join(apn,username,password,auth);
mazgch 74:208e3e32d263 391 #ifdef MDM_DEBUG
mazgch 74:208e3e32d263 392 if (_debugLevel >= 1) dumpIp(ip);
mazgch 74:208e3e32d263 393 #endif
mazgch 57:869bd35f44cc 394 if (ip == NOIP)
mazgch 57:869bd35f44cc 395 return false;
mazgch 57:869bd35f44cc 396 return true;
mazgch 57:869bd35f44cc 397 }
mazgch 57:869bd35f44cc 398
mazgch 74:208e3e32d263 399 bool MDMParser::init(const char* simpin, DevStatus* status, PinName pn)
mazgch 21:c4d64830bf02 400 {
mazgch 74:208e3e32d263 401 int i = 10;
mazgch 95:8282dbbe1492 402 LOCK();
mazgch 76:f7c3dd568dae 403 memset(&_dev, 0, sizeof(_dev));
mazgch 74:208e3e32d263 404 if (pn != NC) {
mazgch 74:208e3e32d263 405 INFO("Modem::wakeup\r\n");
mazgch 74:208e3e32d263 406 DigitalOut pin(pn, 1);
mazgch 74:208e3e32d263 407 while (i--) {
RobMeades 118:f3fd6c30dc19 408 if (_dev.dev != DEV_LISA_N101) {
RobMeades 118:f3fd6c30dc19 409 // SARA-U2/LISA-U2 50..80us
RobMeades 118:f3fd6c30dc19 410 pin = 0; ::wait_us(50);
RobMeades 118:f3fd6c30dc19 411 pin = 1; ::wait_ms(10);
mazgch 79:291df065e345 412
RobMeades 118:f3fd6c30dc19 413 // SARA-G35 >5ms, LISA-C2 > 150ms, LEON-G2 >5ms
RobMeades 118:f3fd6c30dc19 414 pin = 0; ::wait_ms(150);
RobMeades 118:f3fd6c30dc19 415 pin = 1; ::wait_ms(100);
RobMeades 118:f3fd6c30dc19 416 }
mazgch 79:291df065e345 417 // purge any messages
mazgch 101:edfeb8af206e 418 purge();
mazgch 95:8282dbbe1492 419
mazgch 101:edfeb8af206e 420 // check interface
mazgch 74:208e3e32d263 421 sendFormated("AT\r\n");
mazgch 101:edfeb8af206e 422 int r = waitFinalResp(NULL,NULL,1000);
mazgch 95:8282dbbe1492 423 if(RESP_OK == r) break;
RobMeades 118:f3fd6c30dc19 424 if(RESP_ERROR == r) break; // Neul modem responds with ERROR when sent AT with no following parameters
mazgch 74:208e3e32d263 425 }
mazgch 75:ce6e12067d0c 426 if (i < 0) {
mazgch 95:8282dbbe1492 427 ERROR("No Reply from Modem\r\n");
mazgch 95:8282dbbe1492 428 goto failure;
mazgch 75:ce6e12067d0c 429 }
mazgch 21:c4d64830bf02 430 }
mazgch 76:f7c3dd568dae 431 _init = true;
mazgch 75:ce6e12067d0c 432
mazgch 74:208e3e32d263 433 INFO("Modem::init\r\n");
RobMeades 118:f3fd6c30dc19 434 // Attempt to get the manufacturer model string
RobMeades 118:f3fd6c30dc19 435 sendFormated("AT+GMM\r\n");
RobMeades 118:f3fd6c30dc19 436 if (RESP_OK == waitFinalResp(_cbGmmString, _dev.model)) {
RobMeades 118:f3fd6c30dc19 437 // If successful it's probably the Neul modem, do a specific check though
RobMeades 118:f3fd6c30dc19 438 if (strstr (_dev.model, "Neul") == _dev.model) {
RobMeades 118:f3fd6c30dc19 439 _dev.dev = DEV_LISA_N101;
RobMeades 118:f3fd6c30dc19 440 // Neul modem specific init
RobMeades 118:f3fd6c30dc19 441 printf ("Neul AT parser revision 0.1 (for interface NT1001).\n");
RobMeades 118:f3fd6c30dc19 442 // get the manufacturer ID string
RobMeades 118:f3fd6c30dc19 443 sendFormated("AT+GMI\r\n");
RobMeades 118:f3fd6c30dc19 444 if (RESP_OK != waitFinalResp(_cbGmiString, _dev.manu))
RobMeades 118:f3fd6c30dc19 445 goto failure;
RobMeades 118:f3fd6c30dc19 446 #ifndef DISABLE_NEUL_TEST_COMMANDS
RobMeades 120:4f4aaf0c9521 447 /* In a phase 1 deployment special initialisation command should be inserted here, for example: */
RobMeades 120:4f4aaf0c9521 448 /* sendFormated ("AT+DI=0\r\n");
RobMeades 120:4f4aaf0c9521 449 if (RESP_OK != waitFinalResp())
RobMeades 120:4f4aaf0c9521 450 goto failure; */
RobMeades 118:f3fd6c30dc19 451 #endif
RobMeades 118:f3fd6c30dc19 452 // get the sw version
RobMeades 118:f3fd6c30dc19 453 sendFormated("AT+GMR\r\n");
RobMeades 118:f3fd6c30dc19 454 if (RESP_OK != waitFinalResp(_cbGmrString, _dev.ver))
RobMeades 118:f3fd6c30dc19 455 goto failure;
RobMeades 118:f3fd6c30dc19 456 // Don't set an error if this fails as it's not set on some modules
RobMeades 118:f3fd6c30dc19 457 sendFormated("AT+GSN\r\n");
RobMeades 118:f3fd6c30dc19 458 waitFinalResp(NULL, NULL, 1000);
RobMeades 118:f3fd6c30dc19 459 #ifdef C027N_USE_NMI
RobMeades 118:f3fd6c30dc19 460 // Switch on new message indications
RobMeades 118:f3fd6c30dc19 461 sendFormated("AT+NMI=1\r\n");
RobMeades 118:f3fd6c30dc19 462 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 463 goto failure;
RobMeades 118:f3fd6c30dc19 464 #else
RobMeades 118:f3fd6c30dc19 465 sendFormated("AT+NMI=0\r\n");
RobMeades 118:f3fd6c30dc19 466 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 467 goto failure;
RobMeades 118:f3fd6c30dc19 468 #endif
RobMeades 118:f3fd6c30dc19 469 // Switch on send message indications
RobMeades 118:f3fd6c30dc19 470 sendFormated("AT+SMI=1\r\n");
mazgch 52:8071747a7cb3 471 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 472 goto failure;
mazgch 21:c4d64830bf02 473 }
RobMeades 118:f3fd6c30dc19 474 } else {
RobMeades 118:f3fd6c30dc19 475 // 3GPP/CDMA modem init
RobMeades 118:f3fd6c30dc19 476 // echo off
RobMeades 118:f3fd6c30dc19 477 sendFormated("AT E0\r\n");
RobMeades 118:f3fd6c30dc19 478 if(RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 479 goto failure;
RobMeades 118:f3fd6c30dc19 480 // enable verbose error messages
RobMeades 118:f3fd6c30dc19 481 sendFormated("AT+CMEE=2\r\n");
RobMeades 118:f3fd6c30dc19 482 if(RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 483 goto failure;
RobMeades 118:f3fd6c30dc19 484 // set baud rate
RobMeades 118:f3fd6c30dc19 485 sendFormated("AT+IPR=115200\r\n");
mazgch 79:291df065e345 486 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 487 goto failure;
RobMeades 118:f3fd6c30dc19 488 // wait some time until baudrate is applied
RobMeades 118:f3fd6c30dc19 489 wait_ms(200); // SARA-G > 40ms
RobMeades 118:f3fd6c30dc19 490 // identify the module
RobMeades 118:f3fd6c30dc19 491 sendFormated("ATI\r\n");
RobMeades 118:f3fd6c30dc19 492 if (RESP_OK != waitFinalResp(_cbATI, &_dev.dev))
RobMeades 118:f3fd6c30dc19 493 goto failure;
RobMeades 118:f3fd6c30dc19 494 if (_dev.dev == DEV_UNKNOWN)
RobMeades 118:f3fd6c30dc19 495 goto failure;
RobMeades 118:f3fd6c30dc19 496 // 3GPP/CDMA device specific init
RobMeades 118:f3fd6c30dc19 497 if (_dev.dev == DEV_LISA_C200) {
RobMeades 118:f3fd6c30dc19 498 // get the manufacturer
RobMeades 118:f3fd6c30dc19 499 sendFormated("AT+GMI\r\n");
RobMeades 118:f3fd6c30dc19 500 if (RESP_OK != waitFinalResp(_cbString, _dev.manu))
RobMeades 118:f3fd6c30dc19 501 goto failure;
RobMeades 118:f3fd6c30dc19 502 // get the model identification
RobMeades 118:f3fd6c30dc19 503 sendFormated("AT+GMM\r\n");
RobMeades 118:f3fd6c30dc19 504 if (RESP_OK != waitFinalResp(_cbString, _dev.model))
RobMeades 118:f3fd6c30dc19 505 goto failure;
RobMeades 118:f3fd6c30dc19 506 // get the sw version
RobMeades 118:f3fd6c30dc19 507 sendFormated("AT+GMR\r\n");
RobMeades 118:f3fd6c30dc19 508 if (RESP_OK != waitFinalResp(_cbString, _dev.ver))
RobMeades 118:f3fd6c30dc19 509 goto failure;
RobMeades 118:f3fd6c30dc19 510 // get the pseudo ESN or MEID
RobMeades 118:f3fd6c30dc19 511 sendFormated("AT+GSN\r\n");
RobMeades 118:f3fd6c30dc19 512 if (RESP_OK != waitFinalResp(_cbString, _dev.meid))
RobMeades 118:f3fd6c30dc19 513 goto failure;
RobMeades 118:f3fd6c30dc19 514 #if 0
RobMeades 118:f3fd6c30dc19 515 // enable power saving
RobMeades 118:f3fd6c30dc19 516 if (_dev.lpm != LPM_DISABLED) {
RobMeades 118:f3fd6c30dc19 517 // enable power saving (requires flow control, cts at least)
RobMeades 118:f3fd6c30dc19 518 sendFormated("AT+UPSV=1,1280\r\n");
RobMeades 118:f3fd6c30dc19 519 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 520 goto failure;
RobMeades 118:f3fd6c30dc19 521 _dev.lpm = LPM_ACTIVE;
RobMeades 118:f3fd6c30dc19 522 }
RobMeades 118:f3fd6c30dc19 523 #endif
RobMeades 118:f3fd6c30dc19 524 } else {
RobMeades 118:f3fd6c30dc19 525 if ((_dev.dev == DEV_LISA_U200) || (_dev.dev == DEV_LEON_G200)) {
RobMeades 118:f3fd6c30dc19 526 // enable the network identification feature
RobMeades 118:f3fd6c30dc19 527 sendFormated("AT+UGPIOC=20,2\r\n");
RobMeades 118:f3fd6c30dc19 528 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 529 goto failure;
RobMeades 118:f3fd6c30dc19 530 } else if ((_dev.dev == DEV_SARA_U260) || (_dev.dev == DEV_SARA_U270) ||
RobMeades 118:f3fd6c30dc19 531 (_dev.dev == DEV_SARA_G350)) {
RobMeades 118:f3fd6c30dc19 532 // enable the network identification feature
RobMeades 118:f3fd6c30dc19 533 sendFormated("AT+UGPIOC=16,2\r\n");
RobMeades 118:f3fd6c30dc19 534 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 535 goto failure;
RobMeades 118:f3fd6c30dc19 536 }
RobMeades 118:f3fd6c30dc19 537 // check the sim card
RobMeades 118:f3fd6c30dc19 538 for (int i = 0; (i < 5) && (_dev.sim != SIM_READY); i++) {
RobMeades 118:f3fd6c30dc19 539 sendFormated("AT+CPIN?\r\n");
RobMeades 118:f3fd6c30dc19 540 int ret = waitFinalResp(_cbCPIN, &_dev.sim);
RobMeades 118:f3fd6c30dc19 541 // having an error here is ok (sim may still be initializing)
RobMeades 118:f3fd6c30dc19 542 if ((RESP_OK != ret) && (RESP_ERROR != ret))
RobMeades 118:f3fd6c30dc19 543 goto failure;
RobMeades 118:f3fd6c30dc19 544 // Enter PIN if needed
RobMeades 118:f3fd6c30dc19 545 if (_dev.sim == SIM_PIN) {
RobMeades 118:f3fd6c30dc19 546 if (!simpin) {
RobMeades 118:f3fd6c30dc19 547 ERROR("SIM PIN not available\r\n");
RobMeades 118:f3fd6c30dc19 548 goto failure;
RobMeades 118:f3fd6c30dc19 549 }
RobMeades 118:f3fd6c30dc19 550 sendFormated("AT+CPIN=%s\r\n", simpin);
RobMeades 118:f3fd6c30dc19 551 if (RESP_OK != waitFinalResp(_cbCPIN, &_dev.sim))
RobMeades 118:f3fd6c30dc19 552 goto failure;
RobMeades 118:f3fd6c30dc19 553 } else if (_dev.sim != SIM_READY) {
RobMeades 118:f3fd6c30dc19 554 wait_ms(1000);
RobMeades 118:f3fd6c30dc19 555 }
RobMeades 118:f3fd6c30dc19 556 }
RobMeades 118:f3fd6c30dc19 557 if (_dev.sim != SIM_READY) {
RobMeades 118:f3fd6c30dc19 558 if (_dev.sim == SIM_MISSING)
RobMeades 118:f3fd6c30dc19 559 ERROR("SIM not inserted\r\n");
RobMeades 118:f3fd6c30dc19 560 goto failure;
RobMeades 118:f3fd6c30dc19 561 }
RobMeades 118:f3fd6c30dc19 562 // get the manufacturer
RobMeades 118:f3fd6c30dc19 563 sendFormated("AT+CGMI\r\n");
RobMeades 118:f3fd6c30dc19 564 if (RESP_OK != waitFinalResp(_cbString, _dev.manu))
RobMeades 118:f3fd6c30dc19 565 goto failure;
RobMeades 118:f3fd6c30dc19 566 // get the model identification
RobMeades 118:f3fd6c30dc19 567 sendFormated("AT+CGMM\r\n");
RobMeades 118:f3fd6c30dc19 568 if (RESP_OK != waitFinalResp(_cbString, _dev.model))
RobMeades 118:f3fd6c30dc19 569 goto failure;
RobMeades 118:f3fd6c30dc19 570 // get the
RobMeades 118:f3fd6c30dc19 571 sendFormated("AT+CGMR\r\n");
RobMeades 118:f3fd6c30dc19 572 if (RESP_OK != waitFinalResp(_cbString, _dev.ver))
RobMeades 118:f3fd6c30dc19 573 goto failure;
RobMeades 118:f3fd6c30dc19 574 // Returns the ICCID (Integrated Circuit Card ID) of the SIM-card.
RobMeades 118:f3fd6c30dc19 575 // ICCID is a serial number identifying the SIM.
RobMeades 118:f3fd6c30dc19 576 sendFormated("AT+CCID\r\n");
RobMeades 118:f3fd6c30dc19 577 if (RESP_OK != waitFinalResp(_cbCCID, _dev.ccid))
RobMeades 118:f3fd6c30dc19 578 goto failure;
RobMeades 118:f3fd6c30dc19 579 // Returns the product serial number, IMEI (International Mobile Equipment Identity)
RobMeades 118:f3fd6c30dc19 580 sendFormated("AT+CGSN\r\n");
RobMeades 118:f3fd6c30dc19 581 if (RESP_OK != waitFinalResp(_cbString, _dev.imei))
RobMeades 118:f3fd6c30dc19 582 goto failure;
RobMeades 118:f3fd6c30dc19 583 // enable power saving
RobMeades 118:f3fd6c30dc19 584 if (_dev.lpm != LPM_DISABLED) {
RobMeades 118:f3fd6c30dc19 585 // enable power saving (requires flow control, cts at least)
RobMeades 118:f3fd6c30dc19 586 sendFormated("AT+UPSV=1\r\n");
RobMeades 118:f3fd6c30dc19 587 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 588 goto failure;
RobMeades 118:f3fd6c30dc19 589 _dev.lpm = LPM_ACTIVE;
RobMeades 118:f3fd6c30dc19 590 }
RobMeades 118:f3fd6c30dc19 591 // enable the psd registration unsolicited result code
RobMeades 118:f3fd6c30dc19 592 sendFormated("AT+CGREG=2\r\n");
RobMeades 118:f3fd6c30dc19 593 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 594 goto failure;
RobMeades 118:f3fd6c30dc19 595 }
RobMeades 118:f3fd6c30dc19 596 // enable the network registration unsolicited result code
RobMeades 118:f3fd6c30dc19 597 sendFormated("AT+CREG=%d\r\n", (_dev.dev == DEV_LISA_C200) ? 1 : 2);
RobMeades 118:f3fd6c30dc19 598 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 599 goto failure;
RobMeades 118:f3fd6c30dc19 600 // Setup SMS in text mode
RobMeades 118:f3fd6c30dc19 601 sendFormated("AT+CMGF=1\r\n");
RobMeades 118:f3fd6c30dc19 602 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 603 goto failure;
RobMeades 118:f3fd6c30dc19 604 // setup new message indication
RobMeades 118:f3fd6c30dc19 605 sendFormated("AT+CNMI=2,1\r\n");
RobMeades 118:f3fd6c30dc19 606 if (RESP_OK != waitFinalResp())
RobMeades 118:f3fd6c30dc19 607 goto failure;
RobMeades 118:f3fd6c30dc19 608 // Request IMSI (International Mobile Subscriber Identification)
RobMeades 118:f3fd6c30dc19 609 sendFormated("AT+CIMI\r\n");
RobMeades 118:f3fd6c30dc19 610 if (RESP_OK != waitFinalResp(_cbString, _dev.imsi))
RobMeades 118:f3fd6c30dc19 611 goto failure;
RobMeades 118:f3fd6c30dc19 612 if (status)
RobMeades 118:f3fd6c30dc19 613 memcpy(status, &_dev, sizeof(DevStatus));
RobMeades 118:f3fd6c30dc19 614 UNLOCK();
RobMeades 118:f3fd6c30dc19 615 }
mazgch 31:a0bed6c1e05d 616 return true;
mazgch 95:8282dbbe1492 617 failure:
mazgch 95:8282dbbe1492 618 unlock();
mazgch 95:8282dbbe1492 619 return false;
mazgch 31:a0bed6c1e05d 620 }
mazgch 31:a0bed6c1e05d 621
mazgch 74:208e3e32d263 622 bool MDMParser::powerOff(void)
mazgch 74:208e3e32d263 623 {
mazgch 95:8282dbbe1492 624 bool ok = false;
mazgch 76:f7c3dd568dae 625 if (_init) {
mazgch 95:8282dbbe1492 626 LOCK();
mazgch 76:f7c3dd568dae 627 INFO("Modem::powerOff\r\n");
mazgch 76:f7c3dd568dae 628 sendFormated("AT+CPWROFF\r\n");
mazgch 95:8282dbbe1492 629 if (RESP_OK == waitFinalResp(NULL,NULL,120*1000)) {
mazgch 95:8282dbbe1492 630 _init = false;
mazgch 95:8282dbbe1492 631 ok = true;
mazgch 95:8282dbbe1492 632 }
mazgch 95:8282dbbe1492 633 UNLOCK();
mazgch 76:f7c3dd568dae 634 }
mazgch 95:8282dbbe1492 635 return ok;
mazgch 74:208e3e32d263 636 }
mazgch 74:208e3e32d263 637
mazgch 32:8f12ac182bbb 638 int MDMParser::_cbATI(int type, const char* buf, int len, Dev* dev)
mazgch 31:a0bed6c1e05d 639 {
mazgch 37:cc3433329d66 640 if ((type == TYPE_UNKNOWN) && dev) {
mazgch 98:c786461edd40 641 if (strstr(buf, "SARA-G350")) *dev = DEV_SARA_G350;
mazgch 98:c786461edd40 642 else if (strstr(buf, "LISA-U200")) *dev = DEV_LISA_U200;
mazgch 98:c786461edd40 643 else if (strstr(buf, "LISA-C200")) *dev = DEV_LISA_C200;
mazgch 98:c786461edd40 644 else if (strstr(buf, "SARA-U260")) *dev = DEV_SARA_U260;
mazgch 98:c786461edd40 645 else if (strstr(buf, "SARA-U270")) *dev = DEV_SARA_U270;
mazgch 98:c786461edd40 646 else if (strstr(buf, "LEON-G200")) *dev = DEV_LEON_G200;
mazgch 28:4d9509e3b1cf 647 }
mazgch 31:a0bed6c1e05d 648 return WAIT;
mazgch 31:a0bed6c1e05d 649 }
mazgch 31:a0bed6c1e05d 650
mazgch 31:a0bed6c1e05d 651 int MDMParser::_cbCPIN(int type, const char* buf, int len, Sim* sim)
mazgch 31:a0bed6c1e05d 652 {
mazgch 75:ce6e12067d0c 653 if (sim) {
mazgch 75:ce6e12067d0c 654 if (type == TYPE_PLUS){
mazgch 75:ce6e12067d0c 655 char s[16];
mazgch 75:ce6e12067d0c 656 if (sscanf(buf, "\r\n+CPIN: %[^\r]\r\n", s) >= 1)
mazgch 75:ce6e12067d0c 657 *sim = (0 == strcmp("READY", s)) ? SIM_READY : SIM_PIN;
mazgch 75:ce6e12067d0c 658 } else if (type == TYPE_ERROR) {
mazgch 75:ce6e12067d0c 659 if (strstr(buf, "+CME ERROR: SIM not inserted"))
mazgch 75:ce6e12067d0c 660 *sim = SIM_MISSING;
mazgch 31:a0bed6c1e05d 661 }
mazgch 31:a0bed6c1e05d 662 }
mazgch 31:a0bed6c1e05d 663 return WAIT;
mazgch 21:c4d64830bf02 664 }
mazgch 21:c4d64830bf02 665
mazgch 26:07be5faf8925 666 int MDMParser::_cbCCID(int type, const char* buf, int len, char* ccid)
mazgch 26:07be5faf8925 667 {
mazgch 26:07be5faf8925 668 if ((type == TYPE_PLUS) && ccid){
mazgch 26:07be5faf8925 669 if (sscanf(buf, "\r\n+CCID: %[^\r]\r\n", ccid) == 1)
mazgch 31:a0bed6c1e05d 670 /*TRACE("Got CCID: %s\r\n", ccid)*/;
mazgch 26:07be5faf8925 671 }
mazgch 26:07be5faf8925 672 return WAIT;
mazgch 26:07be5faf8925 673 }
mazgch 26:07be5faf8925 674
mazgch 75:ce6e12067d0c 675 bool MDMParser::registerNet(NetStatus* status /*= NULL*/, int timeout_ms /*= 180000*/)
mazgch 75:ce6e12067d0c 676 {
mazgch 75:ce6e12067d0c 677 Timer timer;
mazgch 75:ce6e12067d0c 678 timer.start();
mazgch 75:ce6e12067d0c 679 INFO("Modem::register\r\n");
mazgch 75:ce6e12067d0c 680 while (!checkNetStatus(status) && !TIMEOUT(timer, timeout_ms))
mazgch 95:8282dbbe1492 681 wait_ms(1000);
mazgch 79:291df065e345 682 if (_net.csd == REG_DENIED) ERROR("CSD Registration Denied\r\n");
mazgch 79:291df065e345 683 if (_net.psd == REG_DENIED) ERROR("PSD Registration Denied\r\n");
mazgch 79:291df065e345 684 return REG_OK(_net.csd) || REG_OK(_net.psd);
mazgch 75:ce6e12067d0c 685 }
mazgch 75:ce6e12067d0c 686
mazgch 28:4d9509e3b1cf 687 bool MDMParser::checkNetStatus(NetStatus* status /*= NULL*/)
mazgch 21:c4d64830bf02 688 {
mazgch 95:8282dbbe1492 689 bool ok = false;
mazgch 95:8282dbbe1492 690 LOCK();
mazgch 75:ce6e12067d0c 691 memset(&_net, 0, sizeof(_net));
mazgch 75:ce6e12067d0c 692 _net.lac = 0xFFFF;
mazgch 75:ce6e12067d0c 693 _net.ci = 0xFFFFFFFF;
mazgch 21:c4d64830bf02 694 // check registration
RobMeades 118:f3fd6c30dc19 695 if (_dev.dev == DEV_LISA_N101) {
RobMeades 118:f3fd6c30dc19 696 // Neul modem --------------------------
RobMeades 118:f3fd6c30dc19 697 sendFormated("AT+RAS\r\n");
RobMeades 118:f3fd6c30dc19 698 if (RESP_OK != waitFinalResp(_cbRAS, &ok))
RobMeades 118:f3fd6c30dc19 699 goto failure;
RobMeades 118:f3fd6c30dc19 700 _net.psd = REG_HOME;
RobMeades 118:f3fd6c30dc19 701 sendFormated("AT+CSQ\r\n");
RobMeades 118:f3fd6c30dc19 702 if (RESP_OK != waitFinalResp(_cbCSQN, &(_net.rssi)))
RobMeades 118:f3fd6c30dc19 703 goto failure;
RobMeades 118:f3fd6c30dc19 704 } else {
RobMeades 118:f3fd6c30dc19 705 sendFormated("AT+CREG?\r\n");
RobMeades 118:f3fd6c30dc19 706 waitFinalResp(); // don't fail as service could be not subscribed
RobMeades 118:f3fd6c30dc19 707 if (_dev.dev != DEV_LISA_C200) {
RobMeades 118:f3fd6c30dc19 708 // check PSD registration
RobMeades 118:f3fd6c30dc19 709 sendFormated("AT+CGREG?\r\n");
RobMeades 118:f3fd6c30dc19 710 waitFinalResp(); // don't fail as service could be not subscribed
RobMeades 118:f3fd6c30dc19 711 }
RobMeades 118:f3fd6c30dc19 712 if (REG_OK(_net.csd) || REG_OK(_net.psd))
RobMeades 118:f3fd6c30dc19 713 {
RobMeades 118:f3fd6c30dc19 714 // check modem specific status messages
RobMeades 118:f3fd6c30dc19 715 if (_dev.dev == DEV_LISA_C200) {
RobMeades 118:f3fd6c30dc19 716 sendFormated("AT+CSS?\r\n");
RobMeades 118:f3fd6c30dc19 717 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 718 goto failure;
RobMeades 118:f3fd6c30dc19 719 while (1) {
RobMeades 118:f3fd6c30dc19 720 // get the Telephone number
RobMeades 118:f3fd6c30dc19 721 sendFormated("AT$MDN?\r\n");
RobMeades 118:f3fd6c30dc19 722 if (RESP_OK != waitFinalResp(_cbString, _net.num))
mazgch 95:8282dbbe1492 723 goto failure;
RobMeades 118:f3fd6c30dc19 724 // check if we have a Mobile Directory Number
RobMeades 118:f3fd6c30dc19 725 if (*_net.num && (memcmp(_net.num, "000000", 6) != 0))
RobMeades 118:f3fd6c30dc19 726 break;
RobMeades 118:f3fd6c30dc19 727
RobMeades 118:f3fd6c30dc19 728 INFO("Device not yet activated\r\n");
RobMeades 118:f3fd6c30dc19 729 INFO("Make sure you have a valid contract with the network operator for this device.\r\n");
RobMeades 118:f3fd6c30dc19 730 // Check if the the version contains a V for Verizon
RobMeades 118:f3fd6c30dc19 731 // Verizon: E0.V.xx.00.xxR,
RobMeades 118:f3fd6c30dc19 732 // Sprint E0.S.xx.00.xxR
RobMeades 118:f3fd6c30dc19 733 if (_dev.ver[3] == 'V') {
RobMeades 118:f3fd6c30dc19 734 int i;
RobMeades 118:f3fd6c30dc19 735 INFO("Start device over-the-air activation (this can take a few minutes)\r\n");
RobMeades 118:f3fd6c30dc19 736 sendFormated("AT+CDV=*22899\r\n");
RobMeades 118:f3fd6c30dc19 737 i = 1;
RobMeades 118:f3fd6c30dc19 738 if ((RESP_OK != waitFinalResp(_cbUACTIND, &i, 120*1000)) || (i == 1)) {
RobMeades 118:f3fd6c30dc19 739 ERROR("Device over-the-air activation failed\r\n");
RobMeades 118:f3fd6c30dc19 740 goto failure;
RobMeades 118:f3fd6c30dc19 741 }
RobMeades 118:f3fd6c30dc19 742 INFO("Device over-the-air activation successful\r\n");
RobMeades 118:f3fd6c30dc19 743
RobMeades 118:f3fd6c30dc19 744 INFO("Start PRL over-the-air update (this can take a few minutes)\r\n");
RobMeades 118:f3fd6c30dc19 745 sendFormated("AT+CDV=*22891\r\n");
RobMeades 118:f3fd6c30dc19 746 i = 1;
RobMeades 118:f3fd6c30dc19 747 if ((RESP_OK != waitFinalResp(_cbUACTIND, &i, 120*1000)) || (i == 1)) {
RobMeades 118:f3fd6c30dc19 748 ERROR("PRL over-the-air update failed\r\n");
RobMeades 118:f3fd6c30dc19 749 goto failure;
RobMeades 118:f3fd6c30dc19 750 }
RobMeades 118:f3fd6c30dc19 751 INFO("PRL over-the-air update successful\r\n");
RobMeades 118:f3fd6c30dc19 752
RobMeades 118:f3fd6c30dc19 753 } else {
RobMeades 118:f3fd6c30dc19 754 // Sprint or Aeris
RobMeades 118:f3fd6c30dc19 755 INFO("Wait for OMA-DM over-the-air activation (this can take a few minutes)\r\n");
RobMeades 118:f3fd6c30dc19 756 wait_ms(120*1000);
mazgch 81:3966a5c17037 757 }
mazgch 81:3966a5c17037 758 }
RobMeades 118:f3fd6c30dc19 759 // get the the Network access identifier string
RobMeades 118:f3fd6c30dc19 760 char nai[64];
RobMeades 118:f3fd6c30dc19 761 sendFormated("AT$QCMIPNAI?\r\n");
RobMeades 118:f3fd6c30dc19 762 if (RESP_OK != waitFinalResp(_cbString, nai))
RobMeades 118:f3fd6c30dc19 763 goto failure;
RobMeades 118:f3fd6c30dc19 764 } else {
RobMeades 118:f3fd6c30dc19 765 sendFormated("AT+COPS?\r\n");
RobMeades 118:f3fd6c30dc19 766 if (RESP_OK != waitFinalResp(_cbCOPS, &_net))
RobMeades 118:f3fd6c30dc19 767 goto failure;
RobMeades 118:f3fd6c30dc19 768 // get the MSISDNs related to this subscriber
RobMeades 118:f3fd6c30dc19 769 sendFormated("AT+CNUM\r\n");
RobMeades 118:f3fd6c30dc19 770 if (RESP_OK != waitFinalResp(_cbCNUM, _net.num))
RobMeades 118:f3fd6c30dc19 771 goto failure;
RobMeades 118:f3fd6c30dc19 772 }
RobMeades 118:f3fd6c30dc19 773 // get the signal strength indication
RobMeades 118:f3fd6c30dc19 774 sendFormated("AT+CSQ\r\n");
RobMeades 118:f3fd6c30dc19 775 if (RESP_OK != waitFinalResp(_cbCSQ, &_net))
mazgch 95:8282dbbe1492 776 goto failure;
RobMeades 118:f3fd6c30dc19 777 }
mazgch 75:ce6e12067d0c 778 }
mazgch 28:4d9509e3b1cf 779 if (status) {
mazgch 31:a0bed6c1e05d 780 memcpy(status, &_net, sizeof(NetStatus));
mazgch 25:4045d02e44f1 781 }
RobMeades 118:f3fd6c30dc19 782 if (_dev.dev == DEV_LISA_N101) {
RobMeades 118:f3fd6c30dc19 783 ok = REG_DONE(_net.psd); // No CSD for the Neul modem
RobMeades 118:f3fd6c30dc19 784 } else {
RobMeades 118:f3fd6c30dc19 785 ok = REG_DONE(_net.csd) && REG_DONE(_net.psd);
RobMeades 118:f3fd6c30dc19 786 }
mazgch 95:8282dbbe1492 787 UNLOCK();
mazgch 95:8282dbbe1492 788 return ok;
mazgch 95:8282dbbe1492 789 failure:
mazgch 95:8282dbbe1492 790 unlock();
mazgch 95:8282dbbe1492 791 return false;
mazgch 31:a0bed6c1e05d 792 }
mazgch 31:a0bed6c1e05d 793
mazgch 31:a0bed6c1e05d 794 int MDMParser::_cbCOPS(int type, const char* buf, int len, NetStatus* status)
mazgch 31:a0bed6c1e05d 795 {
mazgch 31:a0bed6c1e05d 796 if ((type == TYPE_PLUS) && status){
mazgch 31:a0bed6c1e05d 797 int act = 99;
mazgch 31:a0bed6c1e05d 798 // +COPS: <mode>[,<format>,<oper>[,<AcT>]]
mazgch 31:a0bed6c1e05d 799 if (sscanf(buf, "\r\n+COPS: %*d,%*d,\"%[^\"]\",%d",status->opr,&act) >= 1) {
mazgch 31:a0bed6c1e05d 800 if (act == 0) status->act = ACT_GSM; // 0: GSM,
mazgch 31:a0bed6c1e05d 801 else if (act == 2) status->act = ACT_UTRAN; // 2: UTRAN
mazgch 31:a0bed6c1e05d 802 }
mazgch 31:a0bed6c1e05d 803 }
mazgch 31:a0bed6c1e05d 804 return WAIT;
mazgch 31:a0bed6c1e05d 805 }
mazgch 31:a0bed6c1e05d 806
mazgch 31:a0bed6c1e05d 807 int MDMParser::_cbCNUM(int type, const char* buf, int len, char* num)
mazgch 31:a0bed6c1e05d 808 {
mazgch 31:a0bed6c1e05d 809 if ((type == TYPE_PLUS) && num){
mazgch 31:a0bed6c1e05d 810 int a;
mazgch 31:a0bed6c1e05d 811 if ((sscanf(buf, "\r\n+CNUM: \"My Number\",\"%31[^\"]\",%d", num, &a) == 2) &&
mazgch 31:a0bed6c1e05d 812 ((a == 129) || (a == 145))) {
mazgch 31:a0bed6c1e05d 813 }
mazgch 31:a0bed6c1e05d 814 }
mazgch 31:a0bed6c1e05d 815 return WAIT;
mazgch 31:a0bed6c1e05d 816 }
mazgch 31:a0bed6c1e05d 817
mazgch 54:7ba8e4c218e2 818 int MDMParser::_cbCSQ(int type, const char* buf, int len, NetStatus* status)
mazgch 31:a0bed6c1e05d 819 {
mazgch 54:7ba8e4c218e2 820 if ((type == TYPE_PLUS) && status){
mazgch 54:7ba8e4c218e2 821 int a,b;
mazgch 54:7ba8e4c218e2 822 char _ber[] = { 49, 43, 37, 25, 19, 13, 7, 0 }; // see 3GPP TS 45.008 [20] subclause 8.2.4
mazgch 31:a0bed6c1e05d 823 // +CSQ: <rssi>,<qual>
mazgch 54:7ba8e4c218e2 824 if (sscanf(buf, "\r\n+CSQ: %d,%d",&a,&b) == 2) {
mazgch 54:7ba8e4c218e2 825 if (a != 99) status->rssi = -113 + 2*a; // 0: -113 1: -111 ... 30: -53 dBm with 2 dBm steps
mazgch 54:7ba8e4c218e2 826 if ((b != 99) && (b < sizeof(_ber))) status->ber = _ber[b]; //
mazgch 31:a0bed6c1e05d 827 }
mazgch 31:a0bed6c1e05d 828 }
mazgch 31:a0bed6c1e05d 829 return WAIT;
mazgch 31:a0bed6c1e05d 830 }
mazgch 21:c4d64830bf02 831
mazgch 81:3966a5c17037 832 int MDMParser::_cbUACTIND(int type, const char* buf, int len, int* i)
mazgch 81:3966a5c17037 833 {
mazgch 81:3966a5c17037 834 if ((type == TYPE_PLUS) && i){
mazgch 82:055dcfcf9dcc 835 int a;
mazgch 82:055dcfcf9dcc 836 if (sscanf(buf, "\r\n+UACTIND: %d", &a) == 1) {
mazgch 82:055dcfcf9dcc 837 *i = a;
mazgch 81:3966a5c17037 838 }
mazgch 81:3966a5c17037 839 }
mazgch 81:3966a5c17037 840 return WAIT;
mazgch 81:3966a5c17037 841 }
mazgch 81:3966a5c17037 842
RobMeades 118:f3fd6c30dc19 843 // Neul radio activity status
RobMeades 118:f3fd6c30dc19 844 int MDMParser::_cbRAS(int type, const char* buf, int len, bool* connected)
RobMeades 118:f3fd6c30dc19 845 {
RobMeades 118:f3fd6c30dc19 846 *connected = false;
RobMeades 118:f3fd6c30dc19 847 char status[32];
RobMeades 118:f3fd6c30dc19 848 if ((type == TYPE_PLUS) && connected) {
RobMeades 118:f3fd6c30dc19 849 // +RAS: <status>
RobMeades 118:f3fd6c30dc19 850 if (sscanf(buf, "\r\n+RAS:%s", status) == 1) {
RobMeades 118:f3fd6c30dc19 851 if (strcmp ("CONNECTED\r\n", status) == 0) {
RobMeades 118:f3fd6c30dc19 852 *connected = true;
RobMeades 118:f3fd6c30dc19 853 }
RobMeades 118:f3fd6c30dc19 854 return RESP_OK;
RobMeades 118:f3fd6c30dc19 855 }
RobMeades 118:f3fd6c30dc19 856 }
RobMeades 118:f3fd6c30dc19 857 return WAIT;
RobMeades 118:f3fd6c30dc19 858 }
RobMeades 118:f3fd6c30dc19 859
mazgch 21:c4d64830bf02 860 // ----------------------------------------------------------------
mazgch 21:c4d64830bf02 861 // internet connection
mazgch 21:c4d64830bf02 862
mazgch 79:291df065e345 863 MDMParser::IP MDMParser::join(const char* apn /*= NULL*/, const char* username /*= NULL*/,
mazgch 79:291df065e345 864 const char* password /*= NULL*/, Auth auth /*= AUTH_DETECT*/)
mazgch 21:c4d64830bf02 865 {
mazgch 95:8282dbbe1492 866 LOCK();
mazgch 78:caf0014375cb 867 INFO("Modem::join\r\n");
mazgch 32:8f12ac182bbb 868 _ip = NOIP;
mazgch 32:8f12ac182bbb 869 if (_dev.dev == DEV_LISA_C200) {
mazgch 76:f7c3dd568dae 870 // make a dumy dns lookup (which will fail, so ignore the result)
mazgch 76:f7c3dd568dae 871 sendFormated("AT+UDNSRN=0,\"u-blox.com\"\r\n");
mazgch 76:f7c3dd568dae 872 waitFinalResp();
mazgch 76:f7c3dd568dae 873 // This fake lookup will enable the IP connection and we
mazgch 76:f7c3dd568dae 874 // should have an IP after this, so we check it
mazgch 76:f7c3dd568dae 875
mazgch 21:c4d64830bf02 876 //Get local IP address
mazgch 21:c4d64830bf02 877 sendFormated("AT+CMIP?\r\n");
mazgch 52:8071747a7cb3 878 if (RESP_OK != waitFinalResp(_cbCMIP, &_ip))
mazgch 95:8282dbbe1492 879 goto failure;
mazgch 21:c4d64830bf02 880 } else {
mazgch 21:c4d64830bf02 881 // check gprs attach status
mazgch 72:d1e943ad6558 882 sendFormated("AT+CGATT=1\r\n");
mazgch 74:208e3e32d263 883 if (RESP_OK != waitFinalResp(NULL,NULL,3*60*1000))
mazgch 95:8282dbbe1492 884 goto failure;
mazgch 31:a0bed6c1e05d 885
mazgch 31:a0bed6c1e05d 886 // Check the profile
mazgch 31:a0bed6c1e05d 887 int a = 0;
mazgch 79:291df065e345 888 bool force = true;
mazgch 31:a0bed6c1e05d 889 sendFormated("AT+UPSND=" PROFILE ",8\r\n");
mazgch 52:8071747a7cb3 890 if (RESP_OK != waitFinalResp(_cbUPSND, &a))
mazgch 95:8282dbbe1492 891 goto failure;
mazgch 79:291df065e345 892 if (a == 1 && force) {
mazgch 31:a0bed6c1e05d 893 // disconnect the profile already if it is connected
mazgch 31:a0bed6c1e05d 894 sendFormated("AT+UPSDA=" PROFILE ",4\r\n");
mazgch 58:e38a2e942fbb 895 if (RESP_OK != waitFinalResp(NULL,NULL,40*1000))
mazgch 95:8282dbbe1492 896 goto failure;
mazgch 79:291df065e345 897 a = 0;
mazgch 31:a0bed6c1e05d 898 }
mazgch 79:291df065e345 899 if (a == 0) {
mazgch 84:a05edb010176 900 bool ok = false;
mazgch 84:a05edb010176 901 // try to lookup the apn settings from our local database by mccmnc
mazgch 84:a05edb010176 902 const char* config = NULL;
mazgch 88:135fb4bb7aac 903 if (!apn && !username && !password)
mazgch 88:135fb4bb7aac 904 config = apnconfig(_dev.imsi);
mazgch 84:a05edb010176 905
mazgch 79:291df065e345 906 // Set up the dynamic IP address assignment.
mazgch 79:291df065e345 907 sendFormated("AT+UPSD=" PROFILE ",7,\"0.0.0.0\"\r\n");
mazgch 52:8071747a7cb3 908 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 909 goto failure;
mazgch 84:a05edb010176 910
mazgch 84:a05edb010176 911 do {
mazgch 84:a05edb010176 912 if (config) {
mazgch 85:dd8f4f0d0ca9 913 apn = _APN_GET(config);
mazgch 85:dd8f4f0d0ca9 914 username = _APN_GET(config);
mazgch 85:dd8f4f0d0ca9 915 password = _APN_GET(config);
mazgch 84:a05edb010176 916 TRACE("Testing APN Settings(\"%s\",\"%s\",\"%s\")\r\n", apn, username, password);
mazgch 79:291df065e345 917 }
mazgch 84:a05edb010176 918 // Set up the APN
mazgch 90:3915192f6d7e 919 if (apn && *apn) {
mazgch 90:3915192f6d7e 920 sendFormated("AT+UPSD=" PROFILE ",1,\"%s\"\r\n", apn);
mazgch 90:3915192f6d7e 921 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 922 goto failure;
mazgch 90:3915192f6d7e 923 }
mazgch 90:3915192f6d7e 924 if (username && *username) {
mazgch 90:3915192f6d7e 925 sendFormated("AT+UPSD=" PROFILE ",2,\"%s\"\r\n", username);
mazgch 90:3915192f6d7e 926 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 927 goto failure;
mazgch 90:3915192f6d7e 928 }
mazgch 90:3915192f6d7e 929 if (password && *password) {
mazgch 90:3915192f6d7e 930 sendFormated("AT+UPSD=" PROFILE ",3,\"%s\"\r\n", password);
mazgch 90:3915192f6d7e 931 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 932 goto failure;
mazgch 90:3915192f6d7e 933 }
mazgch 84:a05edb010176 934 // try different Authentication Protocols
mazgch 84:a05edb010176 935 // 0 = none
mazgch 84:a05edb010176 936 // 1 = PAP (Password Authentication Protocol)
mazgch 84:a05edb010176 937 // 2 = CHAP (Challenge Handshake Authentication Protocol)
mazgch 84:a05edb010176 938 for (int i = AUTH_NONE; i <= AUTH_CHAP && !ok; i ++) {
mazgch 84:a05edb010176 939 if ((auth == AUTH_DETECT) || (auth == i)) {
mazgch 84:a05edb010176 940 // Set up the Authentication Protocol
mazgch 84:a05edb010176 941 sendFormated("AT+UPSD=" PROFILE ",6,%d\r\n", i);
mazgch 84:a05edb010176 942 if (RESP_OK != waitFinalResp())
mazgch 95:8282dbbe1492 943 goto failure;
mazgch 84:a05edb010176 944 // Activate the profile and make connection
mazgch 84:a05edb010176 945 sendFormated("AT+UPSDA=" PROFILE ",3\r\n");
mazgch 84:a05edb010176 946 if (RESP_OK == waitFinalResp(NULL,NULL,150*1000))
mazgch 84:a05edb010176 947 ok = true;
mazgch 84:a05edb010176 948 }
mazgch 84:a05edb010176 949 }
mazgch 99:3116d3e900ed 950 } while (!ok && config && *config); // maybe use next setting ?
mazgch 84:a05edb010176 951 if (!ok) {
mazgch 79:291df065e345 952 ERROR("Your modem APN/password/username may be wrong\r\n");
mazgch 95:8282dbbe1492 953 goto failure;
mazgch 79:291df065e345 954 }
mazgch 74:208e3e32d263 955 }
mazgch 21:c4d64830bf02 956 //Get local IP address
mazgch 21:c4d64830bf02 957 sendFormated("AT+UPSND=" PROFILE ",0\r\n");
mazgch 52:8071747a7cb3 958 if (RESP_OK != waitFinalResp(_cbUPSND, &_ip))
mazgch 95:8282dbbe1492 959 goto failure;
mazgch 31:a0bed6c1e05d 960 }
mazgch 95:8282dbbe1492 961 UNLOCK();
mazgch 32:8f12ac182bbb 962 return _ip;
mazgch 95:8282dbbe1492 963 failure:
mazgch 95:8282dbbe1492 964 unlock();
mazgch 95:8282dbbe1492 965 return NOIP;
mazgch 31:a0bed6c1e05d 966 }
mazgch 31:a0bed6c1e05d 967
mazgch 84:a05edb010176 968 int MDMParser::_cbUDOPN(int type, const char* buf, int len, char* mccmnc)
mazgch 84:a05edb010176 969 {
mazgch 84:a05edb010176 970 if ((type == TYPE_PLUS) && mccmnc) {
mazgch 84:a05edb010176 971 if (sscanf(buf, "\r\n+UDOPN: 0,\"%[^\"]\"", mccmnc) == 1)
mazgch 84:a05edb010176 972 ;
mazgch 84:a05edb010176 973 }
mazgch 84:a05edb010176 974 return WAIT;
mazgch 84:a05edb010176 975 }
mazgch 84:a05edb010176 976
mazgch 32:8f12ac182bbb 977 int MDMParser::_cbCMIP(int type, const char* buf, int len, IP* ip)
mazgch 32:8f12ac182bbb 978 {
mazgch 102:fb982ff9da82 979 if ((type == TYPE_UNKNOWN) && ip) {
mazgch 32:8f12ac182bbb 980 int a,b,c,d;
mazgch 102:fb982ff9da82 981 if (sscanf(buf, "\r\n" IPSTR, &a,&b,&c,&d) == 4)
mazgch 32:8f12ac182bbb 982 *ip = IPADR(a,b,c,d);
mazgch 32:8f12ac182bbb 983 }
mazgch 32:8f12ac182bbb 984 return WAIT;
mazgch 32:8f12ac182bbb 985 }
mazgch 32:8f12ac182bbb 986
mazgch 31:a0bed6c1e05d 987 int MDMParser::_cbUPSND(int type, const char* buf, int len, int* act)
mazgch 31:a0bed6c1e05d 988 {
mazgch 31:a0bed6c1e05d 989 if ((type == TYPE_PLUS) && act) {
mazgch 31:a0bed6c1e05d 990 if (sscanf(buf, "\r\n+UPSND: %*d,%*d,%d", act) == 1)
mazgch 31:a0bed6c1e05d 991 /*nothing*/;
mazgch 21:c4d64830bf02 992 }
mazgch 31:a0bed6c1e05d 993 return WAIT;
mazgch 31:a0bed6c1e05d 994 }
mazgch 31:a0bed6c1e05d 995
mazgch 31:a0bed6c1e05d 996 int MDMParser::_cbUPSND(int type, const char* buf, int len, IP* ip)
mazgch 31:a0bed6c1e05d 997 {
mazgch 31:a0bed6c1e05d 998 if ((type == TYPE_PLUS) && ip) {
mazgch 31:a0bed6c1e05d 999 int a,b,c,d;
mazgch 31:a0bed6c1e05d 1000 // +UPSND=<profile_id>,<param_tag>[,<dynamic_param_val>]
mazgch 31:a0bed6c1e05d 1001 if (sscanf(buf, "\r\n+UPSND: " PROFILE ",0,\"" IPSTR "\"", &a,&b,&c,&d) == 4)
mazgch 31:a0bed6c1e05d 1002 *ip = IPADR(a,b,c,d);
mazgch 31:a0bed6c1e05d 1003 }
mazgch 31:a0bed6c1e05d 1004 return WAIT;
mazgch 31:a0bed6c1e05d 1005 }
mazgch 31:a0bed6c1e05d 1006
mazgch 31:a0bed6c1e05d 1007 int MDMParser::_cbUDNSRN(int type, const char* buf, int len, IP* ip)
mazgch 31:a0bed6c1e05d 1008 {
mazgch 31:a0bed6c1e05d 1009 if ((type == TYPE_PLUS) && ip) {
mazgch 31:a0bed6c1e05d 1010 int a,b,c,d;
mazgch 95:8282dbbe1492 1011 if (sscanf(buf, "\r\n+UDNSRN: \"" IPSTR "\"", &a,&b,&c,&d) == 4)
mazgch 31:a0bed6c1e05d 1012 *ip = IPADR(a,b,c,d);
mazgch 31:a0bed6c1e05d 1013 }
mazgch 31:a0bed6c1e05d 1014 return WAIT;
mazgch 21:c4d64830bf02 1015 }
mazgch 21:c4d64830bf02 1016
mazgch 21:c4d64830bf02 1017 bool MDMParser::disconnect(void)
mazgch 21:c4d64830bf02 1018 {
mazgch 95:8282dbbe1492 1019 bool ok = false;
mazgch 95:8282dbbe1492 1020 LOCK();
mazgch 74:208e3e32d263 1021 INFO("Modem::disconnect\r\n");
mazgch 95:8282dbbe1492 1022 if (_ip != NOIP) {
mazgch 95:8282dbbe1492 1023 if (_dev.dev == DEV_LISA_C200) {
mazgch 95:8282dbbe1492 1024 // There something to do here
mazgch 95:8282dbbe1492 1025 _ip = NOIP;
mazgch 95:8282dbbe1492 1026 ok = true;
mazgch 95:8282dbbe1492 1027 } else {
mazgch 95:8282dbbe1492 1028 sendFormated("AT+UPSDA=" PROFILE ",4\r\n");
mazgch 95:8282dbbe1492 1029 if (RESP_OK != waitFinalResp()) {
mazgch 95:8282dbbe1492 1030 _ip = NOIP;
mazgch 95:8282dbbe1492 1031 ok = true;
mazgch 95:8282dbbe1492 1032 }
mazgch 95:8282dbbe1492 1033 }
mazgch 21:c4d64830bf02 1034 }
mazgch 95:8282dbbe1492 1035 UNLOCK();
mazgch 95:8282dbbe1492 1036 return ok;
mazgch 21:c4d64830bf02 1037 }
mazgch 21:c4d64830bf02 1038
mazgch 31:a0bed6c1e05d 1039 MDMParser::IP MDMParser::gethostbyname(const char* host)
mazgch 21:c4d64830bf02 1040 {
mazgch 31:a0bed6c1e05d 1041 IP ip = NOIP;
mazgch 31:a0bed6c1e05d 1042 int a,b,c,d;
mazgch 31:a0bed6c1e05d 1043 if (sscanf(host, IPSTR, &a,&b,&c,&d) == 4)
mazgch 31:a0bed6c1e05d 1044 ip = IPADR(a,b,c,d);
mazgch 31:a0bed6c1e05d 1045 else {
mazgch 95:8282dbbe1492 1046 LOCK();
mazgch 31:a0bed6c1e05d 1047 sendFormated("AT+UDNSRN=0,\"%s\"\r\n", host);
mazgch 52:8071747a7cb3 1048 if (RESP_OK != waitFinalResp(_cbUDNSRN, &ip))
mazgch 95:8282dbbe1492 1049 ip = NOIP;
mazgch 95:8282dbbe1492 1050 UNLOCK();
mazgch 21:c4d64830bf02 1051 }
mazgch 31:a0bed6c1e05d 1052 return ip;
mazgch 21:c4d64830bf02 1053 }
mazgch 21:c4d64830bf02 1054
mazgch 21:c4d64830bf02 1055 // ----------------------------------------------------------------
mazgch 21:c4d64830bf02 1056 // sockets
mazgch 21:c4d64830bf02 1057
mazgch 103:197fa7920ad8 1058 int MDMParser::_cbUSOCR(int type, const char* buf, int len, int* handle)
mazgch 21:c4d64830bf02 1059 {
mazgch 103:197fa7920ad8 1060 if ((type == TYPE_PLUS) && handle) {
mazgch 108:254bf037f83f 1061 // +USOCR: socket
mazgch 108:254bf037f83f 1062 if (sscanf(buf, "\r\n+USOCR: %d", handle) == 1)
mazgch 108:254bf037f83f 1063 /*nothing*/;
mazgch 21:c4d64830bf02 1064 }
mazgch 21:c4d64830bf02 1065 return WAIT;
mazgch 21:c4d64830bf02 1066 }
mazgch 21:c4d64830bf02 1067
mazgch 63:42cb563a25bc 1068 int MDMParser::socketSocket(IpProtocol ipproto, int port)
mazgch 21:c4d64830bf02 1069 {
mazgch 103:197fa7920ad8 1070 int socket;
mazgch 95:8282dbbe1492 1071 LOCK();
mazgch 103:197fa7920ad8 1072 // find an free socket
mazgch 103:197fa7920ad8 1073 socket = _findSocket();
mazgch 47:9a89e5195721 1074 TRACE("socketSocket(%d)\r\n", ipproto);
mazgch 95:8282dbbe1492 1075 if (socket != SOCKET_ERROR) {
mazgch 106:18aeacdae391 1076 if (ipproto == IPPROTO_UDP) {
mazgch 106:18aeacdae391 1077 // sending port can only be set on 2G/3G modules
mazgch 106:18aeacdae391 1078 if ((port != -1) && (_dev.dev != DEV_LISA_C200)) {
mazgch 106:18aeacdae391 1079 sendFormated("AT+USOCR=17,%d\r\n", port);
mazgch 106:18aeacdae391 1080 } else {
mazgch 106:18aeacdae391 1081 sendFormated("AT+USOCR=17\r\n");
mazgch 106:18aeacdae391 1082 }
mazgch 103:197fa7920ad8 1083 } else /*(ipproto == IPPROTO_TCP)*/ {
mazgch 103:197fa7920ad8 1084 sendFormated("AT+USOCR=6\r\n");
mazgch 103:197fa7920ad8 1085 }
mazgch 103:197fa7920ad8 1086 int handle = SOCKET_ERROR;
mazgch 103:197fa7920ad8 1087 if ((RESP_OK == waitFinalResp(_cbUSOCR, &handle)) &&
mazgch 103:197fa7920ad8 1088 (handle != SOCKET_ERROR)) {
mazgch 103:197fa7920ad8 1089 TRACE("Socket %d: handle %d was created\r\n", socket, handle);
mazgch 103:197fa7920ad8 1090 _sockets[socket].handle = handle;
mazgch 103:197fa7920ad8 1091 _sockets[socket].timeout_ms = TIMEOUT_BLOCKING;
mazgch 103:197fa7920ad8 1092 _sockets[socket].connected = false;
mazgch 103:197fa7920ad8 1093 _sockets[socket].pending = 0;
mazgch 103:197fa7920ad8 1094 }
mazgch 103:197fa7920ad8 1095 else
mazgch 103:197fa7920ad8 1096 socket = SOCKET_ERROR;
mazgch 95:8282dbbe1492 1097 }
mazgch 95:8282dbbe1492 1098 UNLOCK();
mazgch 21:c4d64830bf02 1099 return socket;
mazgch 21:c4d64830bf02 1100 }
mazgch 21:c4d64830bf02 1101
mazgch 21:c4d64830bf02 1102 bool MDMParser::socketConnect(int socket, const char * host, int port)
mazgch 21:c4d64830bf02 1103 {
mazgch 31:a0bed6c1e05d 1104 IP ip = gethostbyname(host);
mazgch 31:a0bed6c1e05d 1105 if (ip == NOIP)
mazgch 21:c4d64830bf02 1106 return false;
mazgch 21:c4d64830bf02 1107 // connect to socket
mazgch 95:8282dbbe1492 1108 bool ok = false;
mazgch 95:8282dbbe1492 1109 LOCK();
mazgch 103:197fa7920ad8 1110 if (ISSOCKET(socket) && (!_sockets[socket].connected)) {
mazgch 95:8282dbbe1492 1111 TRACE("socketConnect(%d,%s,%d)\r\n", socket,host,port);
mazgch 103:197fa7920ad8 1112 sendFormated("AT+USOCO=%d,\"" IPSTR "\",%d\r\n", _sockets[socket].handle, IPNUM(ip), port);
mazgch 95:8282dbbe1492 1113 if (RESP_OK == waitFinalResp())
mazgch 103:197fa7920ad8 1114 ok = _sockets[socket].connected = true;
mazgch 95:8282dbbe1492 1115 }
mazgch 95:8282dbbe1492 1116 UNLOCK();
mazgch 95:8282dbbe1492 1117 return ok;
mazgch 21:c4d64830bf02 1118 }
mazgch 21:c4d64830bf02 1119
mazgch 44:9d12223b78ff 1120 bool MDMParser::socketIsConnected(int socket)
mazgch 44:9d12223b78ff 1121 {
mazgch 95:8282dbbe1492 1122 bool ok = false;
mazgch 95:8282dbbe1492 1123 LOCK();
mazgch 103:197fa7920ad8 1124 ok = ISSOCKET(socket) && _sockets[socket].connected;
mazgch 107:436ee320efd6 1125 TRACE("socketIsConnected(%d) %s\r\n", socket, ok?"yes":"no");
mazgch 95:8282dbbe1492 1126 UNLOCK();
mazgch 95:8282dbbe1492 1127 return ok;
mazgch 44:9d12223b78ff 1128 }
mazgch 44:9d12223b78ff 1129
mazgch 66:69072b3c5bca 1130 bool MDMParser::socketSetBlocking(int socket, int timeout_ms)
mazgch 44:9d12223b78ff 1131 {
mazgch 95:8282dbbe1492 1132 bool ok = false;
mazgch 95:8282dbbe1492 1133 LOCK();
mazgch 103:197fa7920ad8 1134 TRACE("socketSetBlocking(%d,%d)\r\n", socket,timeout_ms);
mazgch 95:8282dbbe1492 1135 if (ISSOCKET(socket)) {
mazgch 95:8282dbbe1492 1136 _sockets[socket].timeout_ms = timeout_ms;
mazgch 95:8282dbbe1492 1137 ok = true;
mazgch 95:8282dbbe1492 1138 }
mazgch 95:8282dbbe1492 1139 UNLOCK();
mazgch 95:8282dbbe1492 1140 return ok;
mazgch 44:9d12223b78ff 1141 }
mazgch 44:9d12223b78ff 1142
mazgch 21:c4d64830bf02 1143 bool MDMParser::socketClose(int socket)
mazgch 21:c4d64830bf02 1144 {
mazgch 95:8282dbbe1492 1145 bool ok = false;
mazgch 95:8282dbbe1492 1146 LOCK();
mazgch 103:197fa7920ad8 1147 if (ISSOCKET(socket) && _sockets[socket].connected) {
mazgch 95:8282dbbe1492 1148 TRACE("socketClose(%d)\r\n", socket);
mazgch 103:197fa7920ad8 1149 sendFormated("AT+USOCL=%d\r\n", _sockets[socket].handle);
mazgch 95:8282dbbe1492 1150 if (RESP_OK == waitFinalResp()) {
mazgch 103:197fa7920ad8 1151 _sockets[socket].connected = false;
mazgch 95:8282dbbe1492 1152 ok = true;
mazgch 95:8282dbbe1492 1153 }
mazgch 95:8282dbbe1492 1154 }
mazgch 95:8282dbbe1492 1155 UNLOCK();
mazgch 95:8282dbbe1492 1156 return ok;
mazgch 21:c4d64830bf02 1157 }
mazgch 21:c4d64830bf02 1158
mazgch 21:c4d64830bf02 1159 bool MDMParser::socketFree(int socket)
mazgch 21:c4d64830bf02 1160 {
mazgch 95:8282dbbe1492 1161 // make sure it is closed
mazgch 21:c4d64830bf02 1162 socketClose(socket);
mazgch 95:8282dbbe1492 1163 bool ok = true;
mazgch 95:8282dbbe1492 1164 LOCK();
mazgch 103:197fa7920ad8 1165 if (ISSOCKET(socket)) {
mazgch 103:197fa7920ad8 1166 TRACE("socketFree(%d)\r\n", socket);
mazgch 103:197fa7920ad8 1167 _sockets[socket].handle = SOCKET_ERROR;
mazgch 103:197fa7920ad8 1168 _sockets[socket].timeout_ms = TIMEOUT_BLOCKING;
mazgch 103:197fa7920ad8 1169 _sockets[socket].connected = false;
mazgch 103:197fa7920ad8 1170 _sockets[socket].pending = 0;
mazgch 95:8282dbbe1492 1171 ok = true;
mazgch 95:8282dbbe1492 1172 }
mazgch 95:8282dbbe1492 1173 UNLOCK();
mazgch 95:8282dbbe1492 1174 return ok;
mazgch 21:c4d64830bf02 1175 }
mazgch 21:c4d64830bf02 1176
mazgch 69:4d6fa520dfca 1177 #define USO_MAX_WRITE 1024 //!< maximum number of bytes to write to socket
mazgch 69:4d6fa520dfca 1178
mazgch 21:c4d64830bf02 1179 int MDMParser::socketSend(int socket, const char * buf, int len)
mazgch 21:c4d64830bf02 1180 {
mazgch 47:9a89e5195721 1181 TRACE("socketSend(%d,,%d)\r\n", socket,len);
mazgch 68:33a96cf64986 1182 int cnt = len;
mazgch 68:33a96cf64986 1183 while (cnt > 0) {
mazgch 69:4d6fa520dfca 1184 int blk = USO_MAX_WRITE;
mazgch 68:33a96cf64986 1185 if (cnt < blk)
mazgch 68:33a96cf64986 1186 blk = cnt;
mazgch 95:8282dbbe1492 1187 bool ok = false;
mazgch 95:8282dbbe1492 1188 LOCK();
mazgch 103:197fa7920ad8 1189 if (ISSOCKET(socket)) {
mazgch 103:197fa7920ad8 1190 sendFormated("AT+USOWR=%d,%d\r\n",_sockets[socket].handle,blk);
mazgch 103:197fa7920ad8 1191 if (RESP_PROMPT == waitFinalResp()) {
mazgch 103:197fa7920ad8 1192 wait_ms(50);
mazgch 103:197fa7920ad8 1193 send(buf, blk);
mazgch 103:197fa7920ad8 1194 if (RESP_OK == waitFinalResp())
mazgch 103:197fa7920ad8 1195 ok = true;
mazgch 103:197fa7920ad8 1196 }
mazgch 95:8282dbbe1492 1197 }
mazgch 95:8282dbbe1492 1198 UNLOCK();
mazgch 95:8282dbbe1492 1199 if (!ok)
mazgch 21:c4d64830bf02 1200 return SOCKET_ERROR;
mazgch 68:33a96cf64986 1201 buf += blk;
mazgch 68:33a96cf64986 1202 cnt -= blk;
mazgch 21:c4d64830bf02 1203 }
mazgch 68:33a96cf64986 1204 return (len - cnt);
mazgch 21:c4d64830bf02 1205 }
mazgch 21:c4d64830bf02 1206
mazgch 21:c4d64830bf02 1207 int MDMParser::socketSendTo(int socket, IP ip, int port, const char * buf, int len)
mazgch 21:c4d64830bf02 1208 {
mazgch 103:197fa7920ad8 1209 TRACE("socketSendTo(%d," IPSTR ",%d,,%d)\r\n", socket,IPNUM(ip),port,len);
mazgch 68:33a96cf64986 1210 int cnt = len;
mazgch 68:33a96cf64986 1211 while (cnt > 0) {
mazgch 69:4d6fa520dfca 1212 int blk = USO_MAX_WRITE;
mazgch 68:33a96cf64986 1213 if (cnt < blk)
mazgch 68:33a96cf64986 1214 blk = cnt;
mazgch 95:8282dbbe1492 1215 bool ok = false;
mazgch 95:8282dbbe1492 1216 LOCK();
mazgch 103:197fa7920ad8 1217 if (ISSOCKET(socket)) {
mazgch 103:197fa7920ad8 1218 sendFormated("AT+USOST=%d,\"" IPSTR "\",%d,%d\r\n",_sockets[socket].handle,IPNUM(ip),port,blk);
mazgch 103:197fa7920ad8 1219 if (RESP_PROMPT == waitFinalResp()) {
mazgch 103:197fa7920ad8 1220 wait_ms(50);
mazgch 103:197fa7920ad8 1221 send(buf, blk);
mazgch 103:197fa7920ad8 1222 if (RESP_OK == waitFinalResp())
mazgch 103:197fa7920ad8 1223 ok = true;
mazgch 103:197fa7920ad8 1224 }
mazgch 95:8282dbbe1492 1225 }
mazgch 95:8282dbbe1492 1226 UNLOCK();
mazgch 95:8282dbbe1492 1227 if (!ok)
mazgch 21:c4d64830bf02 1228 return SOCKET_ERROR;
mazgch 68:33a96cf64986 1229 buf += blk;
mazgch 68:33a96cf64986 1230 cnt -= blk;
mazgch 21:c4d64830bf02 1231 }
mazgch 68:33a96cf64986 1232 return (len - cnt);
mazgch 21:c4d64830bf02 1233 }
mazgch 21:c4d64830bf02 1234
mazgch 21:c4d64830bf02 1235 int MDMParser::socketReadable(int socket)
mazgch 21:c4d64830bf02 1236 {
mazgch 95:8282dbbe1492 1237 int pending = SOCKET_ERROR;
mazgch 95:8282dbbe1492 1238 LOCK();
mazgch 103:197fa7920ad8 1239 if (ISSOCKET(socket) && _sockets[socket].connected) {
mazgch 95:8282dbbe1492 1240 TRACE("socketReadable(%d)\r\n", socket);
mazgch 95:8282dbbe1492 1241 // allow to receive unsolicited commands
mazgch 95:8282dbbe1492 1242 waitFinalResp(NULL, NULL, 0);
mazgch 103:197fa7920ad8 1243 if (_sockets[socket].connected)
mazgch 95:8282dbbe1492 1244 pending = _sockets[socket].pending;
mazgch 95:8282dbbe1492 1245 }
mazgch 95:8282dbbe1492 1246 UNLOCK();
mazgch 95:8282dbbe1492 1247 return pending;
mazgch 21:c4d64830bf02 1248 }
mazgch 21:c4d64830bf02 1249
mazgch 21:c4d64830bf02 1250 int MDMParser::_cbUSORD(int type, const char* buf, int len, char* out)
mazgch 21:c4d64830bf02 1251 {
mazgch 21:c4d64830bf02 1252 if ((type == TYPE_PLUS) && out) {
mazgch 21:c4d64830bf02 1253 int sz, sk;
mazgch 21:c4d64830bf02 1254 if ((sscanf(buf, "\r\n+USORD: %d,%d,", &sk, &sz) == 2) &&
mazgch 21:c4d64830bf02 1255 (buf[len-sz-2] == '\"') && (buf[len-1] == '\"')) {
mazgch 21:c4d64830bf02 1256 memcpy(out, &buf[len-1-sz], sz);
mazgch 21:c4d64830bf02 1257 }
mazgch 21:c4d64830bf02 1258 }
mazgch 21:c4d64830bf02 1259 return WAIT;
mazgch 21:c4d64830bf02 1260 }
mazgch 21:c4d64830bf02 1261
mazgch 21:c4d64830bf02 1262 int MDMParser::socketRecv(int socket, char* buf, int len)
mazgch 21:c4d64830bf02 1263 {
mazgch 21:c4d64830bf02 1264 int cnt = 0;
mazgch 47:9a89e5195721 1265 TRACE("socketRecv(%d,,%d)\r\n", socket, len);
mazgch 95:8282dbbe1492 1266 #ifdef MDM_DEBUG
mazgch 21:c4d64830bf02 1267 memset(buf, '\0', len);
mazgch 95:8282dbbe1492 1268 #endif
mazgch 44:9d12223b78ff 1269 Timer timer;
mazgch 44:9d12223b78ff 1270 timer.start();
mazgch 21:c4d64830bf02 1271 while (len) {
mazgch 69:4d6fa520dfca 1272 int blk = MAX_SIZE; // still need space for headers and unsolicited commands
mazgch 21:c4d64830bf02 1273 if (len < blk) blk = len;
mazgch 95:8282dbbe1492 1274 bool ok = false;
mazgch 95:8282dbbe1492 1275 LOCK();
mazgch 95:8282dbbe1492 1276 if (ISSOCKET(socket)) {
mazgch 103:197fa7920ad8 1277 if (_sockets[socket].connected) {
mazgch 95:8282dbbe1492 1278 if (_sockets[socket].pending < blk)
mazgch 95:8282dbbe1492 1279 blk = _sockets[socket].pending;
mazgch 95:8282dbbe1492 1280 if (blk > 0) {
mazgch 103:197fa7920ad8 1281 sendFormated("AT+USORD=%d,%d\r\n",_sockets[socket].handle, blk);
mazgch 95:8282dbbe1492 1282 if (RESP_OK == waitFinalResp(_cbUSORD, buf)) {
mazgch 95:8282dbbe1492 1283 _sockets[socket].pending -= blk;
mazgch 95:8282dbbe1492 1284 len -= blk;
mazgch 95:8282dbbe1492 1285 cnt += blk;
mazgch 95:8282dbbe1492 1286 buf += blk;
mazgch 95:8282dbbe1492 1287 ok = true;
mazgch 95:8282dbbe1492 1288 }
mazgch 95:8282dbbe1492 1289 } else if (!TIMEOUT(timer, _sockets[socket].timeout_ms)) {
mazgch 95:8282dbbe1492 1290 ok = (WAIT == waitFinalResp(NULL,NULL,0)); // wait for URCs
mazgch 95:8282dbbe1492 1291 } else {
mazgch 95:8282dbbe1492 1292 len = 0;
mazgch 95:8282dbbe1492 1293 ok = true;
mazgch 95:8282dbbe1492 1294 }
mazgch 103:197fa7920ad8 1295 } else {
mazgch 95:8282dbbe1492 1296 len = 0;
mazgch 95:8282dbbe1492 1297 ok = true;
mazgch 21:c4d64830bf02 1298 }
mazgch 21:c4d64830bf02 1299 }
mazgch 95:8282dbbe1492 1300 UNLOCK();
mazgch 107:436ee320efd6 1301 if (!ok) {
mazgch 107:436ee320efd6 1302 TRACE("socketRecv: ERROR\r\n");
mazgch 95:8282dbbe1492 1303 return SOCKET_ERROR;
mazgch 107:436ee320efd6 1304 }
mazgch 21:c4d64830bf02 1305 }
mazgch 107:436ee320efd6 1306 TRACE("socketRecv: %d \"%*s\"\r\n", cnt, cnt, buf-cnt);
mazgch 21:c4d64830bf02 1307 return cnt;
mazgch 21:c4d64830bf02 1308 }
mazgch 21:c4d64830bf02 1309
mazgch 21:c4d64830bf02 1310 int MDMParser::_cbUSORF(int type, const char* buf, int len, USORFparam* param)
mazgch 21:c4d64830bf02 1311 {
mazgch 21:c4d64830bf02 1312 if ((type == TYPE_PLUS) && param) {
mazgch 21:c4d64830bf02 1313 int sz, sk, p, a,b,c,d;
mazgch 95:8282dbbe1492 1314 int r = sscanf(buf, "\r\n+USORF: %d,\"" IPSTR "\",%d,%d,",
mazgch 95:8282dbbe1492 1315 &sk,&a,&b,&c,&d,&p,&sz);
mazgch 95:8282dbbe1492 1316 if ((r == 7) && (buf[len-sz-2] == '\"') && (buf[len-1] == '\"')) {
mazgch 21:c4d64830bf02 1317 memcpy(param->buf, &buf[len-1-sz], sz);
mazgch 21:c4d64830bf02 1318 param->ip = IPADR(a,b,c,d);
mazgch 21:c4d64830bf02 1319 param->port = p;
mazgch 21:c4d64830bf02 1320 }
mazgch 21:c4d64830bf02 1321 }
mazgch 21:c4d64830bf02 1322 return WAIT;
mazgch 21:c4d64830bf02 1323 }
mazgch 21:c4d64830bf02 1324
mazgch 63:42cb563a25bc 1325 int MDMParser::socketRecvFrom(int socket, IP* ip, int* port, char* buf, int len)
mazgch 21:c4d64830bf02 1326 {
mazgch 21:c4d64830bf02 1327 int cnt = 0;
mazgch 63:42cb563a25bc 1328 TRACE("socketRecvFrom(%d,,%d)\r\n", socket, len);
mazgch 95:8282dbbe1492 1329 #ifdef MDM_DEBUG
mazgch 21:c4d64830bf02 1330 memset(buf, '\0', len);
mazgch 95:8282dbbe1492 1331 #endif
mazgch 44:9d12223b78ff 1332 Timer timer;
mazgch 44:9d12223b78ff 1333 timer.start();
mazgch 21:c4d64830bf02 1334 while (len) {
mazgch 69:4d6fa520dfca 1335 int blk = MAX_SIZE; // still need space for headers and unsolicited commands
mazgch 21:c4d64830bf02 1336 if (len < blk) blk = len;
mazgch 95:8282dbbe1492 1337 bool ok = false;
mazgch 95:8282dbbe1492 1338 LOCK();
mazgch 95:8282dbbe1492 1339 if (ISSOCKET(socket)) {
mazgch 95:8282dbbe1492 1340 if (_sockets[socket].pending < blk)
mazgch 95:8282dbbe1492 1341 blk = _sockets[socket].pending;
mazgch 95:8282dbbe1492 1342 if (blk > 0) {
mazgch 103:197fa7920ad8 1343 sendFormated("AT+USORF=%d,%d\r\n",_sockets[socket].handle, blk);
mazgch 95:8282dbbe1492 1344 USORFparam param;
mazgch 95:8282dbbe1492 1345 param.buf = buf;
mazgch 95:8282dbbe1492 1346 if (RESP_OK == waitFinalResp(_cbUSORF, &param)) {
mazgch 95:8282dbbe1492 1347 _sockets[socket].pending -= blk;
mazgch 95:8282dbbe1492 1348 *ip = param.ip;
mazgch 95:8282dbbe1492 1349 *port = param.port;
mazgch 95:8282dbbe1492 1350 len -= blk;
mazgch 95:8282dbbe1492 1351 cnt += blk;
mazgch 95:8282dbbe1492 1352 buf += blk;
mazgch 95:8282dbbe1492 1353 len = 0; // done
mazgch 95:8282dbbe1492 1354 ok = true;
mazgch 95:8282dbbe1492 1355 }
mazgch 95:8282dbbe1492 1356 } else if (!TIMEOUT(timer, _sockets[socket].timeout_ms)) {
mazgch 95:8282dbbe1492 1357 ok = (WAIT == waitFinalResp(NULL,NULL,0)); // wait for URCs
mazgch 95:8282dbbe1492 1358 } else {
mazgch 95:8282dbbe1492 1359 len = 0; // no more data and socket closed or timed-out
mazgch 95:8282dbbe1492 1360 ok = true;
mazgch 21:c4d64830bf02 1361 }
mazgch 95:8282dbbe1492 1362 }
mazgch 95:8282dbbe1492 1363 UNLOCK();
mazgch 107:436ee320efd6 1364 if (!ok) {
mazgch 107:436ee320efd6 1365 TRACE("socketRecv: ERROR\r\n");
mazgch 95:8282dbbe1492 1366 return SOCKET_ERROR;
mazgch 107:436ee320efd6 1367 }
mazgch 21:c4d64830bf02 1368 }
mazgch 44:9d12223b78ff 1369 timer.stop();
mazgch 44:9d12223b78ff 1370 timer.reset();
mazgch 107:436ee320efd6 1371 TRACE("socketRecv: %d \"%*s\"\r\n", cnt, cnt, buf-cnt);
mazgch 21:c4d64830bf02 1372 return cnt;
mazgch 21:c4d64830bf02 1373 }
mazgch 21:c4d64830bf02 1374
mazgch 103:197fa7920ad8 1375 int MDMParser::_findSocket(int handle) {
mazgch 104:c64ba749a422 1376 for (int socket = 0; socket < NUMSOCKETS; socket ++) {
mazgch 103:197fa7920ad8 1377 if (_sockets[socket].handle == handle)
mazgch 103:197fa7920ad8 1378 return socket;
mazgch 103:197fa7920ad8 1379 }
mazgch 103:197fa7920ad8 1380 return SOCKET_ERROR;
mazgch 103:197fa7920ad8 1381 }
mazgch 103:197fa7920ad8 1382
mazgch 21:c4d64830bf02 1383 // ----------------------------------------------------------------
mazgch 31:a0bed6c1e05d 1384
mazgch 31:a0bed6c1e05d 1385 int MDMParser::_cbCMGL(int type, const char* buf, int len, CMGLparam* param)
mazgch 21:c4d64830bf02 1386 {
mazgch 31:a0bed6c1e05d 1387 if ((type == TYPE_PLUS) && param && param->num) {
mazgch 31:a0bed6c1e05d 1388 // +CMGL: <ix>,...
mazgch 31:a0bed6c1e05d 1389 int ix;
mazgch 31:a0bed6c1e05d 1390 if (sscanf(buf, "\r\n+CMGL: %d,", &ix) == 1)
mazgch 31:a0bed6c1e05d 1391 {
mazgch 31:a0bed6c1e05d 1392 *param->ix++ = ix;
mazgch 31:a0bed6c1e05d 1393 param->num--;
mazgch 31:a0bed6c1e05d 1394 }
mazgch 29:53d346010624 1395 }
mazgch 29:53d346010624 1396 return WAIT;
mazgch 21:c4d64830bf02 1397 }
mazgch 21:c4d64830bf02 1398
mazgch 31:a0bed6c1e05d 1399 int MDMParser::smsList(const char* stat /*= "ALL"*/, int* ix /*=NULL*/, int num /*= 0*/) {
mazgch 95:8282dbbe1492 1400 int ret = -1;
mazgch 95:8282dbbe1492 1401 LOCK();
mazgch 31:a0bed6c1e05d 1402 sendFormated("AT+CMGL=\"%s\"\r\n", stat);
mazgch 31:a0bed6c1e05d 1403 CMGLparam param;
mazgch 31:a0bed6c1e05d 1404 param.ix = ix;
mazgch 31:a0bed6c1e05d 1405 param.num = num;
mazgch 95:8282dbbe1492 1406 if (RESP_OK == waitFinalResp(_cbCMGL, &param))
mazgch 95:8282dbbe1492 1407 ret = num - param.num;
mazgch 95:8282dbbe1492 1408 UNLOCK();
mazgch 95:8282dbbe1492 1409 return ret;
mazgch 21:c4d64830bf02 1410 }
mazgch 21:c4d64830bf02 1411
mazgch 21:c4d64830bf02 1412 bool MDMParser::smsSend(const char* num, const char* buf)
mazgch 21:c4d64830bf02 1413 {
mazgch 95:8282dbbe1492 1414 bool ok = false;
mazgch 95:8282dbbe1492 1415 LOCK();
mazgch 80:34985b4d821e 1416 sendFormated("AT+CMGS=\"%s\"\r\n",num);
mazgch 95:8282dbbe1492 1417 if (RESP_PROMPT == waitFinalResp(NULL,NULL,150*1000)) {
mazgch 95:8282dbbe1492 1418 send(buf, strlen(buf));
mazgch 95:8282dbbe1492 1419 const char ctrlZ = 0x1A;
mazgch 95:8282dbbe1492 1420 send(&ctrlZ, sizeof(ctrlZ));
mazgch 95:8282dbbe1492 1421 ok = (RESP_OK == waitFinalResp());
mazgch 21:c4d64830bf02 1422 }
mazgch 95:8282dbbe1492 1423 UNLOCK();
mazgch 95:8282dbbe1492 1424 return ok;
mazgch 21:c4d64830bf02 1425 }
mazgch 21:c4d64830bf02 1426
mazgch 21:c4d64830bf02 1427 bool MDMParser::smsDelete(int ix)
mazgch 21:c4d64830bf02 1428 {
mazgch 95:8282dbbe1492 1429 bool ok = false;
mazgch 95:8282dbbe1492 1430 LOCK();
mazgch 21:c4d64830bf02 1431 sendFormated("AT+CMGD=%d\r\n",ix);
mazgch 95:8282dbbe1492 1432 ok = (RESP_OK == waitFinalResp());
mazgch 95:8282dbbe1492 1433 UNLOCK();
mazgch 95:8282dbbe1492 1434 return ok;
mazgch 21:c4d64830bf02 1435 }
mazgch 21:c4d64830bf02 1436
mazgch 21:c4d64830bf02 1437 int MDMParser::_cbCMGR(int type, const char* buf, int len, CMGRparam* param)
mazgch 21:c4d64830bf02 1438 {
mazgch 21:c4d64830bf02 1439 if (param) {
mazgch 21:c4d64830bf02 1440 if (type == TYPE_PLUS) {
mazgch 21:c4d64830bf02 1441 if (sscanf(buf, "\r\n+CMGR: \"%*[^\"]\",\"%[^\"]", param->num) == 1) {
mazgch 21:c4d64830bf02 1442 }
mazgch 37:cc3433329d66 1443 } else if ((type == TYPE_UNKNOWN) && (buf[len-2] == '\r') && (buf[len-1] == '\n')) {
mazgch 21:c4d64830bf02 1444 memcpy(param->buf, buf, len-2);
mazgch 21:c4d64830bf02 1445 param->buf[len-2] = '\0';
mazgch 21:c4d64830bf02 1446 }
mazgch 21:c4d64830bf02 1447 }
mazgch 21:c4d64830bf02 1448 return WAIT;
mazgch 21:c4d64830bf02 1449 }
mazgch 21:c4d64830bf02 1450
mazgch 21:c4d64830bf02 1451 bool MDMParser::smsRead(int ix, char* num, char* buf, int len)
mazgch 21:c4d64830bf02 1452 {
mazgch 95:8282dbbe1492 1453 bool ok = false;
mazgch 95:8282dbbe1492 1454 LOCK();
mazgch 21:c4d64830bf02 1455 CMGRparam param;
mazgch 21:c4d64830bf02 1456 param.num = num;
mazgch 21:c4d64830bf02 1457 param.buf = buf;
mazgch 21:c4d64830bf02 1458 sendFormated("AT+CMGR=%d\r\n",ix);
mazgch 95:8282dbbe1492 1459 ok = (RESP_OK == waitFinalResp(_cbCMGR, &param));
mazgch 95:8282dbbe1492 1460 UNLOCK();
mazgch 95:8282dbbe1492 1461 return ok;
mazgch 21:c4d64830bf02 1462 }
mazgch 54:7ba8e4c218e2 1463
mazgch 54:7ba8e4c218e2 1464 // ----------------------------------------------------------------
mazgch 70:0a87d256cd24 1465
mazgch 70:0a87d256cd24 1466 int MDMParser::_cbCUSD(int type, const char* buf, int len, char* resp)
mazgch 70:0a87d256cd24 1467 {
mazgch 70:0a87d256cd24 1468 if ((type == TYPE_PLUS) && resp) {
mazgch 70:0a87d256cd24 1469 // +USD: \"%*[^\"]\",\"%[^\"]\",,\"%*[^\"]\",%d,%d,%d,%d,\"*[^\"]\",%d,%d"..);
mazgch 70:0a87d256cd24 1470 if (sscanf(buf, "\r\n+CUSD: %*d,\"%[^\"]\",%*d", resp) == 1) {
mazgch 70:0a87d256cd24 1471 /*nothing*/
mazgch 70:0a87d256cd24 1472 }
mazgch 70:0a87d256cd24 1473 }
mazgch 70:0a87d256cd24 1474 return WAIT;
mazgch 70:0a87d256cd24 1475 }
mazgch 70:0a87d256cd24 1476
mazgch 70:0a87d256cd24 1477 bool MDMParser::ussdCommand(const char* cmd, char* buf)
mazgch 70:0a87d256cd24 1478 {
mazgch 95:8282dbbe1492 1479 bool ok = false;
mazgch 95:8282dbbe1492 1480 LOCK();
mazgch 70:0a87d256cd24 1481 *buf = '\0';
mazgch 95:8282dbbe1492 1482 if (_dev.dev != DEV_LISA_C200) {
mazgch 95:8282dbbe1492 1483 sendFormated("AT+CUSD=1,\"%s\"\r\n",cmd);
mazgch 95:8282dbbe1492 1484 ok = (RESP_OK == waitFinalResp(_cbCUSD, buf));
mazgch 70:0a87d256cd24 1485 }
mazgch 95:8282dbbe1492 1486 UNLOCK();
mazgch 95:8282dbbe1492 1487 return ok;
mazgch 70:0a87d256cd24 1488 }
mazgch 80:34985b4d821e 1489
mazgch 80:34985b4d821e 1490 // ----------------------------------------------------------------
RobMeades 118:f3fd6c30dc19 1491 // Neul AT command handling functions
RobMeades 118:f3fd6c30dc19 1492 int MDMParser::_cbMGS (int type, const char* buf, int len, bool* ok)
RobMeades 118:f3fd6c30dc19 1493 {
RobMeades 118:f3fd6c30dc19 1494 *ok = false;
RobMeades 118:f3fd6c30dc19 1495 if (type == TYPE_PLUS) {
RobMeades 118:f3fd6c30dc19 1496 if (strstr(buf, "\r\n+MGS:OK") == buf) {
RobMeades 118:f3fd6c30dc19 1497 *ok = true;
RobMeades 118:f3fd6c30dc19 1498 return RESP_OK;
RobMeades 118:f3fd6c30dc19 1499 }
RobMeades 118:f3fd6c30dc19 1500 }
RobMeades 118:f3fd6c30dc19 1501 return WAIT;
RobMeades 118:f3fd6c30dc19 1502 }
RobMeades 118:f3fd6c30dc19 1503
RobMeades 118:f3fd6c30dc19 1504 int MDMParser::_cbSMI (int type, const char* buf, int len, bool* sent)
RobMeades 118:f3fd6c30dc19 1505 {
RobMeades 118:f3fd6c30dc19 1506 *sent = false;
RobMeades 118:f3fd6c30dc19 1507 if (type == TYPE_PLUS) {
RobMeades 118:f3fd6c30dc19 1508 if (strstr(buf, "\r\n+SMI:SENT") == buf) {
RobMeades 118:f3fd6c30dc19 1509 *sent = true;
RobMeades 118:f3fd6c30dc19 1510 return RESP_OK;
RobMeades 118:f3fd6c30dc19 1511 }
RobMeades 118:f3fd6c30dc19 1512 }
RobMeades 118:f3fd6c30dc19 1513 return WAIT;
RobMeades 118:f3fd6c30dc19 1514 }
RobMeades 118:f3fd6c30dc19 1515
RobMeades 118:f3fd6c30dc19 1516 bool MDMParser::datagramSend(int size, const char* buf)
RobMeades 118:f3fd6c30dc19 1517 {
RobMeades 118:f3fd6c30dc19 1518 bool ok = false;
RobMeades 118:f3fd6c30dc19 1519
RobMeades 118:f3fd6c30dc19 1520 LOCK();
RobMeades 118:f3fd6c30dc19 1521 sendFormated ("AT+MGS=%d,%.*s\r\n", size / 2, size, buf);
RobMeades 118:f3fd6c30dc19 1522 ok = (RESP_OK == waitFinalResp(_cbMGS, &ok)) && ok;
RobMeades 118:f3fd6c30dc19 1523 if (ok) {
RobMeades 118:f3fd6c30dc19 1524 ok = (RESP_OK == waitFinalResp(NULL));
RobMeades 118:f3fd6c30dc19 1525 if (ok) {
RobMeades 118:f3fd6c30dc19 1526 ok = (RESP_OK == waitFinalResp(_cbSMI, &ok, 30000)) && ok;
RobMeades 118:f3fd6c30dc19 1527 }
RobMeades 118:f3fd6c30dc19 1528 }
RobMeades 118:f3fd6c30dc19 1529 UNLOCK();
RobMeades 118:f3fd6c30dc19 1530
RobMeades 118:f3fd6c30dc19 1531 return ok;
RobMeades 118:f3fd6c30dc19 1532 }
RobMeades 118:f3fd6c30dc19 1533
RobMeades 118:f3fd6c30dc19 1534 int MDMParser::_cbMGR (int type, const char* buf, int len, MGRparam* param)
RobMeades 118:f3fd6c30dc19 1535 {
RobMeades 118:f3fd6c30dc19 1536 int a = 0;
RobMeades 118:f3fd6c30dc19 1537 if (param) {
RobMeades 118:f3fd6c30dc19 1538 if (type == TYPE_PLUS) {
RobMeades 118:f3fd6c30dc19 1539 if ((sscanf(buf, "\r\n+MGR:%d", &a) == 1) && (a * 2 < param->maxlen)) {
RobMeades 118:f3fd6c30dc19 1540 if (sscanf(buf, "\r\n+MGR:%d,%s", &(param->outlen), param->buf) == 2) {
RobMeades 118:f3fd6c30dc19 1541 param->outlen *=2; // length in bytes rather than hex-char representation
RobMeades 118:f3fd6c30dc19 1542 return RESP_OK;
RobMeades 118:f3fd6c30dc19 1543 }
RobMeades 118:f3fd6c30dc19 1544 }
RobMeades 118:f3fd6c30dc19 1545 }
RobMeades 118:f3fd6c30dc19 1546 }
RobMeades 118:f3fd6c30dc19 1547
RobMeades 118:f3fd6c30dc19 1548 return WAIT;
RobMeades 118:f3fd6c30dc19 1549 }
RobMeades 118:f3fd6c30dc19 1550
RobMeades 118:f3fd6c30dc19 1551 bool MDMParser::doMGR (int* size, char* buf, MGRparam *param)
RobMeades 118:f3fd6c30dc19 1552 {
RobMeades 118:f3fd6c30dc19 1553 bool ok;
RobMeades 118:f3fd6c30dc19 1554
RobMeades 118:f3fd6c30dc19 1555 sendFormated ("AT+MGR\r\n");
RobMeades 118:f3fd6c30dc19 1556 ok = (RESP_OK == waitFinalResp(_cbMGR, param, 1000));
RobMeades 118:f3fd6c30dc19 1557 if (ok) {
RobMeades 118:f3fd6c30dc19 1558 if (ok && (param->outlen > 0)) {
RobMeades 118:f3fd6c30dc19 1559 ok = (RESP_OK == waitFinalResp(NULL));
RobMeades 118:f3fd6c30dc19 1560 *size = param->maxlen;
RobMeades 118:f3fd6c30dc19 1561 hexStringToBytes (param->buf, param->outlen, buf, size);
RobMeades 118:f3fd6c30dc19 1562 }
RobMeades 118:f3fd6c30dc19 1563 }
RobMeades 118:f3fd6c30dc19 1564
RobMeades 118:f3fd6c30dc19 1565 return ok;
RobMeades 118:f3fd6c30dc19 1566 }
RobMeades 118:f3fd6c30dc19 1567
RobMeades 118:f3fd6c30dc19 1568 #ifdef C027N_USE_NMI
RobMeades 118:f3fd6c30dc19 1569
RobMeades 118:f3fd6c30dc19 1570 bool MDMParser::datagramRecv(int* size, char* buf, int timeoutMs /* 10000 */)
RobMeades 118:f3fd6c30dc19 1571 {
RobMeades 118:f3fd6c30dc19 1572 bool gotDatagram = false;
RobMeades 118:f3fd6c30dc19 1573 MGRparam param;
RobMeades 118:f3fd6c30dc19 1574 param.buf = buf;
RobMeades 118:f3fd6c30dc19 1575 param.maxlen = *size;
RobMeades 118:f3fd6c30dc19 1576 param.outlen = 0;
RobMeades 118:f3fd6c30dc19 1577
RobMeades 118:f3fd6c30dc19 1578 LOCK();
RobMeades 118:f3fd6c30dc19 1579 if (_outstandingNMI == 0)
RobMeades 118:f3fd6c30dc19 1580 {
RobMeades 118:f3fd6c30dc19 1581 waitFinalResp(NULL, NULL, timeoutMs);
RobMeades 118:f3fd6c30dc19 1582 }
RobMeades 118:f3fd6c30dc19 1583 if (_outstandingNMI > 0)
RobMeades 118:f3fd6c30dc19 1584 {
RobMeades 118:f3fd6c30dc19 1585 gotDatagram = doMGR (size, buf, &param);
RobMeades 118:f3fd6c30dc19 1586 if (gotDatagram) {
RobMeades 118:f3fd6c30dc19 1587 _outstandingNMI--;
RobMeades 118:f3fd6c30dc19 1588 if (param.outlen > 0) {
RobMeades 118:f3fd6c30dc19 1589 gotDatagram = true;
RobMeades 118:f3fd6c30dc19 1590 }
RobMeades 118:f3fd6c30dc19 1591 } else {
RobMeades 118:f3fd6c30dc19 1592 *size = 0;
RobMeades 118:f3fd6c30dc19 1593 }
RobMeades 118:f3fd6c30dc19 1594 }
RobMeades 118:f3fd6c30dc19 1595 UNLOCK();
RobMeades 118:f3fd6c30dc19 1596
RobMeades 118:f3fd6c30dc19 1597 return gotDatagram;
RobMeades 118:f3fd6c30dc19 1598 }
RobMeades 118:f3fd6c30dc19 1599
RobMeades 118:f3fd6c30dc19 1600 #else
RobMeades 118:f3fd6c30dc19 1601
RobMeades 118:f3fd6c30dc19 1602 bool MDMParser::datagramRecv(int* size, char* buf, int timeoutMs /* 10000 */)
RobMeades 118:f3fd6c30dc19 1603 {
RobMeades 118:f3fd6c30dc19 1604 bool ok = false;
RobMeades 118:f3fd6c30dc19 1605 MGRparam param;
RobMeades 118:f3fd6c30dc19 1606 Timer timer;
RobMeades 118:f3fd6c30dc19 1607 param.buf = buf;
RobMeades 118:f3fd6c30dc19 1608 param.maxlen = *size;
RobMeades 118:f3fd6c30dc19 1609 param.outlen = 0;
RobMeades 118:f3fd6c30dc19 1610
RobMeades 118:f3fd6c30dc19 1611 // The correct way to do this would be to switch on NMI and wait, however
RobMeades 118:f3fd6c30dc19 1612 // the NMI carries all the data with it, it's not just a flag, and so
RobMeades 118:f3fd6c30dc19 1613 // the parser here would have to handle queues of data, which it can't.
RobMeades 118:f3fd6c30dc19 1614 // So instead, just poll with AT+MGR until a mode of NMI comes along
RobMeades 118:f3fd6c30dc19 1615 // which leaves the data in the buffer.
RobMeades 118:f3fd6c30dc19 1616
RobMeades 118:f3fd6c30dc19 1617 LOCK();
RobMeades 118:f3fd6c30dc19 1618 timer.start();
RobMeades 118:f3fd6c30dc19 1619 ok = true;
RobMeades 118:f3fd6c30dc19 1620 while (ok && (param.outlen == 0) && (timer.read_ms() < timeoutMs)) {
RobMeades 118:f3fd6c30dc19 1621 ok = doMGR (size, buf, &param);
RobMeades 118:f3fd6c30dc19 1622 if (ok && param.outlen == 0) {
RobMeades 118:f3fd6c30dc19 1623 wait_ms (500);
RobMeades 118:f3fd6c30dc19 1624 }
RobMeades 118:f3fd6c30dc19 1625 }
RobMeades 118:f3fd6c30dc19 1626 if (param.outlen == 0) {
RobMeades 118:f3fd6c30dc19 1627 ok = false;
RobMeades 118:f3fd6c30dc19 1628 *size = 0;
RobMeades 118:f3fd6c30dc19 1629 }
RobMeades 118:f3fd6c30dc19 1630 UNLOCK();
RobMeades 118:f3fd6c30dc19 1631
RobMeades 118:f3fd6c30dc19 1632 return ok;
RobMeades 118:f3fd6c30dc19 1633 }
RobMeades 118:f3fd6c30dc19 1634
RobMeades 118:f3fd6c30dc19 1635 #endif
RobMeades 118:f3fd6c30dc19 1636
RobMeades 118:f3fd6c30dc19 1637 int MDMParser::_cbCSQN(int type, const char* buf, int len, int* rssi)
RobMeades 118:f3fd6c30dc19 1638 {
RobMeades 118:f3fd6c30dc19 1639 if ((type == TYPE_PLUS) && rssi) {
RobMeades 118:f3fd6c30dc19 1640 // +CSQ: <rssi>
RobMeades 118:f3fd6c30dc19 1641 if (sscanf(buf, "\r\n+CSQ: %d", rssi) == 1) {
RobMeades 118:f3fd6c30dc19 1642 return RESP_OK;
RobMeades 118:f3fd6c30dc19 1643 }
RobMeades 118:f3fd6c30dc19 1644 }
RobMeades 118:f3fd6c30dc19 1645
RobMeades 118:f3fd6c30dc19 1646 return WAIT;
RobMeades 118:f3fd6c30dc19 1647 }
RobMeades 118:f3fd6c30dc19 1648
RobMeades 118:f3fd6c30dc19 1649 bool MDMParser::getRssi(int *rssi)
RobMeades 118:f3fd6c30dc19 1650 {
RobMeades 118:f3fd6c30dc19 1651 bool ok = false;
RobMeades 118:f3fd6c30dc19 1652 if (rssi) {
RobMeades 118:f3fd6c30dc19 1653 LOCK();
RobMeades 118:f3fd6c30dc19 1654 sendFormated ("AT+CSQ\r\n");
RobMeades 118:f3fd6c30dc19 1655 ok = (RESP_OK == waitFinalResp(_cbCSQN, rssi));
RobMeades 118:f3fd6c30dc19 1656 if (ok) {
RobMeades 118:f3fd6c30dc19 1657 ok = (RESP_OK == waitFinalResp(NULL));
RobMeades 118:f3fd6c30dc19 1658 }
RobMeades 118:f3fd6c30dc19 1659 UNLOCK();
RobMeades 118:f3fd6c30dc19 1660 }
RobMeades 118:f3fd6c30dc19 1661 return ok;
RobMeades 118:f3fd6c30dc19 1662 }
RobMeades 118:f3fd6c30dc19 1663
RobMeades 118:f3fd6c30dc19 1664 int MDMParser::_cbRB (int type, const char* buf, int len, bool* ok)
RobMeades 118:f3fd6c30dc19 1665 {
RobMeades 118:f3fd6c30dc19 1666 *ok = false;
RobMeades 118:f3fd6c30dc19 1667 if (type == TYPE_PLUS) {
RobMeades 118:f3fd6c30dc19 1668 if (strstr(buf, "\r\n+RB:REBOOTING") == buf) {
RobMeades 118:f3fd6c30dc19 1669 *ok = true;
RobMeades 118:f3fd6c30dc19 1670 return RESP_OK;
RobMeades 118:f3fd6c30dc19 1671 }
RobMeades 118:f3fd6c30dc19 1672 }
RobMeades 118:f3fd6c30dc19 1673 return WAIT;
RobMeades 118:f3fd6c30dc19 1674 }
RobMeades 118:f3fd6c30dc19 1675
RobMeades 118:f3fd6c30dc19 1676 bool MDMParser::neulReboot()
RobMeades 118:f3fd6c30dc19 1677 {
RobMeades 118:f3fd6c30dc19 1678 bool ok = false;
RobMeades 118:f3fd6c30dc19 1679 LOCK();
RobMeades 118:f3fd6c30dc19 1680 sendFormated ("AT+RB\r\n");
RobMeades 118:f3fd6c30dc19 1681 ok = (RESP_OK == waitFinalResp(_cbRB, &ok)) && ok;
RobMeades 118:f3fd6c30dc19 1682 if (ok) {
RobMeades 118:f3fd6c30dc19 1683 ok = (RESP_OK == waitFinalResp(NULL));
RobMeades 118:f3fd6c30dc19 1684 }
RobMeades 118:f3fd6c30dc19 1685 UNLOCK();
RobMeades 118:f3fd6c30dc19 1686
RobMeades 118:f3fd6c30dc19 1687 return ok;
RobMeades 118:f3fd6c30dc19 1688 }
RobMeades 118:f3fd6c30dc19 1689
RobMeades 118:f3fd6c30dc19 1690 void MDMParser::hexStringToBytes (const char *inBuf, int lenInBuf, char * outBuf, int* lenOutBuf)
RobMeades 118:f3fd6c30dc19 1691 {
RobMeades 118:f3fd6c30dc19 1692 int x;
RobMeades 118:f3fd6c30dc19 1693 int y = 0;
RobMeades 118:f3fd6c30dc19 1694 int z;
RobMeades 118:f3fd6c30dc19 1695
RobMeades 118:f3fd6c30dc19 1696 for (x = 0; (x < lenInBuf) && (y < *lenOutBuf); x++)
RobMeades 118:f3fd6c30dc19 1697 {
RobMeades 118:f3fd6c30dc19 1698 z = *(inBuf + x);
RobMeades 118:f3fd6c30dc19 1699 if ((z >= '0') && (z <= '9'))
RobMeades 118:f3fd6c30dc19 1700 {
RobMeades 118:f3fd6c30dc19 1701 z = z - '0';
RobMeades 118:f3fd6c30dc19 1702 }
RobMeades 118:f3fd6c30dc19 1703 else
RobMeades 118:f3fd6c30dc19 1704 {
RobMeades 118:f3fd6c30dc19 1705 z &= ~0x20;
RobMeades 118:f3fd6c30dc19 1706 if ((z >= 'A') && (z <= 'F'))
RobMeades 118:f3fd6c30dc19 1707 {
RobMeades 118:f3fd6c30dc19 1708 z = z - 'A' + 10;
RobMeades 118:f3fd6c30dc19 1709 }
RobMeades 118:f3fd6c30dc19 1710 }
RobMeades 118:f3fd6c30dc19 1711
RobMeades 118:f3fd6c30dc19 1712 if (x % 2 == 0)
RobMeades 118:f3fd6c30dc19 1713 {
RobMeades 118:f3fd6c30dc19 1714 *(outBuf + y) = (z << 4) & 0xF0;
RobMeades 118:f3fd6c30dc19 1715 }
RobMeades 118:f3fd6c30dc19 1716 else
RobMeades 118:f3fd6c30dc19 1717 {
RobMeades 118:f3fd6c30dc19 1718 *(outBuf + y) += z;
RobMeades 118:f3fd6c30dc19 1719 y++;
RobMeades 118:f3fd6c30dc19 1720 }
RobMeades 118:f3fd6c30dc19 1721 }
RobMeades 118:f3fd6c30dc19 1722
RobMeades 118:f3fd6c30dc19 1723 *lenOutBuf = y;
RobMeades 118:f3fd6c30dc19 1724 }
RobMeades 118:f3fd6c30dc19 1725
RobMeades 118:f3fd6c30dc19 1726 // ----------------------------------------------------------------
mazgch 70:0a87d256cd24 1727
mazgch 115:d8d94b73c725 1728 int MDMParser::_cbUDELFILE(int type, const char* buf, int len, void*)
mazgch 115:d8d94b73c725 1729 {
mazgch 115:d8d94b73c725 1730 if ((type == TYPE_ERROR) && strstr(buf, "+CME ERROR: FILE NOT FOUND"))
mazgch 115:d8d94b73c725 1731 return RESP_OK; // file does not exist, so all ok...
mazgch 115:d8d94b73c725 1732 return WAIT;
mazgch 115:d8d94b73c725 1733 }
mazgch 115:d8d94b73c725 1734
mazgch 80:34985b4d821e 1735 bool MDMParser::delFile(const char* filename)
mazgch 80:34985b4d821e 1736 {
mazgch 95:8282dbbe1492 1737 bool ok = false;
mazgch 95:8282dbbe1492 1738 LOCK();
mazgch 80:34985b4d821e 1739 sendFormated("AT+UDELFILE=\"%s\"\r\n", filename);
mazgch 115:d8d94b73c725 1740 ok = (RESP_OK == waitFinalResp(_cbUDELFILE));
mazgch 95:8282dbbe1492 1741 UNLOCK();
mazgch 95:8282dbbe1492 1742 return ok;
mazgch 80:34985b4d821e 1743 }
mazgch 80:34985b4d821e 1744
mazgch 80:34985b4d821e 1745 int MDMParser::writeFile(const char* filename, const char* buf, int len)
mazgch 80:34985b4d821e 1746 {
mazgch 95:8282dbbe1492 1747 bool ok = false;
mazgch 95:8282dbbe1492 1748 LOCK();
mazgch 80:34985b4d821e 1749 sendFormated("AT+UDWNFILE=\"%s\",%d\r\n", filename, len);
mazgch 95:8282dbbe1492 1750 if (RESP_PROMPT == waitFinalResp()) {
mazgch 95:8282dbbe1492 1751 send(buf, len);
mazgch 95:8282dbbe1492 1752 ok = (RESP_OK == waitFinalResp());
mazgch 95:8282dbbe1492 1753 }
mazgch 95:8282dbbe1492 1754 UNLOCK();
mazgch 95:8282dbbe1492 1755 return ok ? len : -1;
mazgch 80:34985b4d821e 1756 }
mazgch 80:34985b4d821e 1757
mazgch 80:34985b4d821e 1758 int MDMParser::readFile(const char* filename, char* buf, int len)
mazgch 80:34985b4d821e 1759 {
mazgch 80:34985b4d821e 1760 URDFILEparam param;
mazgch 80:34985b4d821e 1761 param.filename = filename;
mazgch 80:34985b4d821e 1762 param.buf = buf;
mazgch 80:34985b4d821e 1763 param.sz = len;
mazgch 80:34985b4d821e 1764 param.len = 0;
mazgch 95:8282dbbe1492 1765 LOCK();
mazgch 95:8282dbbe1492 1766 sendFormated("AT+URDFILE=\"%s\"\r\n", filename, len);
mazgch 105:f6bb2a20de70 1767 if (RESP_OK != waitFinalResp(_cbURDFILE, &param))
mazgch 95:8282dbbe1492 1768 param.len = -1;
mazgch 95:8282dbbe1492 1769 UNLOCK();
mazgch 80:34985b4d821e 1770 return param.len;
mazgch 80:34985b4d821e 1771 }
mazgch 80:34985b4d821e 1772
mazgch 80:34985b4d821e 1773 int MDMParser::_cbURDFILE(int type, const char* buf, int len, URDFILEparam* param)
mazgch 80:34985b4d821e 1774 {
mazgch 80:34985b4d821e 1775 if ((type == TYPE_PLUS) && param && param->filename && param->buf) {
mazgch 80:34985b4d821e 1776 char filename[48];
mazgch 80:34985b4d821e 1777 int sz;
mazgch 80:34985b4d821e 1778 if ((sscanf(buf, "\r\n+URDFILE: \"%[^\"]\",%d,", filename, &sz) == 2) &&
mazgch 80:34985b4d821e 1779 (0 == strcmp(param->filename, filename)) &&
mazgch 80:34985b4d821e 1780 (buf[len-sz-2] == '\"') && (buf[len-1] == '\"')) {
mazgch 80:34985b4d821e 1781 param->len = (sz < param->sz) ? sz : param->sz;
mazgch 80:34985b4d821e 1782 memcpy(param->buf, &buf[len-1-sz], param->len);
mazgch 80:34985b4d821e 1783 }
mazgch 80:34985b4d821e 1784 }
mazgch 80:34985b4d821e 1785 return WAIT;
mazgch 80:34985b4d821e 1786 }
mazgch 80:34985b4d821e 1787
mazgch 70:0a87d256cd24 1788 // ----------------------------------------------------------------
mazgch 74:208e3e32d263 1789 bool MDMParser::setDebug(int level)
mazgch 74:208e3e32d263 1790 {
mazgch 74:208e3e32d263 1791 #ifdef MDM_DEBUG
mazgch 117:74e4e0109a9e 1792 if ((_debugLevel >= -1) && (level >= -1) &&
mazgch 117:74e4e0109a9e 1793 (_debugLevel <= 3) && (level <= 3)) {
mazgch 74:208e3e32d263 1794 _debugLevel = level;
mazgch 74:208e3e32d263 1795 return true;
mazgch 74:208e3e32d263 1796 }
mazgch 74:208e3e32d263 1797 #endif
mazgch 74:208e3e32d263 1798 return false;
mazgch 74:208e3e32d263 1799 }
mazgch 74:208e3e32d263 1800
mazgch 73:2b32e0a21df2 1801 void MDMParser::dumpDevStatus(MDMParser::DevStatus* status,
mazgch 73:2b32e0a21df2 1802 _DPRINT dprint, void* param)
mazgch 54:7ba8e4c218e2 1803 {
mazgch 75:ce6e12067d0c 1804 dprint(param, "Modem::devStatus\r\n");
mazgch 98:c786461edd40 1805 const char* txtDev[] = { "Unknown", "SARA-G350", "LISA-U200", "LISA-C200", "SARA-U260", "SARA-U270", "LEON-G200" };
mazgch 98:c786461edd40 1806 if (status->dev < sizeof(txtDev)/sizeof(*txtDev) && (status->dev != DEV_UNKNOWN))
mazgch 73:2b32e0a21df2 1807 dprint(param, " Device: %s\r\n", txtDev[status->dev]);
mazgch 54:7ba8e4c218e2 1808 const char* txtLpm[] = { "Disabled", "Enabled", "Active" };
mazgch 54:7ba8e4c218e2 1809 if (status->lpm < sizeof(txtLpm)/sizeof(*txtLpm))
mazgch 73:2b32e0a21df2 1810 dprint(param, " Power Save: %s\r\n", txtLpm[status->lpm]);
mazgch 75:ce6e12067d0c 1811 const char* txtSim[] = { "Unknown", "Missing", "Pin", "Ready" };
mazgch 98:c786461edd40 1812 if (status->sim < sizeof(txtSim)/sizeof(*txtSim) && (status->sim != SIM_UNKNOWN))
mazgch 73:2b32e0a21df2 1813 dprint(param, " SIM: %s\r\n", txtSim[status->sim]);
mazgch 54:7ba8e4c218e2 1814 if (*status->ccid)
mazgch 73:2b32e0a21df2 1815 dprint(param, " CCID: %s\r\n", status->ccid);
mazgch 54:7ba8e4c218e2 1816 if (*status->imei)
mazgch 73:2b32e0a21df2 1817 dprint(param, " IMEI: %s\r\n", status->imei);
mazgch 54:7ba8e4c218e2 1818 if (*status->imsi)
mazgch 73:2b32e0a21df2 1819 dprint(param, " IMSI: %s\r\n", status->imsi);
mazgch 54:7ba8e4c218e2 1820 if (*status->meid)
mazgch 73:2b32e0a21df2 1821 dprint(param, " MEID: %s\r\n", status->meid); // LISA-C
mazgch 54:7ba8e4c218e2 1822 if (*status->manu)
mazgch 73:2b32e0a21df2 1823 dprint(param, " Manufacturer: %s\r\n", status->manu);
mazgch 54:7ba8e4c218e2 1824 if (*status->model)
mazgch 73:2b32e0a21df2 1825 dprint(param, " Model: %s\r\n", status->model);
mazgch 54:7ba8e4c218e2 1826 if (*status->ver)
mazgch 73:2b32e0a21df2 1827 dprint(param, " Version: %s\r\n", status->ver);
mazgch 54:7ba8e4c218e2 1828 }
mazgch 54:7ba8e4c218e2 1829
mazgch 73:2b32e0a21df2 1830 void MDMParser::dumpNetStatus(MDMParser::NetStatus *status,
mazgch 73:2b32e0a21df2 1831 _DPRINT dprint, void* param)
mazgch 54:7ba8e4c218e2 1832 {
mazgch 75:ce6e12067d0c 1833 dprint(param, "Modem::netStatus\r\n");
mazgch 54:7ba8e4c218e2 1834 const char* txtReg[] = { "Unknown", "Denied", "None", "Home", "Roaming" };
mazgch 98:c786461edd40 1835 if (status->csd < sizeof(txtReg)/sizeof(*txtReg) && (status->csd != REG_UNKNOWN))
mazgch 79:291df065e345 1836 dprint(param, " CSD Registration: %s\r\n", txtReg[status->csd]);
mazgch 98:c786461edd40 1837 if (status->psd < sizeof(txtReg)/sizeof(*txtReg) && (status->psd != REG_UNKNOWN))
mazgch 79:291df065e345 1838 dprint(param, " PSD Registration: %s\r\n", txtReg[status->psd]);
mazgch 54:7ba8e4c218e2 1839 const char* txtAct[] = { "Unknown", "GSM", "Edge", "3G", "CDMA" };
mazgch 98:c786461edd40 1840 if (status->act < sizeof(txtAct)/sizeof(*txtAct) && (status->act != ACT_UNKNOWN))
mazgch 73:2b32e0a21df2 1841 dprint(param, " Access Technology: %s\r\n", txtAct[status->act]);
mazgch 54:7ba8e4c218e2 1842 if (status->rssi)
mazgch 73:2b32e0a21df2 1843 dprint(param, " Signal Strength: %d dBm\r\n", status->rssi);
mazgch 54:7ba8e4c218e2 1844 if (status->ber)
mazgch 73:2b32e0a21df2 1845 dprint(param, " Bit Error Rate: %d\r\n", status->ber);
mazgch 54:7ba8e4c218e2 1846 if (*status->opr)
mazgch 73:2b32e0a21df2 1847 dprint(param, " Operator: %s\r\n", status->opr);
mazgch 54:7ba8e4c218e2 1848 if (status->lac != 0xFFFF)
mazgch 73:2b32e0a21df2 1849 dprint(param, " Location Area Code: %04X\r\n", status->lac);
mazgch 54:7ba8e4c218e2 1850 if (status->ci != 0xFFFFFFFF)
mazgch 73:2b32e0a21df2 1851 dprint(param, " Cell ID: %08X\r\n", status->ci);
mazgch 54:7ba8e4c218e2 1852 if (*status->num)
mazgch 73:2b32e0a21df2 1853 dprint(param, " Phone Number: %s\r\n", status->num);
mazgch 54:7ba8e4c218e2 1854 }
mazgch 54:7ba8e4c218e2 1855
mazgch 73:2b32e0a21df2 1856 void MDMParser::dumpIp(MDMParser::IP ip,
mazgch 73:2b32e0a21df2 1857 _DPRINT dprint, void* param)
mazgch 54:7ba8e4c218e2 1858 {
mazgch 57:869bd35f44cc 1859 if (ip != NOIP)
mazgch 75:ce6e12067d0c 1860 dprint(param, "Modem:IP " IPSTR "\r\n", IPNUM(ip));
mazgch 54:7ba8e4c218e2 1861 }
mazgch 70:0a87d256cd24 1862
mazgch 21:c4d64830bf02 1863 // ----------------------------------------------------------------
mazgch 21:c4d64830bf02 1864 int MDMParser::_parseMatch(Pipe<char>* pipe, int len, const char* sta, const char* end)
mazgch 18:e5697801df29 1865 {
mazgch 18:e5697801df29 1866 int o = 0;
mazgch 21:c4d64830bf02 1867 if (sta) {
mazgch 21:c4d64830bf02 1868 while (*sta) {
mazgch 21:c4d64830bf02 1869 if (++o > len) return WAIT;
mazgch 21:c4d64830bf02 1870 char ch = pipe->next();
mazgch 21:c4d64830bf02 1871 if (*sta++ != ch) return NOT_FOUND;
mazgch 21:c4d64830bf02 1872 }
mazgch 21:c4d64830bf02 1873 }
mazgch 21:c4d64830bf02 1874 if (!end) return o; // no termination
mazgch 35:9275215a3a5b 1875 // at least any char
mazgch 35:9275215a3a5b 1876 if (++o > len) return WAIT;
mazgch 35:9275215a3a5b 1877 pipe->next();
mazgch 35:9275215a3a5b 1878 // check the end
mazgch 21:c4d64830bf02 1879 int x = 0;
mazgch 21:c4d64830bf02 1880 while (end[x]) {
mazgch 21:c4d64830bf02 1881 if (++o > len) return WAIT;
mazgch 21:c4d64830bf02 1882 char ch = pipe->next();
mazgch 21:c4d64830bf02 1883 x = (end[x] == ch) ? x + 1 :
mazgch 21:c4d64830bf02 1884 (end[0] == ch) ? 1 :
mazgch 21:c4d64830bf02 1885 0;
mazgch 21:c4d64830bf02 1886 }
mazgch 21:c4d64830bf02 1887 return o;
mazgch 21:c4d64830bf02 1888 }
mazgch 21:c4d64830bf02 1889
mazgch 21:c4d64830bf02 1890 int MDMParser::_parseFormated(Pipe<char>* pipe, int len, const char* fmt)
mazgch 21:c4d64830bf02 1891 {
mazgch 21:c4d64830bf02 1892 int o = 0;
mazgch 21:c4d64830bf02 1893 int num = 0;
mazgch 21:c4d64830bf02 1894 if (fmt) {
mazgch 21:c4d64830bf02 1895 while (*fmt) {
mazgch 21:c4d64830bf02 1896 if (++o > len) return WAIT;
mazgch 21:c4d64830bf02 1897 char ch = pipe->next();
mazgch 21:c4d64830bf02 1898 if (*fmt == '%') {
mazgch 21:c4d64830bf02 1899 fmt++;
mazgch 21:c4d64830bf02 1900 if (*fmt == 'd') { // numeric
mazgch 21:c4d64830bf02 1901 fmt ++;
mazgch 21:c4d64830bf02 1902 num = 0;
mazgch 21:c4d64830bf02 1903 while (ch >= '0' && ch <= '9') {
mazgch 21:c4d64830bf02 1904 num = num * 10 + (ch - '0');
mazgch 21:c4d64830bf02 1905 if (++o > len) return WAIT;
mazgch 21:c4d64830bf02 1906 ch = pipe->next();
mazgch 21:c4d64830bf02 1907 }
mazgch 21:c4d64830bf02 1908 }
mazgch 21:c4d64830bf02 1909 else if (*fmt == 'c') { // char buffer (takes last numeric as length)
mazgch 21:c4d64830bf02 1910 fmt ++;
mazgch 21:c4d64830bf02 1911 while (num --) {
mazgch 21:c4d64830bf02 1912 if (++o > len) return WAIT;
mazgch 21:c4d64830bf02 1913 ch = pipe->next();
mazgch 21:c4d64830bf02 1914 }
mazgch 21:c4d64830bf02 1915 }
mazgch 80:34985b4d821e 1916 else if (*fmt == 's') {
mazgch 80:34985b4d821e 1917 fmt ++;
mazgch 80:34985b4d821e 1918 if (ch != '\"') return NOT_FOUND;
mazgch 80:34985b4d821e 1919 do {
mazgch 80:34985b4d821e 1920 if (++o > len) return WAIT;
mazgch 80:34985b4d821e 1921 ch = pipe->next();
mazgch 80:34985b4d821e 1922 } while (ch != '\"');
mazgch 80:34985b4d821e 1923 if (++o > len) return WAIT;
mazgch 80:34985b4d821e 1924 ch = pipe->next();
mazgch 80:34985b4d821e 1925 }
mazgch 21:c4d64830bf02 1926 }
mazgch 21:c4d64830bf02 1927 if (*fmt++ != ch) return NOT_FOUND;
mazgch 18:e5697801df29 1928 }
mazgch 18:e5697801df29 1929 }
mazgch 21:c4d64830bf02 1930 return o;
mazgch 21:c4d64830bf02 1931 }
mazgch 21:c4d64830bf02 1932
mazgch 21:c4d64830bf02 1933 int MDMParser::_getLine(Pipe<char>* pipe, char* buf, int len)
mazgch 21:c4d64830bf02 1934 {
mazgch 21:c4d64830bf02 1935 int unkn = 0;
mazgch 21:c4d64830bf02 1936 int sz = pipe->size();
mazgch 21:c4d64830bf02 1937 int fr = pipe->free();
mazgch 21:c4d64830bf02 1938 if (len > sz)
mazgch 21:c4d64830bf02 1939 len = sz;
mazgch 21:c4d64830bf02 1940 while (len > 0)
mazgch 21:c4d64830bf02 1941 {
mazgch 21:c4d64830bf02 1942 static struct {
mazgch 21:c4d64830bf02 1943 const char* fmt; int type;
mazgch 21:c4d64830bf02 1944 } lutF[] = {
mazgch 21:c4d64830bf02 1945 { "\r\n+USORD: %d,%d,\"%c\"", TYPE_PLUS },
mazgch 95:8282dbbe1492 1946 { "\r\n+USORF: %d,\"" IPSTR "\",%d,%d,\"%c\"", TYPE_PLUS },
mazgch 80:34985b4d821e 1947 { "\r\n+URDFILE: %s,%d,\"%c\"", TYPE_PLUS },
mazgch 21:c4d64830bf02 1948 };
mazgch 21:c4d64830bf02 1949 static struct {
mazgch 21:c4d64830bf02 1950 const char* sta; const char* end; int type;
mazgch 21:c4d64830bf02 1951 } lut[] = {
mazgch 21:c4d64830bf02 1952 { "\r\nOK\r\n", NULL, TYPE_OK },
mazgch 21:c4d64830bf02 1953 { "\r\nERROR\r\n", NULL, TYPE_ERROR },
mazgch 31:a0bed6c1e05d 1954 { "\r\n+CME ERROR:", "\r\n", TYPE_ERROR },
mazgch 21:c4d64830bf02 1955 { "\r\n+CMS ERROR:", "\r\n", TYPE_ERROR },
mazgch 21:c4d64830bf02 1956 { "\r\nRING\r\n", NULL, TYPE_RING },
mazgch 21:c4d64830bf02 1957 { "\r\nCONNECT\r\n", NULL, TYPE_CONNECT },
mazgch 21:c4d64830bf02 1958 { "\r\nNO CARRIER\r\n", NULL, TYPE_NOCARRIER },
mazgch 21:c4d64830bf02 1959 { "\r\nNO DIALTONE\r\n", NULL, TYPE_NODIALTONE },
mazgch 21:c4d64830bf02 1960 { "\r\nBUSY\r\n", NULL, TYPE_BUSY },
mazgch 21:c4d64830bf02 1961 { "\r\nNO ANSWER\r\n", NULL, TYPE_NOANSWER },
mazgch 21:c4d64830bf02 1962 { "\r\n+", "\r\n", TYPE_PLUS },
mazgch 21:c4d64830bf02 1963 { "\r\n@", NULL, TYPE_PROMPT }, // Sockets
mazgch 21:c4d64830bf02 1964 { "\r\n>", NULL, TYPE_PROMPT }, // SMS
mazgch 80:34985b4d821e 1965 { "\n>", NULL, TYPE_PROMPT }, // File
mazgch 21:c4d64830bf02 1966 };
mazgch 21:c4d64830bf02 1967 for (int i = 0; i < sizeof(lutF)/sizeof(*lutF); i ++) {
mazgch 21:c4d64830bf02 1968 pipe->set(unkn);
mazgch 21:c4d64830bf02 1969 int ln = _parseFormated(pipe, len, lutF[i].fmt);
mazgch 21:c4d64830bf02 1970 if (ln == WAIT && fr)
mazgch 21:c4d64830bf02 1971 return WAIT;
mazgch 21:c4d64830bf02 1972 if ((ln != NOT_FOUND) && (unkn > 0))
mazgch 31:a0bed6c1e05d 1973 return TYPE_UNKNOWN | pipe->get(buf, unkn);
mazgch 21:c4d64830bf02 1974 if (ln > 0)
mazgch 21:c4d64830bf02 1975 return lutF[i].type | pipe->get(buf, ln);
mazgch 21:c4d64830bf02 1976 }
mazgch 21:c4d64830bf02 1977 for (int i = 0; i < sizeof(lut)/sizeof(*lut); i ++) {
mazgch 21:c4d64830bf02 1978 pipe->set(unkn);
mazgch 21:c4d64830bf02 1979 int ln = _parseMatch(pipe, len, lut[i].sta, lut[i].end);
mazgch 21:c4d64830bf02 1980 if (ln == WAIT && fr)
mazgch 21:c4d64830bf02 1981 return WAIT;
mazgch 21:c4d64830bf02 1982 if ((ln != NOT_FOUND) && (unkn > 0))
mazgch 31:a0bed6c1e05d 1983 return TYPE_UNKNOWN | pipe->get(buf, unkn);
mazgch 21:c4d64830bf02 1984 if (ln > 0)
mazgch 21:c4d64830bf02 1985 return lut[i].type | pipe->get(buf, ln);
mazgch 21:c4d64830bf02 1986 }
mazgch 21:c4d64830bf02 1987 // UNKNOWN
mazgch 21:c4d64830bf02 1988 unkn ++;
mazgch 21:c4d64830bf02 1989 len--;
mazgch 21:c4d64830bf02 1990 }
mazgch 18:e5697801df29 1991 return WAIT;
mazgch 18:e5697801df29 1992 }
mazgch 18:e5697801df29 1993
mazgch 18:e5697801df29 1994 // ----------------------------------------------------------------
mazgch 18:e5697801df29 1995 // Serial Implementation
mazgch 18:e5697801df29 1996 // ----------------------------------------------------------------
mazgch 18:e5697801df29 1997
mazgch 76:f7c3dd568dae 1998 /*! Helper Dev Null Device
mazgch 76:f7c3dd568dae 1999 Small helper class used to shut off stderr/stdout. Sometimes stdin/stdout
mazgch 76:f7c3dd568dae 2000 is shared with the serial port of the modem. Having printfs inbetween the
mazgch 76:f7c3dd568dae 2001 AT commands you cause a failure of the modem.
mazgch 76:f7c3dd568dae 2002 */
mazgch 76:f7c3dd568dae 2003 class DevNull : public Stream {
mazgch 76:f7c3dd568dae 2004 public:
mazgch 76:f7c3dd568dae 2005 DevNull() : Stream(_name+1) { } //!< Constructor
mazgch 76:f7c3dd568dae 2006 void claim(const char* mode, FILE* file)
mazgch 76:f7c3dd568dae 2007 { freopen(_name, mode, file); } //!< claim a stream
mazgch 76:f7c3dd568dae 2008 protected:
mazgch 76:f7c3dd568dae 2009 virtual int _getc() { return EOF; } //!< Nothing
mazgch 76:f7c3dd568dae 2010 virtual int _putc(int c) { return c; } //!< Discard
mazgch 76:f7c3dd568dae 2011 static const char* _name; //!< File name
mazgch 76:f7c3dd568dae 2012 };
mazgch 76:f7c3dd568dae 2013 const char* DevNull::_name = "/null"; //!< the null device name
mazgch 76:f7c3dd568dae 2014 static DevNull null; //!< the null device
mazgch 76:f7c3dd568dae 2015
mazgch 19:2b5d097ca15d 2016 MDMSerial::MDMSerial(PinName tx /*= MDMTXD*/, PinName rx /*= MDMRXD*/,
mazgch 19:2b5d097ca15d 2017 int baudrate /*= MDMBAUD*/,
mazgch 43:a89a7a505991 2018 #if DEVICE_SERIAL_FC
mazgch 19:2b5d097ca15d 2019 PinName rts /*= MDMRTS*/, PinName cts /*= MDMCTS*/,
mazgch 43:a89a7a505991 2020 #endif
mazgch 18:e5697801df29 2021 int rxSize /*= 256*/, int txSize /*= 128*/) :
mazgch 35:9275215a3a5b 2022 SerialPipe(tx, rx, rxSize, txSize)
mazgch 18:e5697801df29 2023 {
mazgch 76:f7c3dd568dae 2024 if (rx == USBRX)
mazgch 76:f7c3dd568dae 2025 null.claim("r", stdin);
mazgch 76:f7c3dd568dae 2026 if (tx == USBTX) {
mazgch 76:f7c3dd568dae 2027 null.claim("w", stdout);
mazgch 76:f7c3dd568dae 2028 null.claim("w", stderr);
mazgch 74:208e3e32d263 2029 #ifdef MDM_DEBUG
mazgch 76:f7c3dd568dae 2030 _debugLevel = -1;
mazgch 76:f7c3dd568dae 2031 #endif
mazgch 76:f7c3dd568dae 2032 }
mazgch 74:208e3e32d263 2033 #ifdef TARGET_UBLOX_C027
mazgch 74:208e3e32d263 2034 _onboard = (tx == MDMTXD) && (rx == MDMRXD);
mazgch 74:208e3e32d263 2035 if (_onboard)
mazgch 74:208e3e32d263 2036 c027_mdm_powerOn(false);
mazgch 74:208e3e32d263 2037 #endif
mazgch 18:e5697801df29 2038 baud(baudrate);
mazgch 35:9275215a3a5b 2039 #if DEVICE_SERIAL_FC
mazgch 35:9275215a3a5b 2040 if ((rts != NC) || (cts != NC))
mazgch 35:9275215a3a5b 2041 {
mazgch 35:9275215a3a5b 2042 Flow flow = (cts == NC) ? RTS :
mazgch 35:9275215a3a5b 2043 (rts == NC) ? CTS : RTSCTS ;
mazgch 35:9275215a3a5b 2044 set_flow_control(flow, rts, cts);
mazgch 35:9275215a3a5b 2045 if (cts != NC) _dev.lpm = LPM_ENABLED;
mazgch 35:9275215a3a5b 2046 }
mazgch 35:9275215a3a5b 2047 #endif
mazgch 18:e5697801df29 2048 }
mazgch 18:e5697801df29 2049
mazgch 76:f7c3dd568dae 2050 MDMSerial::~MDMSerial(void)
mazgch 76:f7c3dd568dae 2051 {
mazgch 76:f7c3dd568dae 2052 powerOff();
mazgch 76:f7c3dd568dae 2053 #ifdef TARGET_UBLOX_C027
mazgch 76:f7c3dd568dae 2054 if (_onboard)
mazgch 76:f7c3dd568dae 2055 c027_mdm_powerOff();
mazgch 76:f7c3dd568dae 2056 #endif
mazgch 76:f7c3dd568dae 2057 }
mazgch 76:f7c3dd568dae 2058
mazgch 18:e5697801df29 2059 int MDMSerial::_send(const void* buf, int len)
mazgch 18:e5697801df29 2060 {
mazgch 35:9275215a3a5b 2061 return put((const char*)buf, len, true/*=blocking*/);
mazgch 18:e5697801df29 2062 }
mazgch 18:e5697801df29 2063
mazgch 18:e5697801df29 2064 int MDMSerial::getLine(char* buffer, int length)
mazgch 18:e5697801df29 2065 {
mazgch 18:e5697801df29 2066 return _getLine(&_pipeRx, buffer, length);
mazgch 18:e5697801df29 2067 }
mazgch 18:e5697801df29 2068
mazgch 18:e5697801df29 2069 // ----------------------------------------------------------------
mazgch 18:e5697801df29 2070 // USB Implementation
mazgch 18:e5697801df29 2071 // ----------------------------------------------------------------
mazgch 18:e5697801df29 2072
mazgch 18:e5697801df29 2073 #ifdef HAVE_MDMUSB
mazgch 76:f7c3dd568dae 2074 MDMUsb::MDMUsb(void)
mazgch 74:208e3e32d263 2075 {
mazgch 74:208e3e32d263 2076 #ifdef MDM_DEBUG
mazgch 74:208e3e32d263 2077 _debugLevel = 1;
mazgch 74:208e3e32d263 2078 #endif
mazgch 74:208e3e32d263 2079 #ifdef TARGET_UBLOX_C027
mazgch 74:208e3e32d263 2080 _onboard = true;
mazgch 74:208e3e32d263 2081 c027_mdm_powerOn(true);
mazgch 74:208e3e32d263 2082 #endif
mazgch 74:208e3e32d263 2083 }
mazgch 76:f7c3dd568dae 2084
mazgch 76:f7c3dd568dae 2085 MDMUsb::~MDMUsb(void)
mazgch 76:f7c3dd568dae 2086 {
mazgch 76:f7c3dd568dae 2087 powerOff();
mazgch 76:f7c3dd568dae 2088 #ifdef TARGET_UBLOX_C027
mazgch 76:f7c3dd568dae 2089 if (_onboard)
mazgch 76:f7c3dd568dae 2090 c027_mdm_powerOff();
mazgch 76:f7c3dd568dae 2091 #endif
mazgch 76:f7c3dd568dae 2092 }
mazgch 76:f7c3dd568dae 2093
mazgch 76:f7c3dd568dae 2094 int MDMUsb::_send(const void* buf, int len) { return 0; }
mazgch 76:f7c3dd568dae 2095
mazgch 18:e5697801df29 2096 int MDMUsb::getLine(char* buffer, int length) { return NOT_FOUND; }
mazgch 76:f7c3dd568dae 2097
mazgch 35:9275215a3a5b 2098 #endif