wnc_control.cpp

00001 #include "mbed.h"
00002 #include <cctype>
00003 #include <string>
00004 #include "config_me.h"
00005 #include "SerialBuffered.h"
00006 #include "wnc_control.h"
00007 
00008 extern Serial pc;
00009 extern Serial mdm;
00010 extern string MyServerIpAddress;
00011 extern string MySocketData;
00012 
00013 int reinitialize_mdm(void);
00014 
00015 enum WNC_ERR_e {
00016     WNC_OK =0,
00017     WNC_CMD_ERR = -1,
00018     WNC_NO_RESPONSE = -2
00019 };
00020 
00021 // Contains result of last call to send_wnc_cmd(..)
00022 WNC_ERR_e WNC_MDM_ERR = WNC_OK;
00023 
00024 // Contains the RAW WNC UART responses
00025 static string wncStr;
00026 static int socketOpen = 0;
00027 
00028 void software_init_mdm(void)
00029 {
00030   do
00031   {
00032     WNC_MDM_ERR = WNC_OK;
00033     at_init_wnc();
00034     if (WNC_MDM_ERR != WNC_OK)
00035       reinitialize_mdm();
00036   } while (WNC_MDM_ERR != WNC_OK); 
00037 }
00038 
00039 void resolve_mdm(void)
00040 {
00041     do
00042     {
00043       WNC_MDM_ERR = WNC_OK;
00044       at_dnsresolve_wnc(MY_SERVER_URL, &MyServerIpAddress);
00045       if (WNC_MDM_ERR == WNC_NO_RESPONSE)
00046       {
00047         reinitialize_mdm();
00048         software_init_mdm();
00049       }
00050       else if (WNC_MDM_ERR == WNC_CMD_ERR)
00051       {
00052         pc.puts("Bad URL!!!!!!\r\n");
00053         MyServerIpAddress = "192.168.0.1";
00054         WNC_MDM_ERR = WNC_OK;
00055       }
00056     } while (WNC_MDM_ERR != WNC_OK);
00057     
00058     pc.printf("My Server IP: %s\r\n", MyServerIpAddress.data());
00059 }
00060 
00061 void sockopen_mdm(void)
00062 {
00063     do
00064     {
00065       at_at_wnc();
00066       at_at_wnc();
00067       WNC_MDM_ERR = WNC_OK;
00068       at_sockopen_wnc(MyServerIpAddress, MY_PORT_STR);
00069       if (WNC_MDM_ERR == WNC_NO_RESPONSE)
00070       {
00071         reinitialize_mdm();
00072         software_init_mdm();
00073       }
00074       else if (WNC_MDM_ERR == WNC_CMD_ERR)
00075         pc.puts("Socket open fail!!!!\r\n");
00076       else
00077         socketOpen = 1;
00078     } while (WNC_MDM_ERR != WNC_OK);
00079 }
00080 
00081 void sockwrite_mdm(const char * s)
00082 {
00083     if (socketOpen == 1)
00084     {
00085     do
00086     {
00087       WNC_MDM_ERR = WNC_OK;
00088       at_sockwrite_wnc(s);
00089       printf("\n\nINSIDE SOCKWRITE\n\n");
00090       if (WNC_MDM_ERR == WNC_NO_RESPONSE)
00091       {
00092         reinitialize_mdm();
00093         software_init_mdm();
00094       }
00095       else if (WNC_MDM_ERR == WNC_CMD_ERR)
00096       {
00097         pc.puts("Socket Write fail!!!\r\n");
00098         // Have seen when write fails modem gets stuck in bad state, try to recover
00099         reinitialize_mdm();
00100         software_init_mdm();
00101       }
00102     } while (WNC_MDM_ERR != WNC_OK);
00103     }
00104     else
00105       puts("Socket is closed for write!\r\n");
00106 }
00107 
00108 void sockread_mdm(string * sockData, int len, int retries)
00109 {
00110     if (socketOpen == 1)
00111     {
00112     do
00113     {
00114       WNC_MDM_ERR = WNC_OK;
00115       at_sockread_wnc(sockData, len, retries);
00116       if (WNC_MDM_ERR == WNC_NO_RESPONSE)
00117       {
00118         reinitialize_mdm();
00119         software_init_mdm();
00120       }
00121       else if (WNC_MDM_ERR == WNC_CMD_ERR)
00122         puts("Sock read fail!!!!\r\n");
00123     } while (WNC_MDM_ERR != WNC_OK);
00124     }
00125     else
00126       puts("Socket is closed for read\r\n");
00127 }
00128 
00129 void sockclose_mdm(void)
00130 {
00131     do
00132     {
00133       WNC_MDM_ERR = WNC_OK;
00134       at_sockclose_wnc();
00135       // Assume close happened even if it went bad
00136       // going bad will result in a re-init anyways and if close
00137       // fails we're pretty much in bad state and not much can do
00138       socketOpen = 0;
00139       if (WNC_MDM_ERR == WNC_NO_RESPONSE)
00140       {
00141         reinitialize_mdm();
00142         software_init_mdm();
00143       }
00144       else if (WNC_MDM_ERR == WNC_CMD_ERR)
00145         puts("Sock close fail!!!\r\n");
00146     } while (WNC_MDM_ERR != WNC_OK);
00147 }
00148 
00149 /**                                                                                                                                                          
00150  * C++ version 0.4 char* style "itoa":                                                                                                                       
00151  * Written by Lukás Chmela                                                                                                                                   
00152  * Released under GPLv3.                                                                                                                                     
00153 */
00154  
00155 char* itoa(int value, char* result, int base)                                                                                                          
00156 {                                                                                                                                                        
00157     // check that the base if valid                                                                                                                      
00158     if ( base < 2 || base > 36 ) {                                                                                                                       
00159         *result = '\0';                                                                                                                                  
00160         return result;                                                                                                                                   
00161     }                                                                                                                                                    
00162  
00163     char* ptr = result, *ptr1 = result, tmp_char;                                                                                                        
00164     int tmp_value;                                                                                                                                       
00165  
00166     do {                                                                                                                                                 
00167         tmp_value = value;                                                                                                                               
00168         value /= base;                                                                                                                                   
00169         *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"[35 + (tmp_value - value * base)];                             
00170     } while ( value );                                                                                                                                   
00171  
00172     // Apply negative sign                                                                                                                               
00173     if ( tmp_value < 0 )                                                                                                                                 
00174     *ptr++ = '-';                                                                                                                                    
00175     *ptr-- = '\0';                                                                                                                                       
00176  
00177     while ( ptr1 < ptr ) {                                                                                                                               
00178     tmp_char = *ptr;                                                                                                                                 
00179     *ptr-- = *ptr1;                                                                                                                                  
00180     *ptr1++ = tmp_char;                                                                                                                              
00181     }                                                                                                                                                    
00182  
00183     return result;                                                                                                                                       
00184 }
00185 
00186 extern int mdm_sendAtCmdRsp(const char *cmd, const char **rsp_list, int timeout_ms, string * rsp, int * len);
00187 
00188 // Sets a global with failure or success, assumes 1 thread all the time
00189 int send_wnc_cmd(const char * s, string ** r, int ms_timeout)
00190 {
00191   static const char * rsp_lst[] = { "OK", "ERROR", NULL };
00192   int len;
00193   
00194   pc.printf("Send: %s\r\n",s);
00195   int res = mdm_sendAtCmdRsp(s, rsp_lst, ms_timeout, &wncStr, &len);
00196   *r = &wncStr;   // Return a pointer to the static string
00197       
00198       printf("\n\nIN SEND WNC COMMAND\n\n");
00199       
00200   if (res >= 0)
00201   {
00202       pc.puts("[");
00203       pc.puts(wncStr.data());
00204       pc.puts("]\n\r");
00205       if (res > 0)
00206       {
00207           if (WNC_MDM_ERR != WNC_NO_RESPONSE)
00208             WNC_MDM_ERR = WNC_CMD_ERR;
00209           return -1;
00210       }
00211       else
00212           return 0;
00213   }
00214   else
00215   {
00216       WNC_MDM_ERR = WNC_NO_RESPONSE;
00217       pc.puts("No response from WNC!\n\r");
00218       return -2;
00219   }
00220 }
00221 
00222 void at_at_wnc(void)
00223 {
00224     string * pRespStr;
00225     send_wnc_cmd("AT", &pRespStr, WNC_TIMEOUT_MS); // Heartbeat?
00226 }
00227 
00228 void at_init_wnc(void)
00229 {
00230   string * pRespStr;
00231   send_wnc_cmd("AT", &pRespStr, WNC_TIMEOUT_MS);             // Heartbeat?
00232   send_wnc_cmd("ATE1", &pRespStr, WNC_TIMEOUT_MS);           // Echo ON
00233   string cmd_str("AT%PDNSET=1,");
00234   cmd_str += MY_APN_STR;
00235   cmd_str += ",IP";
00236   send_wnc_cmd(cmd_str.data(), &pRespStr, 2*WNC_TIMEOUT_MS); // Set APN, cmd seems to take a little longer sometimes
00237   send_wnc_cmd("AT@INTERNET=1", &pRespStr, WNC_TIMEOUT_MS);  // Internet services enabled
00238   send_wnc_cmd("AT@SOCKDIAL=1", &pRespStr, WNC_TIMEOUT_MS);
00239 }
00240 
00241 void at_sockopen_wnc(const string & ipStr, const char * port )
00242 {
00243   string * pRespStr;
00244   send_wnc_cmd("AT@SOCKCREAT=1", &pRespStr, WNC_TIMEOUT_MS);
00245   string cmd_str("AT@SOCKCONN=1,\"");
00246   cmd_str += ipStr;
00247   cmd_str += "\",";
00248   cmd_str += port;
00249   send_wnc_cmd(cmd_str.data(), &pRespStr, WNC_TIMEOUT_MS);
00250 }
00251 
00252 void at_sockclose_wnc(void)
00253 {
00254   string * pRespStr;
00255   send_wnc_cmd("AT@SOCKCLOSE=1", &pRespStr, WNC_TIMEOUT_MS);
00256 }
00257 
00258 int at_dnsresolve_wnc(const char * s, string * ipStr)
00259 {
00260   string * pRespStr;
00261   string str(s);
00262   str = "AT@DNSRESVDON=\"" + str;
00263   str += "\"\r\n";
00264   if (send_wnc_cmd(str.data(), &pRespStr, WNC_TIMEOUT_MS) == 0)
00265   {
00266     size_t pos_start = pRespStr->find(":\"") + 2;
00267     if (pos_start !=  string::npos)
00268     {
00269       size_t pos_end = pRespStr->rfind("\"") - 1;
00270       if (pos_end != string::npos)
00271       {
00272         if (pos_end > pos_start)
00273         {
00274           // Make a copy for use later (the source string is re-used)
00275           *ipStr = pRespStr->substr(pos_start, pos_end - pos_start + 1);
00276           return 1;
00277         }
00278         else
00279           pc.puts("URL Resolve fail, substr Err\r\n");
00280       }
00281       else
00282         pc.puts("URL Resolve fail, no 2nd quote\r\n");
00283     }
00284     else
00285       pc.puts("URL Resolve fail, no quotes\r\n");
00286   }
00287   else
00288     pc.puts("URL Resolve fail, WNC cmd fail\r\n");
00289   
00290   return -1;
00291 }
00292 
00293 void at_sockwrite_wnc(const char * s)
00294 {
00295   string * pRespStr;
00296   char num2str[6];
00297   size_t sLen = strlen(s);
00298   if (sLen <= 99999)
00299   {
00300     printf("\n\nCreating String\n\n");
00301     static string cmd_str("AT@SOCKWRITE=1,");
00302      printf("\n\nSTARTING ITOA FUNCTION\n\n");
00303     itoa(sLen, num2str, 10);
00304      printf("\n\n ENDING ITOA FUNCTION\n\n");
00305     cmd_str += num2str;
00306     cmd_str += ",\"";
00307     while(*s != '\0')
00308     {
00309       itoa((int)*s++, num2str, 16);
00310       // Always 2-digit ascii hex:
00311       if (strlen(num2str) == 1)
00312       {
00313         num2str[2] = '\0';
00314         num2str[1] = num2str[0];
00315         num2str[0] = '0';
00316       }
00317       cmd_str += num2str;
00318     }
00319     cmd_str += "\"";
00320     printf("\n\nAT SOCKWRTIE FUNCTION\n\n");
00321     send_wnc_cmd(cmd_str.data(), &pRespStr, WNC_TIMEOUT_MS);
00322     cmd_str = "";
00323   }
00324   else
00325    printf("\n\nSTRING TO LOMG\n\n");
00326     pc.puts("sockwrite Err, string to long\r\n");
00327 }
00328 
00329 unsigned at_sockread_wnc(string * pS, unsigned n, unsigned retries = 0)
00330 {
00331   unsigned i;
00332   string * pRespStr;
00333   string cmd_str("AT@SOCKREAD=1,");
00334   if (n <= 1500)
00335   {
00336     char num2str[6];
00337     
00338     itoa(n, num2str, 10);
00339     cmd_str += num2str;
00340     retries += 1;
00341     while (retries--)
00342     {
00343       // Assuming someone is sending then calling this to receive response, invoke
00344       // a pause to give the response some time to come back and then also
00345       // between each retry.
00346       wait_ms(10);
00347       
00348       send_wnc_cmd(cmd_str.data(), &pRespStr, WNC_TIMEOUT_MS);
00349       size_t pos_start = pRespStr->find("\"")  + 1;
00350       size_t pos_end   = pRespStr->rfind("\"") - 1;
00351       i = pos_end - pos_start + 1;
00352       if (i > 0)
00353       {
00354         retries = 0;  // If any data found stop retrying
00355         string byte;
00356         pS->erase();
00357         while (pos_start < pos_end)
00358         {
00359           byte = pRespStr->substr(pos_start, 2);
00360           *pS += (char)strtol(byte.data(), NULL, 16);
00361           pos_start += 2;
00362         }
00363         return i;
00364       }
00365     }
00366   }
00367   else
00368     pc.puts("sockread Err, to many to read\r\n");
00369   
00370   return 0;
00371 }