Wifi.cpp

00001 /* Copyright (c) 2013 Henry Leinen (henry[dot]leinen [at] online [dot] de)
00002  *
00003  * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
00004  * and associated documentation files (the "Software"), to deal in the Software without restriction,
00005  * including without limitation the rights to use, copy, modify, merge, publish, distribute,
00006  * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
00007  * furnished to do so, subject to the following conditions:
00008  *
00009  * The above copyright notice and this permission notice shall be included in all copies or
00010  * substantial portions of the Software.
00011  *
00012  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
00013  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00014  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
00015  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00016  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00017  */
00018 #include "mbed.h"
00019 #include "Wifi.h"
00020 #include "DnsQuery.h"
00021 
00022 #define DEBUG
00023 #include "debug.h"
00024 
00025 #define LOBYTE(x)       ((x)&0xFF)
00026 #define HIBYTE(x)       (((x)>>8)&0xFF)
00027 
00028 static Wifi::RX_STATE_t   state = Wifi::Idle;
00029 static int ResponseType = 0;
00030 static int DataLen = 0;
00031 static int DataPtr = 0;
00032 
00033 Wifi* Wifi::_Wifi = NULL;
00034   
00035 
00036 Wifi::Wifi(PinName tx, PinName rx, PinName rst)
00037     : m_wifi(tx, rx), m_reset(rst), m_msgReceived(false), m_ackReceived(false), m_bWifiConnected(false), m_WifiConnectionError(NoFailure), m_lastError(NoError)
00038     , m_bScanResultsReady(false), m_NumLastScanResults(0)
00039 {
00040     _Wifi = this;
00041     m_reset = 1;
00042     m_wifi.baud(115200);
00043     m_wifi.format(8, Serial::None, 2);
00044 
00045     m_buffer = new char [1024];
00046 
00047     if (m_buffer == NULL) {
00048         ERR("Failed to allocate buffer !");
00049         error("WIFI");
00050     }
00051     
00052     m_wifi.attach(this, &Wifi::rx_int);
00053 }
00054 
00055 void Wifi::Reset()
00056 {
00057     m_reset = 0;
00058     wait(0.2);
00059     m_msgReceived = 0;
00060     m_ackReceived = false;
00061     m_bWifiConnected = false;
00062     m_WifiConnectionError = NoFailure;
00063     state = Idle;
00064     m_reset = 1;
00065     wait(0.2);
00066 }
00067 
00068 void Wifi::SendCommand(CMD_MSG_t cmd, int msgDataLen1, char* pData1, int msgDataLen2, char* pData2)
00069 {
00070     //  Wifi Plus Click has little endian format (means LSB comes first)
00071     //  btw. MBED is also little endian format
00072     //  Send Header
00073     m_wifi.putc(0x55);
00074     m_wifi.putc(0xAA);
00075     //  Send Message Command
00076     m_wifi.putc( LOBYTE((short)cmd) );
00077     m_wifi.putc( HIBYTE((short)cmd) );
00078     //  Send Message Data1 Length
00079     m_wifi.putc( LOBYTE((short)msgDataLen1+msgDataLen2) );
00080     m_wifi.putc( HIBYTE((short)msgDataLen1+msgDataLen2) );
00081     
00082     //  Send Data1
00083     if ((msgDataLen1 > 0) && (pData1 != NULL)) {
00084         for (int i = 0 ; i < msgDataLen1 ; i++) {
00085             m_wifi.putc(pData1[i]);
00086         }
00087     }
00088     //  Send Data2
00089     if ((msgDataLen2 > 0) && (pData2 != NULL)) {
00090         for (int i = 0 ; i < msgDataLen2 ; i++) {
00091             m_wifi.putc(pData2[i]);
00092         }
00093     }
00094     
00095     //  Reset Acknowledge Recevied flag
00096     m_ackReceived = false;
00097     m_lastError = NoError;
00098     //  Send Trailer
00099     m_wifi.putc(0x45);
00100 }
00101     
00102 void Wifi::rx_int()
00103 {
00104     char c = m_wifi.getc();
00105 
00106     switch (state) {
00107         case    Idle:
00108             if (c == 0x55) {
00109                 state = Header1_received;
00110             } else {
00111                 if (c == 0x00) {
00112                     m_ackReceived = true;
00113                     INFO("ACK");
00114                 } else {
00115                     INFO("c = 0x%02x", c);
00116                 }
00117             }
00118             break;
00119         case    Header1_received:
00120             if (c == 0xAA) {
00121                 state = Header2_received;
00122                 ResponseType = 0;
00123                 DataLen = 0;
00124             } else {
00125                 if (c == 0x55) {
00126                     state = Header1_received;
00127                 } else {
00128                     state = Idle;
00129                 }
00130             }
00131             break;
00132         case    Header2_received:
00133             ResponseType = c;
00134             state = MessageType_low_received;
00135             break;
00136         case    MessageType_low_received:
00137             ResponseType |= (((short)c)<<8);
00138             state = MessageType_high_received;
00139             break;
00140         case    MessageType_high_received:
00141             DataLen = c;
00142             state = DataLen_low_received;
00143             break;
00144         case    DataLen_low_received:
00145             DataLen |= (((short)c)<<8);
00146             if (DataLen == 0) {
00147                 state = Awaiting_trailer;
00148             } else {
00149                 DataPtr = 0;
00150                 state = Data_receiving;
00151             }
00152             break;
00153         case    Data_receiving:
00154             m_buffer[DataPtr++] = c;
00155             if (DataPtr == DataLen) {
00156                 state = Awaiting_trailer;
00157             }
00158             break;
00159         case Awaiting_trailer:
00160             if (c != 0x45) {
00161                 ERR("Trailer information received is incorrect !");
00162                 ERR("Full Message : ");
00163                 ERR("Response Type : 0x%02x", ResponseType);
00164                 for ( int i = 0; i < DataPtr++ ; i++) {
00165                     ERR ("0x%02x", m_buffer[i]);
00166                 }
00167                 ERR("Trailer : 0x%02x", c);
00168             } else {
00169                 //  Complete Message received, so submit it for processing
00170                 SubmitResponse((RSP_MSG_t)ResponseType, DataLen);
00171             }
00172             state = Idle;
00173             break;
00174         default:
00175             state = Idle;
00176     }
00177 }
00178 
00179 void Wifi::SubmitResponse(RSP_MSG_t rsp, int msgLen)
00180 {
00181     //  Check if Event was received
00182     if (rsp == EVENT_MSG) {
00183         INFO("EVENT !!!!");
00184         switch( m_buffer[0] ) {
00185             case Event_IP_Address_Assigned :
00186                 //  IP Address assigned, set the IP Address
00187                 m_ipAddress.sin_addr.o1 = m_buffer[2];
00188                 m_ipAddress.sin_addr.o2 = m_buffer[3];
00189                 m_ipAddress.sin_addr.o3 = m_buffer[4];
00190                 m_ipAddress.sin_addr.o4 = m_buffer[5];
00191                 INFO("NEW IPADDRESS SET !");
00192                 return;
00193             case Event_WiFi_Connection_Status_Changed :
00194                 if ((m_buffer[1] == 1) || (m_buffer[1] == 4)) {
00195                     m_bWifiConnected = true;
00196                     m_WifiConnectionError = NoFailure;
00197                     INFO("EVENT      WIFI CONNECTED !");
00198                     DigitalOut led2(LED2);
00199                     led2 = 1;
00200                 } else {
00201                     DigitalOut led2(LED2);
00202                     led2 = 0;
00203                     m_bWifiConnected = false;
00204                     m_WifiConnectionError = (CONN_ERROR_t)m_buffer[2];
00205                     if (m_buffer[1] != 2) {
00206                         m_WifiConnectionError = (CONN_ERROR_t)((char)m_WifiConnectionError+20);
00207                         DigitalOut led3(LED3);
00208                         led3 = 1;
00209                         
00210                     }
00211                     INFO("EVENT     WIFI DISCONNECTED !");
00212                 }
00213                 return;
00214             case Event_Error_Event :
00215                 INFO("ERROR EVENT %d (%d, %d, %d, %d) !", *((short*)&m_buffer[2]), m_buffer[4], m_buffer[5], m_buffer[6], m_buffer[7]);
00216                 m_lastError = (ERR_t)*((short*)&m_buffer[2]);
00217                 return ;
00218             case Event_WiFi_Scan_Results_Ready :
00219                 m_NumLastScanResults = m_buffer[1];
00220                 INFO("SCAN RESULTS (#%d) READY !", m_NumLastScanResults);
00221                 m_bScanResultsReady = true;
00222                 return ;
00223             default:
00224                 INFO("EVT %d", m_buffer[0])
00225                 break;
00226         }
00227     } 
00228 
00229     if (m_msgReceived) {
00230         ERR("BUFFER FULL !");
00231     }
00232     m_msgResponse = rsp;
00233     m_msgDataLen = msgLen;
00234     m_msgReceived = true;
00235     INFO("Message received (%d)", rsp);
00236 }
00237 
00238 
00239 bool Wifi::WaitMessage(RSP_MSG_t msg, int timeout)
00240 {
00241     Timer t;
00242     
00243     t.start();
00244     
00245     while(t.read_ms() < timeout) {
00246         if (m_msgReceived) {
00247             //  Successfully received a message
00248             if (m_msgResponse == msg) {
00249                 //  Successfull received correct message
00250                 m_msgReceived = false;
00251                 return true;
00252             } else {
00253                 //  Not the message we wanted to hear, so wait for next one
00254                 m_msgReceived = false;
00255             }
00256         }
00257     }
00258     
00259     //  Timeout
00260     return false;
00261 }
00262 
00263 bool Wifi::WaitEvent(EVT_MSG_t evt, int timeout)
00264 {
00265     Timer t;
00266     
00267     t.start();
00268     
00269     while(t.read_ms() < timeout) {
00270         if (m_msgReceived) {
00271             //  Successfully received a message
00272             if ((m_msgResponse == EVENT_MSG) && (m_buffer[0] == evt)) {
00273                 //  Successfull received correct message
00274                 m_msgReceived = false;
00275                 return true;
00276             } else {
00277                 //  Not the message or eventwe wanted to hear, so wait for next one
00278                 m_msgReceived = false;
00279             }
00280         }
00281     }
00282     
00283     //  Timeout
00284     return false;
00285 }
00286 
00287 bool Wifi::WaitAck(int timeout)
00288 {
00289     Timer t;
00290     
00291     t.start();
00292     
00293     while(t.read_ms() < timeout) {
00294         if (m_ackReceived) {
00295             INFO("ACK after %d ms", t.read_ms());
00296             m_ackReceived = false;
00297             return true;
00298         }
00299     }
00300     
00301     return false;
00302 }
00303 
00304 
00305 
00306 
00307 bool Wifi::ResetMsg()
00308 {
00309     bool bRetVal = false;
00310     
00311     INFO("SENDING RESET_MSG");
00312     SendCommand(RESET_MSG, 0, NULL);
00313 
00314     if (WaitMessage (ACK_MSG, 1000)) {
00315         //  Now wait for the Startup Event
00316         
00317         if (WaitEvent (Event_Startup_Event, 10000)) {
00318             //  Startup Event received
00319             bRetVal = true;
00320             INFO("Successfully Reset the device !");
00321             INFO("Startup condition : 0x%02d", m_buffer[1]);
00322         } else {
00323             ERR("Did not receive a startup event from device after reset !");
00324         }
00325     } else {
00326         ERR("Did not get acknowledge from WifiPlusClick Board !");
00327     }
00328     
00329     return bRetVal;
00330 }
00331 
00332 bool Wifi::GetVersionMsg(char &sw_ver_lo, char &sw_ver_hi, char &rad_ver_lo, char &rad_ver_hi)
00333 {
00334     bool bRetVal = false;
00335     
00336     INFO("SENDING GET_VERSION_MSG");
00337     SendCommand(GET_VERSION_MSG, 0, NULL);
00338     
00339     if (WaitAck (1000)) {
00340         //  Now wait for the asynchroneous Startup Event
00341         
00342         if (WaitEvent (Event_Startup_Event, 2000)) {
00343             //  Startup Event received
00344             bRetVal = true;
00345             sw_ver_hi = m_buffer[3];
00346             sw_ver_lo = m_buffer[2];
00347             rad_ver_hi = m_buffer[5];
00348             rad_ver_lo = m_buffer[4];
00349         } else {
00350             ERR("Did not receive an answer event from device after GET_VERSION_MSG !");
00351         }
00352     } else {
00353         ERR("Did not get acknowledge from WifiPlusClick Board !");
00354     }
00355     
00356     return bRetVal;
00357 }
00358 
00359 bool Wifi::GpioMsg(GPIO_IDX_t pin, GPIO_OP_t operation, GPIO_RES_t &result)
00360 {
00361     char buf[2] = { (char)pin, (char)operation };
00362     bool bRetVal = false;
00363     
00364     INFO("SENDING GPIO_MSG");
00365     SendCommand(GPIO_MSG, 2, buf);
00366     
00367     if (WaitMessage (GPIO_RESPONSE_MSG, 1000)) {
00368         bRetVal = true;
00369         result = (GPIO_RES_t)m_buffer[1];
00370     } else {
00371         ERR("Did not get answer from device after GPIO_MSG !");
00372     }
00373     
00374     return bRetVal;
00375 }
00376 
00377 bool Wifi::SetIpAddress(bool bUseDHCP, IPADDRESS_t *ipAddress)
00378 {
00379     bool bRetVal = false;
00380     char buf[18] = {255, (bUseDHCP ? 0 : 1), 0};
00381             
00382     if (!bUseDHCP) {
00383         if ( ipAddress == NULL) {
00384             ERR("Invalid argument, ipAdress is NULL !");
00385             return false;
00386         }
00387         memcpy( &buf[2], (void*)ipAddress, 16 );
00388     } else {
00389         memset( &buf[2], 0, 16);
00390     }
00391     
00392     INFO("SENDING SET_IP_ADDRESS_MSG");
00393     SendCommand(SET_IP_ADDRESS_MSG, 18, buf);
00394     
00395     if (WaitMessage (ACK_MSG, 1000)) {
00396         bRetVal = true;
00397     } else {
00398         ERR("Did not get acknowledge after SET_IP_ADDRESS_MSG !");
00399     }
00400     
00401     return bRetVal;
00402 }
00403 
00404 bool Wifi::SetSubnetMask(IPADDRESS_t *NetworkMask)
00405 {
00406     bool bRetVal = false;
00407     
00408     if (NetworkMask == NULL)
00409         return false;
00410         
00411     INFO("SENDING SET_NETWORK_MASK_MSG");
00412     SendCommand(SET_NETWORK_MASK_MSG, 16, NetworkMask->sin_addr.o);
00413     
00414     if (WaitMessage (ACK_MSG, 1000)) {
00415         bRetVal = true;
00416     } else {
00417         ERR("Did not get acknowledge after SET_NETWORK_MASK_MSG !");
00418     }
00419     
00420     return bRetVal;
00421 }
00422 
00423 bool Wifi::SetGatewayIpAddress(IPADDRESS_t *IPAddress)
00424 {
00425     bool bRetVal = false;
00426     
00427     if (IPAddress == NULL)
00428         return false;
00429         
00430     INFO("SENDING SET_GATEWAY_IP_ADDRESS");
00431     SendCommand(SET_GATEWAY_IP_ADDRESS_MSG, 16, IPAddress->sin_addr.o);
00432     
00433     if (WaitMessage (ACK_MSG, 1000)) {
00434         bRetVal = true;
00435     } else {
00436         ERR("Did not get acknowledge after SET_GATEWAY_IP_ADDRESS_MSG !");
00437     }
00438     
00439     return bRetVal;
00440 }
00441 
00442 bool Wifi::GetNetworkStatus(char *MacAddress, IPADDRESS_t *IPAddress, IPADDRESS_t *NetworkMask, IPADDRESS_t *GatewayAddress, NET_STAT_t &stat)
00443 {
00444     bool bRetVal = false;
00445     
00446     INFO("SENDING GET_NETWORK_STATUS_MSG");
00447     SendCommand(GET_NETWORK_STATUS_MSG, 0, NULL);
00448     
00449     if (WaitMessage (NETWORK_STATUS_RESPONSE_MSG, 1000)) {
00450         if (MacAddress != NULL) {
00451             memcpy (MacAddress, &m_buffer[1], 6);
00452         }
00453         if (IPAddress != NULL) {
00454             memcpy( IPAddress, &m_buffer[7], 4);
00455         }
00456         if (NetworkMask != NULL) {
00457             memcpy( NetworkMask, &m_buffer[23], 4);
00458         }
00459         if (GatewayAddress != NULL) {
00460             memcpy( GatewayAddress, &m_buffer[39], 4);
00461         }
00462         stat = (NET_STAT_t)m_buffer[55];
00463         bRetVal = true;
00464     } else {
00465         ERR("Did not get Response after GET_NETWORK_STATUS_MSG !");
00466     }
00467     
00468     return bRetVal;
00469 }
00470 
00471 bool Wifi::SetMACAddress( char MACAddress[6])
00472 {
00473     bool bRetVal = false;
00474     
00475     INFO("SENDING SET_MACADDRESS_MSG");
00476     SendCommand(SET_MACADDRESS_MSG, 6, MACAddress);
00477     
00478     if (WaitMessage (ACK_MSG, 1000)) {
00479         bRetVal = true;
00480     } else {
00481         ERR("Did not get acknowledge after SET_MACADDRESS_MSG !");
00482     }
00483     
00484     return bRetVal;
00485 }
00486 
00487 bool Wifi::SetARPTime(unsigned short ARPTime)
00488 {
00489     char buf[2] = { ARPTime&0xFF, (ARPTime>>8)&0xFF };
00490     
00491     bool bRetVal = false;
00492     
00493     INFO("SENDING SET_ARP_TIME_MSG");
00494     SendCommand(SET_ARP_TIME_MSG, 2, buf);
00495     
00496     if (WaitMessage (ACK_MSG, 1000)) {
00497         bRetVal = true;
00498     } else {
00499         ERR("Did not get acknowledge after SET_ARP_TIME_MSG !");
00500     }
00501     
00502     return bRetVal;
00503 }
00504 
00505 bool Wifi::SetNetworkMode(char ProfileNum, NETW_MODE_t NetMode)
00506 {
00507     char buf[2] = { ProfileNum, (char)NetMode };
00508     bool bRetVal = false;
00509     
00510     INFO("SENDING SET_CP_NETWORK_MODE_MSG");
00511     SendCommand(SET_CP_NETWORK_MODE_MSG, 2, buf);
00512     
00513     if (WaitMessage (ACK_MSG, 1000)) {
00514         bRetVal = true;
00515     } else {
00516         ERR("Did not get acknowledge after SET_CP_NETWORK_MODE_MSG !");
00517     }
00518     
00519     return bRetVal;
00520 }
00521 
00522 bool Wifi::SetPowerSaveMode(POWERSAVE_MODE_t pwrsave, short DTIM_Listen)
00523 {
00524     bool bRetVal = false;
00525     char buf[4] = { (char)pwrsave, 0, LOBYTE(DTIM_Listen), HIBYTE(DTIM_Listen) };
00526     
00527     INFO("SENDING SET_POWER_SAVE_MODE_MSG");
00528     SendCommand(SET_POWER_SAVE_MODE_MSG, 4, buf);
00529     
00530     if (WaitMessage(ACK_MSG, 1000)) {
00531         bRetVal = true;
00532     } else {
00533         ERR("Did not get acknowledge after SET_POWER_SAVE_MODE_MSG !");
00534     }
00535     
00536     return bRetVal;
00537 }
00538 
00539 
00540 bool Wifi::SetSSID(char Profile, const char* ssid)
00541 {
00542     bool bRetVal = false;
00543     char len = strlen(ssid);
00544     char buf[2] = { Profile, len };
00545     
00546     if (len <= 32 ) {        
00547         INFO("SENDING SET_CP_SSID_MSG");
00548         SendCommand(SET_CP_SSID_MSG, 2, buf, len, (char*)ssid);
00549         
00550         if (WaitMessage (ACK_MSG, 10000)) {
00551             if (m_lastError != NoError) {
00552                 ERR("Failed to set SSID with error code %d", m_lastError);
00553                 m_lastError = NoError;
00554             } else {
00555                 bRetVal = true;
00556             }
00557         } else {
00558             ERR("Did not get acknowledge after SET_CP_SSID_MSG !");
00559         }
00560     } else {
00561         ERR("SSID is too long !");
00562     }
00563     
00564     return bRetVal;
00565 }
00566 
00567 bool Wifi::SetRegionalDomain(DOMAIN_COUNTRY_CODE_t dcode)
00568 {
00569     bool bRetVal = false;
00570     char buf[2] = { (char)dcode, 0 };
00571     
00572     INFO("SENDING SET_REGIONAL_DOMAIN_MSG");
00573     SendCommand(SET_REGIONAL_DOMAIN_MSG, 2, buf);
00574     
00575     if (WaitMessage (ACK_MSG, 1000)) {
00576         bRetVal = true;
00577     } else {
00578         ERR("Did not get acknowledge after SET_REGIONAL_DOMAIN_MSG !");
00579     }
00580     
00581     return bRetVal;
00582 }
00583 
00584 bool Wifi::SetChannelList(char numListItems, char *ListItems)
00585 {
00586     bool bRetVal = false;
00587     char buf[2] = { numListItems, 0 };
00588         
00589     INFO("SENDING SET_CHANNEL_LIST_MSG");
00590     SendCommand(SET_CHANNEL_LIST_MSG, 2, buf, numListItems, ListItems);
00591     
00592     if (WaitMessage (ACK_MSG, 1000)) {
00593         bRetVal = true;
00594     } else {
00595         ERR("Did not get acknowledge after SET_CHANNEL_LIST_MSG !");
00596     }
00597     
00598     return bRetVal;
00599 }
00600 
00601 bool Wifi::SetRetryCount(char infrastructureRetryCount, char adhocRetryCount)
00602 {
00603     bool bRetVal = false;
00604     char buf[2] = { infrastructureRetryCount, adhocRetryCount };
00605     
00606     INFO("SENDING SET_LIST_RETRY_COUNT_MSG");
00607     SendCommand(SET_LIST_RETRY_COUNT_MSG, 2, buf);
00608     
00609     if (WaitMessage (ACK_MSG, 1000)) {
00610         bRetVal = true;
00611     } else {
00612         ERR("Did not get acknowledge after SET_LIST_RETRY_COUNT_MSG !");
00613     }
00614     
00615     return bRetVal;
00616 }
00617 
00618 bool Wifi::SetSecurityOpen(char Profile)
00619 {
00620     bool bRetVal = false;
00621     char buf[2] = { Profile, 0 };
00622     
00623     INFO("SENDING SET_CP_SECURITY_OPEN_MSG");
00624     SendCommand(SET_CP_SECURITY_OPEN_MSG, 2, buf);
00625     
00626     if (WaitMessage (ACK_MSG, 1000)) {
00627         bRetVal = true;
00628     } else {
00629         ERR("Did not get acknowledge after SET_CP_SECURITY_OPEN_MSG !");
00630     }
00631     
00632     return bRetVal;
00633 }
00634 
00635 bool Wifi::SetSecurityWEP40(char Profile, bool bSharedKey, char DefaultWEPKeyIdx, char SecurityKeys[20])
00636 {
00637     bool bRetVal = false;
00638     char buf[4];
00639     
00640     buf[0] = Profile;
00641     buf[1] = bSharedKey ? 1 : 0;
00642     buf[2] = DefaultWEPKeyIdx;
00643     
00644     INFO("SENDING SET_CP_SECURITY_WEP40_MSG");
00645     SendCommand(SET_CP_SECURITY_WEP40_MSG, 4, buf, 20, SecurityKeys);
00646     
00647     if (WaitMessage (ACK_MSG, 1000)) {
00648         bRetVal = true;
00649     } else {
00650         ERR("Did not get acknowledge after SET_CP_SECURITY_WEP40_MSG !");
00651     }
00652     
00653     return bRetVal;
00654 }
00655 
00656 bool Wifi::SetSecurityWEP104(char Profile, bool bSharedKey, char DefaultWEPKeyIdx, char SecurityKeys[52])
00657 {
00658     bool bRetVal = false;
00659     char buf[4];
00660     
00661     buf[0] = Profile;
00662     buf[1] = bSharedKey ? 1 : 0;
00663     buf[2] = DefaultWEPKeyIdx;
00664     
00665     INFO("SENDING SET_CP_SECURITY_WEP104_MSG");
00666     SendCommand(SET_CP_SECURITY_WEP104_MSG, 4, buf, 52, SecurityKeys);
00667     
00668     if (WaitMessage (ACK_MSG, 1000)) {
00669         bRetVal = true;
00670     } else {
00671         ERR("Did not get acknowledge after SET_CP_SECURITY_WEP104_MSG !");
00672     }
00673     
00674     return bRetVal;
00675 }
00676 
00677 bool Wifi::SetSecurityWPA(char Profile, WPA_SECURITY_t sec, int len, const char* secKeyOrPSK)
00678 {
00679     bool bRetVal = false;
00680     char buf[4];
00681     if ((secKeyOrPSK == NULL) || (*secKeyOrPSK == 0))
00682         return false;
00683             
00684     if (buf != NULL) {
00685         buf[0] = Profile;
00686         buf[1] = sec;
00687         buf[2] = 0;
00688         buf[3] = len;
00689         
00690         INFO("SENDING SET_CP_SECURITY_WPA_MSG");
00691         SendCommand(SET_CP_SECURITY_WPA_MSG, 4, buf, len, (char*)secKeyOrPSK);
00692         
00693         if (WaitMessage (ACK_MSG, 1000)) {
00694             bRetVal = true;
00695         } else {
00696             ERR("Did not get acknowledge after SET_CP_SECURITY_WPA_MSG !");
00697         }
00698     } else {
00699         ERR("Out of memory error in SetCPSecurityWPA !");
00700     }
00701     
00702     return bRetVal;
00703 }
00704 
00705 bool Wifi::GetWPAKey(char Profile, char Key[32])
00706 {
00707     bool bRetVal = false;
00708     char buf[2] = { Profile, 0 };
00709     
00710     INFO("SENDING GET_CP_WPAKEY_MSG");
00711     SendCommand(GET_CP_WPAKEY_MSG, 2, buf);
00712     
00713     if (WaitMessage (WPAKEY_RESPONSE_MSG, 1000)) {
00714         bRetVal = true;
00715         memcpy(Key, m_buffer, 32);
00716     } else {
00717         ERR("Did not get answer from device !");
00718     }
00719     
00720     return bRetVal;
00721 }
00722 
00723 bool Wifi::ScanStartMsg(char Profile)
00724 {
00725     bool bRetVal = false;
00726     
00727     if (m_bWifiConnected) {
00728         ERR("Can not start scan while Wifi is connected !");
00729     } else {
00730         char buf[2] = { Profile, 0 };
00731         
00732         INFO("SENDING SCAN_START_MSG");
00733         m_bScanResultsReady = false;
00734         m_NumLastScanResults = 0;
00735         SendCommand(SCAN_START_MSG, 2, buf);
00736         
00737         if (WaitMessage (ACK_MSG, 1000)) {
00738             bRetVal = true;
00739         } else {
00740             ERR("Did not get acknowledge after SCAN_START_MSG !");
00741         }
00742     }
00743     
00744     return bRetVal;
00745 }
00746 
00747 bool Wifi::ScanGetResults(char index, char ssid[32], AP_CONFIG_t &apCfg, short &beaconInterval, short &ATIMWindow, char &RSSI, NETW_MODE_t &bssType, char &channelNo)
00748 {
00749     bool bRetVal = false;
00750     
00751     if (!m_bScanResultsReady) {
00752         ERR("No scan results !");
00753     } else {
00754         if (index >= m_NumLastScanResults) {
00755             ERR ("No more scan results !");
00756         } else {
00757             char buf[2] = { index, 0 };
00758             
00759             INFO("SENDING SCAN_GET_RESULTS_MSG");
00760             SendCommand(SCAN_GET_RESULTS_MSG, 2, buf);
00761             
00762             if (WaitMessage (SCAN_RESULT_MSG, 1000)) {
00763                 bRetVal = true;
00764                 memcpy(ssid, &m_buffer[7], m_buffer[6]);
00765                 memcpy(&apCfg, &m_buffer[39], 1);
00766                 beaconInterval = *(short*)&m_buffer[40];
00767                 ATIMWindow = *(short*)&m_buffer[42];
00768                 RSSI = m_buffer[52];
00769                 bssType = (NETW_MODE_t)m_buffer[55];
00770                 channelNo = m_buffer[56];
00771             } else {
00772                 ERR("Did not receive message after SCAN_GET_RESULTS_MSG !");
00773             }
00774         }
00775     }
00776     
00777     return bRetVal;
00778 }
00779 
00780 bool Wifi::Connect(char Profile)
00781 {
00782     bool bRetVal = false;
00783     
00784     if (m_bWifiConnected) {
00785         ERR("WIFI is already connected !");
00786     } else {
00787         char buf[2] = { Profile, 0 };
00788         
00789         INFO("SENDING WIFI_CONNECT_MSG");
00790         SendCommand(WIFI_CONNECT_MSG, 2, buf);
00791         
00792         if (WaitMessage (ACK_MSG, 1000)) {
00793             bRetVal = true;
00794         } else {
00795             ERR("Did not get any acknowledge after WIFI_CONNECT_MSG !");
00796         }
00797     }
00798     
00799     return bRetVal;
00800 }
00801 
00802 bool Wifi::Disconnect()
00803 {
00804     bool bRetVal = false;
00805     
00806     if (!m_bWifiConnected) {
00807         ERR("WIFI is not yet connected !");
00808     } else {        
00809         INFO("SENDING WIFI_DISCONNECT_MSG");
00810         SendCommand(WIFI_DISCONNECT_MSG, 0, NULL);
00811         
00812         if (WaitMessage (ACK_MSG, 1000)) {
00813             bRetVal = true;
00814         } else {
00815             ERR("Did not get any acknowledge after WIFI_DISCONNECT_MSG !");
00816         }
00817         
00818    }
00819     
00820     return bRetVal;
00821 }
00822 
00823 
00824 bool Wifi::SocketAllocate(char nTCPSvr, char nTCPClnt, unsigned short TCPSvrRxBuf, unsigned short TCPSvrTxBuf, unsigned short TCPClntRxBuf, unsigned short TCPClntTxBuf)
00825 {
00826     bool bRetVal = false;
00827     __packed struct _sendBuf {
00828         char _nTcpSvr;
00829         char _nTcpClnt;
00830         unsigned short _TcpSvrRxBuf, _TcpSvrTxBuf, _TcpClntRxBuf, _TcpClntTxBuf;
00831     } buf = { nTCPSvr, nTCPClnt, TCPSvrRxBuf, TCPSvrTxBuf, TCPClntRxBuf, TCPClntTxBuf };
00832     
00833     INFO("SENDING SOCKET_ALLOCATE_MSG");
00834     SendCommand(SOCKET_ALLOCATE_MSG, sizeof(buf), (char*)&buf);
00835     
00836     if (WaitMessage (SOCKET_ALLOCATE_RESPONSE_MSG, 2000)) {
00837         if (m_buffer[0] == 0) {
00838             bRetVal = true;
00839         } else if (m_buffer[0] == 0xFF) {
00840             ERR("Too many sockets requested in SOCKET_ALLOCATE_MSG !");
00841         } else  if (m_buffer[0] == 0xFE) {
00842             ERR("Too much buffer requested in SOCKET_ALLOCATE_MSG !");
00843         } else {
00844             ERR("Unknown error in SOCKET_ALLOCATE_MSG !");
00845         }
00846     } else {
00847         ERR("Did not get expected message SOCKET_ALLOCATE_RESPONSE_MSG !");
00848     }
00849     
00850     return bRetVal;
00851 }
00852 
00853 
00854 
00855 SOCKET_HANDLE_t Wifi::SocketCreate( SOCKET_TYPE_t sockType )
00856 {
00857     char sockHandle = InvalidSocketHandle;
00858     char buf[2] = { sockType, 0 };
00859     
00860     INFO("SENDING SOCKET_CREATE_MSG");
00861     SendCommand(SOCKET_CREATE_MSG, 2, buf);
00862     
00863     if (WaitMessage (SOCKET_CREATE_RESPONSE_MSG, 1000)) {
00864         sockHandle = (SOCKET_HANDLE_t)m_buffer[0];
00865         if (m_buffer[0] == 254) {
00866             ERR("Invalid socket handle received after SOCKET_CREATE_MSG !");
00867         } else if (m_buffer[0] == 255) {
00868             ERR("Unknown socket type specified in call to SOCKET_CREATE_MSG !");
00869         } else {
00870             INFO("Valid socket handle received !");
00871         }
00872     } else {
00873         ERR("Did not get expected response after SOCKET_CREATE_MSG !");
00874     }
00875     
00876     return (SOCKET_HANDLE_t)sockHandle;
00877 }
00878 
00879 bool Wifi::SocketClose(SOCKET_HANDLE_t hSock)
00880 {
00881     bool bRetVal = false;
00882     char buf[2] = { hSock, 0 };
00883 
00884     INFO("SENDING SOCKET_CLOSE_MSG");
00885     m_lastError = NoError;
00886     SendCommand(SOCKET_CLOSE_MSG, 2, buf);
00887     
00888     if (WaitMessage (ACK_MSG, 1000)) {
00889         wait(0.1);
00890         if (m_lastError != NoError) {
00891             bRetVal = false;
00892         } else {
00893             bRetVal = true;
00894         }                
00895     } else {
00896         ERR("Did not get expected acknowledge message after SOCKET_CLOSE_MSG !");
00897     }
00898     
00899     return bRetVal;
00900 }
00901 
00902 bool Wifi::SocketBind(SOCKET_HANDLE_t hSock, int Port)
00903 {
00904     bool bRetVal = false;
00905     char buf[4] = { LOBYTE(Port), HIBYTE(Port), hSock, 0 };
00906 
00907     INFO("SENDING SOCKET_BIND_MSG");
00908     SendCommand(SOCKET_BIND_MSG, 4, buf);
00909     
00910     if (WaitMessage (SOCKET_BIND_RESPONSE_MSG, 1000)) {
00911         if (m_buffer[2] == 0) {
00912             bRetVal = true;
00913         } else {
00914             ERR("Bind operation return non-zero result !");
00915         }
00916     } else {
00917         ERR("Did not get expected acknowledge message after SOCKET_CLOSE_MSG !");
00918     }
00919     
00920     return bRetVal;
00921 }
00922 
00923 bool Wifi::SocketListen(SOCKET_HANDLE_t hSock, int& Backlog)
00924 {
00925     bool bRetVal = false;
00926     char buf[2] = { hSock, Backlog };
00927     
00928     INFO("SENDING SOCKET_LISTEN_MSG");
00929     SendCommand(SOCKET_LISTEN_MSG, 2, buf);
00930     
00931     if (WaitMessage (SOCKET_LISTEN_RESPONSE_MSG, 1000)) {
00932         Backlog = m_buffer[1];
00933         if (m_buffer[0] != 255) {
00934             if (m_buffer[0] != 254) {
00935                 bRetVal = true;
00936             } else {
00937                 ERR("SOCKET Listen failed because a socket connection is currently in progress !");
00938             }
00939         } else {
00940             ERR("Socket Listen failed because the socket is already connected !");
00941         }
00942     } else {
00943         ERR("Did not get expected acknowledge message after SOCKET_LISTEN_RESPONSE !");
00944     }
00945 
00946     return bRetVal;
00947 }
00948 
00949 bool Wifi::SocketAccept(SOCKET_HANDLE_t hSock, SOCKET_HANDLE_t &client, int &remotePort, IPADDRESS_t &remoteAddress)
00950 {
00951     bool bRetVal = false;
00952     char buf[2] = { hSock, 0 };
00953     
00954     INFO("SENDING SOCKET_ACCEPT_MSG");
00955     SendCommand(SOCKET_ACCEPT_MSG, 2, buf);
00956     
00957     if (WaitMessage (SOCKET_ACCEPT_RESPONSE_MSG, 1000)) {
00958         client = (SOCKET_HANDLE_t)m_buffer[0];
00959         remotePort = m_buffer[1] + ((int)m_buffer[2])<<8;
00960         memcpy(&remoteAddress, (const void*)&m_buffer[3], 4);
00961         bRetVal = true;
00962     } else {
00963         ERR("Did not get expected response after SOCKET_ACCEPT_MSG !");
00964     }
00965     
00966     return bRetVal;
00967 }
00968 
00969 SOCKET_HANDLE_t Wifi::SocketConnect(SOCKET_HANDLE_t hSock, IPADDRESS_t *IpAddress, int Port)
00970 {
00971     SOCKET_HANDLE_t bRetVal = InvalidSocketHandle;
00972     char buf[4] = { hSock, 0, LOBYTE(Port), HIBYTE(Port) };
00973     
00974     INFO("SENDING SOCKET_CONNECT_MSG");
00975     SendCommand(SOCKET_CONNECT_MSG, 4, buf, 16, (char*)IpAddress);
00976     
00977     if (WaitMessage (SOCKET_CONNECT_RESPONSE_MSG, 1000)) {
00978         bRetVal = (SOCKET_HANDLE_t)m_buffer[0];
00979     } else {
00980         ERR("Did not get expected response after SOCKET_CONNECT_MSG !");
00981     }
00982     
00983     return bRetVal;
00984 }
00985 
00986 int Wifi::SocketSend(SOCKET_HANDLE_t hSock, char* data, int length)
00987 {
00988     int nRetVal = -1;
00989     char buf[4] = { hSock, 0, LOBYTE(length), HIBYTE(length) };
00990     
00991     INFO("SENDING SOCKET_SEND_MSG");
00992     SendCommand(SOCKET_SEND_MSG, 4, buf, length, data);
00993     
00994     if (WaitMessage (SOCKET_SEND_RESPONSE_MSG, 1000)) {
00995         nRetVal = m_buffer[0] + ((int)m_buffer[1])<<8;
00996     } else {
00997         ERR("Did not get expected response after SOCKET_SEND_MSG !");
00998     }
00999     
01000     return nRetVal;
01001 }
01002 
01003 int Wifi::SocketRecv(SOCKET_HANDLE_t hSock, char* data, int length)
01004 {
01005     int nRetVal = -1;
01006     char buf[4] = { hSock, 0, LOBYTE(length), HIBYTE(length) };
01007     
01008     INFO("SENDING SOCKET_RECV_MSG");
01009     SendCommand(SOCKET_RECV_MSG, 4, buf);
01010     
01011     if (WaitMessage (SOCKET_RECV_RESPONSE_MSG, 1000)) {
01012         nRetVal = m_buffer[2] + ((int)m_buffer[3])<<8;
01013         memcpy(data, &m_buffer[4], nRetVal);
01014     } else {
01015         ERR("Did not get expected response after SOCKET_RECV_MSG !");
01016     }
01017     
01018     return nRetVal;
01019 }
01020 
01021 int Wifi::SocketSendTo(SOCKET_HANDLE_t hSock, IPADDRESS_t* remoteAddress, int remotePort, char *data, int length)
01022 {
01023     int nRetVal = -1;
01024     char buf[22] = { hSock, 0, LOBYTE(remotePort), HIBYTE(remotePort) };
01025     
01026     memcpy(&buf[4], remoteAddress, 16);
01027     buf[20] = LOBYTE(length);
01028     buf[21] = HIBYTE(length);
01029     INFO("SENDING SOCKET_SEND_TO_MSG");
01030     SendCommand(SOCKET_SEND_TO_MSG, 22, buf, length, data);
01031     
01032     if (WaitMessage (SOCKET_SEND_TO_RESPONSE_MSG, 1000)) {
01033         nRetVal = m_buffer[0] + (((int)m_buffer[1])<<8);
01034     } else {
01035         ERR("Did not get expected response after SOCKET_SEND_TO_MSG !");
01036     }
01037     
01038     return nRetVal;
01039 }
01040 
01041 int Wifi::SocketRecvFrom(SOCKET_HANDLE_t hSock, IPADDRESS_t *remoteAddress, int *port, char *data, int length)
01042 {
01043     int nRetVal = -1;
01044     char buf[4] = { hSock, 0, LOBYTE(length), HIBYTE(length) };
01045     
01046     INFO("SENDING SOCKET_RECV_FROM_MSG");
01047     SendCommand(SOCKET_RECV_FROM_MSG, 4, buf);
01048 
01049     if (WaitMessage (SOCKET_RECV_FROM_RESPONSE_MSG, 1000)) {
01050         if (port != NULL)
01051             *port = m_buffer[2] + (((int)m_buffer[3])<<8);
01052         if (remoteAddress != NULL)
01053             memcpy(remoteAddress, &m_buffer[4], 4);
01054         nRetVal = m_buffer[20] + (((int)m_buffer[21])<<8);
01055         
01056         memcpy(data, &m_buffer[22], nRetVal > length ? length : nRetVal);
01057         if (nRetVal > length) {
01058             INFO("Socket received %d bytes on port %d which is more than the %d provided by buffer !", nRetVal, *port, length);
01059         }
01060     } else {
01061         ERR("Did not get expected response after SOCKET_RECV_FROM_MSG !");
01062     }
01063     
01064     return nRetVal;
01065 }
01066 
01067 
01068 int Wifi::gethostbyname(const char* host, IPADDRESS_t *IpAddress)
01069 {
01070     //  First issue a get network status message to retrieve the gateway address. The gateway will be used as the DNS.
01071     IPADDRESS_t GatewayIP;
01072     NET_STAT_t     netStat;
01073     
01074     if (IpAddress == NULL)
01075         return -1;
01076     
01077     //  Get the gateway ip address for use as DNS server
01078     if (!GetNetworkStatus(NULL, NULL, NULL, &GatewayIP, netStat)) {
01079         return -1;
01080     }
01081     INFO("Using gateway on %d.%d.%d.%d as DNS !", GatewayIP.sin_addr.o1, GatewayIP.sin_addr.o2, GatewayIP.sin_addr.o3, GatewayIP.sin_addr.o4);        
01082     //  Now create the DNS query
01083     DnsQuery    dns(this, &GatewayIP);
01084     
01085     if( !dns.gethostbyname(host, *IpAddress) ) {
01086         ERR("Failed to get host by name !");
01087         return -1;
01088     }
01089     
01090     return 0;
01091 }
01092 
01093 int Wifi::convert(const char* hostip, IPADDRESS_t *ipAddress)
01094 {
01095     if ((hostip == NULL) || (ipAddress == NULL))
01096         return -1;
01097         
01098     int nCnt = 0;
01099     int val = 0;
01100     while(*hostip != 0) {
01101         if (*hostip != '.') {
01102             val = val*10 + (*hostip)-'0';
01103         } else {
01104             if (nCnt > 3)
01105                 return -1;
01106             ipAddress->sin_addr.o[nCnt++] = val;
01107             val = 0;
01108         }
01109     }
01110     ipAddress->sin_addr.o[nCnt++] = val;
01111 
01112     return 0;
01113 }