Led thresholds working. Callibration working. Final, Viva(ed)

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 
00003 #define state0 0
00004 #define state1 1
00005 #define state2 2
00006 #define state3 3
00007 #define state4 4
00008 #define state5 5
00009 
00010 AnalogIn ain(A0) ;          // Analog input
00011 DigitalOut led1(LED_RED);   // Red LED
00012 DigitalOut externalLed1(D2);
00013 DigitalOut externalLed2(D3);
00014 DigitalOut externalLed3(D4);
00015 DigitalOut externalLed4(D5);
00016 DigitalOut externalLed5(D6);
00017 
00018 DigitalIn externalButton(PTD0); 
00019 
00020 EventQueue queue;                                                               // creates an event queue, to call read ADC
00021 
00022 Serial pc(USBTX, USBRX);                                                        // tx, rx, for debugging
00023 
00024 // This thread runs the event queue
00025 Thread eventThread ;
00026 
00027 // Message type
00028 typedef struct {
00029   uint16_t analog; //                                                           // Analog input value 
00030   uint16_t pressEventOccured;                                                   // Callibration Check for a button press */
00031 } message_t;
00032 
00033 // Mail box
00034 Mail<message_t, 3> mailbox;
00035 
00036 // Function called every 10ms to read ADC
00037 // Average using a low pass filter  
00038 // Every 10th value is sent to mailbox
00039 
00040 volatile int samples = 0 ;
00041 volatile uint16_t smoothed = 0 ; 
00042 volatile int pressEvent = 0 ;                                                   // Variable set by the polling thread
00043 enum buttonPos { up, down, bounce };                                            // Button positions
00044 volatile buttonPos pos = up ;
00045 volatile int bcounter = 0 ;
00046 
00047 void readA0() {
00048     
00049     switch (pos) {
00050             case up :
00051                 if (!externalButton.read()) {                                   // now down 
00052                     pressEvent = 1 ;                                            // transition occurred
00053                     pos = down ;
00054                 }
00055                 break ;
00056             case down : 
00057                 if (externalButton == 1) {                                      // no longer down
00058                     bcounter = 3 ;                                              // wait four cycles
00059                     pos = bounce ;
00060                 }
00061                 break ;
00062             case bounce :
00063                 if (externalButton == 0) {                                      // down again - button has bounced
00064                     pos = down ;                                                // no event
00065                 } else if (bcounter == 0) {
00066                     pos = up ;                                                  // delay passed - reset to up
00067                 } else {
00068                     bcounter-- ;                                                // continue waiting
00069                 }
00070                 break ;
00071         }
00072     
00073     smoothed = (smoothed >> 1) + (ain.read_u16() >> 1) ;
00074     samples++ ;    
00075     
00076     if (samples == 10) {
00077         // send to thread
00078         message_t *mess = mailbox.alloc() ;                                     // may fail but does not block
00079         if (mess) {
00080             mess->analog = smoothed ;
00081             mess->pressEventOccured = pressEvent ;                              // Callibration 
00082             pressEvent = 0;                                                     
00083             mailbox.put(mess);                                                  // fails but does not block if full
00084         }
00085         samples = 0;
00086     }           
00087 }
00088 
00089 // Write voltage digits
00090 //   v  Voltage as scale int, e.g. 3.30 is 330
00091 void vToString(int v, char* s) {    
00092     s[3] = '0' + (v % 10) ;
00093     v = v / 10 ;
00094     s[2] = '0' + (v % 10) ;
00095     v = v / 10 ;
00096     s[0] = '0' + (v % 10) ;
00097 }
00098 
00099 // Main program
00100 //   Initialise variables
00101 //   Attach ISR for ticker
00102 //   Procss messages from mailbox    
00103 
00104 int main() {
00105     led1 = 1 ; // turn off 
00106     int volts = 0 ;
00107     int threshold[6] = {0,0,0,0,0,0}; 
00108     unsigned int systemState = 0;
00109     int counter = 0 ;
00110     char vstring[] = "X.XX\r\n" ;
00111 
00112     // Start the event queue
00113     eventThread.start(callback(&queue, &EventQueue::dispatch_forever));
00114     
00115     // call the readA0 function every 10ms 
00116     queue.call_every(10, readA0) ; 
00117 
00118     while (true) {
00119         
00120         osEvent evt = mailbox.get(); // wait for mail 
00121         
00122         if (evt.status == osEventMail) {
00123             message_t* mess = (message_t*)evt.value.p ;
00124             volts = (mess->analog * 330) / 0xffff ;
00125             if(mess->pressEventOccured == 1) {                                  // Check if callibration needed
00126                 for (int i=0; i<6; i++) {
00127                     threshold[i] = (i*volts)/6 ;                                // Setting new thresholds according to new callibration valued
00128                 }
00129             } 
00130             mailbox.free(mess) ;  // free the message space      
00131         }
00132             
00133             if (volts>=threshold[0] && volts<threshold[1])           
00134                 systemState = state0;
00135             else if (volts>=threshold[1] && volts<threshold[2]) 
00136                 systemState = state1;
00137             else if (volts>=threshold[2] && volts<threshold[3]) 
00138                 systemState = state2;
00139             else if (volts>=threshold[3] && volts<threshold[4]) 
00140                 systemState = state3;
00141             else if (volts>=threshold[4] && volts<threshold[5]) 
00142                 systemState = state4;
00143             else if (volts>=threshold[5])                   
00144                 systemState = state5;
00145                 
00146             vToString(volts, vstring) ;
00147             counter++ ;
00148             if (counter == 10) {                                                // limit bandwidth of serial
00149                 counter = 0 ;
00150                 pc.printf(vstring);
00151                 pc.putc('\n');
00152                 pc.putc('\r');
00153             }
00154             
00155             switch(systemState) {
00156                 case state0:
00157                     externalLed1.write(0);
00158                     externalLed2.write(0);
00159                     externalLed3.write(0);
00160                     externalLed4.write(0);
00161                     externalLed5.write(0);
00162                     break;
00163                 case state1:
00164                     externalLed1.write(1);
00165                     externalLed2.write(0);
00166                     externalLed3.write(0);
00167                     externalLed4.write(0);
00168                     externalLed5.write(0);
00169                     break;
00170                 case state2:
00171                     externalLed1.write(1);
00172                     externalLed2.write(1);
00173                     externalLed3.write(0);
00174                     externalLed4.write(0);
00175                     externalLed5.write(0);
00176                     break;
00177                 case state3:
00178                     externalLed1.write(1);
00179                     externalLed2.write(1);
00180                     externalLed3.write(1);
00181                     externalLed4.write(0);
00182                     externalLed5.write(0);
00183                     break;
00184                 case state4:
00185                     externalLed1.write(1);
00186                     externalLed2.write(1);
00187                     externalLed3.write(1);
00188                     externalLed4.write(1);
00189                     externalLed5.write(0);
00190                     break;
00191                 case state5:
00192                     externalLed1.write(1);
00193                     externalLed2.write(1);
00194                     externalLed3.write(1);
00195                     externalLed4.write(1);
00196                     externalLed5.write(1);
00197                     break;
00198         }
00199     }
00200  }
00201