Dependencies:   mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 
00003 #define get_event
00004 #define ev
00005 #define green   1
00006 #define red     0
00007 #define off     0
00008 #define on      1
00009 #define flashing    2
00010 
00011 enum state {st_GND_DC,st_GND_DO,st_GND_closing,st_DSING_at1,st_GU_closing,st_GND_opening,st_Top_DC,st_Top_DO,st_waiting_for_GND,st_waiting_for_Top,st_DC_moving_up,st_DC_moving_dwn,};
00012 enum event {ev_no_event,ev_Top,ev_GND,ev_near_top,ev_near_GND,ev_swt_up,ev_swt_dwn,ev_LVL1_swt,ev_LVL2_swt,ev_mtr_finish,ev_time_out};
00013 
00014 int green_flashing, red_flashing;
00015 
00016 DigitalOut green_led(LED1);
00017 DigitalOut red_led(LED4);
00018 Ticker led_flasher;
00019 Ticker timer;
00020 
00021 void led(int colour, int mode) {
00022     switch (colour) {
00023         case green:
00024             switch (mode) {
00025                 case off:
00026                     green_led = off;
00027                     green_flashing = off;
00028                     break;
00029                 case on:
00030                     green_led = on;
00031                     green_flashing = off;
00032                     break;
00033                 case flashing:
00034                     green_led = on;
00035                     green_flashing = on;
00036                     break;
00037             }
00038             switch (colour) {
00039                 case red:
00040                     switch (mode) {
00041                         case off:
00042                             red_led = off;
00043                             red_flashing = off;
00044                             break;
00045                         case on:
00046                             red_led = on;
00047                             red_flashing = off;
00048                             break;
00049                         case flashing:
00050                             red_led = on;
00051                             red_flashing = on;
00052                             break;
00053                     }
00054             }
00055 
00056     }
00057 
00058     void new_event(int ev) {
00059         event_queue[ev_load] = ev;
00060         ev_load++;
00061         if (ev_load == 8)
00062             ev_load = 0;
00063     }
00064 
00065     int get_event(void) {
00066         int ev;
00067         if (ev_load != ev_unload) {
00068             ev = event_queue[ev_unload];
00069             ev_unload++;
00070             if (ev_unload ==8)
00071                 ev_unload = 0;
00072         } else ev = no_event;
00073         return ev;
00074     }
00075 
00076     void flash(void) {
00077         if (green_flashing)
00078             green_led = !green_led;
00079         if (red_flashing)
00080             red_led = !red_led;
00081     }
00082 
00083     void update_timeout(void) {
00084         if (time_out) {
00085             time_out --;
00086             if (time_out==0)
00087                 new_event(ev_time_out);
00088         }
00089     }
00090 
00091 
00092 
00093 
00094 
00095 
00096     int main() {
00097 
00098         int state;
00099         led_flasher.attach(&flash,0.15);
00100         timer.attach(&update_timeout,0.1);
00101         switch (state) {
00102             case st_GND_DC:
00103                 ev = get_event();
00104                 if (ev!=no_event) {
00105                     switch (ev) {
00106                         case ev_swt_up:
00107                             led(green,flashing);
00108                             led(red,off);
00109                             time_out = 20;
00110                             state = st_GND_opening;
00111                             break;
00112                         case ev_swt_dwn:
00113                             motor(up,1.0,20);
00114                             state = st_DC_moving_up;
00115                             break;
00116                     }
00117                 }
00118                 break;
00119             case st_GND_DO:
00120                 ev = get_event();
00121                 if (ev!=no_event) {
00122                     switch (ev) {
00123                         case  ev_time_out:
00124                             led(green,off);
00125                             led(red,flashing);
00126                             time_out = 20;
00127                             state = st_GND_closing;
00128                             break;
00129                         case ev_LVL2_swt:
00130                             led(red,flashing);
00131                             led(green,off);
00132                             time_out = 20;
00133                             state = st_GU_closing;
00134                             break;
00135 
00136                     }
00137                 }
00138                 break;
00139             case st_GND_closing:
00140                 ev = get_event();
00141                 if (ev!=no_event) {
00142                     switch (ev) {
00143                         case  ev_time_out:
00144                             led(red,on);
00145                             state = st_GND_DC;
00146                             break;
00147                     }
00148                 }
00149                 break;
00150             case st_GND_opening:
00151                 ev = get_event();
00152                 if (ev!=no_event) {
00153                     switch (ev) {
00154                         case  ev_time_out:
00155                             led(green,on);
00156                             time_out = 20;
00157                             state = st_GND_DC;
00158                             break;
00159                     }
00160                 }
00161                 break;
00162             case st_Top_DC:
00163                 ev = get_event();
00164                 if (ev!=no_event) {
00165                     switch (ev) {
00166                         case  st_Top_DC:
00167                             led(red, of);
00168                             time_out = 20;
00169                             state = st_GND_DC;
00170                             break;
00171                     }
00172                 }
00173                 break;
00174             case st_Top_DO:
00175                 ev = get_event();
00176                 if (ev!=no_event) {
00177                     switch (ev) {
00178                         case ev_time_out:
00179                             time_out = 50;
00180                             led(green, off);
00181                             led(red,flashing);
00182                             state= st_DSING_at1,
00183                             break;
00184 
00185                     }
00186 
00187                 }
00188                 break;
00189             case st_DSING_at1:
00190                 ev = get_event();
00191                 if (ev!=no_event)
00192                     switch (ev) {
00193                         case ev_time_out:
00194                             time_out= 20;
00195                             led(red, off);
00196                             state = st_Top_DC;
00197                             break;
00198                     }
00199                 break;
00200             case st_waiting_for_GND:
00201 
00202                 break;
00203             case st_waiting_for_Top:
00204                 ev= get_event();
00205                 if (ev!=no_event) {
00206                     switch (ev) {
00207                         case ev_Top:
00208                             motor(up,0.0,0.0);
00209                             led(green,flashing);
00210                             led(red, off);
00211                             state= st_Top_DO;
00212                             break;
00213 
00214                     }
00215                 }
00216 
00217                 break;
00218             case st_DC_moving_up:
00219                 ev= get_event();
00220                 if (ev!=no_event) {
00221                     switch (ev) {
00222                         case ev_near_top:
00223                             motor(up,1.0,1.0);
00224                             state= st_waiting_for_Top;
00225                             break;
00226                     }
00227                 }
00228 
00229                 break;
00230             case DC_moving_dwn:
00231                 ev= get_event();
00232                 if (ev!=no_event) {
00233                     switch {
00234                     case ev_near_GND:
00235                     motor(dwn,0.1,2);
00236                     state= st_waiting_for_GND;
00237                     break;
00238                         }
00239             }
00240             break;
00241 
00242 
00243     }
00244 }