hm11.cpp

00001 #include "hm11.h"    
00002 #include "string.h" 
00003    
00004    
00005    #define WAIT_FOR_DATA_TIMEOUT_MS 1000
00006    #define DEFAULT_WAIT_FOR_DATA_TIMEOUT_MS 50  //required to get correct data
00007    
00008     HM11::HM11(PinName uartTx , PinName uartRx):mSerial(uartTx,uartRx){
00009         
00010         mSerial.baud(HM11_SERIAL_DEFAULT_BAUD );
00011     }
00012     
00013 
00014     
00015     bool HM11::sendSetCommand(const char* command, const int param){
00016         
00017         if(!isCorrectCommand(command,HM11_SEND_COMMAND))
00018             return false;
00019         char dataBuf[12];
00020         memset(dataBuf,0,sizeof(dataBuf));
00021         snprintf(dataBuf,strlen(command)+4,"%s%s%d",hm11TestCommands[HM11_START_CMD],command,param); //TODO strlen +4 ? not all params are 1 char long
00022         sendDataToDevice(dataBuf);
00023         return true;
00024     }
00025     
00026     
00027     bool HM11::sendGetCommand(const char* command){
00028         
00029         if(!isCorrectCommand(command,HM11_SEND_COMMAND))
00030             return false;
00031         char dataBuf[12];
00032         memset(dataBuf,0,sizeof(dataBuf));
00033         snprintf(dataBuf,strlen(hm11TestCommands[HM11_START_CMD])+strlen(command)+strlen(hm11TestCommands[HM11_QUERY_SIGN]+2),"%s%s%s\0",hm11TestCommands[HM11_START_CMD],command,hm11TestCommands[HM11_QUERY_SIGN]);
00034         sendDataToDevice(dataBuf);
00035         return true;
00036     }
00037     
00038     //@param : cmdType - 0 test cmd 
00039     bool HM11::isCorrectCommand(const char* command, HM11CommandType cmdType){
00040         int i = 0 ;
00041         const char**cmdPtr=NULL;
00042         if(cmdType>=HM11_NUM_OF_COMMAND_TYPE){
00043             
00044             return false;
00045         }
00046         if(command==NULL)
00047             return false;
00048         switch(cmdType){
00049             case HM11_TEST_COMMAND:
00050                 i = HM11_NUM_OF_TEST_COMMANDS ;
00051                 cmdPtr=hm11TestCommands;
00052             break;    
00053             case HM11_SEND_COMMAND:
00054                 i = HM11_NUM_OF_COMMANDS;
00055                 cmdPtr=hm11SendCommands;
00056             break;   
00057         }      
00058         while(i>0){
00059             if(strcmp(command,cmdPtr[i])==0){
00060                 return true;    
00061             }
00062             i--;   
00063         }
00064         return false;
00065     }
00066  //comands   
00067 
00068     
00069     bool HM11:: waitForData(int timeoutMs){
00070         int endTime;
00071         int startTime; // sometimes not needed 50ms
00072         Timer timer;
00073         timer.start() ;   
00074         startTime=timer.read_ms();
00075         endTime= startTime+timeoutMs;
00076         while((timer.read_ms())<endTime){
00077             if(isRxDataAvailable()&&(timer.read_ms()-startTime)>DEFAULT_WAIT_FOR_DATA_TIMEOUT_MS)
00078                 return true;
00079         }
00080         return false;
00081     }
00082     
00083     
00084     int HM11::sendDataToDevice(const char* data)
00085     {
00086     
00087         return mSerial.printf(data);
00088     }
00089     
00090     int HM11::sendDataToDevice(const uint8_t * byteData,uint8_t dataLength)
00091     {
00092     
00093         return mSerial.write(byteData,dataLength);
00094     }
00095       
00096     int HM11::isRxDataAvailable()
00097     {
00098         return mSerial.readable();
00099     }
00100     
00101     int HM11::copyAvailableDataToBuf(uint8_t *buf, uint8_t bufLength)
00102     {
00103         int lenCounter =0;
00104         if(buf==NULL||bufLength<1)
00105             return -1;
00106         while(isRxDataAvailable()&&lenCounter<bufLength){                    
00107             buf[lenCounter++]=getDataFromRx();
00108         }
00109         return lenCounter;             
00110     }
00111     
00112     bool HM11:: hexToString(uint32_t hex, char*str,uint8_t nrOfNibblesInHex)
00113     {   
00114         if(nrOfNibblesInHex>8||nrOfNibblesInHex==0||str==NULL)
00115             return false;
00116         for(int i=0;i<nrOfNibblesInHex;i++){
00117             int temp =(hex>>(i*4))&0x0F;
00118             if(temp>=0&&temp<=9)
00119             {
00120                 str[nrOfNibblesInHex-i-1]=temp+'0';
00121             }
00122             else
00123             {
00124                 str[nrOfNibblesInHex-i-1]=temp+'A'-10;
00125             }
00126         }
00127         return true;
00128     }
00129     
00130     
00131       //returns hex in  reverse direction
00132     uint32_t HM11::strToHex(char*const str,uint8_t len) //len - nr of nibbles in str
00133     {
00134         uint32_t ret=0;
00135         uint8_t temp;
00136         if(len<1||len>8||str==NULL)
00137             return 0xFFFFFFFF;
00138         
00139         for(int i=0;i<len&&str[i]!='\0';i++)
00140         {
00141             if(str[i]>='0'&&str[i]<='9')
00142             {
00143                 temp=str[i]-'0';
00144                 ret|=temp<<(i*4);
00145             }
00146             else if(str[i]>='A'&&str[i]<='F')
00147             {
00148                 temp=str[i]-'A'+10;
00149                 ret|=temp<<(i*4);
00150             }
00151             else if(str[i]>='a'&&str[i]<='f')
00152             {
00153                 temp=str[i]-'a'+10;
00154                 ret|=temp<<(i*4);
00155             }
00156             else 
00157                 return 0xFFFFFFFF;  //-1 :-)
00158         }
00159         return ret;
00160     }
00161     
00162 // public methods
00163     bool HM11::queryModuleAddress(char* addrBuf)
00164     {
00165         flushBuffers();
00166         sendDataToDevice("AT+ADDR?");
00167         char headerBuf[8];//for OK+ADDR:
00168         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00169             return false;
00170         else{
00171             copyAvailableDataToBuf((uint8_t*)headerBuf,sizeof(headerBuf));
00172             if(strncmp(headerBuf,"OK+ADDR:",sizeof(headerBuf)) == 0){
00173                 if(copyAvailableDataToBuf((uint8_t*)addrBuf,12)){
00174                     addrBuf[12]='\0';
00175                     return true;
00176                 }
00177             }
00178         return false;         
00179         }       
00180     }
00181     
00182 
00183     bool HM11::setAdvertisingInterval(AdvertisingInterval_t advInt)
00184     {
00185         flushBuffers();
00186         char buf[9]={"AT+ADVI"};        
00187         hexToString((uint32_t)advInt, &buf[7],1);
00188         buf[8]='\0';
00189         sendDataToDevice(buf);
00190         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00191             return false;
00192         else
00193         {
00194             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00195             if(strncmp(buf,"OK+Set:",7) == 0){
00196                 if(strToHex(&buf[7],1)<_INVALID_ADV_INTERVAL){
00197                     return true;
00198                 }
00199             }
00200             return false;         
00201         }           
00202     }
00203     
00204     
00205     AdvertisingInterval_t HM11::queryAdvertisingInterval(void)
00206     {
00207         flushBuffers();
00208         AdvertisingInterval_t retVal=_INVALID_ADV_INTERVAL;
00209         char respBuf[8];        
00210         sendDataToDevice("AT+ADVI?");
00211         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00212         {
00213             //nothing
00214         }
00215         else
00216         {
00217             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00218             if(strncmp(respBuf,"OK+Get:",sizeof(respBuf)-1) == 0){
00219                 retVal=(AdvertisingInterval_t)strToHex(&respBuf[sizeof(respBuf)-1],1);
00220             }
00221                                      
00222         }
00223         return retVal;  
00224     }
00225  
00226      
00227     bool HM11::setAdvertisingType(AdvertisingType_t advInt)
00228     {
00229         flushBuffers();
00230         char buf[9]={"AT+ADTY"};        
00231         hexToString((uint32_t)advInt, &buf[7],1);
00232         buf[8]='\0';
00233         sendDataToDevice(buf);
00234         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00235             return false;
00236         else
00237         {
00238             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00239             if(strncmp(buf,"OK+Set:",7) == 0){
00240                 if(strToHex(&buf[7],1)<_INVALID_ADV_TYPE){
00241                     return true;
00242                 }
00243             }
00244             return false;         
00245         }              
00246     }
00247     
00248     AdvertisingType_t HM11::queryAdvertisingType(void)
00249     {
00250         flushBuffers();
00251         AdvertisingType_t retVal=_INVALID_ADV_TYPE;
00252         char respBuf[8];        
00253         sendDataToDevice("AT+ADTY?");
00254         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00255         {
00256             //nothing
00257         }
00258         else
00259         {
00260             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00261             if(strncmp(respBuf,"OK+Get:",sizeof(respBuf)-1) == 0){
00262                 retVal=(AdvertisingType_t)strToHex(&respBuf[sizeof(respBuf)-1],1);
00263             }                                     
00264         }
00265         return retVal;  
00266     }
00267      
00268      
00269  
00270     bool HM11::setAncsSwitch(uint8_t enable)
00271     {
00272         flushBuffers();
00273         char buf[9]={"AT+ANCS"};        
00274         hexToString(enable, &buf[7],1);
00275         buf[8]='\0';
00276         sendDataToDevice(buf);
00277         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00278             return false;
00279         else
00280         {
00281             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00282             if(strncmp(buf,"OK+Set:",7) == 0){
00283                 if(strToHex(&buf[7],1)<0x2){
00284                     return true;
00285                 }
00286             }
00287             return false;         
00288         }              
00289     }
00290     
00291     
00292 
00293     uint8_t HM11::queryAncsSwitch(void)
00294     {
00295         flushBuffers();
00296         uint8_t retVal=0xFF;
00297         char respBuf[8];        
00298         sendDataToDevice("AT+ANCS?");
00299         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00300         {
00301             retVal=0xFF;
00302         }
00303         else
00304         {
00305             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00306             if(strncmp(respBuf,"OK+Get:",sizeof(respBuf)-1) == 0){
00307                 retVal=strToHex(&respBuf[sizeof(respBuf)-1],1);
00308             }                                     
00309         }
00310         return retVal;  
00311     }
00312     
00313   
00314     bool HM11::setWhitelistSwitch(uint8_t enable)
00315     {
00316         flushBuffers();
00317         char buf[9]={"AT+ALLO"};        
00318         hexToString(enable, &buf[7],1);
00319         buf[8]='\0';
00320         sendDataToDevice(buf);
00321         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00322             return false;
00323         else
00324         {
00325             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00326             if(strncmp(buf,"OK+Set:",7) == 0){
00327                 if(strToHex(&buf[7],1)<0x2){
00328                     return true;
00329                 }
00330             }
00331             return false;         
00332         }              
00333     }
00334     
00335 
00336     uint8_t HM11::queryWhitelistSwitch(void)
00337     {
00338         flushBuffers();
00339         uint8_t retVal=0xFF;
00340         char respBuf[8];        
00341         sendDataToDevice("AT+ALLO?");
00342         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00343         {
00344             retVal=0xFF;
00345         }
00346         else
00347         {
00348             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00349             if(strncmp(respBuf,"OK+Get:",sizeof(respBuf)-1) == 0){
00350                 retVal=strToHex(&respBuf[sizeof(respBuf)-1],1);
00351             }                                     
00352         }
00353         return retVal;  
00354     }
00355     
00356 
00357     bool HM11::setWhitelistMacAddress (uint8_t nrOfMacAddrLinkedToModule, const char* const macAddress)
00358     {
00359         if(nrOfMacAddrLinkedToModule>3 ||macAddress ==NULL)
00360         {
00361             return false;
00362         }
00363         char buf[19]={"AT+AD"}; 
00364         flushBuffers();
00365         hexToString(nrOfMacAddrLinkedToModule, &buf[5],1);
00366         memcpy(&buf[6],macAddress,12);
00367         buf[18]='\0';
00368         sendDataToDevice(buf);
00369         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00370             return false;
00371         else
00372         {
00373             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00374             if(strncmp(buf,"OK+AD",5) == 0){
00375                 return true;
00376             }
00377             return false;         
00378         } 
00379     }
00380     
00381     bool HM11::queryWhitelistMacAddress(uint8_t nrOfMacAddrLinkedToModule, char* const macAddrBuf, uint8_t macAddrBufLen)
00382     {
00383         
00384         if(macAddrBuf==NULL||nrOfMacAddrLinkedToModule>3||macAddrBufLen<12) //12 -len of macAddr eg. 001122334455 
00385             return false;
00386         flushBuffers();
00387         char buf[20]={"AT+ADx??"};
00388         buf[8]='\0';  
00389         hexToString(nrOfMacAddrLinkedToModule, &buf[5],1);
00390         sendDataToDevice(buf); 
00391         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00392             return false;
00393         else
00394         {
00395             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00396             if(strncmp(buf,"OK+AD",5) == 0){
00397                 memcpy(macAddrBuf,&buf[8],12);
00398                 return true;
00399             }
00400             return false;         
00401         } 
00402     
00403     }
00404 
00405 
00406     bool HM11::setBatteryMonitorSwitch(uint8_t battSwitchEnable)
00407     {
00408         flushBuffers();
00409         char buf[9]={"AT+BATCx"};
00410         buf[8]='\0';        
00411         hexToString(battSwitchEnable, &buf[7],1);
00412         sendDataToDevice(buf);
00413         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00414             return false;
00415         else
00416         {
00417             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00418             if(strncmp(buf,"OK+Set:",7) == 0){
00419                 if(strToHex(&buf[7],1)<0x2){
00420                     return true;
00421                 }
00422             }
00423             return false;         
00424         }              
00425     }
00426     
00427  
00428     uint8_t HM11::queryBatteryMonitorSwitch(void)
00429     {
00430         flushBuffers();
00431         uint8_t retVal=0xFF;
00432         char respBuf[8];        
00433         sendDataToDevice("AT+BATC?");
00434         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00435         {
00436             retVal=0xFF;
00437         }
00438         else
00439         {
00440             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00441             if(strncmp(respBuf,"OK+Get:",sizeof(respBuf)-1) == 0){
00442                 retVal=strToHex(&respBuf[sizeof(respBuf)-1],1);
00443             }                                     
00444         }
00445         return retVal;  
00446     }
00447     
00448     
00449 
00450     uint8_t HM11::queryBatteryInformation(void)
00451     {
00452         flushBuffers();
00453         uint8_t retVal=0xFF;
00454         char respBuf[12];        
00455         sendDataToDevice("AT+BATT?");
00456         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00457         {
00458             retVal=0xFF;
00459         }
00460         else
00461         {
00462             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00463             if(strncmp(respBuf,"OK+BATT:",7) == 0){
00464                 retVal=strToHex(&respBuf[7],3);
00465             }                                     
00466         }
00467         return retVal;      
00468         
00469     }
00470 
00471     
00472 
00473     bool HM11::setIBeaconIntoServiceMode(void)   //NOT USED ANYMORE
00474     {
00475         flushBuffers();        
00476         sendDataToDevice("AT+BUSHU");
00477         char respBuf[10];
00478         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00479         {
00480             return false;
00481         }
00482         else
00483         {
00484             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00485             if(strncmp(respBuf,"OK+BUSHU",7) == 0)
00486             {
00487                 return true;
00488             }                                     
00489         }
00490         return false;  
00491         
00492     }
00493     
00494     
00495   
00496     bool HM11::setBitFormat(uint8_t bit7Format)
00497     {
00498         if(bit7Format>1)
00499             return false;
00500         flushBuffers();
00501         char buf[9]={"AT+BIT7x"};
00502         buf[8]='\0';        
00503         hexToString(bit7Format, &buf[7],1);
00504         sendDataToDevice(buf);
00505         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00506             return false;
00507         else
00508         {
00509             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00510             if(strncmp(buf,"OK+Set:",7) == 0){
00511                 if(strToHex(&buf[7],1)<0x2){
00512                     return true;
00513                 }
00514             }
00515             return false;         
00516         }              
00517     }
00518     
00519  
00520     uint8_t HM11::queryBitFormat(void)
00521     {
00522         flushBuffers();
00523         uint8_t retVal=0xFF;
00524         char respBuf[8];        
00525         sendDataToDevice("AT+BIT7?");
00526         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00527         {
00528             retVal=0xFF;
00529         }
00530         else
00531         {
00532             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00533             if(strncmp(respBuf,"OK+Get:",7) == 0){
00534                 retVal=strToHex(&respBuf[7],1);
00535             }                                     
00536         }
00537         return retVal; 
00538     }
00539     
00540   
00541  
00542     bool HM11::setBaudRate(BaudRate_t baud)
00543     {
00544         if(baud >=_INVALID_BAUDRATE)
00545             return false;
00546         flushBuffers();
00547         char buf[9]={"AT+BAUDx"};        
00548         hexToString((uint32_t)baud, &buf[7],1);
00549         buf[8]='\0';
00550         sendDataToDevice(buf);
00551         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00552             return false;
00553         else
00554         {
00555             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00556             if(strncmp(buf,"OK+Set:",7) == 0){
00557                 if(strToHex(&buf[7],1)<_INVALID_BAUDRATE){
00558                     return true;
00559                 }
00560             }
00561             return false;         
00562         }               
00563     }
00564     
00565     
00566     BaudRate_t HM11::queryBaudRate(void)
00567     {
00568         flushBuffers();
00569         BaudRate_t retVal=_INVALID_BAUDRATE;
00570         char respBuf[8];        
00571         sendDataToDevice("AT+BAUD?");
00572         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00573         {
00574             //nothing
00575         }
00576         else
00577         {
00578             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00579             if(strncmp(respBuf,"OK+Get:",7) == 0){
00580                 retVal=(BaudRate_t)strToHex(&respBuf[7],1);
00581             }
00582                                      
00583         }
00584         return retVal;            
00585     }  
00586     
00587 
00588     bool HM11::setCharacteristic(uint16_t chValue)
00589     {
00590         if(chValue <0x0001||chValue>0xFFFE)
00591             return false;
00592         flushBuffers();
00593         char buf[14]={"AT+CHAR0xiiii"};        
00594         hexToString((uint32_t)chValue, &buf[9],4);
00595         buf[13]='\0';
00596         sendDataToDevice(buf);
00597         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00598             return false;
00599         else
00600         {
00601             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00602             if(strncmp(buf,"OK+Set:0x",9) == 0){
00603                 return true;
00604 
00605             }
00606             return false;         
00607         }   
00608     }
00609     
00610     uint16_t HM11::queryCharacteristic(void)
00611     {
00612         flushBuffers();
00613         uint16_t retVal=0xFFFF;
00614         char respBuf[14];        
00615         sendDataToDevice("AT+CHAR?");
00616         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00617         {
00618             //nothing
00619         }
00620         else
00621         {
00622             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00623             if(strncmp(respBuf,"OK+Get:0x",9) == 0){
00624                 retVal=(uint16_t)strToHex(&respBuf[9],4);
00625             }                                   
00626         }
00627         return retVal;   
00628     } 
00629   
00630 
00631     ConnectionStatus_t HM11::connectToLastDevice(void)
00632     {
00633         
00634         ConnectionStatus_t retVal=  _INVALID_CONECTIONSTATUS;
00635         flushBuffers();
00636         char buf[9]={"AT+CONNL"};        
00637         buf[8]='\0';
00638         sendDataToDevice(buf);
00639         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS*5))
00640         {
00641             //nothing
00642         }
00643         else
00644         {
00645             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00646             if(strncmp(buf,"OK+CONN",7) == 0){
00647                 for(int i=0; i<_INVALID_CONECTIONSTATUS ;++i){
00648                     if(strncmp(&buf[7],&ConnectionStatusArr[i],1) == 0)
00649                         retVal= ( ConnectionStatus_t)i;      
00650                 }
00651             }                   
00652         } 
00653         return retVal;                  
00654     }
00655     
00656     ConnectionStatus_t HM11::connectToAnAddress(const char* const macAddress)
00657     {
00658         ConnectionStatus_t retVal= _INVALID_CONECTIONSTATUS;
00659         if(macAddress ==NULL)
00660         {
00661             return retVal;
00662         }       
00663         flushBuffers();
00664         char buf[19]={"AT+CON"};
00665         memcpy(&buf[6],macAddress,12);       
00666         buf[18]='\0';
00667         sendDataToDevice(buf);
00668         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS*5))
00669         {
00670             //nothing
00671         }
00672         else
00673         {
00674             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00675             if(strncmp(buf,"OK+CONN",7) == 0){
00676                 for(int i=0; i<_INVALID_CONECTIONSTATUS ;++i){
00677                     if(strncmp(&buf[7],&ConnectionStatusArr[i],1) == 0)
00678                         retVal= ( ConnectionStatus_t)i;      
00679                 }
00680             }                   
00681         } 
00682         return retVal;   
00683     } 
00684     
00685   
00686     uint8_t HM11::queryInputOutputState(void)
00687     {
00688         flushBuffers();
00689         uint8_t retVal=0xFF;
00690         char respBuf[12];        
00691         sendDataToDevice("AT+COL??");
00692         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00693         {
00694             //nothing
00695         }
00696         else
00697         {
00698             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00699             if(strncmp(respBuf,"OK+Col:0x",9) == 0){
00700                 retVal=(uint8_t)strToHex(&respBuf[9],2);
00701             }                                   
00702         }
00703         return retVal;   
00704         
00705     
00706     }
00707     
00708 
00709     bool HM11::setPioCollectionRate (uint8_t colRateSec)
00710     {
00711         if(colRateSec>90)
00712             return false;
00713         flushBuffers();
00714         char buf[9]={"AT+CYCxx"};        
00715         hexToString((uint32_t)colRateSec, &buf[6],2);
00716         buf[8]='\0';
00717         sendDataToDevice(buf);
00718         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00719             return false;
00720         else
00721         {
00722             copyAvailableDataToBuf((uint8_t*)buf,sizeof(buf));
00723             if(strncmp(buf,"OK+Set:",7) == 0){
00724                 uint8_t secVal= (uint8_t)strToHex(&buf[7],2);
00725                 //if(secVal==colRateSec)
00726                     return true;
00727             }      
00728         } 
00729         return false;         
00730     }
00731     
00732    
00733     uint8_t HM11::queryPioCollectionRate(void)
00734     {
00735         flushBuffers();
00736         uint8_t retVal=0xFF;
00737         char respBuf[12];        
00738         sendDataToDevice("AT+CYC??");
00739         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
00740         {
00741             //nothing
00742         }
00743         else
00744         {
00745             copyAvailableDataToBuf((uint8_t*)respBuf,sizeof(respBuf));
00746             if(strncmp(respBuf,"OK+Get:",7) == 0){
00747                 retVal=(uint8_t)strToHex(&respBuf[7],2);
00748             }                                   
00749         }
00750         return retVal;     
00751     }
00752     
00753     
00754  #if 0  
00755     bool HM11::startDeviceDiscoveryScan(ScanResult_t* scanRes) 
00756     {
00757         
00758     }    
00759     
00760   
00761     bool HM11::connectToDiscoveryDevice(ScanResult_t* scanRes) 
00762     {
00763         
00764     }    
00765     
00766        
00767 
00768     bool HM11::setIBeaconDeployMode(DeployMode_t depMode)
00769     {
00770         
00771     }    
00772     
00773    
00774     bool HM11::setFilterOfHmModules(FilterOfHmModules_t filter) 
00775     {
00776         
00777     }    
00778     
00779  
00780     FilterOfHmModules_t HM11::queryFilterOfHmModules(void) 
00781     {
00782         
00783     }    
00784    
00785   
00786     bool HM11::removeBondInformation(void) 
00787     {
00788         
00789     }    
00790 
00791     bool HM11::getSystemHelpInformation(char* helpInformationBuf)
00792     {
00793         
00794     }    
00795   
00796     bool HM11::setModuleWorkType(ModuleWorkType_t modWorkType) 
00797     {
00798         
00799     }    
00800     
00801    
00802     ModuleWorkType_t HM11::queryModuleWorkType(void)
00803     {
00804         
00805     }    
00806    
00807    
00808   
00809    
00810     bool HM11::setModuleIBeaconSwitch (uint8_t turnOnOff)
00811     
00812   
00813     uint8_t HM11::queryModuleIBeaconSwitch (void);
00814      
00815    
00816        
00817     bool HM11::setIBeaconUuid (uint32_t uuid0,uint32_t uuid1,uint32_t uuid2, uint32_t uuid3); 
00818     bool HM11::setIBeaconUuid (uint32_t* uuid); 
00819     
00820  
00821     uint32_t HM11::queryIBeaconUuid(uint32_t* nr_of_uuid);
00822      
00823     
00824     
00825  
00826     bool HM11::setIBeaconMajor(uint16_t mjrVersion); 
00827     
00828    
00829     uint16_t HM11::queryIBeaconMajor(void);
00830     
00831     
00832     
00833   
00834     bool HM11::setIBeaconMinor(uint16_t mnrVersion); 
00835     
00836   
00837     uint16_t HM11::queryIBeaconMinor(void);
00838    
00839    
00840    
00841   
00842     bool HM11::setIBeaconMeasuredPower(uint16_t measuredPwr); 
00843     
00844     
00845    
00846     uint16_t HM11::queryIBeaconMeasuredPower(void);
00847    
00848    
00849      
00850     bool HM11::setModuleWorkMode(ModuleWorkMode_t workMode); 
00851     
00852     
00853   
00854     ModuleWorkMode_t  HM11::queryModuleWorkMode(void);
00855    
00856  
00857  
00858      
00859     bool HM11::setModuleName(char* name, uint8_t nameLength); 
00860     
00861    
00862     bool HM11::queryModuleName(char *name);
00863  
00864  
00865  
00866    
00867     bool HM11::setParityBit(ParityBit_t pBit); 
00868     
00869     
00870   
00871     ParityBit_t HM11::queryParityBit(void);
00872     
00873   
00874     bool HM11::setPio1OutputStatus(uint8_t status); 
00875     
00876     
00877   
00878     uint8_t HM11::queryPio1OutputStatus(void);
00879     
00880     
00881     
00882     
00883  
00884     bool HM11::setPioPinsOutput(uint8_t nrOfPio, uint8_t val ); 
00885     
00886    
00887     uint8_t HM11::queryPioPinsOutput(uint8_t nrOfPio);
00888  
00889  
00890  
00891   
00892     bool HM11::setPinCode (uint32_t pinCode ); 
00893     
00894     
00895  
00896     uint8_t HM11::queryPinCode (void);
00897  
00898  
00899  
00900   
00901     bool HM11::setModulePower(ModulePower_t modPower); 
00902     
00903     
00904   
00905     ModulePower_t HM11::queryModulePower (void);
00906  
00907  
00908   
00909     bool HM11::setModuleSleepType(uint8_t modSleepType ); 
00910     
00911     
00912   
00913    uint8_t HM11::queryModuleSleepType (void);
00914  
00915  
00916  
00917   
00918     bool HM11::restoreAll(void); 
00919     
00920   
00921     bool HM11::restartModule(void);
00922     
00923     
00924  
00925     bool HM11::setMasterAndSlaveRole(uint8_t role); 
00926     
00927     
00928   
00929     uint8_t HM11::queryMasterAndSlaveRole(void); 
00930    
00931    
00932    
00933   
00934     uint8_t HM11::queryRssiValue(void); 
00935    
00936    
00937    
00938   
00939     char* HM11::queryLastConnectedDeviceAddress(void);
00940    
00941    
00942    
00943  
00944     bool HM11::setModuleSensorWorkInterval(uint8_t interval); 
00945     
00946     
00947    
00948     uint8_t HM11::queryModuleSensorWorkInterval(void); 
00949     
00950     
00951  
00952     bool HM11::workImmediately(void);
00953     
00954     
00955  
00956     bool HM11::queryModuleIntoSleepMode(void); 
00957     
00958     
00959  
00960     bool HM11::setModuleSaveConnectedAddressParam(uint8_t saveParam); 
00961     
00962   
00963     uint8_t HM11::queryModuleSaveConnectedAddressParam(void);
00964     
00965     
00966  
00967     bool HM11::setSensorTypeOnModulePio(SensorType_t sensorType); 
00968     
00969     
00970   
00971     SensorType_t HM11::querySensorTypeOnModulePio(void);  
00972    
00973     
00974     bool HM11::setDiscoveryParameter (SensorType_t discoverParam); 
00975     
00976 
00977     uint8_t HM11::queryDiscoveryParameter (void); 
00978     
00979     
00980     
00981   
00982     bool HM11::queryModuleSensorTempAndHumidity(uint8_t* temp, uint8_t* hum); 
00983     
00984     
00985 
00986     bool HM11::queryDS18B20SensorTemperature (uint8_t* temp); 
00987     
00988     
00989     
00990    
00991     bool HM11::setModuleConnectRemoteDeviceTimeoutValue(uint32_t timeout); 
00992     
00993     
00994     
00995 
00996     uint32_t HM11::queryModuleConnectRemoteDeviceTimeoutValue(void); 
00997     
00998     
00999   
01000     bool HM11::setModuleBondMode(BondMode_t bondMode); 
01001     
01002     
01003   
01004     BondMode_t HM11::queryModuleBondMode(void); 
01005     
01006     
01007     
01008     
01009   
01010     bool HM11::setServiceUuid (uint16_t serviceUuid); 
01011     
01012     
01013   
01014     uint16_t HM11::queryServiceUuid(void);
01015     
01016     
01017     
01018   
01019     bool HM11::setUartSleepType (uint8_t sleepType); 
01020     
01021     
01022   
01023     uint8_t HM11::queryUartSleepType(void);
01024 #endif  
01025     
01026     bool HM11::querySoftwareVersion(char* verBuf, uint8_t bufLen)
01027     {
01028         if(!verBuf)
01029         {
01030             return false;
01031         }
01032         flushBuffers();
01033         sendDataToDevice("AT+VERR?");
01034         if(!waitForData(WAIT_FOR_DATA_TIMEOUT_MS))
01035             return false;
01036         else
01037         {
01038             copyAvailableDataToBuf((uint8_t*)verBuf,bufLen);
01039             return true;
01040         }        
01041         
01042                 
01043     }
01044