test

Dependencies:   mbed MMA8452Q

Fork of HelloWorld by Simon Ford

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 /**** Vincent Labbé - labv2507  *****/
00002 /**** Karan Kalsi - kalk2701  *****/
00003 #include "mbed.h"    
00004 #include "MMA8452Q.h"
00005 
00006 Serial xbee_routeur(p13,p14);
00007 Serial pc(USBTX, USBRX); // tx, rx
00008 DigitalOut rst1(p8); //Digital reset for the XBee, 200ns for reset
00009 DigitalIn btn(p15); //Bouton read
00010 //MMA8452Q mma8452(p9,p10,0x1d);
00011 
00012 LocalFileSystem local("local");               // Create the local filesystem under the name "local"
00013 DigitalOut myled(LED1);
00014 Ticker sample;
00015 int currentStateButton;
00016 int previousStateButton;
00017 int validationStateButton;
00018 
00019 uint16_t panId;  // panId
00020 uint8_t panId_LSB;
00021 uint8_t panId_MSB;
00022 
00023 char*   url;    // url
00024 char URL[10];
00025 
00026 void seperatePanId(void);
00027 void ReadFile (void);
00028 void envoyer_tramme(char commande[], uint8_t data[], uint8_t length_MSB, uint8_t length_LSB, uint8_t API_frame_name);
00029 void transmisson(uint8_t data[], uint8_t length_MSB, uint8_t length_LSB, uint8_t API_frame_name);
00030 void initialisation_xbee(void);
00031 void readBtn(void);
00032 
00033 int main() { 
00034  
00035     ReadFile();// when you run first time without this line, the setup file is on created
00036     wait(1);
00037     seperatePanId(); // séparé msb et lsb du panId
00038     
00039     /*
00040     pc.printf("panId lsb : %x\n\r",panId_LSB);
00041     pc.printf("panId msb : %x\n\r",panId_MSB);
00042     pc.printf("panId : %x\n\r",panId);
00043     pc.printf("url: %s\n\r",URL);
00044     */
00045     
00046     initialisation_xbee();
00047     
00048     char commande0[2] = {'I','D'};
00049     uint8_t data0[2] = {panId_MSB, panId_LSB};
00050     envoyer_tramme(commande0, data0, 0x00, 0x06, 0x09);
00051     
00052     char commande1[2] = {'S','C'};
00053     uint8_t data1[2] = {0x09};
00054     envoyer_tramme(commande1, data1, 0x00, 0x05, 0x09);
00055     
00056     /*
00057     char commande2[2] = {'W','R'};
00058     uint8_t data2[10] = {};
00059     envoyer_tramme(commande2, data2, 0x00, 0x04, 0x09);
00060     */
00061     /*
00062     char commande3[2] = {'A','C'};
00063     uint8_t data3[2] = {};
00064     envoyer_tramme(commande3, data3, 0x00, 0x04, 0x09);
00065     */
00066     
00067     sample.attach(&readBtn,0.05);
00068     
00069     while(1)
00070     {   
00071     
00072     
00073     
00074     //myled = 1;
00075     if(xbee_routeur.readable())
00076     {
00077      pc.putc(xbee_routeur.getc());   
00078     }
00079     
00080     if(pc.readable())
00081     {
00082      xbee_routeur.putc(pc.getc());   
00083     }
00084 
00085     }
00086 }
00087 
00088 void readBtn(void)
00089 {
00090     uint8_t data4[2];
00091     currentStateButton = btn.read();  // lecture courante numérique button 
00092     
00093         if(previousStateButton != currentStateButton)   // détection de changement d'état pour bouton
00094         {    
00095             wait_ms(50);
00096             
00097             validationStateButton = btn.read();   // nouvelle lecture apres stabilisation button 
00098             
00099             if(currentStateButton == validationStateButton)  
00100             {        
00101                 if(previousStateButton != currentStateButton)
00102                 {
00103                     if(currentStateButton == 1)
00104                     {
00105                     data4[0] = 0x01;
00106                     }
00107                     else
00108                     {
00109                     data4[0] = 0x00;
00110                     }
00111                     transmisson(data4, 0x00, 0x0F, 0x10);
00112                 }
00113             }
00114         }
00115         previousStateButton = validationStateButton; // mise a jour de l'état précédente button 1
00116 }
00117 
00118 void initialisation_xbee(void)
00119 {
00120     xbee_routeur.baud(9600); //set baud rate
00121     rst1 = 0;   // xbee reset
00122     wait_ms(400);
00123     rst1 = 1;
00124     xbee_routeur.printf("+++");
00125     wait_ms(500);
00126 }
00127 
00128 void transmisson(uint8_t data[], uint8_t length_MSB, uint8_t length_LSB, uint8_t API_frame_name)
00129 {
00130     int sum = 0;
00131     
00132     xbee_routeur.putc(0x7E); // start delimiter
00133     xbee_routeur.putc(length_MSB); // MSB length
00134     xbee_routeur.putc(length_LSB); // LSB length
00135     xbee_routeur.putc(API_frame_name); // API frame name 
00136     xbee_routeur.putc(0x01); // Frame Id
00137     xbee_routeur.putc(0x00); // 64-bit address (broadcast)  
00138     xbee_routeur.putc(0x00); // 
00139     xbee_routeur.putc(0x00); // 
00140     xbee_routeur.putc(0x00); // 
00141     xbee_routeur.putc(0x00); // 
00142     xbee_routeur.putc(0x00); // 
00143     xbee_routeur.putc(0x00); // 
00144     xbee_routeur.putc(0x00); // 
00145     xbee_routeur.putc(0xFF); // 16-bit address (broadcast)
00146     xbee_routeur.putc(0xFE); // 16-bit address (broadcast)
00147     xbee_routeur.putc(0x00); // Broadcast radius
00148     xbee_routeur.putc(0x00); // Options
00149     
00150     uint16_t length = length_MSB;
00151     length = (length << 8) + length_LSB;
00152     //pc.printf("length : %x\n\r",length);
00153     
00154     for (int i = 0 ; i < length - 14; i++)
00155     {
00156         xbee_routeur.putc(data[i]); // API frame name 
00157         //pc.printf("data %d : %x\n\r",i,data[i]);
00158         sum = sum + data[i]; 
00159     }
00160     
00161     sum = sum + API_frame_name + 0x01 + 0xFF +0xFE;
00162     char checksum = (0xFF - (sum & 0xFF));
00163     //pc.printf("checksum : %x\n\r",checksum);
00164     xbee_routeur.putc(checksum); // checksum
00165 }
00166 
00167 
00168 void envoyer_tramme(char commande[], uint8_t data[], uint8_t length_MSB, uint8_t length_LSB, uint8_t API_frame_name)
00169 {
00170     int sum = 0;
00171     
00172     xbee_routeur.putc(0x7E); // start delimiter
00173     xbee_routeur.putc(length_MSB); // MSB length
00174     xbee_routeur.putc(length_LSB); // LSB length
00175     xbee_routeur.putc(API_frame_name); // API frame name 
00176     xbee_routeur.putc(0x01); // Frame Id
00177     xbee_routeur.putc(commande[0]); // Commande lettre 1
00178     xbee_routeur.putc(commande[1]); // Commande lettre 2
00179     
00180     uint16_t length = length_MSB;
00181     length = (length << 8) + length_LSB;
00182     //pc.printf("length : %x\n\r",length);
00183     
00184     for (int i = 0 ; i < length - 4; i++)
00185     {
00186         xbee_routeur.putc(data[i]); // API frame name 
00187         //pc.printf("data %d : %x\n\r",i,data[i]);
00188         sum = sum + data[i]; 
00189     }
00190     
00191     sum = sum + API_frame_name + 0x01 + commande[0]+ commande[1];
00192     char checksum = (0xFF - (sum & 0xFF));
00193     //pc.printf("checksum : %x\n\r",checksum);
00194     xbee_routeur.putc(checksum); // checksum
00195 }
00196 
00197 void seperatePanId(void)
00198 {
00199     panId_LSB = (panId & 0x00FF);
00200     panId_MSB = ((panId >> 8) & 0x00FF);
00201 }
00202 
00203 void ReadFile (void) 
00204 {
00205     FILE *set = fopen("/local/config.txt", "r");  // Open "setup.txt" on the local file system for read
00206     fscanf(set,"%x",&panId); // read offset
00207     fscanf(set,"%s %f",URL,&url);   // read gain
00208     fclose(set);
00209 }
00210 
00211 
00212 
00213 
00214 
00215 
00216 
00217 
00218 
00219 
00220 
00221 
00222 
00223 
00224 
00225 
00226 
00227 
00228 
00229 
00230 
00231 
00232 
00233 
00234 
00235 
00236 
00237 
00238 
00239 // SPI COMMUNICATION
00240 /*
00241 int main() {
00242 
00243      float x, y, z ;
00244      MMA8452Q acc(p9,p10,0x1d);     // acceleration object
00245      
00246          cs = 0;    //Clear display SPI
00247          wait(0.1);
00248          spi.write(0x76); // Clear display
00249          cs = 1;
00250          wait(0.1);
00251          cs = 1;
00252          
00253      while (true) {       
00254          x = acc.getAccX() ; 
00255          y = acc.getAccY() ;
00256          z = acc.getAccZ() ;
00257          printf("X[%.3f] Y[%.3f] Z[%.3f]\n",x, y, z) ;
00258          wait(0.1);
00259 
00260         int X = x * 1000; //Pour enlever floating point et garder une précision
00261         int Y = y * 1000;
00262         int Z = z * 1000;
00263 
00264         int angle = (1000-(((2*X*X+2*Y*Y)*1000/(X*X+Y*Y+Z*Z)))); //Calcul vectoriel pour calculer l'angle à l'horizontal
00265         
00266         pc.printf("avant acos = %d", angle);
00267         
00268         float ratioZaccel = angle/1000.0; //Remettre en floating point pour acos
00269         int resultatRAD = 500*acos((ratioZaccel)); //Reponse en RAD
00270         
00271         pc.printf("valeur rad new= %d", resultatRAD);
00272         int degree = resultatRAD * 18000/31400; //Tranfo degree
00273         pc.printf("valeur deg new = %d", degree);
00274         pc.printf("valeur deg new = %d", degree);
00275         
00276         // extracting digits
00277         int digit;
00278         int digits[4] = {0,0,0,0};
00279         int i = 0;
00280         while(degree > 0) {
00281         digit = degree % 10; //to get the right most digit
00282         digits[i]=digit;
00283         pc.printf("digit %d = %d, degree int: %d", i, digits[i], degree);
00284         degree /= 10;              //reduce the number by one digit
00285         ++i;
00286         }
00287          
00288          spi.write(0x77); // Decimal control command    // Pour la communication SPI
00289          cs = 1;
00290          wait(0.01);
00291          cs = 0;
00292          spi.write(0x04);// Turn on decimal
00293          cs = 1;
00294          wait(0.01);
00295          cs = 0;
00296          spi.write(digits[3]);
00297          cs = 1;
00298          wait(0.01);
00299          cs = 0;
00300          spi.write(digits[2]);
00301          cs = 1;
00302          wait(0.01);
00303          cs = 0;
00304          spi.write(digits[1]);
00305          cs = 1;
00306          wait(0.01);
00307          cs = 0;
00308          spi.write(digits[0]);
00309          cs = 1; 
00310          */
00311          /*     Test
00312          cs = 0;
00313          wait(0.1);
00314          spi.write(0x5);
00315          cs = 1;
00316          */
00317     //    }
00318 //} 
00319 
00320 
00321 
00322 // UART COMMUNICATION
00323 /*
00324 void UARTInit()
00325 {
00326  uint16_t usFdiv;   
00327     
00328  LPC_SC->PCONP       |=  (1 << 25);  // Power up the UART3 it's disabled on powerup.
00329   
00330  LPC_PINCON->PINSEL1 |= (3 << 18);   // Pin P0.25 used as TXD0 (Com0)     // Enable the pins on the device to use UART3 
00331  LPC_PINCON->PINSEL1 |= (3 << 20);   // Pin P0.26 used as RXD0 (Com0) 
00332     
00333  LPC_SC->PCLKSEL1    &= ~(3 << 18); // Clean all to 0    // Setup the PCLK for UART3
00334  LPC_SC->PCLKSEL1    |=  (1 << 18); // PCLK = CCLK
00335 
00336  LPC_UART3->LCR  =   0x83;  // 0000 0000 1000 0011       // Word select 8-bit character length and set DLAB
00337 
00338  usFdiv = (SystemCoreClock / (16*9600));    //Baud rate calculation
00339  LPC_UART3->DLM  =  usFdiv / 256;
00340  LPC_UART3->DLL  =   usFdiv % 256;
00341 
00342  LPC_UART3->FCR       = 0x7;     // Enable and reset UART3 FIFOs.
00343 
00344  LPC_UART3->LCR &= ~(1 << 7);    // Clear DLAB
00345 }
00346 
00347 char UART3Transmit(int out)
00348 {
00349     LPC_UART3 -> THR = out;
00350     while(! (LPC_UART3->LSR & (0x01 << 0x06)));
00351 
00352     return 1;
00353 }
00354 
00355 int main() {
00356     
00357  UARTInit();
00358 
00359      float x, y, z ;
00360     
00361      MMA8452Q acc(p9,p10,0x1d);     // acceleration object
00362          
00363          UART3Transmit(0x76); // Clear display UART
00364      while (true) {  
00365           
00366          x = acc.getAccX() ; 
00367          y = acc.getAccY() ;
00368          z = acc.getAccZ() ;
00369          printf("X[%.3f] Y[%.3f] Z[%.3f]\n",x, y, z) ;
00370          wait(0.1);
00371 
00372         int X = x * 1000; //Pour enlever floating point et garder une précision
00373         int Y = y * 1000;
00374         int Z = z * 1000;
00375 
00376         int angle = (1000-(((2*X*X+2*Y*Y)*1000/(X*X+Y*Y+Z*Z)))); //Calcul vectoriel pour calculer l'angle à l'horizontal
00377         
00378         pc.printf("avant acos = %d", angle);
00379         
00380         float ratioZaccel = angle/1000.0; //Remettre en floating point pour acos
00381         int resultatRAD = 500*acos((ratioZaccel)); //Reponse en RAD
00382         
00383         pc.printf("valeur rad new= %d", resultatRAD);
00384         int degree = resultatRAD * 18000/31400; //Tranfo degree
00385         pc.printf("valeur deg new = %d", degree);
00386         
00387         pc.printf("valeur deg new = %d", degree);
00388         
00389         
00390         int digit;      // extracting digits
00391         int digits[4] = {0,0,0,0};
00392         int i = 0;
00393         while(degree > 0) {
00394         digit = degree % 10; //to get the right most digit
00395         digits[i]=digit;
00396         pc.printf("digit %d = %d, degree int: %d", i, digits[i], degree);
00397         degree /= 10;              //reduce the number by one digit
00398         ++i;
00399         }
00400          
00401          UART3Transmit(0x77); // Decimal control command    // Pour la communication UART
00402          UART3Transmit(0x04);// Turn on decimal
00403          
00404          UART3Transmit(digits[3]);
00405          UART3Transmit(digits[2]);
00406          UART3Transmit(digits[1]);
00407          UART3Transmit(digits[0]);      //UART3Transmit(0xA5);
00408         }
00409 } 
00410 */        
00411 
00412 
00413 /* // communication I2C 
00414 Serial pc(USBTX, USBRX); // tx, rx
00415 I2C i2c(p9,p10);   
00416 
00417 int main() {
00418     i2c.frequency(100000);
00419     char cmd[2] = {0,0};
00420     int addr = 0x5A;
00421     int data = 0xA4;
00422     cmd[0] = addr;
00423     cmd[1] = data;
00424     
00425 while(1){
00426     i2c.write(0x3A,cmd,2);
00427     wait_ms(5);
00428     }
00429 }
00430  */
00431 // I2C write
00432 //i2c.frequency(100000);
00433 //int cmd[0] = 0x0D;
00434 //12c.write(addr,cmd,1,true);
00435 //i2c.read(addr,cmd,1);
00436 
00437  /* // communication UART
00438 Serial pc(USBTX, USBRX); // tx, rx
00439 Serial mc(p9,p10);
00440 int main() {
00441     
00442     int nombre;
00443     pc.printf("Entrez un nombre de 4 chiffres : ");
00444     pc.scanf("%d", &nombre);
00445     pc.printf("Votre numero entrez est le : %d", nombre);
00446     //mc.printf(nombre);
00447     mc.putc(nombre);
00448 }
00449  */
00450 
00451 /*
00452 DigitalOut myled(LED3);
00453 
00454 int main() {
00455     while(1) {
00456         myled = 1;
00457         wait(0.2);
00458         myled = 0;
00459         wait(0.2);
00460     }
00461 }
00462 */
00463 
00464 // I2C write
00465 /*
00466 I2C    i2c( p28, p26 );        // sda, scl
00467  
00468 int main() {
00469     char    data[3];
00470  
00471     data[0]   = 0x16;
00472     data[1]   = 0x55;
00473     data[2]   = 0x55;
00474  
00475     i2c.write( 0xC0, data, 3 ); //0xC0 is slave adress 
00476 }*/
00477 
00478 // I2C Read
00479 /*
00480 short read_sensor_lower_8bit( void )
00481 {
00482     char    v;
00483     char    cmd;
00484  
00485     cmd    = 0x05;
00486  
00487     i2c.write( 0x88, &cmd, 1 );
00488     i2c.read( 0x88, &v, 1 );
00489  
00490     return( v );
00491 }
00492 */
00493 
00494 /*
00495 int main() {
00496     set_time(1256729737);  // Set RTC time to Wed, 28 Oct 2009 11:35:37
00497 }*/
00498 
00499 /*
00500 int main() {
00501     while(1) {
00502         time_t seconds = time(NULL);
00503 
00504         printf("Time as seconds since January 1, 1970 = %d\n", seconds);
00505 
00506         printf("Time as a basic string = %s", ctime(&seconds));
00507 
00508         char buffer[32];
00509         strftime(buffer, 32, "%I:%M %p\n", localtime(&seconds));
00510         printf("Time as a custom formatted string = %s", buffer);
00511 
00512         wait(1);
00513     }
00514 }*/
00515 /*
00516 int main() {
00517 
00518     // get the current time from the terminal
00519     struct tm t;
00520     printf("Enter current date and time:\n");
00521     printf("YYYY MM DD HH MM SS[enter]\n");    
00522     scanf("%d %d %d %d %d %d", &t.tm_year, &t.tm_mon, &t.tm_mday
00523                              , &t.tm_hour, &t.tm_min, &t.tm_sec);
00524 
00525     // adjust for tm structure required values
00526     t.tm_year = t.tm_year - 1900;
00527     t.tm_mon = t.tm_mon - 1;
00528     
00529     // set the time
00530     set_time(mktime(&t));
00531         
00532     // display the time
00533     while(1) {    
00534         time_t seconds = time(NULL);
00535         printf("Time as a basic string = %s", ctime(&seconds));
00536         wait(1);
00537     }
00538 }*/