main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "Motor.h"
00004 #include "SDFileSystem.h"
00005 #include "wave_player.h"
00006 #include "SongPlayer.h"
00007 #include "Speaker.h"
00008 #include "MCP23S17.h"
00009 #include "mbed.h"
00010 
00011 Serial pc(USBTX, USBRX);
00012 
00013 //ZIGBEE (XBEE)
00014 Serial xbee(p9, p10);
00015 DigitalOut xbee_rst(p8);
00016     
00017 //DC MOTORS
00018 Motor motor_left(p26, p30, p29); // pwm, fwd, rev
00019 Motor motor_right(p23, p25, p24); // pwm, fwd, rev
00020 
00021 //SD CARD
00022 SDFileSystem sd(p11, p12, p13, p14, "sd"); // (MOSI,MISO,SCLK,CS,NAME)
00023 
00024 // I/O EXPANDER
00025 SPI IO_spi(p5, p6, p7); //MOSI(SI), MISO(SO), SCLK(SCK)
00026 DigitalOut IO_rst(p15);
00027 
00028 //Speaker
00029 AnalogOut DACout(p18);
00030 wave_player waver(&DACout);
00031 FILE *wave_file;
00032 
00033 //LED Signals
00034 DigitalOut brake_sig(p20);
00035 DigitalOut left_turn_sig(p22);
00036 DigitalOut right_turn_sig(p21);
00037 
00038 //Mutex Lock
00039 Mutex mutex;
00040 
00041 //Threads
00042 Thread motor_thread;
00043 Thread speaker_thread;
00044 Thread RGB_LED_bar_thread;
00045 
00046 volatile float left_speed;
00047 volatile float right_speed;
00048 volatile float old_left;
00049 volatile float old_right;
00050 volatile char RX_char;
00051 
00052 float get_left_speed(char input)
00053 {
00054     switch(input)
00055     {
00056         case 'f':
00057             return 1.0;
00058         case 'm':
00059             return 0.66;
00060         case 's':
00061             return 0.33;
00062         case 'n':
00063             return 0;
00064         case 'r':
00065             return -0.33;
00066         case 'l':
00067             return -0.66;
00068         case 'e':
00069             return -1.0;
00070         default:
00071             return old_left;
00072     }
00073 }
00074 
00075 float get_right_speed(char input)
00076 {
00077     switch(input)
00078     {
00079         case 'F':
00080             return 1.0;
00081         case 'M':
00082             return 0.66;
00083         case 'S':
00084             return 0.33;
00085         case 'N':
00086             return 0;
00087         case 'R':
00088             return -0.33;
00089         case 'L':
00090             return -0.66;
00091         case 'E':
00092             return -1.0;
00093         default:
00094             return old_right;
00095     }
00096 }
00097 
00098 void control_motors()
00099 {
00100     // reset the Zigbee (at least 200ns)
00101     xbee_rst = 0;
00102     wait_ms(1); 
00103     xbee_rst = 1;
00104     wait_ms(1); 
00105     pc.printf("ZIGBEE COMMUNICATION SETUP COMPLETE\n\r");
00106     
00107     while(1)
00108     {
00109         if(xbee.readable()) 
00110         {
00111             RX_char = xbee.getc();
00112             //pc.printf("receiving... %c\n\r", RX_char);
00113             pc.putc(RX_char); 
00114             
00115             left_speed = get_left_speed(RX_char);
00116             old_left = left_speed;
00117             right_speed = get_right_speed(RX_char);
00118             old_right = right_speed;
00119             
00120             //Signal and Brake Control
00121             if((left_speed == 0) && (right_speed == 0))
00122             {
00123                 brake_sig = 1;
00124                 left_turn_sig = 0;
00125                 right_turn_sig = 0;
00126             }
00127             
00128             else if(left_speed > right_speed)
00129             
00130             {
00131                 brake_sig = 0;
00132                 left_turn_sig = ! left_turn_sig;
00133                 right_turn_sig = 0;
00134             }
00135             
00136             else if(left_speed < right_speed)
00137             {
00138                 brake_sig = 0;
00139                 right_turn_sig = ! right_turn_sig;
00140                 left_turn_sig = 0;
00141             }
00142             
00143             else
00144             {
00145                 brake_sig = 0;
00146                 left_turn_sig = 0;
00147                 right_turn_sig = 0;
00148             }
00149             
00150             motor_left.speed(left_speed);
00151             motor_right.speed(right_speed);
00152         }
00153     }
00154 }
00155 
00156 void speaker()
00157 {
00158     //Mount the filesystem
00159     //sd.mount();
00160     //wave_file=fopen("/sd/wavfiles/police_siren.wav","r");
00161     //waver.play(wave_file);
00162     //Thread::wait(31000);  //wait 31 seconds
00163     while(1)
00164     {
00165         if (RX_char == 'w')
00166         {
00167             wave_file=fopen("/sd/wavfiles/police_siren.wav","r");
00168             waver.play(wave_file);
00169             fclose(wave_file);
00170             Thread::wait(31000);  //wait 31 seconds
00171         }
00172         Thread::wait(500);  //wait 500ms
00173     }
00174 }
00175 
00176 
00177 void RGB_LED_bar()
00178 {
00179     //Device Opcode Defined:
00180     // 0 1 0 0   A2 A1 A0 0
00181     
00182     //chipR --> Red
00183     //chipG --> Green
00184     //chipB --> Blue
00185     
00186     //MCP23S17 ChipR
00187     // A0, A1, A2 of MCP23S17 chip0 are tied to ground on the breadboard, so the 8-bit address for writes is 0x40
00188     // This is referred to as the opcode in the device datasheet
00189     //A2=0      A1=0        A0=0
00190     char OpcodeR = 0x40;
00191     // Next create a MCP23S17
00192     // mbed p16 is connected to ~chipSelect on the MCP23S17
00193     MCP23S17 chipR = MCP23S17(IO_spi, p16, OpcodeR);
00194     
00195     //MCP23S17 ChipG
00196     //A2=0      A1=0        A0=1
00197     char OpcodeG = 0x42;
00198     // Next create a MCP23S17
00199     // mbed p17 is connected to ~chipSelect on the MCP23S17
00200     MCP23S17 chipG = MCP23S17(IO_spi, p17, OpcodeG);
00201     
00202     //MCP23S17 ChipB
00203     //A2=0      A1=1        A0=0
00204     char OpcodeB = 0x44;
00205     // Next create a MCP23S17
00206     // mbed p19 is connected to ~chipSelect on the MCP23S17
00207     MCP23S17 chipB = MCP23S17(IO_spi, p19, OpcodeB);
00208     
00209     IO_rst = 0;
00210     wait_us(10);
00211     IO_rst = 1;
00212     
00213     //0x00 = 'input'    0xFF = 'output'
00214     //Set all 8 Port A bits to output direction
00215     chipR.direction(PORT_A, 0x00);
00216     chipG.direction(PORT_A, 0x00);
00217     chipB.direction(PORT_A, 0x00);
00218     //Set all 8 Port B bits to output direction
00219     chipR.direction(PORT_B, 0x00);
00220     chipG.direction(PORT_B, 0x00);
00221     chipB.direction(PORT_B, 0x00);
00222     
00223         int init_wait = 500;
00224         mutex.lock();
00225         chipR.write(PORT_A, 0xFF);
00226         chipR.write(PORT_B, 0xFF);
00227         mutex.unlock();
00228         Thread::wait(init_wait);
00229         mutex.lock();
00230         chipG.write(PORT_A, 0xFF);
00231         chipG.write(PORT_B, 0xFF);
00232         mutex.unlock();
00233         Thread::wait(init_wait);
00234         mutex.lock();
00235         chipB.write(PORT_A, 0xFF);
00236         chipB.write(PORT_B, 0xFF);
00237         mutex.unlock();
00238         Thread::wait(init_wait);
00239         mutex.lock();
00240         chipR.write(PORT_A, 0x00);
00241         chipR.write(PORT_B, 0x00);
00242         mutex.unlock();
00243         Thread::wait(init_wait);
00244         mutex.lock();
00245         chipG.write(PORT_A, 0x00);
00246         chipG.write(PORT_B, 0x00);
00247         mutex.unlock();
00248         Thread::wait(init_wait);
00249         mutex.lock();
00250         chipB.write(PORT_A, 0x00);
00251         chipB.write(PORT_B, 0x00);
00252         mutex.unlock();
00253         Thread::wait(init_wait);
00254         
00255         bool flag = 0;
00256         volatile int redA_i = 0b10000000;
00257         volatile int greenA_i = 0b10000000;
00258         volatile int redB_i = 0b00000001;
00259         volatile int greenB_i = 0b00000001;
00260         volatile int redA;
00261         volatile int redB;
00262         volatile int greenA;
00263         volatile int greenB;
00264         volatile int blueA = 0b11111111;
00265         volatile int blueB = 0b11111111;
00266         
00267         
00268     while(1)
00269     {
00270         //2-PART CYCLON SWEEP (LED LIGHTING EFFECT)
00271         mutex.lock();
00272         if (flag == 0)
00273         {
00274             redA_i = redA_i>>1;
00275             greenA_i = greenA_i>>1;
00276             redB_i = redB_i<<1;
00277             greenB_i = greenB_i<<1;
00278             if (redA_i == 0b00000001)
00279             {
00280                 flag = 1;
00281             }
00282         }
00283         else if (flag == 1)
00284         {
00285             redA_i = redA_i<<1;
00286             greenA_i = greenA_i<<1;
00287             redB_i = redB_i>>1;
00288             greenB_i = greenB_i>>1;
00289             if (redA_i == 0b10000000)
00290             {
00291                 flag = 0;
00292             }
00293         }
00294         redA = redA_i ^ 0b11111111; //XOR
00295         greenA = greenA_i ^ 0b11111111; //XOR
00296         redB = redB_i ^ 0b11111111; //XOR
00297         greenB = greenB_i ^ 0b11111111; //XOR
00298         chipR.write(PORT_A, redA);
00299         chipR.write(PORT_B, redB);
00300         chipG.write(PORT_A, greenA);
00301         chipG.write(PORT_B, greenB);
00302         chipB.write(PORT_A, blueA);
00303         chipB.write(PORT_B, blueB);
00304         mutex.unlock();
00305         Thread::wait(100);
00306     }
00307 }
00308 
00309 
00310 int main()
00311 {
00312     
00313     // Start Threads
00314     motor_thread.start(control_motors);
00315     speaker_thread.start(speaker);
00316     RGB_LED_bar_thread.start(RGB_LED_bar);
00317     
00318 }