main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "LM75B.h"
00004 #include "C12832.h"
00005 
00006 CANMessage msg;
00007 
00008 // STEP 1/////////////////////////////////////////////////////
00009 //baseboard address
00010 #define BASE_ADDRESS 150
00011 
00012 
00013 
00014 // STEP 2//////////////////////////////////////////////////////
00015 // phyiscal inputs
00016 DigitalIn joy_up(p15);
00017 DigitalIn joy_down(p12);
00018 DigitalIn joy_left(p13);
00019 DigitalIn joy_right(p16);
00020 DigitalIn joy_fire(p14);
00021 
00022 LM75B sensor(p28,p27);
00023 
00024 
00025 
00026 //STEP 3///////////////////////////////////////////////////////
00027 //physical outputs
00028 DigitalOut led1(LED1);
00029 DigitalOut led2(LED2);
00030 PwmOut spkr(p26);
00031 
00032 //STEP 4///////////////////////////////////////////////////////
00033 // message structure can
00034 
00035 ///////////////////////////////////////////////////////
00036 typedef struct {
00037 
00038     int   id;      /* can id */
00039     char  data[8]; /*can data */
00040 
00041 } can_message_t;
00042 
00043 
00044 
00045 
00046 
00047 //STEP 4///////////////////////////////////////////////////////
00048 // ipc for can write thread
00049 ///////////////////////////////////////////////////////
00050 MemoryPool<can_message_t, 8> can_write_mpool;
00051 Queue<can_message_t, 8> can_write_queue;
00052 
00053 //STEP 5///////////////////////////////////////////////////////
00054 // ipc for digital output thread
00055 
00056 ////////////////////////////////////////////////////////
00057 MemoryPool<can_message_t, 8> digital_output_mpool;
00058 Queue<can_message_t, 8> digital_output_queue;
00059 
00060 
00061 //STEP 6///////////////////////////////////////////////////////
00062 // ipc for analog output thread
00063 
00064 ////////////////////////////////////////////////////////
00065 MemoryPool<can_message_t, 8> analog_output_mpool;
00066 Queue<can_message_t, 8> analog_output_queue;
00067 
00068 //STEP 7///////////////////////////////////////////////////////
00069 // set up canbus
00070 ///////////////////////////////////////////////////////
00071 CAN can1(p30, p29);
00072 //CAN can1(p9, p10);
00073 
00074 //STEP 8///////////////////////////////////////////////////////
00075 /* digital input Thread */
00076 //////////////////////////////////////////////////////
00077 void digital_input_thread (void const *args) {
00078 
00079     while (true) {
00080 
00081         can_message_t *message = can_write_mpool.alloc();
00082         message->id = BASE_ADDRESS + 0; 
00083         message->data[0] = joy_up;
00084         message->data[1] = joy_down;
00085         message->data[2] = joy_left;
00086         message->data[3] = joy_right;
00087         message->data[4] = joy_fire;
00088   
00089 
00090 
00091         can_write_queue.put(message);
00092         
00093         //fun bit nod yes on fire
00094         if(joy_fire == 1)
00095             {
00096             can_message_t *message = can_write_mpool.alloc();
00097             message->id = 142; 
00098             message->data[0] = 5;
00099 
00100             can_write_queue.put(message);   
00101             }
00102         else if(joy_left == 1)
00103             {
00104             can_message_t *message = can_write_mpool.alloc();
00105             message->id = 141; 
00106             message->data[0] = 1;
00107 
00108             can_write_queue.put(message);                 
00109             }
00110         else if(joy_right == 1)
00111             {
00112             can_message_t *message = can_write_mpool.alloc();
00113             message->id = 141; 
00114             message->data[0] = 2;
00115 
00116             can_write_queue.put(message);      
00117             }
00118         else if(joy_up == 1)
00119             {
00120             can_message_t *message = can_write_mpool.alloc();
00121             message->id = 141; 
00122             message->data[0] = 4;
00123 
00124             can_write_queue.put(message);      
00125             }
00126         else if(joy_down == 1)
00127             {
00128             can_message_t *message = can_write_mpool.alloc();
00129             message->id = 141; 
00130             message->data[0] = 3;
00131 
00132             can_write_queue.put(message);      
00133             }
00134      
00135         Thread::wait(500);
00136     }
00137 
00138 }
00139 
00140 //STEP 9///////////////////////////////////////////////////////
00141 /* analog input Thread */
00142 //////////////////////////////////////////////////////
00143 void analog_input_thread (void const *args) {
00144 
00145 //if (sensor.open()) {
00146 
00147        // printf("Device detected!\n");
00148     while (true) {
00149         can_message_t *message = can_write_mpool.alloc();
00150         message->id = BASE_ADDRESS + 1; 
00151         message->data[0] = sensor.read();
00152         can_write_queue.put(message);
00153 
00154         Thread::wait(500);
00155     }
00156  //else{
00157 
00158   //  printf("Device faulty!\n");
00159 
00160     //}
00161 }
00162 
00163 //STEP 10///////////////////////////////////////////////////////
00164 // Can write thread
00165 //////////////////////////////////////////////////////
00166 void can_write_thread(void const *args) {
00167 
00168   while (true) {
00169         osEvent evt = can_write_queue.get();
00170          if (evt.status == osEventMessage) {
00171          can_message_t *message = (can_message_t*)evt.value.p;
00172 
00173          //send canbus message
00174          //can1.write(CANMessage(message->id, message->data, 8));
00175          can1.write(CANMessage(message->id,message->data, 8));
00176          can_write_mpool.free(message);
00177         }
00178 
00179   }
00180 
00181 }
00182 
00183 
00184 
00185 //STEP 11///////////////////////////////////////////////////////
00186 //Can read thread
00187 //////////////////////////////////////////////////////
00188 void can_read_thread (void const *args) {
00189 
00190  while (true) {
00191         printf("loop()\n");
00192         if(can1.read(msg))  
00193             {
00194         
00195          if(msg.id == BASE_ADDRESS + 5) // Then its an analog out message
00196             {
00197             //send to analog output ipc
00198             can_message_t *message = analog_output_mpool.alloc();
00199             message->id = msg.id; 
00200             message->data[0] = msg.data[0];
00201             analog_output_queue.put(message);
00202 
00203             Thread::wait(500);
00204             }
00205    
00206 
00207         else if(msg.id == BASE_ADDRESS + 6) //then its an do message
00208             {
00209             //send to digital output ipc
00210             can_message_t *message = digital_output_mpool.alloc();
00211 
00212             message->id = msg.id; 
00213             message->data[0] = msg.data[0];
00214 
00215             digital_output_queue.put(message);
00216             Thread::wait(500);
00217 
00218             } 
00219 
00220       //  else {
00221 
00222             //handler for other messages
00223 
00224          //   }
00225 
00226          Thread::wait(100);
00227 
00228       }//end of if can.read
00229 
00230  }//end of while(1)
00231 
00232 } //end of thread
00233 
00234 
00235 
00236 
00237 
00238 
00239 
00240 //STEP 12///////////////////////////////////////////////////////
00241 // Analog_ouptut_thread
00242 //////////////////////////////////////////////////////
00243 void Analog_ouptut_thread(void const *args) {
00244 
00245   while (true) {
00246 
00247         osEvent evt = analog_output_queue.get();
00248        
00249 
00250           if (evt.status == osEventMessage) {
00251             can_message_t *message = (can_message_t*)evt.value.p;
00252            
00253 
00254            //drive the speaker based on can message
00255            spkr.period(1/(2000 + (message->data[0]* 50))); //generate a tone based on data[0] value range from 2000 + 0*50 to 2000 + 255*50
00256            spkr=0.5;
00257                
00258           analog_output_mpool.free(message);
00259           }
00260   }
00261 
00262 }
00263 
00264 
00265 
00266 //STEP 13///////////////////////////////////////////////////////
00267 // Digital_ouptut_thread
00268 //////////////////////////////////////////////////////
00269 void Digital_output_thread(void const *args) {
00270 
00271   while (true) {
00272 
00273         osEvent evt = digital_output_queue.get();
00274        
00275 
00276         if (evt.status == osEventMessage) {
00277             can_message_t *message = (can_message_t*)evt.value.p;
00278             
00279         //drive the digital ouptut based on can message
00280         
00281             if (message->data[0] == 1 )  {   
00282 
00283              led1 = 1;}
00284 
00285             else {
00286 
00287              led1 = 0;}
00288 
00289              
00290 
00291             digital_output_mpool.free(message);
00292 
00293         } //end of if statement
00294 
00295   }//end of while loop
00296 
00297 }
00298 
00299 
00300 
00301 //STEP 13///////////////////////////////////////////////////////
00302 // START THREADS
00303 //////////////////////////////////////////////////////
00304 int main() {
00305 Thread thread1(Digital_output_thread);
00306 
00307 Thread thread2(Analog_ouptut_thread);
00308 
00309 Thread thread3(can_read_thread);
00310 
00311 Thread thread4(can_write_thread);
00312 
00313 Thread thread5(analog_input_thread );
00314 
00315 Thread thread6(digital_input_thread);
00316 
00317 
00318 while(true)
00319 
00320     {
00321 
00322     led2 !=led2;
00323 
00324     Thread::wait(500);
00325 
00326     }
00327 
00328 
00329 
00330 }