MuRata.cpp

00001 #include "MuRata.h"
00002 
00003 using namespace SmartLabMuRata;
00004 
00005 MuRata::MuRata(PinName tx, PinName rx)
00006     : _SSIDRecordIndication(NULL),_WIFIConnectionIndication(NULL),_TCPStatusIndication(NULL),_SocketReceiveInidcation(NULL),
00007       _UDPReceivedIndication(NULL),_HTTPResponseIndication(NULL),
00008       _WIFIStatusResponse(NULL),_InitializationResponse(NULL),_SendFromSocketResponse(NULL),_DHCPInfoResponse(NULL),_SocketStartReceiveResponse(NULL),_CreateSocketResponse(NULL),_HTTPResponse(NULL)
00009 {
00010     serial = new Serial(tx,rx);
00011     serial->format();
00012     serial->baud(DEFAULT_BAUDRATE );
00013 }
00014 
00015 MuRata::MuRata(PinName tx, PinName rx, int baudrate ,int bits, Serial::Parity parity, int stop_bits)
00016     : _SSIDRecordIndication(NULL),_WIFIConnectionIndication(NULL),_TCPStatusIndication(NULL),_SocketReceiveInidcation(NULL),
00017       _UDPReceivedIndication(NULL),_HTTPResponseIndication(NULL),
00018       _WIFIStatusResponse(NULL),_InitializationResponse(NULL),_SendFromSocketResponse(NULL),_DHCPInfoResponse(NULL),_SocketStartReceiveResponse(NULL),_CreateSocketResponse(NULL),_HTTPResponse(NULL)
00019 {
00020     serial = new Serial(tx,rx);
00021     serial->format(bits, parity, stop_bits);
00022     serial->baud(baudrate);
00023 }
00024 
00025 SSIDRecordIndication * MuRata::Get_ScanResultIndication()
00026 {
00027     if (FrameReceive())
00028         if (_payload.GetResponseFlag() == Request_Indication
00029                 && _frame.GetCommandID() == CMD_ID_WIFI
00030                 && _payload.GetSubCommandID() == WIFI_SCAN_RESULT_IND) {
00031             _SSIDRecordIndication.SetPayload(&_payload);
00032             return &_SSIDRecordIndication;
00033         }
00034 
00035     return NULL;
00036 }
00037 
00038 WIFIConnectionIndication * MuRata::Get_WiFiStatusIndication()
00039 {
00040     if (FrameReceive())
00041         if (_payload.GetResponseFlag() == Request_Indication
00042                 && _frame.GetCommandID() == CMD_ID_WIFI
00043                 && _payload.GetSubCommandID() == WIFI_NETWORK_STATUS_IND) {
00044             _WIFIConnectionIndication.SetPayload(&_payload);
00045             return &_WIFIConnectionIndication;
00046         }
00047 
00048     return NULL;
00049 }
00050 
00051 ResetCode MuRata::Get_PowerUpIndication()
00052 {
00053     if (FrameReceive())
00054         if (_payload.GetResponseFlag() == Request_Indication
00055                 && _frame.GetCommandID() == CMD_ID_GEN
00056                 && _payload.GetSubCommandID() == GEN_PWR_UP_IND)
00057             return (ResetCode)(_payload.GetData()[2] << 8 | _payload.GetData()[3]);
00058 
00059     return N0_Indication;
00060 }
00061 
00062 TCPStatusIndication * MuRata::Get_TcpConnectionStatusIndication()
00063 {
00064     if (FrameReceive())
00065         if (_payload.GetResponseFlag() == Request_Indication
00066                 && _frame.GetCommandID() == CMD_ID_SNIC
00067                 && _payload.GetSubCommandID() == SNIC_TCP_CONNECTION_STATUS_IND) {
00068             _TCPStatusIndication.SetPayload(&_payload);
00069             return &_TCPStatusIndication;
00070         }
00071 
00072     return NULL;
00073 }
00074 
00075 SocketReceiveInidcation * MuRata::Get_SocketReceiveIndication()
00076 {
00077     if (FrameReceive())
00078         if (_payload.GetResponseFlag() == Request_Indication
00079                 && _frame.GetCommandID() == CMD_ID_SNIC
00080                 && _payload.GetSubCommandID() == SNIC_CONNECTION_RECV_IND) {
00081             _SocketReceiveInidcation.SetPayload(&_payload);
00082             return &_SocketReceiveInidcation;
00083         }
00084 
00085     return NULL;
00086 }
00087 
00088 UDPReceivedIndication * MuRata::Get_UDPReceiveIndication()
00089 {
00090     if (FrameReceive())
00091         if (_payload.GetResponseFlag() == Request_Indication
00092                 && _frame.GetCommandID() == CMD_ID_SNIC
00093                 && _payload.GetSubCommandID() == SNIC_UDP_RECV_IND) {
00094             _UDPReceivedIndication.SetPayload(&_payload);
00095             return &_UDPReceivedIndication;
00096         }
00097 
00098     return NULL;
00099 }
00100 
00101 HTTPResponseIndication * MuRata::Get_HTTPResponseIndication()
00102 {
00103     if (FrameReceive())
00104         if (_payload.GetResponseFlag() == Request_Indication
00105                 && _frame.GetCommandID() == CMD_ID_SNIC
00106                 && _payload.GetSubCommandID() == SNIC_HTTP_RSP_IND) {
00107             _HTTPResponseIndication.SetPayload(&_payload);
00108             return &_HTTPResponseIndication;
00109         }
00110 
00111     return NULL;
00112 }
00113 
00114 void MuRata::Send()
00115 {
00116     _frame.SetACKRequired(false);
00117     _payload.SetResponseFlag(Request_Indication);
00118     serial->putc(UARTFrame::SOM);
00119 
00120     serial->putc(_frame.GetL0() | 0x80);
00121     serial->putc(_frame.GetL1() | 0x80 | (_frame.GetACKRequired() ? 0x40 : 0x00));
00122 
00123     serial->putc(_frame.GetCommandID() | 0x80);
00124 
00125     for (int i = 0; i < _payload.GetPosition(); i++)
00126         serial->putc(_payload.GetData()[i]);
00127 
00128     serial->putc(_frame.GetChecksum() | 0x80);
00129 
00130     serial->putc(UARTFrame::EOM);
00131 }
00132 
00133 bool MuRata::FrameReceive()
00134 {
00135     timer.reset();
00136     timer.start();
00137 
00138     while (serial->readable() <= 0) {
00139         if (timer.read_ms() > 1000) {
00140             timer.stop();
00141             return false;
00142         }
00143     }
00144     timer.stop();
00145 
00146     int value = serial->getc();
00147     while (value != UARTFrame::SOM)
00148         value = serial->getc();
00149 
00150     _frame.SetL0(serial->getc());
00151     _frame.SetL1(serial->getc());
00152 
00153     _frame.SetCommandID(serial->getc());
00154 
00155     int _size = _frame.GetPayloadLength();
00156 
00157     _payload.Allocate(_size);
00158     while (_payload.GetPosition() < _size)
00159         _payload.SetContent(serial->getc());
00160 
00161     _frame.SetChecksum(serial->getc());
00162 
00163     if (serial->getc() == UARTFrame::EOM && _frame.VerifyChecksum())
00164         return true;
00165     else return false;
00166 }
00167 
00168 const char * MuRata::GEN_GetFirmwareVersionInfo()
00169 {
00170     _payload.Rewind();
00171     _payload.SetSubCommandID(GEN_FW_VER_GET_REQ);
00172     _payload.SetFrameID(_payload.GetFrameID() + 1);
00173 
00174     _frame.SetCommandID(CMD_ID_GEN);
00175     _frame.SetPayload(&_payload);
00176 
00177     Send();
00178 
00179     while (FrameReceive()) {
00180         if (_frame.GetCommandID() == CMD_ID_GEN && _payload.GetSubCommandID() == GEN_FW_VER_GET_REQ) {
00181             if (_payload.GetData()[2] == GEN_SUCCESS) {
00182                 // set the null for the string
00183                 _payload.GetData()[4 + _payload.GetData()[3]] = 0x00;
00184                 return _payload.GetData() + 4;
00185             }
00186         }
00187     }
00188     return NULL;
00189 }
00190 
00191 CMDCode MuRata::GEN_RestoreNVMtoFactoryDefault()
00192 {
00193     _payload.Rewind();
00194     _payload.SetSubCommandID(GEN_RESTORE_REQ);
00195     _payload.SetFrameID(_payload.GetFrameID() + 1);
00196 
00197     _frame.SetCommandID(CMD_ID_GEN);
00198     _frame.SetPayload(&_payload);
00199 
00200     Send();
00201 
00202     while (FrameReceive())
00203         if (_frame.GetCommandID() == CMD_ID_GEN && _payload.GetSubCommandID() == GEN_RESTORE_REQ)
00204             return (CMDCode)_payload.GetData()[2];
00205 
00206     return GEN_NORESPONSE;
00207 }
00208 
00209 CMDCode MuRata::GEN_SoftReset()
00210 {
00211     _payload.Rewind();
00212     _payload.SetSubCommandID(GEN_RESET_REQ);
00213     _payload.SetFrameID(_payload.GetFrameID() + 1);
00214 
00215     _frame.SetCommandID(CMD_ID_GEN);
00216     _frame.SetPayload(&_payload);
00217 
00218     Send();
00219 
00220     while (FrameReceive())
00221         if (_frame.GetCommandID() == CMD_ID_GEN && _payload.GetSubCommandID() == GEN_RESET_REQ)
00222             return (CMDCode)_payload.GetData()[2];
00223 
00224     return GEN_NORESPONSE;
00225 }
00226 
00227 CMDCode MuRata::GEN_UARTConfiguration(UARTConfig * config)
00228 {
00229     _payload.Rewind();
00230     _payload.SetSubCommandID(GEN_UART_CFG_REQ);
00231     _payload.SetFrameID(_payload.GetFrameID() + 1);
00232     _payload.SetContent(config->GetValue(), 0, 6);
00233 
00234     _frame.SetCommandID(CMD_ID_GEN);
00235     _frame.SetPayload(&_payload);
00236 
00237     Send();
00238 
00239     while (FrameReceive())
00240         if (_frame.GetCommandID() == CMD_ID_GEN && _payload.GetSubCommandID() == GEN_UART_CFG_REQ)
00241             return (CMDCode)_payload.GetData()[2];
00242 
00243     return GEN_NORESPONSE;
00244 }
00245 
00246 
00247 WIFICode MuRata::WIFI_TurnOn()
00248 {
00249     _payload.Rewind();
00250     _payload.SetSubCommandID(WIFI_ON_REQ);
00251     _payload.SetFrameID(_payload.GetFrameID() + 1);
00252     /*
00253      * Country code is a 2-character ASCII string. E.g., “US” = the United States. For the complete list, see Appendix A. The default country code is “US”, which is one of the startup parameters in NVM. If the WIFI_ON_REQ has no intention of changing the country code, put 0x0000 in the two-byte Country code, so that the firmware will use the country code configured in NVM.
00254      */
00255     _payload.SetContent(0x00);
00256     _payload.SetContent(0x00);
00257 
00258     _frame.SetCommandID(CMD_ID_WIFI);
00259     _frame.SetPayload(&_payload);
00260 
00261     Send();
00262 
00263     while (FrameReceive())
00264         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_ON_REQ)
00265             return (WIFICode)_payload.GetData()[2];
00266 
00267     return WIFI_NORESPONSE;
00268 }
00269 
00270 WIFICode MuRata::WIFI_TurnOff()
00271 {
00272     _payload.Rewind();
00273     _payload.SetSubCommandID(WIFI_OFF_REQ);
00274     _payload.SetFrameID(_payload.GetFrameID() + 1);
00275 
00276     _frame.SetCommandID(CMD_ID_WIFI);
00277     _frame.SetPayload(&_payload);
00278 
00279     Send();
00280 
00281     while (FrameReceive())
00282         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_OFF_REQ)
00283             return (WIFICode)_payload.GetData()[2];
00284 
00285     return WIFI_NORESPONSE;
00286 }
00287 
00288 /*
00289  * Parameters are as follows:
00290  * UINT8 Request Sequence
00291  * UINT8 Onoff
00292  * UINT8 Persistency
00293  * UINT8 SSID [up to 33]
00294  * UINT8 Channel
00295  * UINT8 Security mode
00296  * UINT8 Security key length (0-64)
00297  * … Security key [ ]
00298  * OnOff = 0 indicates AP is to be turned off. The rest of the parameters are ignored.
00299  * OnOff = 1 indicates turning on soft AP using existing NVM parameters,
00300  * OnOff = 2 indicates turning on AP with the parameters provided. If the soft AP is already on, it is first turned off.
00301  * Persistency=1 indicates the soft AP’s on/off state and parameters (if OnOff = 2) will be saved in NVM. For example, if OnOff =0 and Persistency=1, the soft AP will not be turned on after a reset.
00302  */
00303 WIFICode MuRata::WIFI_SoftAPControl(SoftAPConfig * config)
00304 {
00305     _payload.Rewind();
00306     _payload.SetSubCommandID(WIFI_AP_CTRL_REQ);
00307     _payload.SetFrameID(_payload.GetFrameID() + 1);
00308 
00309     _payload.SetContent(config->GetOnOffStatus());
00310     _payload.SetContent(config->GetPersistency());
00311     if (config->GetOnOffStatus() == SoftAPConfig::ON_PARAMETERS) {
00312         const char * ssid = config->GetSSID();
00313         int length = strlen(ssid);
00314         _payload.SetContent(ssid, 0 , length);
00315         _payload.SetContent(0x00);
00316     }
00317     _payload.SetContent(config->GetChannel());
00318     _payload.SetContent(config->GetSecurityMode());
00319 
00320     const char * key = config->GetSecurityKey();
00321     int keyLength = 0;
00322     if (key != NULL)
00323         keyLength = strlen(key);
00324 
00325     _payload.SetContent(keyLength);
00326     if (config->GetSecurityMode() != WIFI_SECURITY_OPEN && keyLength > 0)
00327         _payload.SetContent(key, 0 , keyLength);
00328 
00329     _frame.SetCommandID(CMD_ID_WIFI);
00330     _frame.SetPayload(&_payload);
00331 
00332     Send();
00333 
00334     while (FrameReceive())
00335         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_AP_CTRL_REQ)
00336             return (WIFICode)_payload.GetData()[2];
00337 
00338     return WIFI_NORESPONSE;
00339 }
00340 
00341 WIFICode MuRata::WIFI_AssociateNetwork(WIFINetwork * AP)
00342 {
00343     _payload.Rewind();
00344     _payload.SetSubCommandID(WIFI_JOIN_REQ);
00345     _payload.SetFrameID(_payload.GetFrameID() + 1);
00346     _payload.SetContent(AP->GetSSID(), 0, strlen(AP->GetSSID()));
00347     _payload.SetContent(0x00);
00348 
00349     _payload.SetContent(AP->GetSecurityMode());
00350 
00351     int keyLength = strlen(AP->GetSecurityKey());
00352     _payload.SetContent(keyLength);
00353     if (keyLength > 0)
00354         _payload.SetContent(AP->GetSecurityKey(), 0, keyLength);
00355 
00356     if (AP->GetBSSID() != NULL) {
00357         _payload.SetContent(AP->GetChannel());
00358         _payload.SetContent(AP->GetBSSID(), 0, 6);
00359     }
00360 
00361     _frame.SetCommandID(CMD_ID_WIFI);
00362     _frame.SetPayload(&_payload);
00363 
00364     Send();
00365 
00366     while (FrameReceive())
00367         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_JOIN_REQ)
00368             return (WIFICode)_payload.GetData()[2];
00369 
00370     return WIFI_NORESPONSE;
00371 }
00372 
00373 WIFICode MuRata::WIFI_DisconnectNetwork()
00374 {
00375     _payload.Rewind();
00376     _payload.SetSubCommandID(WIFI_DISCONNECT_REQ);
00377     _payload.SetFrameID(_payload.GetFrameID() + 1);
00378 
00379     _frame.SetCommandID(CMD_ID_WIFI);
00380     _frame.SetPayload(&_payload);
00381 
00382     Send();
00383 
00384     while (FrameReceive())
00385         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_DISCONNECT_REQ)
00386             return (WIFICode)_payload.GetData()[2];
00387 
00388     return WIFI_NORESPONSE;
00389 }
00390 WIFIStatusResponse * MuRata::WIFI_GetStatus(const WIFIInterface WiFiInterface)
00391 {
00392     _payload.Rewind();
00393     _payload.SetSubCommandID(WIFI_GET_STATUS_REQ);
00394     _payload.SetFrameID(_payload.GetFrameID() + 1);
00395     _payload.SetContent(WiFiInterface);
00396 
00397     _frame.SetCommandID(CMD_ID_WIFI);
00398     _frame.SetPayload(&_payload);
00399 
00400     Send();
00401 
00402     while (FrameReceive())
00403         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_GET_STATUS_REQ) {
00404             _WIFIStatusResponse.SetPayload(&_payload);
00405             return &_WIFIStatusResponse;
00406         }
00407 
00408     return NULL;
00409 }
00410 
00411 int8_t MuRata::WIFI_GetRSSI()
00412 {
00413     _payload.Rewind();
00414     _payload.SetSubCommandID(WIFI_GET_STA_RSSI_REQ);
00415     _payload.SetFrameID(_payload.GetFrameID() + 1);
00416 
00417     _frame.SetCommandID(CMD_ID_WIFI);
00418     _frame.SetPayload(&_payload);
00419 
00420     Send();
00421 
00422     while (FrameReceive())
00423         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_GET_STA_RSSI_REQ)
00424             return _payload.GetData()[2];
00425 
00426     return 127;
00427 }
00428 
00429 WIFICode MuRata::WIFI_StartWPSProcess(const WPSMode mode, const char * pin, int pinLength)
00430 {
00431     _payload.Rewind();
00432     _payload.SetSubCommandID(WIFI_WPS_REQ);
00433     _payload.SetFrameID(_payload.GetFrameID() + 1);
00434     _payload.SetContent(mode);
00435 
00436     if (mode == Pin) {
00437         if (Pin == NULL)
00438             return WIFI_NORESPONSE;
00439 
00440         _payload.SetContent(pin, 0 , pinLength);
00441         _payload.SetContent(0x00);
00442     }
00443 
00444     _frame.SetCommandID(CMD_ID_WIFI);
00445     _frame.SetPayload(&_payload);
00446 
00447     Send();
00448 
00449     while (FrameReceive())
00450         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_WPS_REQ)
00451             return (WIFICode)_payload.GetData()[2];
00452 
00453     return WIFI_NORESPONSE;
00454 }
00455 
00456 WIFICode MuRata::WIFI_ScanNetworks(const ScanType scan, const BSSType bss)
00457 {
00458     /*
00459      * This command instructs the module to scan available networks. Parameters are as follows:
00460      * UINT8 Request Sequence
00461      * UINT8 Scan Type
00462      * UINT8 BSS Type
00463      * UINT8 BSSID [6]
00464      * UINT8 Channel list []
00465      * UINT8 SSID[]
00466      * BSSID, Channel List, and SSID are optional fields. All 0’s for BSSID, Channel list or SSID indicates it is not present.
00467      * - Scan Type: 0 = Active scan, 1= Passive scan
00468      * - BSS Type: 0 = Infrastructure, 1 = ad hoc, 2 = any
00469      * - BSSID: 6 bytes MAC address of the AP or STA. 6 bytes of 0’s indicates it is not present.
00470      * - Channel list: 0 terminated array, up to 10 array elements.
00471      * - SSID: 0 terminated string for the AP or STA SSID, up to 33 bytes including NUL-termination.
00472      */
00473 
00474     _payload.Rewind();
00475     _payload.SetSubCommandID(WIFI_SCAN_REQ);
00476     _payload.SetFrameID(_payload.GetFrameID() + 1);
00477     _payload.SetContent(scan);
00478     _payload.SetContent(bss);
00479 
00480     for (int i = 0; i < 8; i++)
00481         _payload.SetContent(0x00);
00482 
00483     _frame.SetCommandID(CMD_ID_WIFI);
00484     _frame.SetPayload(&_payload);
00485 
00486     Send();
00487 
00488     if (FrameReceive())
00489         if (_frame.GetCommandID() == CMD_ID_WIFI && _payload.GetSubCommandID() == WIFI_SCAN_REQ)
00490             return (WIFICode)_payload.GetData()[2];
00491 
00492     return WIFI_NORESPONSE;
00493 }
00494 
00495 InitializationResponse * MuRata::SNIC_Initialization(int receiveBufferSize)
00496 {
00497     _payload.Rewind();
00498     _payload.SetSubCommandID(SNIC_INIT_REQ);
00499     _payload.SetFrameID(_payload.GetFrameID() + 1);
00500     _payload.SetContent(receiveBufferSize >> 8);
00501     _payload.SetContent(receiveBufferSize);
00502 
00503     _frame.SetCommandID(CMD_ID_SNIC);
00504     _frame.SetPayload(&_payload);
00505 
00506     Send();
00507 
00508     while (FrameReceive())
00509         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_INIT_REQ) {
00510             _InitializationResponse.SetPayload(&_payload);
00511             return &_InitializationResponse;
00512         }
00513 
00514     return NULL;
00515 }
00516 
00517 SNICCode MuRata::SNIC_Cleanup()
00518 {
00519     _payload.Rewind();
00520     _payload.SetSubCommandID(SNIC_CLEANUP_REQ);
00521     _payload.SetFrameID(_payload.GetFrameID() + 1);
00522 
00523     _frame.SetCommandID(CMD_ID_SNIC);
00524     _frame.SetPayload(&_payload);
00525 
00526     Send();
00527 
00528     while (FrameReceive())
00529         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_CLEANUP_REQ)
00530             return (SNICCode)_payload.GetData()[2];
00531 
00532     return SNIC_NORESPONSE;
00533 
00534 }
00535 
00536 
00537 SendFromSocketResponse * MuRata::SNIC_SendFromSocket(const char SocketID, const SocketSentOption option, const char * payload, int offset, int length)
00538 {
00539     _payload.Rewind();
00540     _payload.SetSubCommandID(SNIC_SEND_FROM_SOCKET_REQ);
00541     _payload.SetFrameID(_payload.GetFrameID() + 1);
00542     _payload.SetContent(SocketID);
00543     _payload.SetContent(option);
00544     _payload.SetContent(length >> 8);
00545     _payload.SetContent(length);
00546     _payload.SetContent(payload, offset, length);
00547 
00548     _frame.SetCommandID(CMD_ID_SNIC);
00549     _frame.SetPayload(&_payload);
00550 
00551     Send();
00552 
00553     while (FrameReceive())
00554         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_SEND_FROM_SOCKET_REQ) {
00555             _SendFromSocketResponse.SetPayload(&_payload);
00556             return &_SendFromSocketResponse;
00557         }
00558 
00559     return NULL;
00560 }
00561 
00562 SNICCode MuRata::SNIC_SloseSocket(const char SocketID)
00563 {
00564     _payload.Rewind();
00565     _payload.SetSubCommandID(SNIC_CLOSE_SOCKET_REQ);
00566     _payload.SetFrameID(_payload.GetFrameID() + 1);
00567     _payload.SetContent(SocketID);
00568 
00569     _frame.SetCommandID(CMD_ID_SNIC);
00570     _frame.SetPayload(&_payload);
00571 
00572     Send();
00573 
00574     while (FrameReceive())
00575         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_CLOSE_SOCKET_REQ)
00576             return (SNICCode)_payload.GetData()[2];
00577 
00578     return SNIC_NORESPONSE;
00579 }
00580 
00581 DHCPInfoResponse * MuRata::SNIC_GetDHCPInfo(const WIFIInterface wifiInterface)
00582 {
00583     _payload.Rewind();
00584     _payload.SetSubCommandID(SNIC_GET_DHCP_INFO_REQ);
00585     _payload.SetFrameID(_payload.GetFrameID() + 1);
00586     _payload.SetContent(wifiInterface);
00587 
00588     _frame.SetCommandID(CMD_ID_SNIC);
00589     _frame.SetPayload(&_payload);
00590 
00591     Send();
00592 
00593     while (FrameReceive())
00594         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_GET_DHCP_INFO_REQ) {
00595             _DHCPInfoResponse.SetPayload(&_payload);
00596             return &_DHCPInfoResponse;
00597         }
00598 
00599     return NULL;
00600 }
00601 
00602 IPAddress * MuRata::SNIC_ResolveHostName(const char * host)
00603 {
00604     int hostLength = strlen(host);
00605 
00606     _payload.Rewind();
00607     _payload.SetSubCommandID(SNIC_RESOLVE_NAME_REQ);
00608     _payload.SetFrameID(_payload.GetFrameID() + 1);
00609     _payload.SetContent(STA);
00610     _payload.SetContent(hostLength);
00611     _payload.SetContent(host, 0, hostLength);
00612 
00613     _frame.SetCommandID(CMD_ID_SNIC);
00614     _frame.SetPayload(&_payload);
00615 
00616     Send();
00617 
00618     while (FrameReceive())
00619         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_RESOLVE_NAME_REQ)
00620             if ((SNICCode)_payload.GetData()[2] == SNIC_SUCCESS) {
00621                 ip.SetValue(_payload.GetData(), 3);
00622                 return &ip;
00623             }
00624 
00625     return NULL;
00626 }
00627 
00628 SNICCode MuRata::SNIC_ConfigureDHCPorStaticIP(DHCPConfig * config)
00629 {
00630     _payload.Rewind();
00631     _payload.SetSubCommandID(SNIC_IP_CONFIG_REQ);
00632     _payload.SetFrameID(_payload.GetFrameID() + 1);
00633     _payload.SetContent(config->GetInterface());
00634     _payload.SetContent(config->GetDHCPMode());
00635 
00636     if (config->GetDHCPMode() != dynamic_IP) {
00637         _payload.SetContent(config->GetLocalIP()->GetValue(), 0, 4);
00638         _payload.SetContent(config->GetNetmask()->GetValue(), 0, 4);
00639         _payload.SetContent(config->GetGatewayIP()->GetValue(), 0, 4);
00640     }
00641 
00642     if (config->GetDHCPMode() == soft_AP) {
00643         _payload.SetContent(config->GetIPRangeFirst()->GetValue(), 0, 4);
00644         _payload.SetContent(config->GetIPRangeLast()->GetValue(), 0, 4);
00645     }
00646 
00647     _frame.SetCommandID(CMD_ID_SNIC);
00648     _frame.SetPayload(&_payload);
00649 
00650     Send();
00651 
00652     while (FrameReceive())
00653         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_IP_CONFIG_REQ)
00654             return (SNICCode)_payload.GetData()[2];
00655 
00656     return SNIC_NORESPONSE;
00657 }
00658 
00659 SocketStartReceiveResponse * MuRata::SNIC_ConnectTCPServer(const char SocketID, IPAddress * remoteIP, const int remotePort, const char timeout, const int receiveBufferSize)
00660 {
00661     _payload.Rewind();
00662     _payload.SetSubCommandID(SNIC_TCP_CONNECT_TO_SERVER_REQ);
00663     _payload.SetFrameID(_payload.GetFrameID() + 1);
00664     _payload.SetContent(SocketID);
00665     _payload.SetContent(remoteIP->GetValue(), 0, 4);
00666     _payload.SetContent((remotePort >> 8));
00667     _payload.SetContent(remotePort);
00668     _payload.SetContent((receiveBufferSize >> 8));
00669     _payload.SetContent(receiveBufferSize);
00670     _payload.SetContent(timeout);
00671 
00672     _frame.SetCommandID(CMD_ID_SNIC);
00673     _frame.SetPayload(&_payload);
00674 
00675     Send();
00676 
00677     while (FrameReceive())
00678         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_TCP_CONNECT_TO_SERVER_REQ) {
00679             _SocketStartReceiveResponse.SetPayload(&_payload);
00680             return &_SocketStartReceiveResponse;
00681         }
00682 
00683     return NULL;
00684 }
00685 
00686 CreateSocketResponse * MuRata::SNIC_CreateTCPSocket(const bool bind, IPAddress * localIP, const int localPort)
00687 {
00688     return SNIC_CreateSocket(SNIC_TCP_CREATE_SOCKET_REQ, bind, localIP, localPort);
00689 }
00690 
00691 CreateSocketResponse * MuRata::SNIC_CreateUDPSocket(const bool bind, IPAddress * localIP, const int localPort)
00692 {
00693     return SNIC_CreateSocket(SNIC_UDP_CREATE_SOCKET_REQ, bind, localIP, localPort);
00694 }
00695 
00696 CreateSocketResponse * MuRata::SNIC_CreateSocket(const SubCommandID subID, const bool bind, IPAddress * localIP, const int localPort)
00697 {
00698     _payload.Rewind();
00699     _payload.SetSubCommandID(subID);
00700     _payload.SetFrameID(_payload.GetFrameID() + 1);
00701     _payload.SetContent(bind ? 0x01 : 0x00);
00702 
00703     if (bind) {
00704         if (localIP != NULL)
00705             _payload.SetContent(localIP->GetValue(), 0, 4);
00706         else {
00707             _payload.SetContent(0x00);
00708             _payload.SetContent(0x00);
00709             _payload.SetContent(0x00);
00710             _payload.SetContent(0x00);
00711         }
00712 
00713         _payload.SetContent(localPort >> 8);
00714         _payload.SetContent(localPort);
00715     }
00716 
00717     _frame.SetCommandID(CMD_ID_SNIC);
00718     _frame.SetPayload(&_payload);
00719 
00720     Send();
00721 
00722     while (FrameReceive())
00723         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == subID) {
00724             _CreateSocketResponse.SetPayload(&_payload);
00725             return &_CreateSocketResponse;
00726         }
00727 
00728     return NULL;
00729 }
00730 
00731 SocketStartReceiveResponse * MuRata::SNIC_StartUDPReceive(const char SocketID, const int receiveBufferSize)
00732 {
00733     _payload.Rewind();
00734     _payload.SetSubCommandID(SNIC_UDP_START_RECV_REQ);
00735     _payload.SetFrameID(_payload.GetFrameID() + 1);
00736     _payload.SetContent(SocketID);
00737     _payload.SetContent(receiveBufferSize >> 8);
00738     _payload.SetContent(receiveBufferSize);
00739 
00740     _frame.SetCommandID(CMD_ID_SNIC);
00741     _frame.SetPayload(&_payload);
00742 
00743     Send();
00744 
00745     while (FrameReceive())
00746         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_UDP_START_RECV_REQ) {
00747             _SocketStartReceiveResponse.SetPayload(&_payload);
00748             return &_SocketStartReceiveResponse;
00749         }
00750 
00751     return NULL;
00752 }
00753 
00754 SendFromSocketResponse * MuRata::SNIC_SendUDPPacket(IPAddress * remoteIP, const int remotePort, const char * payload, int offset, int length)
00755 {
00756     _payload.Rewind();
00757     _payload.SetSubCommandID(SNIC_UDP_SIMPLE_SEND_REQ);
00758     _payload.SetFrameID(_payload.GetFrameID() + 1);
00759     _payload.SetContent(remoteIP->GetValue(), 0 ,4);
00760     _payload.SetContent(remotePort >> 8);
00761     _payload.SetContent(remotePort);
00762     _payload.SetContent(length >> 8);
00763     _payload.SetContent(length);
00764     _payload.SetContent(payload, offset, length);
00765 
00766     _frame.SetCommandID(CMD_ID_SNIC);
00767     _frame.SetPayload(&_payload);
00768 
00769     Send();
00770 
00771     while (FrameReceive())
00772         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_UDP_SIMPLE_SEND_REQ) {
00773             _SendFromSocketResponse.SetPayload(&_payload);
00774             return &_SendFromSocketResponse;
00775         }
00776 
00777     return NULL;
00778 }
00779 
00780 SendFromSocketResponse * MuRata::SNIC_SendUDPFromSocket(IPAddress * remoteIP, const int remotePort, const char SocketID, const bool connectServer, const char * payload, int offset, int length)
00781 {
00782     _payload.Rewind();
00783     _payload.SetSubCommandID(SNIC_UDP_SEND_FROM_SOCKET_REQ);
00784     _payload.SetFrameID(_payload.GetFrameID() + 1);
00785     _payload.SetContent(remoteIP->GetValue(),0, 4);
00786     _payload.SetContent(remotePort >> 8);
00787     _payload.SetContent(remotePort);
00788     _payload.SetContent(SocketID);
00789     _payload.SetContent(connectServer ? 0x01 : 0x00);
00790     _payload.SetContent(length >> 8);
00791     _payload.SetContent(length);
00792     _payload.SetContent(payload, offset, length);
00793 
00794     _frame.SetCommandID(CMD_ID_SNIC);
00795     _frame.SetPayload(&_payload);
00796 
00797     Send();
00798 
00799     while (FrameReceive())
00800         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_UDP_SEND_FROM_SOCKET_REQ) {
00801             _SendFromSocketResponse.SetPayload(&_payload);
00802             return &_SendFromSocketResponse;
00803         }
00804 
00805     return NULL;
00806 }
00807 
00808 HTTPResponse * MuRata::SNIC_SendHTTPRequest(HTTPContent * content, const bool isHTTPS, const bool chunked)
00809 {
00810     SubCommandID _id = (isHTTPS == true) ? SNIC_HTTPS_REQ: SNIC_HTTP_REQ;
00811 
00812     _payload.Rewind();
00813     _payload.SetSubCommandID(_id);
00814     _payload.SetFrameID(_payload.GetFrameID() + 1);
00815     _payload.SetContent(content->GetRemotePort() >> 8);
00816     _payload.SetContent(content->GetRemotePort());
00817     _payload.SetContent(content->GetMethod());
00818     _payload.SetContent(content->GetTimeout());
00819 
00820     _payload.SetContent(content->GetRemoteHost(), 0, strlen(content->GetRemoteHost()));
00821     _payload.SetContent(0x00);
00822 
00823     _payload.SetContent(content->GetURI(), 0, strlen(content->GetURI()));
00824     _payload.SetContent(0x00);
00825 
00826     _payload.SetContent(content->GetContentType(), 0, strlen(content->GetContentType()));
00827     _payload.SetContent(0x00);
00828 
00829     string _others;
00830     content->GetOtherHeaders(&_others);
00831     _payload.SetContent(_others.c_str(), 0, _others.length());
00832     _payload.SetContent(0x00);
00833 
00834     while (content->GetMethod() == POST) {
00835         int length = content->GetContentLength();
00836 
00837         char msb = length >> 8;
00838         if (chunked)
00839             msb |= 0x80;
00840         else msb &= 0x7F;
00841 
00842         _payload.SetContent(msb);
00843         _payload.SetContent(length);
00844 
00845         if (length > 0)
00846             _payload.SetContent(content->GetBody(), 0, length);
00847     }
00848 
00849     _frame.SetCommandID(CMD_ID_SNIC);
00850     _frame.SetPayload(&_payload);
00851 
00852     Send();
00853 
00854     while (FrameReceive())
00855         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == _id) {
00856             _HTTPResponse.SetPayload(&_payload);
00857             return &_HTTPResponse;
00858         }
00859 
00860     return NULL;
00861 }
00862 
00863 HTTPResponse * MuRata::SNIC_SendHTTPMoreRequest(HTTPContent * content, const bool chunked)
00864 {
00865     _payload.Rewind();
00866     _payload.SetSubCommandID(SNIC_HTTP_MORE_REQ);
00867     _payload.SetFrameID(_payload.GetFrameID() + 1);
00868 
00869     int length = content->GetContentLength();
00870     char msb = length;
00871     if (chunked)
00872         msb |= 0x80;
00873     else msb &= 0x7F;
00874 
00875     _payload.SetContent(msb);
00876     _payload.SetContent(length);
00877 
00878     if (length > 0)
00879         _payload.SetContent(content->GetBody(), 0, length);
00880 
00881     _frame.SetCommandID(CMD_ID_SNIC);
00882     _frame.SetPayload(&_payload);
00883 
00884     Send();
00885 
00886     if (chunked)
00887         return NULL;
00888 
00889     while (FrameReceive())
00890         if (_frame.GetCommandID() == CMD_ID_SNIC && _payload.GetSubCommandID() == SNIC_HTTP_MORE_REQ) {
00891             _HTTPResponse.SetPayload(&_payload);
00892             return &_HTTPResponse;
00893         }
00894 
00895     return NULL;
00896 }
00897 
00898 CreateSocketResponse * MuRata::SNIC_CreateAdvancedTLSTCP(const bool bind, IPAddress * localIP, const int localPort)
00899 {
00900     return SNIC_CreateSocket(SNIC_TCP_CREATE_ADV_TLS_SOCKET_REQ, bind, localIP, localPort);
00901 }
00902 
00903 CreateSocketResponse * MuRata::SNIC_CreateSimpleTLSTCP(const bool bind, IPAddress * localIP, const int localPort)
00904 {
00905     return SNIC_CreateSocket(SNIC_TCP_CREAET_SIMPLE_TLS_SOCKET_REQ, bind, localIP, localPort);
00906 }