assignment3tasks.cpp

00001 #include "header.h"
00002 
00003 
00004 //definitions of tasks
00005 //lock and unlock variables in struct when performing calculations 
00006 
00007 //pedals 
00008 AnalogIn            brake_pedal(pin_analog_1);
00009 AnalogIn            accel_pedal(pin_analog_2);
00010 
00011 
00012 //switches
00013 DigitalIn           ngene(pin_digital_1);
00014 DigitalIn           leftsw(pin_digital_2);
00015 DigitalIn           rightsw(pin_digital_3);
00016 DigitalIn           sidesw(pin_digital_4);
00017 
00018 
00019 //indicators 
00020 DigitalOut          ngeneind(pin_LED1);
00021 DigitalOut          leftind(pin_LED2); //was digitalout
00022 DigitalOut         rightind(pin_LED3);//was digitalout
00023 DigitalOut          sideind(pin_LED4);
00024 
00025 
00026 //RED box lights
00027 DigitalOut          brakeind(pin_LED5);
00028 DigitalOut          overspeedind(pin_LED6);
00029 
00030 
00031 
00032 //
00033 extern SDATA speed;
00034 extern CARINFO info;
00035 extern SIMU_DATA sim;
00036 
00037 // LCD
00038 
00039 extern WattBob_TextLCD *display;
00040 
00041 // MUTEX
00042 
00043 extern Mutex simuXS;
00044 extern Mutex speedXS;
00045 extern Mutex carstateXS;
00046 //
00047 
00048 //serial port 
00049 Serial PC(USBTX, USBRX);
00050 
00051 void task1readbrake()
00052 {  
00053    float delay = 1000 / TASKFREQ1;
00054    while(true){
00055        
00056    speedXS.lock();//lock
00057    
00058    speed.brakevalue = brake_pedal.read(); 
00059    
00060    speedXS.unlock();//unlock
00061    
00062    Thread::wait( (int) delay);
00063    
00064    }
00065 }
00066 
00067 void task2readaccel()
00068 {
00069    float delay = 1000 / TASKFREQ2;
00070    while(true){
00071        
00072    speedXS.lock();//lock
00073    
00074    speed.accelvalue = accel_pedal.read(); 
00075    
00076    speedXS.unlock();//unlock
00077    
00078    Thread::wait( (int) delay);
00079    
00080    }
00081    
00082 }
00083 
00084 void task3enginestate()
00085 {
00086     float delay = 125;      
00087     while(true){
00088     //lock
00089     carstateXS.lock();
00090     uint8_t engineonoff = ngene.read();  
00091     info.ENGINESTATE = engineonoff;
00092     carstateXS.unlock();
00093     //unlock
00094     
00095     if(engineonoff == 1){
00096         ngeneind = 1;
00097         }
00098     else{
00099         ngeneind = 0;
00100         }
00101         
00102     Thread::wait(125);
00103     }             
00104 }
00105 
00106 void task4average()
00107 {
00108     float delay = 1000 / TASKFREQ4;    
00109     while(true){
00110     speedXS.lock();//lock
00111     
00112     for(int i = 0; i < SAMPLESIZE - 1 ; i++){
00113         //speed.rawspeed = (speed.accelvalue - speed.brakevalue)*MAXSPEED;
00114         speed.average += speed.array[i];
00115         }
00116         speed.average = (speed.average / SAMPLESIZE);    
00117                
00118     speedXS.unlock();//unlock 
00119     
00120     Thread::wait( (int) delay);
00121     }
00122 }
00123 
00124 void task5brakeLED()
00125 {
00126     float delay = 1000 / TASKFREQ5;
00127     while(true){
00128         
00129         //lock
00130         speedXS.lock();
00131         float braketest = speed.brakevalue;     
00132         
00133         speedXS.unlock();//unlock
00134         
00135         if( braketest > 0.2) // speed increase
00136             brakeind = 1;
00137         else
00138             brakeind = 0;
00139     
00140     Thread::wait((int)delay);
00141         }
00142 }
00143 
00144 
00145 void task6speedmonitor()
00146 {
00147     float delay = 1000 / TASKFREQ6;
00148     while(true){
00149         
00150         carstateXS.lock();  //lock carstate
00151         speedXS.lock();     //lock speed
00152         
00153         
00154         info.odometer += (speed.rawspeed / TASKFREQ6);
00155         uint8_t temp_enginestate = info.ENGINESTATE;
00156         
00157         carstateXS.unlock(); //unlock carstate
00158         
00159         float temp_accel = 0.0;
00160         if(temp_enginestate != 0)
00161             temp_accel = speed.accelvalue;
00162         
00163         //update speed    
00164         speed.rawspeed += (temp_accel - speed.brakevalue) * MAXSPEED; 
00165         
00166         if(speed.rawspeed < 0)
00167             speed.rawspeed = 0;
00168         if(speed.rawspeed > MAXSPEED)
00169             speed.rawspeed = MAXSPEED;   
00170         
00171         // Saving the new speed
00172         for (int i = 0; i < SAMPLESIZE - 1; i++)
00173             speed.array[i]= speed.array[i+1]; 
00174             speed.array[4]= speed.rawspeed;
00175             
00176         float temp = speed.rawspeed;
00177         
00178         // UNLOCK Speed
00179         speedXS.unlock();
00180         
00181         // Update Overspeed display
00182         
00183         if (temp > 39.3395) //88 mph to ms
00184             overspeedind = 1;
00185         else
00186             overspeedind = 0;
00187             
00188         Thread::wait((int)delay);
00189         }
00190 }
00191 
00192 void task7displayvalues()
00193 {
00194     float delay = 1000 / TASKFREQ7;
00195     display->cls();
00196     while(true){
00197         
00198         
00199     
00200         //LOCK data
00201         carstateXS.lock();
00202         //LOCK Speed
00203         speedXS.lock();
00204         
00205         display->locate(1,0);
00206         display->printf("AvgS: %.2f m/s",speed.average);
00207         display->locate(0,0);
00208         display->printf("ODOM: %d m",(int) info.odometer);
00209      
00210         //UNLOCK data
00211         carstateXS.unlock();
00212         //UNLOCK Speed
00213         speedXS.unlock();
00214         
00215 
00216 
00217         
00218         Thread::wait(500);
00219         
00220         
00221         }
00222 }
00223 
00224 void task8sidelights()
00225 {
00226     float delay = 1000 / TASKFREQ8;
00227     while(true){
00228                
00229         // LOCK Car data
00230         carstateXS.lock();
00231         
00232         info.sideind = sidesw.read();
00233         uint8_t temp = info.sideind;
00234         
00235         //UNLOCK Car data
00236         carstateXS.unlock();
00237         
00238         if (temp == 1)
00239             sideind = 1;
00240         else
00241             sideind = 0;
00242         
00243         Thread::wait((int)delay);
00244         
00245         
00246         
00247         
00248         }
00249 }
00250 
00251 void task9indLED()
00252 {
00253     int count = 0;
00254     while(true){
00255         
00256        
00257 
00258        count++;
00259        leftind = leftsw;
00260        rightind = rightsw;
00261        (leftsw==1)?         info.leftind = 1:   info.leftind = 0;
00262        (rightsw==1)?        info.rightind = 1:   info.rightind = 0;
00263        
00264        if (leftsw == 1 && rightsw == 1){
00265         carstateXS.lock();
00266         leftind = 0;
00267         rightind = 0; // current issue :just stopping here 
00268         carstateXS.unlock();
00269         }
00270         if (count == 2||count == 4){ // flash indicators every second
00271                     carstateXS.lock();
00272                if (leftind == 1 && rightind == 0){
00273                 leftind = 0;
00274                     }
00275         else if (rightind == 1 && leftind == 0){
00276                 rightind = 0;
00277                     }
00278         
00279         else if (leftind == 0 && rightind == 0){
00280                     }
00281                     carstateXS.unlock();
00282         }
00283         if (count == 4){ // send data every 2 seconds
00284             count = 0;
00285         }
00286         Thread::wait(500);
00287         
00288         }
00289 
00290 }
00291 
00292 
00293 void taskXserialdump()
00294 {
00295     while(true)
00296     {
00297     speedXS.lock();
00298     
00299     PC.printf("SPEED: %.1f\r\n",speed.rawspeed);
00300     PC.printf("BRAKE: %.2f\r\n",speed.brakevalue);
00301     PC.printf("ACCELEROMETER: %.2f\r\n",speed.accelvalue);
00302     
00303     speedXS.unlock();
00304     
00305     carstateXS.lock();  
00306     
00307     PC.printf("LEFT INDICATOR  : %.1f\r\n",info.leftind);
00308     PC.printf("RIGHT INDICATOR : %.1f\r\n",info.rightind);
00309     
00310     carstateXS.unlock();
00311     
00312     float delay = 1000/ TASKFREQX;
00313     Thread:: wait((int)delay);
00314       
00315     }
00316 
00317 
00318 
00319 }