source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/libraries/GSM/src/GSM3ShieldV1AccessProvider.cpp @ 46

Last change on this file since 46 was 46, checked in by jrpelegrina, 4 years ago

First release to Xenial

File size: 9.3 KB
Line 
1/*
2This file is part of the GSM3 communications library for Arduino
3-- Multi-transport communications platform
4-- Fully asynchronous
5-- Includes code for the Arduino-Telefonica GSM/GPRS Shield V1
6-- Voice calls
7-- SMS
8-- TCP/IP connections
9-- HTTP basic clients
10
11This library has been developed by Telefónica Digital - PDI -
12- Physical Internet Lab, as part as its collaboration with
13Arduino and the Open Hardware Community.
14
15September-December 2012
16
17This library is free software; you can redistribute it and/or
18modify it under the terms of the GNU Lesser General Public
19License as published by the Free Software Foundation; either
20version 2.1 of the License, or (at your option) any later version.
21
22This library is distributed in the hope that it will be useful,
23but WITHOUT ANY WARRANTY; without even the implied warranty of
24MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25Lesser General Public License for more details.
26
27You should have received a copy of the GNU Lesser General Public
28License along with this library; if not, write to the Free Software
29Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
30
31The latest version of this library can always be found at
32https://github.com/BlueVia/Official-Arduino
33*/
34#include <GSM3ShieldV1AccessProvider.h>
35#include <Arduino.h>
36#include "GSM3IO.h"
37
38#define __TOUTSHUTDOWN__ 5000
39#define __TOUTMODEMCONFIGURATION__ 5000//equivalent to 30000 because of time in interrupt routine.
40#define __TOUTAT__ 1000
41
42const char _command_AT[] PROGMEM = "AT";
43const char _command_CGREG[] PROGMEM = "AT+CGREG?";
44
45
46GSM3ShieldV1AccessProvider::GSM3ShieldV1AccessProvider(bool debug)
47{
48        theGSM3ShieldV1ModemCore.setDebug(debug);
49
50}
51
52void GSM3ShieldV1AccessProvider::manageResponse(byte from, byte to)
53{
54        switch(theGSM3ShieldV1ModemCore.getOngoingCommand())
55        {
56                case MODEMCONFIG:
57                        ModemConfigurationContinue();
58                        break;
59                case ALIVETEST:
60                        isModemAliveContinue();
61                        break;
62        }
63}
64
65///////////////////////////////////////////////////////CONFIGURATION FUNCTIONS///////////////////////////////////////////////////////////////////
66
67// Begin
68// Restart or start the modem
69// May be synchronous
70GSM3_NetworkStatus_t GSM3ShieldV1AccessProvider::begin(char* pin, bool restart, bool synchronous)
71{       
72        pinMode(__RESETPIN__, OUTPUT);
73
74        #ifdef TTOPEN_V1
75        pinMode(__POWERPIN__, OUTPUT);
76        digitalWrite(__POWERPIN__, HIGH);
77        #endif
78
79        // If asked for modem restart, restart
80        if (restart) 
81                HWrestart();
82        else 
83                HWstart();
84 
85        theGSM3ShieldV1ModemCore.gss.begin(9600);
86        // Launch modem configuration commands
87        ModemConfiguration(pin);
88        // If synchronous, wait till ModemConfiguration is over
89        if(synchronous)
90        {
91                // if we shorten this delay, the command fails
92                while(ready()==0) 
93                        delay(1000); 
94        }
95        return getStatus();
96}
97
98//HWrestart.
99int GSM3ShieldV1AccessProvider::HWrestart()
100{
101        #ifdef TTOPEN_V1
102        digitalWrite(__POWERPIN__, HIGH);
103        delay(1000);
104        #endif
105       
106        theGSM3ShieldV1ModemCore.setStatus(IDLE);
107        digitalWrite(__RESETPIN__, HIGH);
108        delay(12000);
109        digitalWrite(__RESETPIN__, LOW);
110        delay(1000);
111        return 1; //configandwait(pin);
112}
113
114//HWrestart.
115int GSM3ShieldV1AccessProvider::HWstart()
116{
117
118        theGSM3ShieldV1ModemCore.setStatus(IDLE);
119        digitalWrite(__RESETPIN__, HIGH);
120        delay(2000);
121        digitalWrite(__RESETPIN__, LOW);
122        //delay(1000);
123
124        return 1; //configandwait(pin);
125}
126
127//Initial configuration main function.
128int GSM3ShieldV1AccessProvider::ModemConfiguration(char* pin)
129{
130        theGSM3ShieldV1ModemCore.setPhoneNumber(pin);
131        theGSM3ShieldV1ModemCore.openCommand(this,MODEMCONFIG);
132        theGSM3ShieldV1ModemCore.setStatus(CONNECTING);
133        ModemConfigurationContinue();
134        return theGSM3ShieldV1ModemCore.getCommandError();
135}
136
137//Initial configuration continue function.
138void GSM3ShieldV1AccessProvider::ModemConfigurationContinue()
139{
140        bool resp;
141
142        // 1: Send AT
143        // 2: Wait AT OK and SetPin or CGREG
144        // 3: Wait Pin OK and CGREG
145        // 4: Wait CGREG and Flow SW control or CGREG
146        // 5: Wait IFC OK and SMS Text Mode
147        // 6: Wait SMS text Mode OK and Calling line identification
148        // 7: Wait Calling Line Id OK and Echo off
149        // 8: Wait for OK and COLP command for connecting line identification.
150        // 9: Wait for OK.
151        int ct=theGSM3ShieldV1ModemCore.getCommandCounter();
152        if(ct==1)
153        {
154                // Launch AT   
155                theGSM3ShieldV1ModemCore.setCommandCounter(2);
156                theGSM3ShieldV1ModemCore.genericCommand_rq(_command_AT);
157        }
158        else if(ct==2)
159        {
160                // Wait for AT - OK.
161           if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
162           {
163                        if(resp)
164                        { 
165                                // OK received
166                                if(theGSM3ShieldV1ModemCore.getPhoneNumber() && (theGSM3ShieldV1ModemCore.getPhoneNumber()[0]!=0)) 
167                                        {
168                                                theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+CPIN="), false);
169                                                theGSM3ShieldV1ModemCore.setCommandCounter(3);
170                                                theGSM3ShieldV1ModemCore.genericCommand_rqc(theGSM3ShieldV1ModemCore.getPhoneNumber());
171                                        }
172                                else 
173                                        {
174                                                //DEBUG
175                                                //Serial.println("AT+CGREG?"); 
176                                                theGSM3ShieldV1ModemCore.setCommandCounter(4);
177                                                theGSM3ShieldV1ModemCore.takeMilliseconds();
178                                                theGSM3ShieldV1ModemCore.genericCommand_rq(_command_CGREG);
179                                        }
180                        }
181                        else theGSM3ShieldV1ModemCore.closeCommand(3);
182                }
183        }
184        else if(ct==3)
185        {
186                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
187            {
188                        if(resp)
189                        {
190                                theGSM3ShieldV1ModemCore.setCommandCounter(4);
191                                theGSM3ShieldV1ModemCore.takeMilliseconds();
192                                theGSM3ShieldV1ModemCore.delayInsideInterrupt(2000);
193                                theGSM3ShieldV1ModemCore.genericCommand_rq(_command_CGREG);
194                        }
195                        else theGSM3ShieldV1ModemCore.closeCommand(3);
196            }
197        }
198        else if(ct==4)
199        {
200                char auxLocate1 [12];
201                char auxLocate2 [12];
202                prepareAuxLocate(PSTR("+CGREG: 0,1"), auxLocate1);
203                prepareAuxLocate(PSTR("+CGREG: 0,5"), auxLocate2);
204                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp, auxLocate1, auxLocate2))
205                {
206                        if(resp)
207                        {
208                                theGSM3ShieldV1ModemCore.setCommandCounter(5);
209                                theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+IFC=1,1"));
210                        }
211                        else
212                        {
213                                // If not, launch command again
214                                if(theGSM3ShieldV1ModemCore.takeMilliseconds() > __TOUTMODEMCONFIGURATION__)
215                                {
216                                        theGSM3ShieldV1ModemCore.closeCommand(3);
217                                }
218                                else 
219                                {
220                                        theGSM3ShieldV1ModemCore.delayInsideInterrupt(2000);
221                                        theGSM3ShieldV1ModemCore.genericCommand_rq(_command_CGREG);
222                                }
223                        }
224                }       
225        }
226        else if(ct==5)
227        {
228                // 5: Wait IFC OK
229                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
230                {
231                        //Delay for SW flow control being active.
232                        theGSM3ShieldV1ModemCore.delayInsideInterrupt(2000);
233                        // 9: SMS Text Mode
234                        theGSM3ShieldV1ModemCore.setCommandCounter(6);
235                        theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+CMGF=1"));
236                }
237        }
238        else if(ct==6)
239        {
240                // 6: Wait SMS text Mode OK
241                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
242                {
243                        //Calling line identification
244                        theGSM3ShieldV1ModemCore.setCommandCounter(7);                 
245                        theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+CLIP=1"));
246                }
247        }
248        else if(ct==7)
249        {
250                // 7: Wait Calling Line Id OK
251                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
252                {
253                        // Echo off
254                        theGSM3ShieldV1ModemCore.setCommandCounter(8);                 
255                        theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("ATE0"));
256                }
257        }
258        else if(ct==8)
259        {
260                // 8: Wait ATEO OK, send COLP
261                // In Arduino Mega, attention, take away the COLP step
262                // It looks as we can only have 8 steps
263                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
264                {
265                        theGSM3ShieldV1ModemCore.setCommandCounter(9);
266                        theGSM3ShieldV1ModemCore.genericCommand_rq(PSTR("AT+COLP=1"));
267                }
268        }
269        else if(ct==9)
270        {
271                // 9: Wait ATCOLP OK
272                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp))
273                {
274                        if (resp) 
275                                {
276                                        theGSM3ShieldV1ModemCore.setStatus(GSM_READY);
277                                        theGSM3ShieldV1ModemCore.closeCommand(1);
278                                }
279                        else theGSM3ShieldV1ModemCore.closeCommand(3);
280                }
281        }
282}
283
284//Alive Test main function.
285int GSM3ShieldV1AccessProvider::isAccessAlive()
286{
287        theGSM3ShieldV1ModemCore.setCommandError(0);
288        theGSM3ShieldV1ModemCore.setCommandCounter(1);
289        theGSM3ShieldV1ModemCore.openCommand(this,ALIVETEST);
290        isModemAliveContinue();
291        return theGSM3ShieldV1ModemCore.getCommandError();
292}
293
294//Alive Test continue function.
295void GSM3ShieldV1AccessProvider::isModemAliveContinue()
296{
297bool rsp;
298switch (theGSM3ShieldV1ModemCore.getCommandCounter()) {
299    case 1:
300                theGSM3ShieldV1ModemCore.genericCommand_rq(_command_AT);
301                theGSM3ShieldV1ModemCore.setCommandCounter(2);
302      break;
303        case 2:
304                if(theGSM3ShieldV1ModemCore.genericParse_rsp(rsp))
305                {
306                        if (rsp) theGSM3ShieldV1ModemCore.closeCommand(1);
307                        else theGSM3ShieldV1ModemCore.closeCommand(3);
308                }
309      break;
310        }
311}
312
313//Shutdown.
314bool GSM3ShieldV1AccessProvider::shutdown()
315{
316        unsigned long m;
317        bool resp;
318        char auxLocate [18];
319       
320        // It makes no sense to have an asynchronous shutdown
321        pinMode(__RESETPIN__, OUTPUT);
322        digitalWrite(__RESETPIN__, HIGH);
323        delay(1500);
324        digitalWrite(__RESETPIN__, LOW);
325        theGSM3ShieldV1ModemCore.setStatus(IDLE);
326        theGSM3ShieldV1ModemCore.gss.close();
327       
328        m=millis();
329        prepareAuxLocate(PSTR("POWER DOWN"), auxLocate);
330        while((millis()-m) < __TOUTSHUTDOWN__)
331        {
332                delay(1);
333                if(theGSM3ShieldV1ModemCore.genericParse_rsp(resp, auxLocate))
334                        return resp;
335        }
336        return false;
337}
338
339//Secure shutdown.
340bool GSM3ShieldV1AccessProvider::secureShutdown()
341{
342        // It makes no sense to have an asynchronous shutdown
343        pinMode(__RESETPIN__, OUTPUT);
344        digitalWrite(__RESETPIN__, HIGH);
345        delay(900);
346        digitalWrite(__RESETPIN__, LOW);
347        theGSM3ShieldV1ModemCore.setStatus(OFF);
348        theGSM3ShieldV1ModemCore.gss.close();
349
350#ifdef TTOPEN_V1
351        _delay_ms(12000);
352        digitalWrite(__POWERPIN__, LOW);
353#endif
354       
355        return true;
356}
Note: See TracBrowser for help on using the repository browser.