Eeabp1.cpp

00001 #include "Eeabp1.h"
00002 //#include "rtos.h"
00003 
00004 //Thread thread;
00005 static const int lora_msg_max_len = 11;
00006 
00007 Eeabp1::Eeabp1() : pwr_en(P0_0), led(P0_23), 
00008     lora_power(P0_5), lora_reset(P0_22), grove_power(P0_6),
00009     grv_sel2a(P0_19), grv_sel2g(P0_18), grv_sel1a(P0_17), grv_sel1g(P0_16),
00010     grv_p1s1a(P0_2), grv_p1s2a(P0_1),
00011     grv_p2s1a(P0_4), grv_p2s2a(P0_3)
00012 {
00013     this->led_state = LED_OFF;
00014     this->led = 0;
00015     this->serial = new RawSerial(P0_9, P0_11);
00016     this->serial->baud(9600); /* use for LoRa */
00017     this->pwr_en = 1; // メイン電源投入
00018     this->lora_power = 0;
00019     this->lora_reset = 0;
00020     this->grove_power = 0;
00021     this->lora_enabled = false;
00022     this->grove_enabled = false;
00023     // Grove端子をHiZに
00024     this->grv_sel1g = 1;
00025     this->grv_sel1a = 1;
00026     this->grv_sel2g = 1;
00027     this->grv_sel2a = 1;
00028     grv_p1s1do = NULL, grv_p1s2do = NULL, grv_p1s1di = NULL, grv_p1s2di = NULL;
00029     grv_p2s1do = NULL, grv_p2s2do = NULL, grv_p2s1di = NULL, grv_p2s2di = NULL;
00030     temp_humid_sensor = NULL;
00031 }
00032 
00033 int Eeabp1::setLedState(EeabLedState state)
00034 {
00035     this->led_state = state;
00036 
00037     if (this->led_state == LED_OFF) {
00038         this->led = 0;
00039     } else {
00040         this->led = 1;
00041     }
00042 
00043     return 0;
00044 }
00045 
00046 void Eeabp1::loop(void)
00047 {
00048     switch (this->led_state) {
00049         case LED_OFF:
00050             /* fall through */
00051         case LED_ON:
00052             break;
00053         case LED_BLINK_FAST:
00054         case LED_BLINK_MID:
00055         case LED_BLINK_SLOW:
00056             this->led = !this->led;
00057             break;
00058     }
00059 }
00060 
00061 int Eeabp1::debug(const char * format, ...)
00062 {
00063     char tmp[80];
00064     int ret;
00065 
00066     std::va_list arg;
00067     va_start(arg, format);
00068     vsnprintf(tmp, sizeof(tmp), format, arg);
00069     va_end(arg);
00070 
00071     delete this->serial;
00072     this->serial = new RawSerial(P0_8, P0_10);
00073     ret = this->serial->puts(tmp);
00074     delete this->serial;
00075     this->serial = new RawSerial(P0_9, P0_11);
00076 
00077     return ret;
00078 }
00079 
00080 int Eeabp1::setLoRaPower(bool on)
00081 {
00082     int ret;
00083 
00084     if (on) {
00085         if (lora_enabled)
00086             return 0;  /* power is already on, do nothing */
00087 
00088         this->lora_power= 1;
00089         this->lora_reset = 1;
00090         wait_us(500000);
00091         serial->printf("mod set_echo off\r\n"); // ローカルエコー：無効
00092         wait(1);
00093         flushSerial();
00094         serial->printf("mod factory_reset\r\n"); // ファクトリーリセットを行い鍵をリフレッシュ
00095         ret = chkSerialCharOk();
00096         if (ret != 0)
00097             return ret;
00098         serial->printf("mod set_echo off\r\n"); // ローカルエコー：無効
00099         wait(1);
00100         serial->printf("lorawan join otaa\r\n"); // Gatewayに接続(OTAA)
00101         ret = chkSerialCharRes('a'); // 成功 ">> accepted" 失敗 ">> unsuccess"
00102         if (ret != 0)
00103             return ret;
00104         serial->printf("lorawan set_dr 2\r\n"); // データレートの設定(11byte)
00105         ret = chkSerialCharOk();
00106         if (ret != 0)
00107             return ret;
00108 
00109         this->lora_enabled = true;
00110     } else { /* off */
00111         if (!lora_enabled)
00112             return 0;  /* power is already off, do nothing */
00113 
00114         lora_power= 0;
00115         lora_enabled = false;
00116     }
00117 
00118     return 0;
00119 }
00120 
00121 int Eeabp1::sendLoRaString(const char * format, ...)
00122 {
00123     char str[lora_msg_max_len+1] = {0x00, };
00124     char msg[64];
00125     char *p = msg;
00126 
00127     std::va_list arg;
00128     va_start(arg, format);
00129     vsnprintf(str, sizeof(str), format, arg);
00130     va_end(arg);
00131 
00132     p += sprintf(msg, "lorawan tx ucnf 16 ");
00133     for (unsigned int i = 0; i < strlen(str); i++) {
00134         p += sprintf(p, "%02x", str[i]);
00135     }
00136     sprintf(p, "\r\n");
00137 
00138     flushSerial();
00139     serial->puts(msg);
00140 
00141     return 0;
00142 }
00143 
00144 void Eeabp1::setGrovePower(bool on)
00145 {
00146     if (on) {
00147         if (grove_enabled)
00148             return; /* power is already on, do nothing */
00149 
00150         grove_power = 1;
00151     } else {
00152         if (!grove_enabled)
00153             return; /* power is already off, do nothing */
00154         
00155         // Grove端子をHiZに
00156         grv_sel1g = 1;
00157         grv_sel1a = 1;
00158         grv_sel2g = 1;
00159         grv_sel2a = 1;
00160         grove_power = 0;
00161     }
00162 }
00163 
00164 int Eeabp1::setGrovePortType(EeabGrovePort port, EeabGrovePortType type)
00165 {
00166     switch (port) {
00167         case GROVE_CH1:
00168             if (type == GROVE_ANALOG) {
00169                 grv_sel1g = 1;
00170                 grv_sel1a = 0;
00171             } else {
00172                 grv_sel1g = 0;
00173                 grv_sel1a = 1;
00174             }
00175             break;
00176         case GROVE_CH2:
00177             if (type == GROVE_ANALOG) {
00178                 grv_sel2g = 1;
00179                 grv_sel2a = 0;
00180             } else {
00181                 grv_sel2g = 0;
00182                 grv_sel2a = 1;
00183             }
00184             break;
00185         default:
00186             /* do nothing */
00187             break;
00188     }
00189 
00190     return 0;
00191 }
00192 
00193 int Eeabp1::setGroveDioDirection(EeabGrovePort port, EeabGroveDioDirection dir, Callback<void()> f)
00194 {
00195     switch (port) {
00196         case GROVE_CH1:
00197             if(dir == GROVE_DIO_OUT) {
00198                 if (grv_p1s1di) {
00199                     delete grv_p1s1di;
00200                     grv_p1s1di = NULL;
00201                 }
00202                 grv_p1s1do = new DigitalOut(P0_13);
00203 
00204                 if (grv_p1s2di) {
00205                     delete grv_p1s2di;
00206                     grv_p1s2di = NULL;
00207                 }
00208                 grv_p1s2do = new DigitalOut(P0_12);
00209             } else { /* GROVE_DIO_IN */
00210                 if (grv_p1s1do) {
00211                     delete grv_p1s1do;
00212                     grv_p1s1do = NULL;
00213                 }
00214                 grv_p1s1di = new InterruptIn(P0_13);
00215                 if (f)
00216                     grv_p1s1di->rise(f);
00217 
00218                 if (grv_p1s2do) {
00219                     delete grv_p1s2do;
00220                     grv_p1s2do = NULL;
00221                 }
00222                 grv_p1s2di = new InterruptIn(P0_12);
00223                 grv_p1s2di->rise(f);
00224             }
00225             break;
00226         case GROVE_CH2:
00227             if(dir == GROVE_DIO_OUT) {
00228                 if (grv_p2s1di) {
00229                     delete grv_p2s1di;
00230                     grv_p2s1di = NULL;
00231                 }
00232                 grv_p2s1do = new DigitalOut(P0_15);
00233 
00234                 if (grv_p2s2di) {
00235                     delete grv_p2s2di;
00236                     grv_p2s2di = NULL;
00237                 }
00238                 grv_p2s2do = new DigitalOut(P0_14);
00239             } else { /* GROVE_DIO_IN */
00240                 if (grv_p2s1do) {
00241                     delete grv_p2s1do;
00242                     grv_p2s1do = NULL;
00243                 }
00244                 grv_p2s1di = new InterruptIn(P0_15);
00245                 if (f)
00246                     grv_p2s1di->rise(f);
00247 
00248                 if (grv_p2s2do) {
00249                     delete grv_p2s2do;
00250                     grv_p2s2do = NULL;
00251                 }
00252                 grv_p2s2di = new InterruptIn(P0_14);
00253                 grv_p2s2di->rise(f);
00254             }
00255             break;
00256         default:
00257             /* do nothing */
00258             break;
00259     }
00260 
00261     return 0;
00262 }
00263 
00264 int Eeabp1::setGroveDio(EeabGrovePort port, EeabGroveDio val)
00265 {
00266     switch (port) {
00267         case GROVE_CH1:
00268             *grv_p1s1do = val;
00269             *grv_p1s2do = val;
00270             break;
00271         case GROVE_CH2:
00272             *grv_p2s1do = val;
00273             *grv_p2s2do = val;
00274             break;
00275         default:
00276             break;
00277     }
00278 
00279     return 0;
00280 }
00281 
00282 int Eeabp1::setGroveDio(EeabGrovePort port, EeabGroveSig sig , EeabGroveDio val)
00283 {
00284     switch (port) {
00285         case GROVE_CH1:
00286                     (sig == GROVE_SIG1) ? *grv_p1s1do = val : *grv_p1s2do = val;
00287             break;
00288         case GROVE_CH2:
00289                     (sig == GROVE_SIG1) ? *grv_p2s1do = val : *grv_p2s2do = val;
00290             break;
00291         default:
00292             break;
00293     }
00294     return 0;
00295 }
00296 
00297 
00298 int Eeabp1::getGroveDio(EeabGrovePort port, EeabGroveSig sig)
00299 {
00300     switch (port) {
00301         case GROVE_CH1:
00302             if (grv_p1s1di == NULL)
00303                 return -1;
00304             return (sig == GROVE_SIG1) ?
00305                 grv_p1s1di->read() : grv_p1s2di->read();
00306         case GROVE_CH2:
00307             if (grv_p2s1di == NULL)
00308                 return -1;
00309             return (sig == GROVE_SIG1) ?
00310                 grv_p2s1di->read() : grv_p2s2di->read();
00311         default:
00312             break;
00313     }
00314 
00315     return -1;
00316 }
00317 
00318 float Eeabp1::getGroveAnalog(EeabGrovePort port, EeabGroveSig sig)
00319 {
00320     switch (port) {
00321         case GROVE_CH1:
00322             return (sig == GROVE_SIG1) ?
00323                 grv_p1s1a.read() : grv_p1s2a.read();
00324         case GROVE_CH2:
00325             return (sig == GROVE_SIG1) ?
00326                 grv_p2s1a.read() : grv_p2s2a.read();
00327         default:
00328             break;
00329     }
00330 
00331     return -1;
00332 }
00333 
00334 int Eeabp1::enableTempHumidSensor(void)
00335 {
00336     temp_humid_sensor = new Sht31(P0_30, P0_7);    
00337     return 0;
00338 }
00339 
00340 float Eeabp1::getTemp(void)
00341 {
00342     if (!temp_humid_sensor)
00343         return -1;
00344 
00345     return temp_humid_sensor->readTemperature();
00346 }
00347 
00348 float Eeabp1::getHumid(void)
00349 {
00350     if (!temp_humid_sensor)
00351         return -1;
00352 
00353     return temp_humid_sensor->readHumidity();
00354 }
00355 
00356 int Eeabp1::enableAccelerometer(void)
00357 {
00358     accelerometer = new ADXL345_I2C(P0_30, P0_7);
00359 
00360     this->debug("Device ID is: 0x%02x\n", accelerometer->getDeviceID());
00361     wait(.001);
00362     
00363     // These are here to test whether any of the initialization fails. It will print the failure
00364     if (accelerometer->setPowerControl(0x00)) {
00365          this->debug("didn't intitialize power control\n"); 
00366          return -1;
00367     }
00368     wait(.001);
00369      
00370     //Full resolution, +/-16g, 4mg/LSB.
00371     if(accelerometer->setDataFormatControl(0x0B)) {
00372         this->debug("didn't set data format\n");
00373         return -1;
00374     }
00375      wait(.001);
00376      
00377     //3.2kHz data rate.
00378     if(accelerometer->setDataRate(ADXL345_3200HZ)) {
00379         this->debug("didn't set data rate\n");
00380         return -1;
00381     }
00382     wait(.001);
00383      
00384     //Measurement mode.
00385     if(accelerometer->setPowerControl(MeasurementMode)) {
00386         this->debug("didn't set the power control to measurement\n");
00387         return -1;
00388     }
00389     
00390     return 0;
00391 }
00392 
00393 int Eeabp1::getAcc(int *x, int *y, int *z)
00394 {
00395     int readings[3] = {0, 0, 0};
00396     accelerometer->getOutput(readings);
00397     *x = readings[0];
00398     *y = readings[1];
00399     *z = readings[2];
00400     
00401     return 0;
00402 }
00403 
00404 /* private functions */
00405 void Eeabp1::flushSerial()
00406 {
00407     while(serial->readable() == true) {
00408         serial->getc();
00409         wait_us(1000);
00410     }
00411 }
00412 
00413 int Eeabp1::chkSerialChar(const char ch,uint16_t timeout_ms)
00414 {
00415     uint32_t timeoutCount = 0;
00416 
00417     while(serial->readable() == false) {
00418         wait_us(50);
00419         timeoutCount++;
00420         if((timeoutCount  / 20) >= timeout_ms)
00421             return -2;
00422     }
00423 
00424     return (serial->getc() == ch) ? 0 : -1;
00425 }
00426 
00427 int Eeabp1::waitSerialChar(const char ch,uint16_t timeout_ms)
00428 {
00429     uint32_t timeoutCount = 0;
00430 
00431     do {
00432         while(serial->readable() == false) {
00433             wait_us(50);
00434             timeoutCount++;
00435             if((timeoutCount  / 20) >= timeout_ms)
00436                 return -2;
00437         }
00438     } while(serial->getc() != ch);
00439 
00440     return 0;
00441 }
00442 
00443 int Eeabp1::chkSerialCharOk()
00444 {
00445     int ret;
00446     ret = waitSerialChar('>',4000);
00447     if (ret != 0)
00448         return __LINE__;
00449 
00450     ret = chkSerialChar('>',2000);
00451     if (ret != 0)
00452         return __LINE__;
00453 
00454     ret = chkSerialChar(' ',2000);
00455     if (ret != 0)
00456         return __LINE__;
00457 
00458     ret = chkSerialChar('O',2000);
00459     if (ret != 0)
00460         return __LINE__;
00461 
00462     ret = chkSerialChar('k',2000);
00463     if (ret != 0)
00464         return __LINE__;
00465 
00466     ret = waitSerialChar('>',4000);
00467     if (ret != 0)
00468         return __LINE__;
00469 
00470     wait_us(1000);
00471 
00472     return 0;
00473 }
00474 
00475 int Eeabp1::chkSerialCharRes(char chkchr)
00476 {
00477     int ret;
00478     ret = waitSerialChar('>', 10000);
00479     if (ret != 0)
00480         return __LINE__;
00481 
00482     ret = chkSerialChar('>',2000);
00483     if (ret != 0)
00484         return __LINE__;
00485 
00486     ret = chkSerialChar(' ',2000);
00487     if (ret != 0)
00488         return __LINE__;
00489 
00490     ret = chkSerialChar('O',2000);
00491     if (ret != 0)
00492         return __LINE__;
00493 
00494     ret = chkSerialChar('k',2000);
00495     if (ret != 0)
00496         return __LINE__;
00497 
00498     ret = waitSerialChar('>',16000);
00499     if (ret != 0)
00500         return __LINE__;
00501 
00502     ret = chkSerialChar('>',2000);
00503     if (ret != 0)
00504         return __LINE__;
00505 
00506     ret = chkSerialChar(' ',2000);
00507     if (ret != 0)
00508         return __LINE__;
00509 
00510     ret = waitSerialChar(chkchr,4000);
00511     if (ret != 0)
00512         return __LINE__;
00513 
00514     ret = waitSerialChar('>',4000);
00515     if (ret != 0)
00516         return __LINE__;
00517 
00518     wait_us(1000);
00519 
00520     return 0;
00521 }