main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "C12832.h"
00004 #include "MMA7660.h"
00005 
00006 
00007 
00008 
00009 //FINITE STATE MACHINE EVENTS
00010 #define NO_EVENT 0
00011 #define TIME_OUT 1
00012 #define BUTTON_PRESS 2
00013 #define TILT 3
00014 #define PUSH 4
00015 
00016 //STATES
00017 #define STATE_0 0
00018 #define STATE_1 1
00019 #define STATE_2 2
00020 
00021 //Mutex
00022 Mutex LED_RGB;
00023 
00024 //pass event via message queue
00025 typedef struct {
00026     int    event;   /* AD result of measured voltage */
00027 } message_t;
00028 
00029 MemoryPool<message_t, 16> mpool;
00030 Queue<message_t, 16> queue;
00031 
00032 //Digital input
00033 //DigitalIn coin(p14);
00034 InterruptIn button(p14);
00035 
00036 //Analog input
00037 AnalogIn push(p19);
00038 
00039 //Setup hardware
00040 MMA7660 MMA(p28, p27);
00041 C12832 lcd(p5, p7, p6, p8, p11);
00042 
00043 //RGB LEDs
00044 DigitalOut led_R(p23); //LED RGB red
00045 DigitalOut led_G(p24); //LED RGB green
00046 DigitalOut led_B(p25); //LED RGB Blue
00047 
00048 //leds for debug
00049 DigitalOut led4(LED4); //LED
00050 DigitalOut led3(LED3); //LED
00051 DigitalOut led2(LED2); //LED
00052 
00053 //Global varible
00054 int button_press=0;
00055 
00056 
00057 void timeout_event(void const *n)
00058 {
00059 
00060     //event via a message queue
00061     message_t *message = mpool.alloc();
00062     message->event = TIME_OUT;
00063     queue.put(message);
00064 
00065     led4 =  !led4;
00066 
00067 }
00068 
00069 
00070 void button_event_thread(void const *argument)
00071 {
00072 
00073     while (true) {
00074 
00075         if (button_press == 1) {
00076 
00077             //event via a message queue
00078             message_t *message = mpool.alloc();
00079             message->event = BUTTON_PRESS;
00080             queue.put(message);
00081 
00082             led3 = !led3;
00083             button_press = 0;
00084             Thread::wait(500);
00085         }
00086 
00087 
00088 
00089     }
00090 }
00091 
00092 
00093 void tilt_event_thread(void const *argument)
00094 {
00095     float tilt_value_Y = MMA.y();
00096     float tilt_value_X = MMA.x();
00097     while (true) {
00098 
00099         //debouce delay for switch
00100 
00101 
00102         if (tilt_value_Y <= MMA.y()-0.2 ^ tilt_value_Y >= MMA.y()+0.2 ) {
00103 
00104             //event via a message queue
00105             message_t *message = mpool.alloc();
00106             message->event = TILT;
00107             queue.put(message);
00108 
00109             led3 = !led3;
00110             Thread::wait(1500);
00111             tilt_value_Y = MMA.y();
00112         }
00113 
00114 
00115     }
00116 
00117 
00118 }
00119 
00120 void push_event_thread(void const *argument)
00121 {
00122     float push_value = push.read();
00123     while (true) {
00124 
00125         //debouce delay for switch
00126 
00127         if (push_value >= push.read()- 0.15 ^ push_value <= push.read()+ 0.15 ) {
00128             //event via a message queue
00129             message_t *message = mpool.alloc();
00130             message->event = PUSH;
00131             queue.put(message);
00132             led3 = !led3;
00133             Thread::wait(1000);
00134             push_value = push.read();
00135         }
00136     }
00137 
00138 
00139 }
00140 void flash_led_thread(void const *argument)
00141 {
00142     while (true) {
00143         Thread::signal_wait(0x1);
00144 
00145         for (int i=0; i<=20; i++) {
00146             LED_RGB.lock();
00147             led_R = !led_R;
00148             LED_RGB.unlock();
00149             Thread::wait(100);
00150         }
00151         LED_RGB.lock();
00152         led_R = 1;
00153         LED_RGB.unlock();
00154     }
00155 
00156 }
00157 
00158 
00159 
00160 void Button_Inter()
00161 {
00162 //Flash_LED_Thread.signal_set(0x1);
00163 
00164     button_press=1;
00165 
00166 }
00167 
00168 int main (void)
00169 {
00170 
00171 //Thread fsm(fsm_thread);
00172     Thread button_event(button_event_thread);
00173     Thread tilt_event(tilt_event_thread);
00174     Thread push_event(push_event_thread);
00175     Thread Flash_LED_Thread(flash_led_thread);
00176     RtosTimer timer(timeout_event, osTimerPeriodic, (void *)0);
00177 
00178 //Interrupts
00179     button.rise(&Button_Inter);
00180 
00181     int state = STATE_0;
00182 
00183     LED_RGB.lock();
00184     led_R=1;
00185     led_G=1;
00186     led_B=1;
00187     LED_RGB.unlock();
00188 
00189     if (MMA.testConnection())   //setup accler
00190 
00191         //start timer with a 2 sec timeout
00192         timer.start(2000);
00193 
00194     while (true) {
00195 
00196 
00197         switch(state) {
00198             case STATE_0:
00199                 osEvent evt = queue.get();
00200                 if (evt.status == osEventMessage) {
00201                     message_t *message = (message_t*)evt.value.p;
00202 
00203 
00204                     if(message->event == BUTTON_PRESS) {
00205                         LED_RGB.lock();
00206                         led_G=0;
00207                         led_R=1;
00208                         LED_RGB.unlock();
00209                         lcd.cls();
00210                         lcd.locate(0,2);
00211                         lcd.printf("Enter");
00212                         state = STATE_1;
00213                     }
00214                     if(message->event == PUSH) {
00215                         LED_RGB.lock();
00216                         led_G=1;    //off
00217                         led_R=0;    //on
00218                         LED_RGB.unlock();
00219                         lcd.cls();
00220                         lcd.locate(0,2);
00221                         lcd.printf("Insert Coin push");
00222                         state = STATE_0;
00223                     }
00224                     if(message->event == TILT) {
00225                         LED_RGB.lock();
00226                         led_G=1;
00227                         led_R=1;
00228                         LED_RGB.unlock();
00229                         lcd.cls();
00230                         lcd.locate(0,0);
00231                         lcd.printf("STOP");
00232                         lcd.locate(0,10);
00233                         lcd.printf("Please Insert Coin");
00234                         Flash_LED_Thread.signal_set(0x1);
00235                         state = STATE_2;
00236                     }
00237                     if(message->event == TIME_OUT) {
00238                         LED_RGB.lock();
00239                         led_G=1;
00240                         led_R=0;
00241                         LED_RGB.unlock();
00242                         lcd.cls();
00243                         lcd.locate(0,2);
00244                         lcd.printf("Hello");
00245                         state = STATE_0;
00246                     }
00247                     mpool.free(message);
00248                 }
00249 
00250                 timer.start(2000);
00251 
00252                 break;
00253 
00254             case STATE_1:
00255 
00256                 evt = queue.get();
00257                 if (evt.status == osEventMessage) {
00258                     message_t *message = (message_t*)evt.value.p;
00259 
00260 
00261                     if(message->event == BUTTON_PRESS) {
00262                         lcd.cls();
00263                         lcd.locate(0,2);
00264                         lcd.printf("Thanks");
00265                         state = STATE_1;
00266                     }
00267                     if(message->event == PUSH) {
00268                         LED_RGB.lock();
00269                         led_R=0;
00270                         led_G=1;
00271                         LED_RGB.unlock();
00272                         lcd.cls();
00273                         lcd.locate(0,2);
00274                         lcd.printf("Hello");
00275                         state = STATE_0;
00276                     }
00277 
00278                     mpool.free(message);
00279                 }
00280 
00281                 timer.start(2000);
00282 
00283 
00284                 break;
00285 
00286             case STATE_2:
00287 
00288                 evt = queue.get();
00289                 if (evt.status == osEventMessage) {
00290                     message_t *message = (message_t*)evt.value.p;
00291 
00292                     if(message->event == BUTTON_PRESS) {
00293                         LED_RGB.lock();
00294                         led_G=0;
00295                         led_R=1;
00296                         LED_RGB.unlock();
00297                         lcd.cls();
00298                         lcd.locate(0,2);
00299                         lcd.printf("Enter");
00300                         state = STATE_1;
00301 
00302                     }
00303                     if(message->event == TILT) {
00304                         lcd.cls();
00305                         lcd.locate(0,0);
00306                         lcd.printf("STOP");
00307                         lcd.locate(0,10);
00308                         lcd.printf("Please Insert Coin");
00309                         state = STATE_2;
00310                         Flash_LED_Thread.signal_set(0x1);
00311                     }
00312                     if(message->event == TIME_OUT) {
00313                         LED_RGB.lock();
00314                         led_R=0;
00315                         led_G=1;
00316                         LED_RGB.unlock();
00317                         lcd.cls();
00318                         lcd.locate(0,2);
00319                         lcd.printf("Insert Coin");
00320                         state = STATE_0;
00321                     }
00322                     mpool.free(message);
00323                 }
00324 
00325                 timer.start(2000);
00326 
00327                 break;
00328 
00329 
00330 
00331         }//End of switch
00332 
00333         //toggle led for local testing
00334         //led2= !led2;
00335 
00336     }//end of while(1)
00337 
00338 
00339 }