LM005A Lora Module test

Dependents:   LoRaTest OnenetTest

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers BC95B.cpp Source File

BC95B.cpp

00001 /* BC95B oneNet Application 
00002 * reference document:Quectel_BC95_OneNET_Application_Note_V1.2.pdf
00003 * By modular-2 team 2018/7/26
00004 */
00005 
00006 #include "BC95B.h"
00007 
00008 #define   BC95B_DEFAULT_BAUD_RATE   9600
00009 #define READ 0
00010 #define WRITE 1
00011 #define DISCOVER 2
00012 BC95B::BC95B(PinName tx, PinName rx, bool debug)
00013     : _serial(tx, rx, BC95B_DEFAULT_BAUD_RATE), 
00014       _parser(&_serial),
00015       _fail(false)
00016 {
00017     _serial.set_baud( BC95B_DEFAULT_BAUD_RATE );
00018     _parser.debug_on(debug);
00019     _parser.set_delimiter("\r\n");
00020      _parser.oob("+MIPLWRITE:", callback(this, &BC95B::_write_handler));
00021      _parser.oob("+MIPLREAD:", callback(this, &BC95B::_read_handler));
00022      _parser.oob("+MIPLOBSERVE:", callback(this, &BC95B::_obs_handler));
00023     _parser.oob("+MIPLDISCOVER:", callback(this, &BC95B::_discover_handler));
00024 }
00025 
00026 const char * BC95B::get_firmware_version()
00027 {   
00028         if (!(_parser.send("AT+MIPLVER?")
00029         && _parser.recv("+MIPLVER:%s\n",buffer)
00030         && _parser.recv("OK"))) {
00031         return NULL;
00032     }
00033    return buffer;
00034     
00035 }
00036 const char * BC95B::get_imei()
00037 {   
00038         if (!(_parser.send("AT+CGSN=1")
00039         && _parser.recv("+CGSN:%s\n",buffer)
00040         && _parser.recv("OK"))) {
00041         return NULL;
00042     }
00043    return buffer;
00044     
00045 }
00046 const char * BC95B::get_imsi()
00047 {   
00048         if (!(_parser.send("AT+CIMI")
00049         && _parser.recv("%s\n",buffer)
00050         && _parser.recv("OK"))) {
00051         return NULL;
00052     }
00053    return buffer;
00054     
00055 }
00056 bool BC95B::get_SignalStrength(int* rssi,int* ber)
00057 {   
00058         if (!(_parser.send("AT+CSQ")
00059         && _parser.recv("+CSQ:%d,%d\n",rssi,ber)
00060         && _parser.recv("OK"))) {
00061         return false;
00062     }
00063    return true;
00064     
00065 }
00066 int BC95B::create_suite()
00067 {   int result;
00068         if (!(_parser.send("AT+MIPLCREATE")
00069         && _parser.recv("+MIPLCREATE:%d",&result)
00070         && _parser.recv("OK"))) {
00071         return -1;
00072     }
00073    return result;
00074     
00075 }
00076 bool BC95B::create_object(int ch,const int name,int insCount,const char * bitmap,int attrCount,int actCount)
00077 {
00078    
00079         if (!(_parser.send("AT+MIPLADDOBJ=%d,%d,%d,\"%s\",%d,%d",ch,name,insCount,bitmap,attrCount,actCount)
00080         && _parser.recv("OK"))) {
00081         return false;
00082     }
00083    return true; 
00084    }
00085 bool  BC95B::register_request(int ref,int lifetime,int timeout)
00086  {
00087          if (!(_parser.send("AT+MIPLOPEN=%d,%d,%d",ref,lifetime,timeout)
00088         && _parser.recv("OK") 
00089         && _parser.recv("+MIPLEVENT: 0,1") 
00090         && _parser.recv("+MIPLEVENT: 0,2") 
00091         && _parser.recv("+MIPLEVENT: 0,4") 
00092         && _parser.recv("+MIPLEVENT: 0,6")))
00093          {
00094         return false;
00095     }
00096    return true; 
00097      } 
00098 /*bool BC95B::respond_discover(int ref,int result ,int length,char *valuestring)
00099 {
00100          if (!(_parser.send("AT+MIPLDISCOVERRSP=%d,%s,%d,%d,%S",ref,msg,result,length,valuestring)
00101         && _parser.recv("OK"))){
00102             return false;
00103             } 
00104             return true;
00105     } */
00106 bool BC95B::delete_object(int ref,const char * objid)
00107 {
00108         if (!(_parser.send("AT+MIPLDELOBJ=%d,%s",ref,objid)
00109         && _parser.recv("OK"))){
00110             return false;
00111             } 
00112             return true;
00113     } 
00114 bool BC95B::deregister(int ref)
00115 {
00116         if (!(_parser.send("AT+MIPLCLOSE=%d",ref)
00117         && _parser.recv("OK"))){
00118             return false;
00119             } 
00120             return true;
00121     } 
00122 bool BC95B::notify_resource(int ref,int objid,int ins,int resid,int valueType,int len,const char * value,int index,int flg)
00123 {  
00124 if (!(_parser.send("AT+MIPLNOTIFY=%d,%d,%d,%d,%d,%d,%d,%s,%d,%d", ref,obsmsg,objid,ins,resid,valueType,len,value,index,flg)
00125         && _parser.recv("OK"))){
00126             return false;
00127             } 
00128             return true;
00129     }
00130                  
00131 bool BC95B::init(void)
00132 {   
00133     if (!_parser.recv("Bootup Completed!!!"))
00134     return false;
00135     return true;
00136       }
00137 bool BC95B::reset(void)
00138 {
00139         if (!(_parser.send("AT+NRB")
00140         &&_parser.recv("REBOOTING"))) {
00141         return false;
00142     }  
00143   return true;
00144 }
00145  
00146    
00147 
00148 
00149 /*
00150 +MIPLWRITE--平台下发的写指令
00151 +MIPLWRITE: <ref>,<msgId>,<objI d>,<insId>,<resId>,<valueType>,<len>,<value>,<flag>,<index> 
00152 response:
00153 AT+MIPLWRITERSP=<ref>,<msgId>,< result> 
00154 */
00155 
00156 
00157 void BC95B::_write_handler()
00158 {   
00159   if (!(_parser.recv("%d,%d,%d,%d,%d,%d,%d,",&ref,&msg,&objId,&insId,&resId,&valueType,&len)
00160      && _parser.read(value,len*2)
00161      &&_parser.recv(",%d,%d\n",&flag,&index))) {       
00162         return;
00163     }    
00164   
00165  //  printf("v=%.*s\n",len*2,value);
00166  currCode=WRITE;
00167  curr_objId=objId;
00168  curr_insId=insId;
00169  curr_resId=resId;
00170  valueLength=len*2;
00171     _callback();
00172     result=2;
00173     if (! _parser.send("AT+MIPLWRITERSP=%d,%d,%d",ref,msg,result))
00174    { 
00175    return;
00176    }
00177    
00178  }
00179  /*
00180  +MIPLREAD--平台下发的读指令
00181  +MIPLREAD: <ref>,<msgId>,<objId>,<insId>, <resId> 
00182  response:
00183    AT+MIPLREADRSP=<ref>,<msgId>, <result>[,<objId>,<insId>,<resId>,< valueType>,<len>,<value>,<index>, <flag>] 
00184  */
00185  void BC95B::_read_handler()
00186  { int valueType,len,index,flg;
00187       if (!_parser.recv("%d,%d,%d,%d,%d\n",&ref,&msg,&objId,&insId,&resId))         
00188          {
00189         return  ;
00190         }
00191   //getValue(objId,insId,resId);
00192  //"AT+MIPLREADRSP=%d,%s",ref,msgId,result,objId,insId,resId,valueType,len,value,index,flg)
00193  currCode=READ;
00194  curr_objId=objId;
00195  curr_insId=insId;
00196  curr_resId=resId;
00197  _callback();
00198     len=4;index=0;flg=0;result=1;valueType=currType;
00199   //  memcpy(value,"3.8",3);
00200      if (! _parser.send("AT+MIPLREADRSP=%d,%d,%d,%d,%d,%d,%d,%d,%s,%d,%d ",ref,msg,result,objId,insId,resId,valueType,len,value,index,flg))
00201    { 
00202    return;
00203    }
00204      }
00205 /*
00206 +MIPLOBSERVE: <ref>,<msgId>,<flag>,<objI d>,<insId>,<resId> 
00207 AT+MIPLDISCOVERRSP=<ref>,<msgI d>,<result>[,<length>,<valuestring>] 
00208 */
00209 void BC95B::_obs_handler()
00210 {   
00211     if (!_parser.recv("%d,%d,%d,%d,%d,%d\n",&ref,&obsmsg,&flag,&objId,&insId,&resId)) {
00212         return;
00213     }
00214     result=1;
00215    if (! _parser.send("AT+MIPLOBSERVERSP=%d,%d,%d",ref,obsmsg,result))
00216      {
00217          return;
00218          }  
00219     }
00220 void BC95B::_discover_handler()
00221 {   
00222     if (!_parser.recv("%d,%d,%d\n",&ref,&msg,&objId)) {
00223         return;
00224     }
00225    // printf("discover\n");
00226     currCode=DISCOVER;
00227     curr_objId=objId;
00228     _callback();
00229     result=1;
00230    if (! _parser.send("AT+MIPLDISCOVERRSP=0,%d,%d,%d,\"%s\"",msg,result,resLength,resNames))
00231      {
00232          return;
00233          }  
00234     }
00235 bool BC95B::recv()
00236 {
00237      if (!_parser.process_oob()) {
00238             return false;
00239         }
00240     return true;    
00241         }
00242 
00243 void BC95B::setTimeout(uint32_t timeout_ms)
00244 {
00245     _parser.set_timeout(timeout_ms);
00246 }
00247 
00248 void BC95B::attach(void (*func)(void))
00249 {
00250     _callback=func;
00251 
00252     }
00253 
00254   int BC95B::getEventCode()
00255   {  
00256   return currCode;
00257       }
00258   ;
00259     void BC95B::getCurrentID(long *msgId,int *objId,int *insId,int *resId)
00260     {
00261         *msgId=curr_msgId;
00262         *objId=curr_objId;
00263         *insId=curr_insId;
00264         *resId=curr_resId;
00265         };
00266     int  BC95B::getCurrentValue(char *buf)
00267     {
00268         memcpy(buf,value,valueLength);
00269        return valueLength;
00270         };
00271     int  BC95B::putCurrentValue(int type,char *buf,int length)
00272     {  
00273         valueLength= length ;
00274         currType=type;
00275          memcpy(value,buf,valueLength);
00276          return valueLength;
00277         };
00278   
00279   int  BC95B::putCurrentResNames(int type,char *buf,int length)
00280     { 
00281         printf("reslength=%d\n",length);
00282         resLength= length ;
00283         currType=type;
00284          memcpy(resNames,buf,resLength);
00285          return resLength;
00286         };
00287