main.cpp

00001 #include "mbed.h"
00002 #include "Sht31.h"
00003 #include "MAX44009.h"
00004 #include "mbed_wait_api.h"
00005 #include <list>
00006 
00007 Serial pc(p13,p14);
00008 Sht31 sht31(p9, p10);
00009 MAX44009 myMAX44009 ( p9, p10, MAX44009::MAX44009_ADDRESS_A0_GND, 400000 );
00010 I2C i2c(p9, p10); //pins for I2C communication (SDA, SCL)
00011 
00012 InterruptIn smthing_from_BLE(p12);
00013 DigitalOut BLE_Can_receive(p11); // 0 = can recieve
00014 AnalogIn input(p15);
00015 Timer t;
00016 class RGB{
00017     public :    int C;
00018                 int R;
00019                 int G;
00020                 int B;
00021     };
00022 class RGBf{
00023     public :    float C;
00024                 float R;
00025                 float G;
00026                 float B;
00027     };  
00028 class TandH{
00029     public : float t;
00030              float h;
00031     };
00032 class myData{
00033     public :    int timestamp;
00034                 unsigned short light;
00035                 unsigned short noise;
00036                
00037     };  
00038     
00039 RGB RGBdata[10];
00040 TandH THdata[10];
00041 float luxdata[10];
00042 myData sleepData[1000];
00043 int sleepDataPos=0;
00044 int counter = 10; //to tackle with 0 mod 10 problem, use 10 instead;
00045 int sendCounter=0; // for sending in auto/ instant measure
00046 int _30Scounter=0;
00047 bool allfilled = false;
00048 RGBf RGBavg;
00049 TandH THavg;
00050 float luxavg;
00051 
00052 bool wrote=false;
00053 DigitalOut led(LED1);
00054 char    signal[1];
00055 //LocalFileSystem local("local"); //Create the local filesystem under the name "local"
00056 
00057  void letsee() {
00058             led=!led;
00059             pc.scanf("%1s", signal);
00060             wrote=true;
00061 }
00062 
00063 
00064 
00065 
00066 int main()
00067 {   
00068    set_time(1587744159); 
00069   
00070     led=1;
00071     //pc.read
00072     BLE_Can_receive = 0;
00073     pc.baud ( 19200 );
00074     smthing_from_BLE.fall(&letsee);
00075  
00076        
00077     while(1) { 
00078         counter = counter%10;
00079         time_t seconds = time(NULL);
00080         t.start();
00081         float peakToPeak=0, signalMax=0, signalMin=1024;
00082         float _sample;
00083         int start = t.read_ms();
00084         while (t.read_ms() - start < 50) {
00085             _sample=input.read();
00086             if (_sample>signalMax){
00087                 signalMax=_sample;
00088                 }
00089             else if (_sample<signalMin){
00090                 signalMin=_sample;
00091                 }
00092         } 
00093         int end = t.read_ms();
00094         
00095     
00096         t.reset();
00097         peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude
00098     
00099         float volts = peakToPeak * 0.707;  // convert to RMS voltage
00100         float first = log10(volts/0.00631)*20;
00101         float second = first + 94 - 44 - 25; //Gain == 11 board gain ==25
00102       
00103 
00104         //time_t seconds = time(NULL);
00105         {
00106             int sensor_addr = 41 << 1;
00107             char id_regval[1] = {146};
00108             char data[1] = {0};
00109             i2c.write(sensor_addr,id_regval,1, true);
00110             i2c.read(sensor_addr,data,1,false);
00111 
00112     
00113     // Initialize color sensor
00114             char timing_register[2] = {129,192};
00115             //char timing_register[2] = {129,0};
00116             i2c.write(sensor_addr,timing_register,2,false);
00117             char control_register[2] = {143,0};
00118             char temp[2]={0,0};
00119             //char control_register[2] = {143,3};
00120             i2c.write(sensor_addr,control_register,2,false);
00121     
00122             char enable_register[2] = {128,3};
00123             i2c.write(sensor_addr,enable_register,2,false);
00124     
00125     // Read data from color sensor (Clear/Red/Green/Blue)
00126     
00127            char clear_reg[1] = {148};
00128            char clear_data[2] = {0,0};
00129            i2c.write(sensor_addr,clear_reg,1, true);
00130            i2c.read(sensor_addr,clear_data,2, false);
00131         
00132            int clear_value = ((int)clear_data[1] << 8) | clear_data[0];
00133         
00134            char red_reg[1] = {150};
00135            char red_data[2] = {0,0};
00136            i2c.write(sensor_addr,red_reg,1, true);
00137            i2c.read(sensor_addr,red_data,2, false);
00138         
00139            int red_value = ((int)red_data[1] << 8) | red_data[0];
00140         
00141            char green_reg[1] = {152};
00142            char green_data[2] = {0,0};
00143            i2c.write(sensor_addr,green_reg,1, true);
00144            i2c.read(sensor_addr,green_data,2, false);
00145         
00146            int green_value = ((int)green_data[1] << 8) | green_data[0];
00147         
00148            char blue_reg[1] = {154};
00149            char blue_data[2] = {0,0};
00150            i2c.write(sensor_addr,blue_reg,1, true);
00151            i2c.read(sensor_addr,blue_data,2, false);
00152         
00153            int blue_value = ((int)blue_data[1] << 8) | blue_data[0];
00154         
00155                 // print sensor readings
00156            if (allfilled == true){
00157                 RGBavg.C = RGBavg.C*10-RGBdata[counter].C;
00158                 RGBavg.R = RGBavg.R*10-RGBdata[counter].R;
00159                 RGBavg.G = RGBavg.G*10-RGBdata[counter].G;
00160                 RGBavg.B = RGBavg.B*10-RGBdata[counter].B;
00161             }
00162             RGBdata[counter].C= clear_value;
00163             RGBdata[counter].R= red_value;
00164             RGBdata[counter].G= green_value;
00165             RGBdata[counter].B= blue_value;
00166            //pc.printf("Clear (%d), Red (%d), Green (%d), Blue (%d)\n", clear_value, red_value, green_value, blue_value);
00167         }
00168         {
00169 
00170         MAX44009::MAX44009_status_t       aux;
00171         MAX44009::MAX44009_vector_data_t  myMAX44009_Data;
00172         
00173         aux  =   myMAX44009.MAX44009_Configuration ( MAX44009::CONFIGURATION_CONT_DEFAULT_MODE, MAX44009::CONFIGURATION_MANUAL_DEFAULT_MODE, MAX44009::CONFIGURATION_CDR_CURRENT_NOT_DIVIDED, MAX44009::CONFIGURATION_TIM_800_MS );
00174         aux  =   myMAX44009.MAX44009_GetLux( MAX44009::RESOLUTION_EXTENDED_RESOLUTION, &myMAX44009_Data );
00175         aux  =   myMAX44009.MAX44009_GetCurrentDivisionRatio   ( &myMAX44009_Data );
00176         aux  =   myMAX44009.MAX44009_GetIntegrationTime        ( &myMAX44009_Data );
00177         
00178         if (allfilled == true){
00179             luxavg = luxavg*10-luxdata[counter];
00180         } 
00181         
00182         luxdata[counter] = myMAX44009_Data.lux;
00183         
00184 
00185         }
00186         
00187         {
00188 
00189         //float t = sht31.readTemperature();
00190         //float h = sht31.readHumidity();
00191 
00192         if (allfilled == true){
00193             THavg.t = THavg.t*10-THdata[counter].t;
00194             THavg.h = THavg.h*10-THdata[counter].h;
00195         } 
00196         THdata[counter].t = sht31.readTemperature();
00197         THdata[counter].h = sht31.readHumidity();
00198 
00199         //pc.printf("[TEMP/HUM]");
00200         
00201         }
00202 ////////////////////////////////////////////////////////////////////
00203             
00204             /*BLE_Can_receive = 0;
00205             wait_ms(5);
00206             pc.printf("counter119\n = %d", counter);
00207             for (int i =0;i<10;i++){
00208                 pc.printf("i=%d ,", i);
00209                 pc.printf("%d,%d,%d,%d,%3.2f,%3.2f%,%0.001f\n", RGBdata[i].C, RGBdata[i].R, RGBdata[i].G, RGBdata[i].B,THdata[i].t, THdata[i].h,luxdata[i]);
00210             }
00211             BLE_Can_receive = 1;*/
00212             
00213             if (allfilled == true){
00214             RGBavg.C = ((RGBavg.C+RGBdata[counter].C)/10.0);
00215             RGBavg.R = ((RGBavg.R+RGBdata[counter].R)/10.0);
00216             RGBavg.G = ((RGBavg.G+RGBdata[counter].G)/10.0);
00217             RGBavg.B = ((RGBavg.B+RGBdata[counter].B)/10.0);
00218                         
00219             THavg.t = (THavg.t+THdata[counter].t)/10;
00220             THavg.h = (THavg.h+THdata[counter].h)/10;
00221             
00222             luxavg = (luxavg+luxdata[counter])/10;
00223             }
00224             else{
00225 
00226                     RGBavg.C= (RGBavg.C*(counter) + RGBdata[counter].C)   /(float)(counter+1);
00227                     RGBavg.R= (RGBavg.R*(counter) + RGBdata[counter].R)   /(float)(counter+1);
00228                     RGBavg.G= (RGBavg.G*(counter) + RGBdata[counter].G)   /(float)(counter+1);
00229                     RGBavg.B= (RGBavg.B*(counter) + RGBdata[counter].B)   /(float)(counter+1);
00230                     
00231                     THavg.t = ((THavg.t*(counter) + THdata[counter].t))/(counter+1);
00232                     THavg.h = ((THavg.h*(counter) + THdata[counter].h))/(counter+1);
00233                 
00234                     luxavg = ((luxavg*(counter) + luxdata[counter]))/(counter+1);
00235             }
00236             
00237         
00238             BLE_Can_receive = 0;
00239             counter++;
00240             if (counter == 10 &&_30Scounter==0){
00241                 _30Scounter=0;
00242                // pc.printf("%u,%u\n",(unsigned short)(luxavg*1000),(unsigned short)(second*1000));
00243                 sleepData[sleepDataPos].timestamp=(int)seconds;
00244                 sleepData[sleepDataPos].light=(unsigned short)(luxavg*1000);
00245                 sleepData[sleepDataPos].noise=(unsigned short)(second*1000);
00246                 sleepDataPos++;
00247                 allfilled = true; 
00248             }
00249             else 
00250             if (counter==10){
00251                 _30Scounter++;
00252                  allfilled = true; 
00253             }
00254             BLE_Can_receive = 1;
00255         if (wrote){
00256            if (signal[0]=='s'){
00257                for (int i=0;i <=sleepDataPos;i++){
00258                 if (i==sleepDataPos){
00259                     wait_ms(500);
00260                     pc.printf("\"send\"");
00261                     }
00262                 else {
00263                     float tempL=sleepData[i].light/1000.0f;
00264                     float tempN=sleepData[i].noise/1000.0f;
00265                     pc.printf("[\"%d\",\"%f\",\"%f\"],",sleepData[i].timestamp,tempL,tempN);
00266                     }
00267                 }
00268                 sleepDataPos=0;
00269                 wrote=false;
00270             }
00271             else 
00272             {
00273                 sendCounter++;
00274                 pc.printf("%d,%d,%d,%d,%d,%3.2f,%3.2f%,%0.001f,%f\n",sendCounter,(int)(RGBavg.C+0.5), (int)(RGBavg.R+0.5), (int)(RGBavg.G+0.5), (int)(RGBavg.B+0.5),THavg.t, THavg.h,luxavg,second);
00275                 if (sendCounter == 10){ //10 = all element is filled {  
00276                     if (signal[0]=='i'){
00277                           wait_ms(500);
00278                         pc.printf("end");
00279                     }
00280                     else if (signal[0]=='a')
00281                     {
00282                           wait_ms(500);
00283                         pc.printf("aend");
00284                     }
00285                     sendCounter=0;
00286                     wrote=false;
00287                     }
00288                 }
00289             
00290         }
00291 
00292 
00293     }
00294 }