main.cpp

00001 /*=============================================================================
00002 Copyright University of Essex 2017
00003 Author: Ruihao Li
00004 
00005 FILE - main.c
00006     mbed LPC1768 application.
00007     
00008 DESCRIPTION
00009     alarm 1 laboratory solution.
00010     hardware: mbed LPC1768, an extension board.
00011     Use a terminal program such as 'HyperTerminal' to communicate with the application.
00012     The serial port configuration is shown below.
00013         9600 Baud 
00014         8 data bits 
00015         No parity bits 
00016         One stop bit 
00017         No hardware flow control    
00018 ==============================================================================*/
00019 
00020 
00021 /******************************************************************************
00022 Include head files.
00023 ******************************************************************************/
00024 #include "mbed.h"
00025 #include "TextLCD.h"
00026 
00027 // TextLCD 
00028 TextLCD lcd(p15, p16, p17, p18, p19, p20);//, TextLCD::LCD20x4); // rs, e, d4-d7
00029 
00030 // Read from switches and keypad
00031 BusOut rows(p26,p25,p24);
00032 BusIn cols(p14,p13,p12,p11);
00033 
00034 // Control external LEDs
00035 SPI sw(p5, p6, p7);
00036 DigitalOut cs(p8); 
00037 
00038 // Serial USB
00039 Serial pc(USBTX, USBRX); // tx, rx
00040 
00041 // Temperature reading
00042 I2C i2c(p9, p10);              // I2C: SDA, SCL
00043 
00044 DigitalOut Sounder(LED1);
00045 DigitalOut led4(LED4);
00046 
00047 /******************************************************************************
00048 Declaration of functions.
00049 ******************************************************************************/
00050 void alarmConfig(void);
00051 void alarm_state(); 
00052 
00053 int  read_switch(void);
00054 int  switchleds(void);
00055 void initleds();
00056 void setleds(int ledall);
00057 void setled(int ledno, int ledstate);
00058 int  readled(int ledno);
00059 int  readleds();
00060 
00061 char getKey();
00062 void setKey(void); 
00063 int  testCode(void);
00064 
00065 void sounder_blink();
00066 void pattern(void);
00067 void patternoff(void);
00068 void Sounderoff(void);
00069 
00070 void system_alarm(void);
00071 void system_set(void);
00072 
00073 /******************************************************************************
00074 Global variables.
00075 ******************************************************************************/
00076 enum State {unset, exits, set, entry, alarm, report} state;          
00077 char Keytable[] = { 'F', 'E', 'D', 'C',   
00078                     '3', '6', '9', 'B',   
00079                     '2', '5', '8', '0',   
00080                     '1', '4', '7', 'A'    
00081                    };
00082 char keyCode[] = {'1','2','3','4'};
00083 char code[4];
00084 int  fail = 0; // number of failed attempts
00085 int  success;  // 0~4: number of successful matched keycodes; 5 indicates switch changing; 6 indicates time expired
00086 int  zone;     
00087 int  led_bits = 0;   // global LED status used for readback
00088 bool time_expired ;
00089 Ticker timer;
00090 Timeout t_alarm, t_entry, t_exit;            
00091             
00092 /*=============================================================================
00093 
00094 FILE - main.cpp
00095 
00096 DESCRIPTION
00097     Initiates the Finite State Machine
00098 =============================================================================*/
00099 int main() { 
00100     alarmConfig(); 
00101 
00102     lcd.cls();
00103     lcd.locate(2,0);
00104     lcd.printf("Alarm Lab");
00105     pc.printf("\n\n\r              ALARM LAB\n\r (c)Copyright University of Essex 2017 \n\r            Author: Ruihao Li\n\r");
00106     
00107     setKey();  
00108     while (1){
00109         switchleds();
00110         alarm_state();  // FSM routine
00111     }
00112 }
00113 
00114 /**********************************************************************************
00115 Finite State Machine for Alarm
00116 **********************************************************************************/
00117 void alarm_state(){
00118     int s;
00119     
00120     switch(state){
00121  /*--------------------------------------------------------------------------------
00122     UN_SET STATE (STATE 1)
00123         un_set led enabled
00124         Internal sounder disabledabled 
00125         Sensors not monitored.  
00126 ---------------------------------------------------------------------------------*/ 
00127     case unset:
00128         setled(8,3);  // turn unset led on
00129         pc.printf("\n\r Unset mode\n\r");
00130         lcd.cls();
00131         lcd.printf("Unset mode");
00132         
00133         success = testCode();
00134         if (success == 4) {
00135             fail = 0;  // failure counter reset
00136             state = exits;    
00137         }
00138         else if (fail == 2) {
00139             pc.printf("\n\r attemp %d", fail+1);   
00140             state = alarm;
00141             zone = 5;    // zone identifier(5 represents an invalid code is entered three times)
00142             fail = 0;      //failure counter reset   
00143         }
00144         else{
00145             fail++;
00146             state = unset;
00147             pc.printf("\n\r attemp %d", fail);    
00148         }
00149         break;
00150 /*--------------------------------------------------------------------------------
00151     EXIT STATE (STATE 2)
00152         un_set led flashes
00153         Internal sounder enabled for 250msec every 500msec. 
00154 ---------------------------------------------------------------------------------*/  
00155     case exits:  
00156         setled(7,3);   // turn exits led on   
00157         pattern();     // Sounder switches on and then off at 250ms intervals            
00158         pc.printf("\n\r Exit mode\n\r");
00159         lcd.cls();
00160         lcd.printf("Exit mode"); 
00161         
00162         // you should program here!       
00163                 
00164         
00165             
00166         break;
00167  /*--------------------------------------------------------------------------------
00168     SET STATE (STATE 3) 
00169         set led enabled
00170         Internal sounder disabled.
00171 ---------------------------------------------------------------------------------*/ 
00172     case set: 
00173         setled(6,3);   // turn set led on
00174         
00175         pc.printf("\n\r Set mode\n\r");
00176         lcd.cls();
00177         lcd.printf("Set mode"); 
00178          
00179          
00180          // you should program here!     
00181  
00182         break;
00183 /*--------------------------------------------------------------------------------
00184     ENTRY STATE (STATE 4) 
00185         un_set led flashes
00186         Internal sounder enabled for 250ms every 500ms.
00187 ---------------------------------------------------------------------------------*/ 
00188     case entry:
00189         setled(5,3);   // turn entry led on
00190         pattern();     // Sounder switches on and then off at 250ms intervals
00191         
00192         pc.printf("\n\r Entry mode\n\r");
00193         lcd.cls();
00194         lcd.printf("Entry mode"); 
00195         
00196         // you should program here!   
00197         
00198         break;
00199 /*--------------------------------------------------------------------------------
00200     ALARM STATE (STATE 5)
00201         alarm led enabled
00202         Internal and External sounders enabled.
00203 ---------------------------------------------------------------------------------*/ 
00204     case alarm:
00205         setled(4,3);   // turn entry led on
00206         Sounder = 1;   //Sounder enabled all the time during alarm state
00207         
00208         pc.printf("\n\r Alarm mode\n\r");
00209         lcd.cls();
00210         lcd.printf("Alarm mode");         
00211         
00212         // you should program here!  
00213 
00214         break;      
00215 /*--------------------------------------------------------------------------------
00216     REPORT (STATE 6)
00217         un-set and alarm leds enabled
00218         Internal sounder remains enabled.
00219         External sounder enabled.
00220 ---------------------------------------------------------------------------------*/         
00221     case report:
00222         setled(3,3);   // turn entry led on
00223         
00224         pc.printf("\n\r Report mode\n\r");
00225         lcd.cls();
00226         lcd.printf("Zone numbers:%i",zone);    
00227         lcd.locate(0,1);
00228         lcd.printf("C key to clear");  
00229         
00230         while (1){
00231             char b = getKey();  
00232             if (b == 'C'){
00233                 state = unset;
00234                 break;
00235             }            
00236         }     
00237         break;
00238     } // end switch(state)
00239 
00240 } // end alarm_state()
00241 
00242 
00243 /**********************************************************************************
00244 Configurations
00245 **********************************************************************************/
00246 void alarmConfig() 
00247 {
00248     cs=0;
00249     sw.format(16,0); 
00250     sw.frequency(1000000);
00251     
00252     state = unset;   // Initial state
00253     
00254     led_bits  = 0x0000;  // turn off all the external leds
00255     sw.write(led_bits); 
00256     cs = 1;
00257     cs = 0;
00258 }
00259 
00260 /**********************************************************************************
00261 External switches 
00262 **********************************************************************************/
00263 int read_switch()
00264 {
00265     rows = 4;
00266     int switches = cols;
00267     rows = 5;
00268     switches = switches*16 + cols;
00269     
00270     return switches;
00271 }
00272 
00273 int switchleds()
00274 {
00275     int switches = read_switch();
00276         
00277     for(int i=0;i<=7;i++){
00278         if ((switches & 0x0001<<i)!=0){                         // 1, then turn on 
00279             led_bits  = led_bits | (0x0003 << i*2); }
00280         else {                                                  // 0, then turn off
00281             led_bits  = led_bits & ((0x0003 << i*2) ^ 0xffff); }
00282     }
00283     sw.write(led_bits); 
00284     cs = 1;
00285     cs = 0;
00286 
00287     return switches;
00288 }
00289 
00290 /**********************************************************************************
00291 External LED functionality
00292 **********************************************************************************/
00293 void initleds() {
00294     cs = 0;                                        // latch must start low
00295     sw.format(16,0);                               // SPI 16 bit data, low state, high going clock
00296     sw.frequency(1000000);                         // 1MHz clock rate
00297 }
00298 
00299 void setleds(int ledall) {
00300     led_bits = ledall;                              // update global LED status
00301     sw.write((led_bits & 0x03ff) | ((led_bits & 0xa800) >> 1) | ((led_bits & 0x5400) << 1));
00302     cs = 1;                                        // latch pulse start 
00303     cs = 0;                                        // latch pulse end
00304 }
00305 
00306 void setled(int ledno, int ledstate) {
00307     ledno = 9 - ledno;
00308     ledno = ((ledno - 1) & 0x0007) + 1;             // limit led number
00309     ledno = (8 - ledno) * 2;                        // offset of led state in 'led_bits'
00310     ledstate = ledstate & 0x0003;                   // limit led state
00311     ledstate = ledstate << ledno;
00312     int statemask = ((0x0003 << ledno) ^ 0xffff);   // mask used to clear led state
00313     led_bits = ((led_bits & statemask) | ledstate); // clear and set led state
00314     setleds(led_bits);
00315 }
00316 
00317 int readled(int ledno) {
00318     ledno = 9 - ledno;
00319     ledno = ((ledno - 1) & 0x0007) + 1;             // limit led number
00320     ledno = (8 - ledno) * 2;                        // offset of led state in 'led_bits'
00321     int ledstate = led_bits;
00322     ledstate = ledstate >> ledno;                   // shift selected led state into ls 2 bits
00323     return (ledstate & 0x0003);                     // mask out and return led state
00324 }
00325 
00326 int readleds() {
00327     return led_bits;                                // return LED status
00328 }
00329 
00330 /**********************************************************************************
00331 Keypad functionality
00332 **********************************************************************************/
00333 char getKey()
00334 {
00335     int i,j;
00336     char ch=' ';
00337     
00338     for (i = 0; i <= 3; i++) {
00339         rows = i; 
00340         for (j = 0; j <= 3; j++) {           
00341             if (((cols ^ 0x00FF)  & (0x0001<<j)) != 0) {
00342                 ch = Keytable[(i * 4) + j];
00343             }            
00344         }        
00345     }
00346     wait(0.2); //debouncing
00347     return ch;
00348 }
00349 
00350 int testCode(void)
00351 {
00352     int a, y;
00353     char b;
00354     
00355     lcd.locate(0, 1);   
00356     lcd.printf("Enter Code: ____");
00357     y = 0; 
00358     for(a = 0; a < 4; a++) {
00359         b = getKey();     
00360         switch(b) {
00361             case ' ':
00362                 a--; 
00363                 break;
00364             case 'C':   // use 'C' to delete input
00365                 if (a > 0){
00366                     a = a-2;
00367                     lcd.locate(13+a, 1);    
00368                     lcd.putc('_'); 
00369                     if ( code[a+1] == keyCode[a+1]){
00370                         y--;    
00371                     }                    
00372                 }
00373                 else if (a == 0){
00374                     a--;
00375                 }
00376                 break;              
00377             default:
00378                 code[a] = b; 
00379                 lcd.locate(12+a, 1);    
00380                 lcd.putc('*');
00381                 if(code[a] == keyCode[a]) {
00382                     y++; 
00383                 }
00384         }
00385     }
00386     lcd.cls();
00387     lcd.locate(0,1);
00388     lcd.printf("Press B to set");  
00389     while (1){
00390         b = getKey();  
00391         if (b == 'B')
00392             break;
00393     }
00394     
00395     return(y); 
00396 } 
00397 
00398 void setKey(void) 
00399 {
00400     int a;
00401     char b;
00402     
00403     lcd.locate(0, 1);   
00404     lcd.printf("Init  Code: ____");
00405     for(a = 0; a < 4; a++) {
00406         b = getKey(); 
00407 
00408         switch(b){
00409             case ' ':
00410                 a--; 
00411                 break;
00412             case 'C':
00413                 if (a > 0){
00414                     a = a-2;
00415                     lcd.locate(13+a, 1);    
00416                     lcd.putc('_');                     
00417                 }
00418                 else if (a == 0){
00419                     a--;
00420                 }
00421                 break; 
00422             default:
00423                 lcd.locate(12+a, 1);    
00424                 lcd.putc(b);
00425                 keyCode[a] = b; 
00426         }
00427     }
00428     wait(1);
00429 } 
00430 
00431 /**********************************************************************************
00432 Simulation of alarm  internal sounder
00433 **********************************************************************************/
00434 void sounder_blink()
00435 {
00436     Sounder = !Sounder;    
00437 }
00438 
00439 void pattern(void)
00440 {
00441     timer.attach(&sounder_blink, 0.25); 
00442 }
00443 
00444 void patternoff(void)
00445 {
00446     timer.detach();  // turn the Sounder off 
00447     Sounder = 0;  
00448 }
00449 
00450 void Sounderoff(void)
00451 {
00452     Sounder = 0;    
00453 }
00454 
00455 /**********************************************************************************
00456 Set system state
00457 **********************************************************************************/
00458 void system_alarm(void)
00459 {
00460     state = alarm; 
00461     time_expired = true;    
00462 }
00463 
00464 void system_set(void)
00465 {
00466     state = set; 
00467     time_expired = true;   
00468 }
00469