source: rtos_arduino/trunk/arduino_lib/libraries/GSM/src/GSM3ShieldV1MultiClientProvider.cpp@ 136

Last change on this file since 136 was 136, checked in by ertl-honda, 8 years ago

ライブラリとOS及びベーシックなサンプルの追加．
File size: 14.3 KB
Line 
1#include <GSM3ShieldV1MultiClientProvider.h>
2#include <GSM3ShieldV1ModemCore.h>
3
4const char _command_MultiQISRVC[] PROGMEM = "AT+QISRVC=";
5
6#define __TOUTFLUSH__ 10000
7
8GSM3ShieldV1MultiClientProvider::GSM3ShieldV1MultiClientProvider()
9{
10 theGSM3MobileClientProvider=this;
11 theGSM3ShieldV1ModemCore.registerUMProvider(this);
12};
13
14//Response management.
15void GSM3ShieldV1MultiClientProvider::manageResponse(byte from, byte to)
16{
17 switch(theGSM3ShieldV1ModemCore.getOngoingCommand())
18 {
19 case XON:
20 if (flagReadingSocket)
21 {
22// flagReadingSocket = 0;
23 fullBufferSocket = (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()<3);
24 }
25 else theGSM3ShieldV1ModemCore.setOngoingCommand(NONE);
26 break;
27 case NONE:
28 theGSM3ShieldV1ModemCore.gss.cb.deleteToTheEnd(from);
29 break;
30 case CONNECTTCPCLIENT:
31 connectTCPClientContinue();
32 break;
33 case DISCONNECTTCP:
34 disconnectTCPContinue();
35 break;
36 case BEGINWRITESOCKET:
37 beginWriteSocketContinue();
38 break;
39 case ENDWRITESOCKET:
40 endWriteSocketContinue();
41 break;
42 case AVAILABLESOCKET:
43 availableSocketContinue();
44 break;
45 case FLUSHSOCKET:
46 fullBufferSocket = (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()<3);
47 flushSocketContinue();
48 break;
49 }
50}
51
52//Connect TCP main function.
53int GSM3ShieldV1MultiClientProvider::connectTCPClient(const char* server, int port, int id_socket)
54{
55 theGSM3ShieldV1ModemCore.setPort(port);
56 idSocket = id_socket;
57
58 theGSM3ShieldV1ModemCore.setPhoneNumber((char*)server);
59 theGSM3ShieldV1ModemCore.openCommand(this,CONNECTTCPCLIENT);
60 connectTCPClientContinue();
61 return theGSM3ShieldV1ModemCore.getCommandError();
62}
63
64int GSM3ShieldV1MultiClientProvider::connectTCPClient(IPAddress add, int port, int id_socket)
65{
66 remoteIP=add;
67 theGSM3ShieldV1ModemCore.setPhoneNumber(0);
68 return connectTCPClient(0, port, id_socket);
69}
70
71//Connect TCP continue function.
72void GSM3ShieldV1MultiClientProvider::connectTCPClientContinue()
73{
74 bool resp;
75 // 0: Dot or DNS notation activation
76 // 1: Disable SW flow control
77 // 2: Waiting for IFC OK
78 // 3: Start-up TCP connection "AT+QIOPEN"
79 // 4: Wait for connection OK
80 // 5: Wait for CONNECT
81
82 switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
83 case 1:
84 theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+QIDNSIP="), false);
85 if ((theGSM3ShieldV1ModemCore.getPhoneNumber()!=0)&&
86 ((*(theGSM3ShieldV1ModemCore.getPhoneNumber())<'0')||((*(theGSM3ShieldV1ModemCore.getPhoneNumber())>'9'))))
87 {
88 theGSM3ShieldV1ModemCore.print('1');
89 theGSM3ShieldV1ModemCore.print('\r');
90 }
91 else
92 {
93 theGSM3ShieldV1ModemCore.print('0');
94 theGSM3ShieldV1ModemCore.print('\r');
95 }
96 theGSM3ShieldV1ModemCore.setCommandCounter(2);
97 break;
98 case 2:
99 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
100 {
101 //Response received
102 if(resp)
103 {
104 // AT+QIOPEN
105 theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+QIOPEN="),false);
106 theGSM3ShieldV1ModemCore.print(idSocket);
107 theGSM3ShieldV1ModemCore.print(",\"TCP\",\"");
108 if(theGSM3ShieldV1ModemCore.getPhoneNumber()!=0)
109 {
110 theGSM3ShieldV1ModemCore.print(theGSM3ShieldV1ModemCore.getPhoneNumber());
111 }
112 else
113 {
114 remoteIP.printTo(theGSM3ShieldV1ModemCore);
115 }
116 theGSM3ShieldV1ModemCore.print('"');
117 theGSM3ShieldV1ModemCore.print(',');
118 theGSM3ShieldV1ModemCore.print(theGSM3ShieldV1ModemCore.getPort());
119 theGSM3ShieldV1ModemCore.print('\r');
120 theGSM3ShieldV1ModemCore.setCommandCounter(3);
121 }
122 else theGSM3ShieldV1ModemCore.closeCommand(3);
123 }
124 break;
125
126 case 3:
127 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
128 {
129 // Response received
130 if(resp)
131 {
132 // OK Received
133 // Great. Go for the next step
134 theGSM3ShieldV1ModemCore.setCommandCounter(4);
135 }
136 else theGSM3ShieldV1ModemCore.closeCommand(3);
137 }
138 break;
139 case 4:
140 char auxLocate [12];
141 prepareAuxLocate(PSTR("CONNECT OK"), auxLocate);
142 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp,auxLocate))
143 {
144 // Response received
145 if(resp)
146 {
147 // Received CONNECT OK
148 // Great. We're done
149 theGSM3ShieldV1ModemCore.closeCommand(1);
150 }
151 else
152 theGSM3ShieldV1ModemCore.closeCommand(3);
153 }
154 break;
155
156 }
157}
158
159//Disconnect TCP main function.
160int GSM3ShieldV1MultiClientProvider::disconnectTCP(bool client1Server0, int id_socket)
161{
162 idSocket = id_socket;
163
164 // First of all, we will flush the socket synchronously
165 unsigned long m;
166 m=millis();
167 flushSocket();
168 while(((millis()-m)< __TOUTFLUSH__ )&&(ready()==0))
169 delay(10);
170
171 // Could not flush the communications... strange
172 if(ready()==0)
173 {
174 theGSM3ShieldV1ModemCore.setCommandError(2);
175 return theGSM3ShieldV1ModemCore.getCommandError();
176 }
177
178 // Set up the command
179 client1_server0 = client1Server0;
180 flagReadingSocket=0;
181 theGSM3ShieldV1ModemCore.openCommand(this,DISCONNECTTCP);
182 disconnectTCPContinue();
183 return theGSM3ShieldV1ModemCore.getCommandError();
184}
185
186//Disconnect TCP continue function
187void GSM3ShieldV1MultiClientProvider::disconnectTCPContinue()
188{
189 bool resp;
190 // 1: Send AT+QISRVC
191 // 2: "AT+QICLOSE"
192 // 3: Wait for OK
193
194 switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
195 case 1:
196 theGSM3ShieldV1ModemCore.genericCommand_rq(_command_MultiQISRVC, false);
197 if (client1_server0) theGSM3ShieldV1ModemCore.print('1');
198 else theGSM3ShieldV1ModemCore.print('2');
199 theGSM3ShieldV1ModemCore.print('\r');
200 theGSM3ShieldV1ModemCore.setCommandCounter(2);
201 break;
202 case 2:
203 // Parse response to QISRVC
204 theGSM3ShieldV1ModemCore.genericParse_rsp(resp);
205 if(resp)
206 {
207 // Send QICLOSE command
208 theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+QICLOSE="),false);
209 theGSM3ShieldV1ModemCore.print(idSocket);
210 theGSM3ShieldV1ModemCore.print('\r');
211 theGSM3ShieldV1ModemCore.setCommandCounter(3);
212 }
213 else
214 theGSM3ShieldV1ModemCore.closeCommand(3);
215 break;
216 case 3:
217 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
218 {
219 theGSM3ShieldV1ModemCore.setCommandCounter(0);
220 if (resp)
221 theGSM3ShieldV1ModemCore.closeCommand(1);
222 else
223 theGSM3ShieldV1ModemCore.closeCommand(3);
224 }
225 break;
226 }
227}
228
229//Write socket first chain main function.
230void GSM3ShieldV1MultiClientProvider::beginWriteSocket(bool client1Server0, int id_socket)
231{
232 idSocket = id_socket;
233 client1_server0 = client1Server0;
234 theGSM3ShieldV1ModemCore.openCommand(this,BEGINWRITESOCKET);
235 beginWriteSocketContinue();
236}
237
238//Write socket first chain continue function.
239void GSM3ShieldV1MultiClientProvider::beginWriteSocketContinue()
240{
241 bool resp;
242 // 1: Send AT+QISRVC
243 // 2: Send AT+QISEND
244 // 3: wait for > and Write text
245 switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
246 case 1:
247 // AT+QISRVC
248 theGSM3ShieldV1ModemCore.genericCommand_rq(_command_MultiQISRVC, false);
249 if (client1_server0)
250 theGSM3ShieldV1ModemCore.print('1');
251 else
252 theGSM3ShieldV1ModemCore.print('2');
253 theGSM3ShieldV1ModemCore.print('\r');
254 theGSM3ShieldV1ModemCore.setCommandCounter(2);
255 break;
256 case 2:
257 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
258 {
259 // Response received
260 if(resp)
261 {
262 // AT+QISEND
263 theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+QISEND="), false);
264 theGSM3ShieldV1ModemCore.print(idSocket);
265 theGSM3ShieldV1ModemCore.print('\r');
266 theGSM3ShieldV1ModemCore.setCommandCounter(3);
267 }
268 else
269 {
270 theGSM3ShieldV1ModemCore.closeCommand(3);
271 }
272 }
273 break;
274 case 3:
275 char aux[2];
276 aux[0]='>';
277 aux[1]=0;
278 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp, aux))
279 {
280 if(resp)
281 {
282 // Received ">"
283 theGSM3ShieldV1ModemCore.closeCommand(1);
284 }
285 else
286 {
287 theGSM3ShieldV1ModemCore.closeCommand(3);
288 }
289 }
290 break;
291 }
292}
293
294//Write socket next chain function.
295void GSM3ShieldV1MultiClientProvider::writeSocket(const char* buf)
296{
297 theGSM3ShieldV1ModemCore.print(buf);
298}
299
300//Write socket character function.
301void GSM3ShieldV1MultiClientProvider::writeSocket(char c)
302{
303 theGSM3ShieldV1ModemCore.print(c);
304}
305
306//Write socket last chain main function.
307void GSM3ShieldV1MultiClientProvider::endWriteSocket()
308{
309 theGSM3ShieldV1ModemCore.openCommand(this,ENDWRITESOCKET);
310 endWriteSocketContinue();
311}
312
313//Write socket last chain continue function.
314void GSM3ShieldV1MultiClientProvider::endWriteSocketContinue()
315{
316 bool resp;
317 // 1: Write text (ctrl-Z)
318 // 2: Wait for OK
319 switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
320 case 1:
321 theGSM3ShieldV1ModemCore.write(26); // Ctrl-Z
322 theGSM3ShieldV1ModemCore.setCommandCounter(2);
323 break;
324 case 2:
325 if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
326 {
327 // OK received
328 if (resp) theGSM3ShieldV1ModemCore.closeCommand(1);
329 else theGSM3ShieldV1ModemCore.closeCommand(3);
330 }
331 break;
332 }
333}
334
335//Available socket main function.
336int GSM3ShieldV1MultiClientProvider::availableSocket(bool client1Server0, int id_socket)
337{
338 if(flagReadingSocket==1)
339 {
340 theGSM3ShieldV1ModemCore.setCommandError(1);
341 return 1;
342 }
343 client1_server0 = client1Server0;
344 idSocket = id_socket;
345 theGSM3ShieldV1ModemCore.openCommand(this,AVAILABLESOCKET);
346 availableSocketContinue();
347 return theGSM3ShieldV1ModemCore.getCommandError();
348}
349
350//Available socket continue function.
351void GSM3ShieldV1MultiClientProvider::availableSocketContinue()
352{
353 bool resp;
354 // 1: AT+QIRD
355 // 2: Wait for OK and Next necessary AT+QIRD
356
357 switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
358 case 1:
359 theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+QIRD=0,"),false);
360 if (client1_server0)
361 theGSM3ShieldV1ModemCore.print('1');
362 else
363 theGSM3ShieldV1ModemCore.print('2');
364 theGSM3ShieldV1ModemCore.print(',');
365 theGSM3ShieldV1ModemCore.print(idSocket);
366 theGSM3ShieldV1ModemCore.print(",1500");
367 // theGSM3ShieldV1ModemCore.print(",120");
368 theGSM3ShieldV1ModemCore.print('\r');
369 theGSM3ShieldV1ModemCore.setCommandCounter(2);
370 break;
371 case 2:
372 if(parseQIRD_head(resp))
373 {
374 if (!resp)
375 {
376 theGSM3ShieldV1ModemCore.closeCommand(4);
377 }
378 else
379 {
380 flagReadingSocket=1;
381 theGSM3ShieldV1ModemCore.closeCommand(1);
382 }
383 }
384 else
385 {
386 theGSM3ShieldV1ModemCore.closeCommand(3);
387 }
388 break;
389 }
390}
391
392//Read Socket Parse head.
393bool GSM3ShieldV1MultiClientProvider::parseQIRD_head(bool& rsp)
394{
395 char _qird [8];
396 prepareAuxLocate(PSTR("+QIRD:"), _qird);
397 fullBufferSocket = (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()<3);
398 if(theGSM3ShieldV1ModemCore.theBuffer().locate(_qird))
399 {
400 theGSM3ShieldV1ModemCore.theBuffer().chopUntil(_qird, true);
401 // Saving more memory, reuse _qird
402 _qird[0]='\n';
403 _qird[1]=0;
404 theGSM3ShieldV1ModemCore.theBuffer().chopUntil(_qird, true);
405 rsp = true;
406 return true;
407 }
408 else if(theGSM3ShieldV1ModemCore.theBuffer().locate("OK"))
409 {
410 rsp = false;
411 return true;
412 }
413 else
414 {
415 rsp = false;
416 return false;
417 }
418}
419/*
420//Read socket main function.
421int GSM3ShieldV1MultiClientProvider::readSocket()
422{
423 char charSocket;
424 charSocket = theGSM3ShieldV1ModemCore.theBuffer().read();
425 //Case buffer not full
426 if (!fullBufferSocket)
427 {
428 //The last part of the buffer after data is CRLFOKCRLF
429 if (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()==125)
430 {
431 //Start again availableSocket function.
432 flagReadingSocket=0;
433 theGSM3ShieldV1ModemCore.openCommand(this,AVAILABLESOCKET);
434 availableSocketContinue();
435 }
436 }
437 else if (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()==127)
438 {
439 // The buffer is full, no more action is possible until we have read()
440 theGSM3ShieldV1ModemCore.theBuffer().flush();
441 flagReadingSocket = 1;
442 theGSM3ShieldV1ModemCore.openCommand(this,XON);
443 theGSM3ShieldV1ModemCore.gss.spaceAvailable();
444 //A small delay to assure data received after xon.
445 delay(10);
446 }
447 //To distinguish the case no more available data in socket.
448 if (ready()==1)
449 return charSocket;
450 else
451 return 0;
452}
453*/
454int GSM3ShieldV1MultiClientProvider::readSocket()
455{
456 char charSocket;
457
458 if(theGSM3ShieldV1ModemCore.theBuffer().availableBytes()==0)
459 {
460 Serial.println();Serial.println("*");
461 return 0;
462 }
463
464 charSocket = theGSM3ShieldV1ModemCore.theBuffer().read();
465 //Case buffer not full
466 if (!fullBufferSocket)
467 {
468 //The last part of the buffer after data is CRLFOKCRLF
469 if (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()==125)
470 {
471 //Start again availableSocket function.
472 flagReadingSocket=0;
473 theGSM3ShieldV1ModemCore.openCommand(this,AVAILABLESOCKET);
474 availableSocketContinue();
475 }
476 }
477 else if (theGSM3ShieldV1ModemCore.theBuffer().availableBytes()>=100)
478 {
479 // The buffer was full, we have to let the data flow again
480 // theGSM3ShieldV1ModemCore.theBuffer().flush();
481 flagReadingSocket = 1;
482 theGSM3ShieldV1ModemCore.openCommand(this,XON);
483 theGSM3ShieldV1ModemCore.gss.spaceAvailable();
484 //A small delay to assure data received after xon.
485 delay(100);
486 if(theGSM3ShieldV1ModemCore.theBuffer().availableBytes() >=6)
487 fullBufferSocket=false;
488 }
489
490 return charSocket;
491
492}
493
494//Read socket main function.
495int GSM3ShieldV1MultiClientProvider::peekSocket()
496{
497 return theGSM3ShieldV1ModemCore.theBuffer().peek(0);
498}
499
500
501//Flush SMS main function.
502void GSM3ShieldV1MultiClientProvider::flushSocket()
503{
504 flagReadingSocket=0;
505 theGSM3ShieldV1ModemCore.openCommand(this,FLUSHSOCKET);
506 flushSocketContinue();
507}
508
509//Send SMS continue function.
510void GSM3ShieldV1MultiClientProvider::flushSocketContinue()
511{
512 bool resp;
513 // 1: Deleting SMS
514 // 2: wait for OK
515 switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
516 case 1:
517 //DEBUG
518 //Serial.println("Flushing Socket.");
519 theGSM3ShieldV1ModemCore.theBuffer().flush();
520 if (fullBufferSocket)
521 {
522 //Serial.println("Buffer flushed.");
523 theGSM3ShieldV1ModemCore.gss.spaceAvailable();
524 }
525 else
526 {
527 //Serial.println("Socket flushed completely.");
528 theGSM3ShieldV1ModemCore.closeCommand(1);
529 }
530 break;
531 }
532}
533
534//URC recognize.
535// Momentarily, we will not recognize "closes" in client mode
536bool GSM3ShieldV1MultiClientProvider::recognizeUnsolicitedEvent(byte oldTail)
537{
538 return false;
539}
540
541int GSM3ShieldV1MultiClientProvider::getSocket(int socket)
542{
543 if(socket==-1)
544 {
545 int i;
546 for(i=minSocket(); i<=maxSocket(); i++)
547 {
548 if (!(sockets&(0x0001<<i)))
549 {
550 sockets|=((0x0001)<<i);
551 return i;
552 }
553 }
554 }
555 else
556 {
557 if (!(sockets&(0x0001<<socket)))
558 {
559 sockets|=((0x0001)<<socket);
560 return socket;
561 }
562 }
563 return -1;
564}
565
566void GSM3ShieldV1MultiClientProvider::releaseSocket(int socket)
567{
568 if (sockets&((0x0001)<<socket))
569 sockets^=((0x0001)<<socket);
570}
571
572bool GSM3ShieldV1MultiClientProvider::getStatusSocketClient(uint8_t socket)
573{
574 if(socket>8)
575 return 0;
576 if(sockets&(0x0001<<socket))
577 return 1;
578 else
579 return 0;
580};
581
582
583
Note: See TracBrowser for help on using the repository browser.