main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "MbedJSONValue.h"
00004 #include <string>
00005 #include "Outputs.h"
00006 #include "MailBoxes.h"
00007 #include "SensorSuite.h"
00008 
00009 
00010 DigitalOut myled(LED1);
00011 DigitalOut myled2(LED2);
00012 DigitalOut relayOne(p26);
00013 DigitalOut relayTwo(p25);
00014 DigitalOut relayThree(p24);
00015 DigitalOut backlight(p17);
00016 
00017 
00018 
00019 
00020 #define OFF 1
00021 #define ON 0
00022 
00023 
00024 uint16_t backgroundColor = ST7735_BLACK;
00025 
00026 
00027 LocalFileSystem local("local");
00028 
00029 //Adafruit_ST7735 tft(p11, p12, p13, p10, p8, p9); // MOSI, MISO, SCLK, SSEL, TFT_DC, TFT_RST
00030 
00031 #include "Icons.h"
00032 #include "Inputs.h"
00033 #include "Settings.h"
00034 #include "SettingsTest.h"
00035 #include "LogManager.h"
00036 #include "LogRecord.h"
00037 #include "Screens.h"
00038 #include "RaspiSerial.h"
00039 
00040 
00041 void createScreens();
00042 void changeBackgroundColor();
00043 bool settingsExist( const char *fname);
00044 void uiThread();
00045 void logThread();
00046 void sensorThread();
00047 
00048 uint16_t currentColor;
00049 
00050 // ensure that settings are not initialised
00051 bool Settings::settingsInitialised = false;
00052 MbedJSONValue Settings:: holder;    // JSON Data structure to store settings read from file
00053 uint16_t Settings::backgroundColor = 0;
00054 
00055 // ensure that sensor data is initialised
00056 
00057 
00058 
00059 MainMenuScreen *menu;
00060 BatteriesScreen *batteriesScreen;
00061 BatteryScreen *battScreen;
00062 SolarScreen *solarScreen;
00063 OutputScreen *outputScreen;
00064 SettingsScreen *settingsScreen;
00065 SolarGraphScreen *solarGraphScreen;
00066 SolarValueScreen *solarValueScreen;
00067 TestScreen *test;
00068 LogScreen *logg;
00069 LogSelectScreen *logSelect2;
00070 LogSelectScreen *logSelect1;
00071 LogDurationScreen *logDuration;
00072 LogDurationScreen *logDuration2;
00073 ViewLogScreen *viewLog;
00074 DeleteLogScreen *deleteLog;
00075 LogManager *log1;
00076 RaspberryPiScreen *rpiScreen;
00077 UtilityScreen   *utilityScreen;
00078 //LogManager *log2;
00079 Thread loggingThread(osPriorityNormal, (DEFAULT_STACK_SIZE * 2.25), NULL);
00080 
00081 int main()
00082 {
00083     // launch the sensors
00084     Thread thread(osPriorityNormal, (DEFAULT_STACK_SIZE * 2.25), NULL);
00085     thread.start(sensorThread);
00086 
00087     // launch the user interface
00088     // turn on backlight
00089     
00090 
00091     
00092     backlight = 1;
00093     Thread thread2(osPriorityNormal, (DEFAULT_STACK_SIZE * 2.25), NULL);
00094     thread2.start(uiThread);
00095     
00096 
00097 
00098     while(true) {
00099 
00100 
00101     }
00102 
00103 
00104 }
00105 
00106 void sensorThread()
00107 {
00108     SensorSuite suite;
00109     // launch the sensor suite
00110     suite.begin();
00111 }
00112 
00113 void logThread()
00114 {
00115     
00116     LogManager logg;
00117     // launch the log thread
00118     logg.createNewLog(logInstructions.parameter,logInstructions.duration);
00119 }
00120 
00121 void uiThread()
00122 {
00123     // set the current time
00124     set_time(1475252667);
00125     // Use this initializer if you're using a 1.8" TFT
00126     tft.initR(INITR_BLACKTAB);   // initialize a ST7735S chip, black tab
00127 
00128 
00129 
00130     // create the settings object
00131     Settings settings;
00132     currentColor = settings.getBackgroundColor();
00133     backgroundColor = currentColor;
00134 
00135     tft.fillScreen(backgroundColor);
00136     // landscape view
00137     tft.setRotation(1);
00138     createScreens();
00139 
00140     //struct setting lcdBackground;
00141     //lcdBackground.value = 1;
00142     //lcdBackground.key = 1;
00143     //rewind(ptr_myfile);
00144     //fseek(ptr_myfile,sizeof(struct setting)*0,SEEK_SET);
00145     //fwrite(&emptySetting, sizeof(struct setting), 1, ptr_myfile);
00146     //fread(&lcdBackground, sizeof(struct setting), 1, ptr_myfile);
00147 
00148 
00149 
00150 
00151 
00152 
00153 
00154     bool backToFirstLayer = false;
00155     bool backToSecondLayer = false;
00156     bool backToThirdLayer = false;
00157     bool backToFourthLayer = false;
00158 
00159     while(1) {
00160 
00161         int val = menu->start();
00162 
00163         if (val == 1) {
00164 
00165             backToFirstLayer = false;
00166 
00167             while(!backToFirstLayer) {
00168 
00169                 switch(batteriesScreen->start()) {
00170 
00171                     case 1:
00172                         // clear screen
00173                         tft.fillScreen(backgroundColor);
00174                         backToSecondLayer = false;
00175 
00176                         while(!backToSecondLayer) {
00177                             switch(battScreen->start(BATTERY_ONE)) {
00178                                 case -1:
00179                                     // clear screen
00180                                     tft.fillScreen(backgroundColor);
00181                                     backToSecondLayer = true;
00182                                     break;
00183                                 default:
00184                                     // do nothing
00185                                     break;
00186                             }
00187                         }
00188                         break;
00189 
00190                     case 2:
00191                         // clear screen
00192                         tft.fillScreen(backgroundColor);
00193                         backToSecondLayer = false;
00194 
00195                         while(!backToSecondLayer) {
00196                             switch(battScreen->start(BATTERY_TWO)) {
00197                                 case -1:
00198                                     // clear screen
00199                                     tft.fillScreen(backgroundColor);
00200                                     backToSecondLayer = true;
00201                                     break;
00202                                 default:
00203                                     // do nothing
00204                                     break;
00205                             }
00206                         }
00207                         break;
00208 
00209                     case -1:
00210                         // clear screen
00211                         tft.fillScreen(backgroundColor);
00212                         backToFirstLayer = true;
00213                         break;
00214 
00215                     default:
00216 
00217                         break;
00218                 }
00219             }
00220 
00221         } else  if (val == 2) {
00222 
00223             backToFirstLayer = false;
00224 
00225             while (!backToFirstLayer) {
00226 
00227                 switch(outputScreen->start()) {
00228 
00229                     case 1:
00230                         // clear screen
00231                         tft.fillScreen(backgroundColor);
00232                         backToSecondLayer = false;
00233 
00234                         while(!backToSecondLayer) {
00235                             switch(rpiScreen->start()) {
00236                                 case -1:
00237                                     // clear screen
00238                                     tft.fillScreen(backgroundColor);
00239                                     backToSecondLayer = true;
00240                                     break;
00241                                 default:
00242                                     // do nothing
00243                                     break;
00244                             }
00245                         }
00246 
00247                         break;
00248 
00249                     case 2:
00250                         // clear screen
00251                         tft.fillScreen(backgroundColor);
00252                         backToSecondLayer = false;
00253 
00254                         while(!backToSecondLayer) {
00255                             switch(utilityScreen->start()) {
00256                                 case -1:
00257                                     // clear screen
00258                                     tft.fillScreen(backgroundColor);
00259                                     backToSecondLayer = true;
00260                                     break;
00261                                 default:
00262                                     // do nothing
00263                                     break;
00264                             }
00265                         }
00266 
00267                         break;
00268 
00269                     case -1:
00270                         // clear screen
00271                         tft.fillScreen(backgroundColor);
00272                         backToFirstLayer = true;
00273                         break;
00274 
00275                     default:
00276                         // do nothing
00277                         break;
00278                 }
00279             }
00280         } else if (val == 3) {
00281 
00282             backToFirstLayer = false;
00283 
00284             while(!backToFirstLayer) {
00285 
00286                 switch(solarScreen->start()) {
00287 
00288                     case 1:
00289                         // clear screen
00290                         tft.fillScreen(backgroundColor);
00291                         backToSecondLayer = false;
00292 
00293                         while(!backToSecondLayer) {
00294                             switch(solarValueScreen->start()) {
00295                                 case -1:
00296                                     // clear screen
00297                                     tft.fillScreen(backgroundColor);
00298                                     backToSecondLayer = true;
00299                                     break;
00300                                 default:
00301                                     // do nothing
00302                                     break;
00303 
00304                             }
00305                         }
00306                         break;
00307 
00308                     case 2:
00309                         // clear screen
00310                         tft.fillScreen(backgroundColor);
00311                         backToSecondLayer = false;
00312 
00313                         while(!backToSecondLayer) {
00314                             switch(solarGraphScreen->start()) {
00315                                 case -1:
00316                                     // clear screen
00317                                     tft.fillScreen(backgroundColor);
00318                                     backToSecondLayer = true;
00319                                     break;
00320                                 default:
00321                                     // do nothing
00322                                     break;
00323 
00324                             }
00325                         }
00326                         break;
00327                     case -1:
00328                         // clear screen
00329                         tft.fillScreen(backgroundColor);
00330                         backToFirstLayer = true;
00331                         break;
00332 
00333                     default:
00334                         // do nothing
00335                         break;
00336                 }
00337             }
00338 
00339         } else if (val == 4) {
00340 
00341             backToFirstLayer = false;
00342 
00343             while (!backToFirstLayer) {
00344 
00345                 switch(settingsScreen->start()) {
00346                     case 1:
00347 
00348                         // clear screen
00349                         tft.fillScreen(backgroundColor);
00350                         backToSecondLayer = false;
00351 
00352                         while (!backToSecondLayer) {
00353 
00354                             switch(test->start()) {
00355                                 case -1:
00356                                     // clear screen
00357                                     // first check if the background color was changed
00358                                     // then change the background colors
00359                                     changeBackgroundColor();
00360                                     tft.fillScreen(backgroundColor);
00361                                     backToSecondLayer = true;
00362                                     break;
00363                             }
00364                         }
00365                         break;
00366                     case 2:
00367 
00368                         // clear the screen
00369                         tft.fillScreen(backgroundColor);
00370                         backToSecondLayer = false;
00371 
00372                         while (!backToSecondLayer) {
00373 
00374                             switch(logg->start()) {
00375 
00376                                 case 1:
00377                                     // clear the screen
00378                                     tft.fillScreen(backgroundColor);
00379                                     backToThirdLayer = false;
00380 
00381                                     while(!backToThirdLayer) {
00382 
00383                                         switch(viewLog->start()) {
00384 
00385                                             case -1:
00386                                                 tft.fillScreen(backgroundColor);
00387                                                 backToThirdLayer = true;
00388                                                 break;
00389 
00390                                         }
00391 
00392                                     }
00393 
00394                                     break;
00395 
00396                                 case 2:
00397 
00398                                     // clear the screen
00399                                     tft.fillScreen(backgroundColor);
00400                                     backToThirdLayer = false;
00401 
00402                                     while(!backToThirdLayer) {
00403 
00404                                         switch(logSelect2->start()) {
00405 
00406                                             case 1:
00407                                                 // clear the screen
00408                                                 tft.fillScreen(backgroundColor);
00409                                                 backToFourthLayer = false;
00410 
00411                                                 while(!backToFourthLayer) {
00412                                                     switch(logDuration->start()) {
00413 
00414                                                         case 1:
00415                                                             // start logging for 30 seconds
00416                                                             tft.fillScreen(backgroundColor);
00417 
00418 
00419                                                             // navigate all the way back to log screen
00420                                                             backToFourthLayer = true;
00421                                                             backToThirdLayer = true;
00422                                                             break;
00423                                                         case 2:
00424                                                             // start logging for 1 minute
00425                                                             tft.fillScreen(backgroundColor);
00426 
00427 
00428                                                             // navigate all the way to log screen
00429                                                             backToFourthLayer = true;
00430                                                             backToThirdLayer = true;
00431                                                             break;
00432 
00433                                                         case -1:
00434                                                             // clear the screen
00435                                                             tft.fillScreen(backgroundColor);
00436                                                             backToFourthLayer = true;
00437                                                     }
00438                                                 }
00439                                                 break;
00440                                             case 2:
00441                                                 // clear the screen
00442                                                 tft.fillScreen(backgroundColor);
00443                                                 backToFourthLayer = false;
00444 
00445                                                 while(!backToFourthLayer) {
00446                                                     switch(logDuration->start()) {
00447 
00448                                                         case 1:
00449                                                             // start logging for 30 seconds
00450                                                             //log1 = new LogManager();
00451                                                             //log1->createNewLog(POWER_CONSUMPTION,THIRTY_SECONDS);
00452                                                         
00453                                                             //logInstructions.parameter = POWER_CONSUMPTION;
00454                                                             //logInstructions.duration = THIRTY_SECONDS;
00455                                                             //loggingThread.start(logThread);
00456                                                             
00457                                                             tft.fillScreen(backgroundColor);
00458                                                             // navigate all the way back to log screen
00459                                                             backToFourthLayer = true;
00460                                                             backToThirdLayer = true;
00461                                                             break;
00462                                                         case 2:
00463                                                             // start logging for 1 minute
00464                                                             //log1 = new LogManager();
00465                                                             //log1.createNewLog(ONE_MINUTE,SOLAR_POWER);
00466                                                             tft.fillScreen(backgroundColor);
00467 
00468                                                             // navigate all the way to log screen
00469                                                             backToFourthLayer = true;
00470                                                             backToThirdLayer = true;
00471                                                             break;
00472 
00473                                                         case -1:
00474                                                             // clear the screen
00475                                                             tft.fillScreen(backgroundColor);
00476                                                             backToFourthLayer = true;
00477                                                             break;
00478                                                     }
00479                                                 }
00480                                                 break;
00481 
00482                                             case -1:
00483                                                 tft.fillScreen(backgroundColor);
00484                                                 backToThirdLayer = true;
00485                                                 break;
00486 
00487                                             default:
00488                                                 break;
00489                                         }
00490                                     }
00491                                     break;
00492                                 case 3:
00493                                     // clear the screen
00494                                     tft.fillScreen(backgroundColor);
00495                                     backToThirdLayer = false;
00496 
00497                                     while(!backToThirdLayer) {
00498 
00499                                         switch(deleteLog->start()) {
00500                                             case -1:
00501                                                 // clear the screen
00502                                                 tft.fillScreen(backgroundColor);
00503                                                 backToThirdLayer = true;
00504                                                 break;
00505                                         }
00506                                     }
00507                                     break;
00508                                 case -1:
00509 
00510                                     tft.fillScreen(backgroundColor);
00511                                     backToSecondLayer = true;
00512                                     break;
00513                                 default:
00514                                     break;
00515                             }
00516                         }
00517                         break;
00518                     case -1:
00519                         // clear screen
00520                         tft.fillScreen(backgroundColor);
00521                         backToFirstLayer = true;
00522                         break;
00523                 }
00524 
00525             }
00526 
00527         }
00528         tft.fillScreen(backgroundColor);
00529     }
00530 
00531 
00532 }
00533 
00534 
00535 
00536 
00537 void changeBackgroundColor()
00538 {
00539     Settings settings;
00540     if (currentColor != settings.getBackgroundColor()) {
00541         currentColor = settings.getBackgroundColor();
00542         backgroundColor = currentColor;
00543 
00544         // delete all the pointer
00545         delete menu;
00546         delete batteriesScreen;
00547         delete solarScreen;
00548         delete outputScreen;
00549         delete settingsScreen;
00550         delete solarGraphScreen;
00551         delete test;
00552         delete logg;
00553         delete logSelect2;
00554         delete logDuration;
00555         delete viewLog;
00556         delete deleteLog;
00557         delete battScreen;
00558         delete solarValueScreen;
00559         delete rpiScreen;
00560         delete utilityScreen;
00561 
00562         // create new screens
00563         createScreens();
00564 
00565     }
00566 
00567 }
00568 
00569 void createScreens()
00570 {
00571     menu  = new MainMenuScreen(backgroundColor);
00572     batteriesScreen = new BatteriesScreen(backgroundColor);
00573     solarScreen = new SolarScreen(backgroundColor);
00574     outputScreen = new OutputScreen(backgroundColor);
00575     settingsScreen = new SettingsScreen(backgroundColor);
00576     solarGraphScreen = new SolarGraphScreen(backgroundColor);
00577     test = new TestScreen(backgroundColor);
00578     logg = new LogScreen(backgroundColor);
00579     logSelect2 = new LogSelectScreen(backgroundColor);
00580     logDuration = new LogDurationScreen(backgroundColor);
00581     viewLog = new ViewLogScreen(backgroundColor);
00582     deleteLog = new DeleteLogScreen(backgroundColor);
00583     battScreen = new BatteryScreen(backgroundColor);
00584     solarValueScreen = new SolarValueScreen(backgroundColor);
00585     rpiScreen = new RaspberryPiScreen(backgroundColor);
00586     utilityScreen = new UtilityScreen(backgroundColor);
00587 }
00588