main.cpp

00001 // skeleton code for ECE 2036 thermostat lab
00002 // code must be added by students
00003 #include "mbed.h"
00004 #include "TMP36.h"
00005 #include "SDFileSystem.h"
00006 #include "uLCD_4DGL.h"
00007 #include "PinDetect.h"
00008 #include "Speaker.h"
00009 #include "RGBLed.h"
00010 // must add your new class code to the project file Shiftbrite.h
00011 
00012 enum Statetype { Off, Heat_off , Heat_on , Cool_off , Cool_on };
00013  //p21,22,24 RGB
00014 //RGBLed myRGBLed(p21,p22,p24);
00015 // use class to setup temperature sensor pins
00016 TMP36 myTMP36(p15);  //Analog in
00017 
00018 // use class to setup microSD card filesystem
00019 //SDFileSystem sd(p5, p6, p7, p8, "sd");
00020 
00021 // use class to setup the  Color LCD
00022 uLCD_4DGL uLCD(p28, p27, p29); // create a global uLCD object
00023 
00024 // use class to setup pushbuttons pins
00025 PinDetect pb1(p25);
00026 PinDetect pb2(p24);//p24
00027 PinDetect pb3(p23);
00028 
00029 PinDetect pb4(p22); //p22
00030 // use class to setup speaker pin
00031 Speaker mySpeaker(p21); //PWM out //p21
00032 
00033 // use class to setup Shiftbrite pins
00034 //Shiftbrite myShiftbrite(p9, p10, p11, p12, p13);// ei li di n/c ci
00035 
00036 // use class to setup Mbed's four on-board LEDs
00037 DigitalOut myLED1(LED1);
00038 DigitalOut myLED2(LED2);
00039 DigitalOut myLED3(LED3);
00040 DigitalOut myLED4(LED4);
00041 
00042 //Shiftbrite myShiftbrite(p9, p10, p11, p12, p13);
00043 RGBLed myRGBLed(p11,p12,p13);
00044 
00045 //also setting any unused analog input pins to digital outputs reduces A/D noise a bit
00046 //see http://mbed.org/users/chris/notebook/Getting-best-ADC-performance/
00047 DigitalOut P16(p16);
00048 DigitalOut P17(p17);
00049 DigitalOut P18(p18);
00050 DigitalOut P19(p19);
00051 DigitalOut P20(p20);
00052 
00053 
00054 
00055 
00056 // Global variables used in callbacks and main program
00057 // C variables in interrupt routines should use volatile keyword
00058 int volatile heat_setting=75; // heat to temp
00059 int volatile cool_setting=70; // cool to temp
00060 int volatile mode_change = 0; // mode change variable
00061 int volatile temp_change = 0;
00062 int volatile beep1 = 0;
00063 int volatile beep2 = 0;
00064 bool volatile mode=false; // heat or cool mode
00065 
00066 void display(float tempC, float tempF, int setHC, int setHF, int setCC, int setCF,  Statetype state)
00067 {
00068     int C,F;
00069     F = static_cast<int>(tempF);
00070     C = static_cast<int>(tempC);
00071     if(temp_change == 0){
00072         switch(state){
00073             case OFF:
00074                 uLCD.color(BLACK);
00075                 uLCD.text_width(2);
00076                 uLCD.text_height(2);
00077                 uLCD.locate(3,3);
00078                 uLCD.printf("%d F",F);
00079                 break;
00080             case Heat_off:
00081             case Heat_on:
00082                 uLCD.color(WHITE);
00083                 uLCD.text_width(1);
00084                 uLCD.text_height(1);
00085                 uLCD.locate(8,4);
00086                 uLCD.printf("%d F",setHF);
00087                 uLCD.text_width(2);
00088                 uLCD.text_height(2);
00089                 uLCD.locate(3,4);
00090                 uLCD.printf("%d F",F);
00091                 break;
00092             case Cool_off:
00093             case Cool_on:
00094                 uLCD.color(WHITE);
00095                 uLCD.text_width(1);
00096                 uLCD.text_height(1);
00097                 uLCD.locate(8,11);
00098                 uLCD.printf("%d F",setCF);
00099                 uLCD.text_width(2);
00100                 uLCD.text_height(2);
00101                 uLCD.locate(3,3);
00102                 uLCD.printf("%d F",F);
00103                 break;
00104             
00105         }
00106     }
00107     else{
00108         switch(state){
00109             case OFF:
00110                 uLCD.text_width(2);
00111                 uLCD.text_height(2);
00112                 uLCD.locate(3,3);
00113                 uLCD.printf("%d C",C);
00114                 break;
00115             case Heat_off:
00116             case Heat_on:
00117                 uLCD.text_width(1);
00118                 uLCD.text_height(1);
00119                 uLCD.locate(8,4);
00120                 uLCD.printf("%d C",setHC);
00121                 uLCD.text_width(2);
00122                 uLCD.text_height(2);
00123                 uLCD.locate(3,4);
00124                 uLCD.printf("%d C",C);
00125                 break;
00126             case Cool_off:
00127             case Cool_on:
00128                 uLCD.text_width(1);
00129                 uLCD.text_height(1);
00130                 uLCD.locate(8,11);
00131                 uLCD.printf("%d C",setCC);
00132                 uLCD.text_width(2);
00133                 uLCD.text_height(2);
00134                 uLCD.locate(3,3);
00135                 uLCD.printf("%d C",C);
00136                 break;
00137             
00138         }       
00139     }
00140     
00141 }
00142 // Callback routine is interrupt activated by a debounced pb1 hit
00143 void pb1_hit_callback (void)
00144 {
00145 // ADD CODE HERE
00146     beep1++;
00147     if(temp_change == 0){
00148         if(mode_change == 1)
00149             heat_setting++;
00150         else if(mode_change ==2)
00151             cool_setting++;
00152     }
00153     else{
00154         if(mode_change == 1)
00155             heat_setting=heat_setting+1.8;
00156         else if(mode_change ==2)
00157             cool_setting=cool_setting+1.8;
00158                 
00159     }
00160 }
00161 // Callback routine is interrupt activated by a debounced pb2 hit
00162 void pb2_hit_callback (void)
00163 {
00164 // ADD CODE HERE
00165     beep1++;
00166     
00167     if(temp_change == 0){
00168         if(mode_change == 1)
00169             heat_setting--;
00170         else if(mode_change ==2)
00171             cool_setting--;
00172     }
00173     else{
00174         if(mode_change == 1)
00175             heat_setting=heat_setting-1.8;
00176         else if(mode_change ==2)
00177             cool_setting=cool_setting-1.8;
00178                 
00179     }
00180     
00181 }
00182 // Callback routine is interrupt activated by a debounced pb3 hit
00183 void pb3_hit_callback (void)
00184 {
00185     mode_change = ( mode_change + 1 ) % 3;
00186 }
00187 
00188 void pb4_hit_callback (void)
00189 {
00190     temp_change = (temp_change+1)%2;
00191 }
00192 
00193 int main()
00194 {
00195     float tempC=0.0, tempF=0.0;
00196  //   myRGBLed.write(1.0,0,0);
00197     // Use internal pullups for the three pushbuttons
00198     pb1.mode(PullUp);
00199     pb2.mode(PullUp);
00200     pb3.mode(PullUp);
00201     pb4.mode(PullUp);
00202     
00203     // Delay for initial pullup to take effect
00204     wait(.01);
00205     // Setup Interrupt callback functions for a pb hit
00206     pb1.attach_deasserted(&pb1_hit_callback);
00207     pb2.attach_deasserted(&pb2_hit_callback);
00208     pb3.attach_deasserted(&pb3_hit_callback);
00209     pb4.attach_deasserted(&pb4_hit_callback);
00210     // Start sampling pb inputs using interrupts
00211     pb1.setSampleFrequency();
00212     pb2.setSampleFrequency();
00213     pb3.setSampleFrequency();
00214     pb4.setSampleFrequency();
00215     // pushbuttons now setup and running
00216 
00217 
00218     // start I/O examples - DELETE THIS IN YOUR CODE..BUT WILL USE THESE I/O IDEAS ELSEWHERE
00219     // since all this compiles - the needed *.h files for these are in the project
00220     //
00221     //Current_temp = myTMP36; //Read temp sensor
00222     printf("Hello PC World\n\r"); // need terminal application running on PC to see this output
00223    // uLCD.printf("\n\rHello LCD World\n\r"); // LCD
00224     mySpeaker.PlayNote(500.0, 1.0, 1.0); // Speaker buzz
00225     //myShiftbrite.write( 0, 50 ,0); // Green RGB LED
00226     // SD card write file example - prints error message on PC when running until SD card hooked up
00227     // Delete to avoid run time error
00228     /*
00229     mkdir("/sd/mydir", 0777); // set up directory and permissions
00230     FILE *fp = fopen("/sd/mydir/sdtest.txt", "w"); //open SD
00231     if(fp == NULL) {
00232         error("Could not open file for write\n");
00233     }
00234     fprintf(fp, "Hello SD Card World!"); // write SD
00235     fclose(fp); // close SD card
00236     */
00237     //
00238     // end I/O examples
00239 
00240 
00241 
00242 
00243     // State machine code below will need changes and additions
00244     while (1) {
00245         {
00246             Statetype state = Off;
00247             int setHC,setCC;
00248             int prev_heat_setting, prev_cool_setting, prev_mode_change,prev_C,prev_F,prev_temp_change;
00249             
00250             int C,F;
00251     
00252            prev_mode_change = -1;
00253             while(1) {              
00254             
00255             tempC = myTMP36.read();
00256             tempF = (9.0*tempC)/5.0 + 32.0;         
00257             setHC = static_cast<int>( (static_cast<float>(heat_setting)-32)/1.8 );    
00258             setCC = static_cast<int>( (static_cast<float>(cool_setting)-32)/1.8 );    
00259             F = static_cast<int>(tempF);
00260             C = static_cast<int>(tempC);           
00261            
00262            
00263            if(beep1 >0){
00264                 mySpeaker.PlayNote(1000.0, 0.02, 1.0);
00265                 beep1 = 0;
00266             }
00267             if(beep2 >0){
00268                 mySpeaker.PlayNote(1500.0, 0.05, 1.0);
00269                 beep2 = 0;
00270             }
00271             if(prev_heat_setting != heat_setting){
00272                 display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00273                 prev_heat_setting = heat_setting;
00274             }
00275             if(temp_change != prev_temp_change){
00276                 display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00277                 prev_temp_change = temp_change;             
00278             }
00279             if(prev_cool_setting != cool_setting){
00280                 display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00281                 prev_cool_setting = cool_setting;
00282             
00283             }
00284             if(prev_C != C)
00285             {
00286                 if(temp_change ==1)
00287                     display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);                  
00288                 prev_C=C;
00289             }
00290             if(prev_F !=F)
00291             {
00292                 if(temp_change ==0)
00293                     display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00294                 prev_F=F;
00295             }
00296             
00297             if(prev_mode_change != mode_change){
00298                 beep2++;
00299                 switch(mode_change){
00300                     case 0:
00301                         state = Off;
00302                         
00303                         uLCD.cls();
00304 
00305                         uLCD.circle(65, 60, 55, WHITE);
00306                         uLCD.filled_circle(65,60,45,GREEN); 
00307                         uLCD.textbackground_color(GREEN);                   
00308                         uLCD.color(BLACK);
00309                         uLCD.text_width(1);
00310                         uLCD.text_width(1);
00311                         uLCD.locate(8,10);
00312                         uLCD.printf("OFF");                    
00313                         break;
00314                     case 1:   
00315           
00316                         state = Heat_off;
00317                         uLCD.cls();
00318 
00319                         uLCD.circle(65, 60, 55, WHITE);
00320                         uLCD.filled_circle(65,60,45,BLACK);
00321                         uLCD.circle(65,60,45,WHITE);
00322                         uLCD.triangle(65,45,55,55,75,55,WHITE);          
00323                         uLCD.triangle(65,46,56,54,74,54,WHITE);          
00324                         uLCD.triangle(65,47,57,53,73,53,WHITE);   
00325                         uLCD.textbackground_color(BLACK);            
00326                         break;
00327                     case 2:
00328                         state = Cool_off;
00329                         uLCD.cls();
00330 
00331                         uLCD.circle(65, 60, 55, WHITE);
00332                         uLCD.filled_circle(65,60,45,BLACK);
00333                         uLCD.circle(65,60,45,WHITE);
00334                         uLCD.triangle(65,80,55,70,75,70,WHITE);          
00335                         uLCD.triangle(65,79,56,71,74,71,WHITE);          
00336                         uLCD.triangle(65,78,57,72,73,72,WHITE);     
00337                         uLCD.textbackground_color(BLACK);        
00338                         break;
00339                 }
00340                 
00341                 prev_mode_change = mode_change;
00342                 display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00343             }
00344             
00345                 switch (state) {
00346                     case Off:
00347                         myLED1 = 0;
00348                         myLED2 = 0;
00349                         myLED3 = 0;
00350                         myLED4 = 0;
00351                         myRGBLed.write(0,1,0);
00352                          
00353                         break;
00354                         
00355                     case Cool_off:
00356                         myRGBLed.write(0,0,0);
00357                         myLED1 = 0;
00358                         myLED2 = 1;
00359                         myLED3 = 0;
00360                         myLED4 = 0;
00361                         
00362                         
00363                         
00364                         if(tempF >= cool_setting + 1){
00365                             beep2++;
00366                             state = Cool_on;
00367                             uLCD.cls();
00368                             uLCD.circle(65, 60, 55, WHITE);
00369                             uLCD.filled_circle(65,60,45,BLUE);
00370                             uLCD.textbackground_color(BLUE);
00371                             uLCD.triangle(65,80,55,70,75,70,WHITE);          
00372                             uLCD.triangle(65,79,56,71,74,71,WHITE);          
00373                             uLCD.triangle(65,78,57,72,73,72,WHITE);  
00374                             uLCD.textbackground_color(BLUE);     
00375                             uLCD.color(WHITE);
00376 
00377 
00378                             display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00379                         }
00380                         break;
00381                         
00382                     case Cool_on:
00383                         myRGBLed.write(0,0,1);
00384                         myLED1 = 0;
00385                         myLED2 = 1;
00386                         myLED3 = 0;
00387                         myLED4 = 1;
00388                         if(tempF <= cool_setting- 1){
00389                             beep2++;
00390                             state = Cool_off;
00391                             uLCD.cls();
00392                             uLCD.circle(65, 60, 55, WHITE);
00393                         uLCD.filled_circle(65,60,45,BLACK);
00394                         uLCD.circle(65,60,45,WHITE);
00395                         uLCD.triangle(65,80,55,70,75,70,WHITE);          
00396                         uLCD.triangle(65,79,56,71,74,71,WHITE);          
00397                         uLCD.triangle(65,78,57,72,73,72,WHITE);     
00398                         uLCD.textbackground_color(BLACK);     
00399                             uLCD.color(WHITE);
00400                             display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00401                         }
00402                         break;
00403                         
00404                         
00405                     case Heat_off:
00406                         myRGBLed.write(0,0,0);
00407                         myLED1 = 1;
00408                         myLED2 = 0;
00409                         myLED3 = 0;
00410                         myLED4 = 0;
00411                         if(tempF <= heat_setting - 1){
00412                             beep2++;
00413                             state = Heat_on;
00414                             uLCD.cls();
00415                         
00416                         uLCD.circle(65, 60, 55, WHITE);
00417                         uLCD.filled_circle(65,60,45,RED);
00418 
00419                         uLCD.triangle(65,45,55,55,75,55,WHITE);          
00420                         uLCD.triangle(65,46,56,54,74,54,WHITE);          
00421                         uLCD.triangle(65,47,57,53,73,53,WHITE);   
00422                         uLCD.textbackground_color(RED); 
00423                         uLCD.color(WHITE);
00424                         display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00425                                 
00426                         }
00427                         break;
00428                         
00429                     case Heat_on:
00430                        myRGBLed.write(1,0,0);
00431                         myLED1 = 1;
00432                         myLED2 = 0;
00433                         myLED3 = 0;
00434                         myLED4 = 1;
00435                         if(tempF >= heat_setting+ 1){
00436                             beep2++;
00437                             state = Heat_off;
00438                             uLCD.cls();
00439                         uLCD.circle(65, 60, 55, WHITE);
00440                         uLCD.filled_circle(65,60,45,BLACK);
00441                         uLCD.circle(65,60,45,WHITE);
00442                         uLCD.triangle(65,45,55,55,75,55,WHITE);          
00443                         uLCD.triangle(65,46,56,54,74,54,WHITE);          
00444                         uLCD.triangle(65,47,57,53,73,53,WHITE);   
00445                         uLCD.textbackground_color(BLACK);      
00446                             display(tempC,tempF, setHC, heat_setting, setCC, cool_setting, state);
00447                         }
00448                         break;
00449                 } 
00450 
00451                 wait(0.4);
00452             }
00453             
00454             
00455             
00456         }
00457     }
00458 }