main.cpp

00001 /* mbed Microcontroller Library
00002  * Copyright (c) 2019 ARM Limited
00003  * SPDX-License-Identifier: Apache-2.0
00004  */
00005 
00006 #include "mbed.h"
00007 #include "platform/mbed_thread.h"
00008 
00009 // populate from databuffer queue raw samples data before sending over ble
00010 // struct RawData samples_raw_data;
00011 // int sampleIndex = 0;
00012 // int ptr = 0;
00013 // while(sampleIndex < mumberOffSamples)
00014 //  status byte is index 0
00015 //  samples_raw_data.green_led_cnt  = (databuf[ptr+1]  << 16)  + (databuf[ptr+2]  << 8)  + (databuf[ptr+3]);
00016 //  samples_raw_data.ir_led_cnt     = (databuf[ptr+4]  << 16)  + (databuf[ptr+5]  << 8)  + (databuf[ptr+6]);
00017 //  samples_raw_data.red_led_cnt    = (databuf[ptr+7]  << 16)  + (databuf[ptr+8]  << 8)  + (databuf[ptr+9]);
00018 //  samples_raw_data.green2_led_cnt = (databuf[ptr+10] << 16)  + (databuf[ptr+11] << 8)  + (databuf[ptr12]);
00019 //  samples_raw_data.x              = (databuf[ptr+19] << 8)   + (databuf[ptr+20]);
00020 //  samples_raw_data.y              = (databuf[ptr+21] << 8)   + (databuf[ptr+22]);
00021 //  samples_raw_data.z              = (databuf[ptr+23] << 8)   + (databuf[ptr+24]);
00022 struct RawData
00023 {
00024   uint32_t green_led_cnt;
00025   uint32_t ir_led_cnt;
00026   uint32_t red_led_cnt;
00027   uint32_t green2_led_cnt;
00028   int16_t x;
00029   int16_t y;
00030   int16_t z;
00031 };
00032 
00033 // Blinking rate in milliseconds
00034 #define BLINKING_RATE_MS                                                    500
00035 
00036 #define RST_PIN   P5_6
00037 #define MFIO_PIN  P5_4
00038 
00039 I2C i2c(P3_4, P3_5);
00040 
00041 const int addr = 0xAA;//0x55;
00042 
00043 int main()
00044 {   
00045     i2c.frequency(400000);
00046     char cmd[4];
00047         
00048     // Initialise the digital pin LED1 as an output
00049     DigitalOut led(LED1);
00050     DigitalOut rst(RST_PIN);
00051     DigitalOut mfio(MFIO_PIN);
00052     
00053     mfio = 0;
00054     rst = 1;
00055     thread_sleep_for(10);
00056     rst = 0;
00057     thread_sleep_for(10);
00058     rst = 1;
00059     //thread_sleep_for(1500);
00060     thread_sleep_for(100);
00061 
00062     //scanI2C();
00063 
00064     while (true) {
00065         //Read out status (app or boot mode)
00066         cmd[0] = 0x02;
00067         cmd[1] = 0x00;
00068         i2c.write(addr, cmd, 2);
00069         thread_sleep_for(2);
00070         
00071         cmd[0] = 0x00;
00072         cmd[1] = 0x00;
00073         i2c.read(addr, cmd, 2);
00074         printf("1: %x %x\n", cmd[0], cmd[1]);
00075     
00076         //Switch to APP mode
00077         cmd[0] = 0x01;
00078         cmd[1] = 0x00;
00079         cmd[2] = 0x00;
00080         i2c.write(addr, cmd, 3);
00081         thread_sleep_for(1500);
00082         
00083         //Switch off MFIO
00084         mfio = 0;
00085         thread_sleep_for(1); //Wait 300us
00086         
00087         //Read out status (app or boot mode)
00088         cmd[0] = 0x02;
00089         cmd[1] = 0x00;
00090         i2c.write(addr, cmd, 2);
00091         thread_sleep_for(2);
00092         
00093         cmd[0] = 0x00;
00094         cmd[1] = 0x00;
00095         i2c.read(addr, cmd, 2);
00096         printf("2: %x %x\n", cmd[0], cmd[1]);
00097 
00098         //Sensor hub firmware nummer opvragen
00099         cmd[0] = 0xFF;
00100         cmd[1] = 0x03;
00101         i2c.write(addr, cmd, 2);
00102         thread_sleep_for(2);
00103         
00104         cmd[0] = 0x00;
00105         cmd[1] = 0x00;
00106         cmd[2] = 0x00;
00107         cmd[3] = 0x00;
00108         i2c.read(addr, cmd, 4);
00109         printf("3: %d %d %d %d\n", cmd[0], cmd[1], cmd[2], cmd[3]);
00110 
00111         //Raw data mode
00112         cmd[0] = 0x10;
00113         cmd[1] = 0x00;
00114         cmd[2] = 0x03;
00115 
00116         i2c.write(addr, cmd, 3);
00117         thread_sleep_for(2);
00118         
00119         cmd[0] = 0x00;
00120         i2c.read(addr, cmd, 1);
00121         printf("4: %x\n", cmd[0]);
00122         
00123         //Interrupt threshold
00124         cmd[0] = 0x10;
00125         cmd[1] = 0x01;
00126         cmd[2] = 0x01;
00127 
00128         i2c.write(addr, cmd, 3);
00129         thread_sleep_for(2);
00130         
00131         cmd[0] = 0x00;
00132         i2c.read(addr, cmd, 1);
00133         printf("5: %x\n", cmd[0]);
00134         
00135         //Set sample report period
00136         cmd[0] = 0x10;
00137         cmd[1] = 0x02;
00138         cmd[2] = 0x01;
00139 
00140         i2c.write(addr, cmd, 3);
00141         thread_sleep_for(2);
00142         
00143         cmd[0] = 0x00;
00144         i2c.read(addr, cmd, 1);
00145         printf("6: %x\n", cmd[0]);
00146         
00147         //Enable accelerometer
00148         cmd[0] = 0x44;
00149         cmd[1] = 0x04;
00150         cmd[2] = 0x01;
00151         cmd[3] = 0x00; //0x01
00152         
00153         i2c.write(addr, cmd, 4);
00154         thread_sleep_for(20);
00155         
00156         cmd[0] = 0x00;
00157         i2c.read(addr, cmd, 1);
00158         printf("7: %x\n", cmd[0]);
00159         
00160         //Read accelerometer WHO_AM_I register
00161         cmd[0] = 0x41;
00162         cmd[1] = 0x04;
00163         cmd[2] = 0x0F;   
00164              
00165         i2c.write(addr, cmd, 3);
00166         thread_sleep_for(2);
00167         
00168         cmd[0] = 0x00;
00169         cmd[1] = 0x00;
00170         i2c.read(addr, cmd, 2);
00171         printf("8: %x %x\n", cmd[0], cmd[1]);
00172         
00173         
00174         
00175         printf("Start\n");
00176 
00177 
00178 
00179         //Enable AFE
00180         cmd[0] = 0x44;
00181         cmd[1] = 0x00;
00182         cmd[2] = 0x01; 
00183         //MAYBE 4
00184         
00185         i2c.write(addr, cmd, 3);
00186         thread_sleep_for(250);
00187         
00188         cmd[0] = 0x00;
00189         i2c.read(addr, cmd, 1);
00190         printf("9: %x\n", cmd[0]);
00191         
00192         //Set 100Hz read samples
00193         cmd[0] = 0x40;
00194         cmd[1] = 0x00;
00195         cmd[2] = 0x12; 
00196         cmd[3] = 0x18; 
00197                 
00198         i2c.write(addr, cmd, 4);
00199         thread_sleep_for(2);
00200         
00201         cmd[0] = 0x00;
00202         i2c.read(addr, cmd, 1);
00203         printf("10: %x\n", cmd[0]);
00204         
00205         
00206         
00207         
00208         //get data
00209         struct RawData samples_raw_data;
00210         int sampleIndex = 0;
00211         char rawData[1024];
00212         uint8_t amount = 0;
00213         memset(rawData,0,sizeof(rawData));
00214         for(uint8_t i=0; i<250; i++)
00215         {
00216             //Get status sensor hub
00217             cmd[0] = 0x00;
00218             cmd[1] = 0x00;
00219             i2c.write(addr, cmd, 2);
00220             thread_sleep_for(2);
00221         
00222             cmd[0] = 0x00;
00223             cmd[1] = 0x00;
00224             i2c.read(addr, cmd, 2);
00225             printf("dat1: %x %x\n", cmd[0], cmd[1]);
00226             
00227             //Get number of samples in the fifo
00228             cmd[0] = 0x12;
00229             cmd[1] = 0x00;
00230             i2c.write(addr, cmd, 2);
00231             thread_sleep_for(2);
00232         
00233             cmd[0] = 0x00;
00234             cmd[1] = 0x00;
00235             i2c.read(addr, cmd, 2);
00236             amount = cmd[1];
00237             printf("dat2: %x %x\n", cmd[0], cmd[1]);
00238             
00239             //Get data from fifo
00240             cmd[0] = 0x12;
00241             cmd[1] = 0x01;
00242             i2c.write(addr, cmd, 2);
00243             thread_sleep_for(2);
00244             
00245             i2c.read(addr, rawData, 1+((36+6)*amount));
00246             
00247             printf("Satus: %x\n", rawData[0]);
00248             printf("Data: ");
00249             for(uint32_t j=1; j<1+((36+6)*amount); j+=42)
00250             {
00251                 //%zu
00252                 printf("%u, %d, %d, %d\n", (uint32_t)(0x00<<24 | rawData[j+1]<<16 | rawData[j+2]<<8 | rawData[j+3]), (rawData[j+37]<<8 | rawData[j+38]), (rawData[j+39]<<8 | rawData[j+40]), (rawData[j+41]<<8 | rawData[j+42]));
00253             }
00254                 
00255             //thread_sleep_for(200); 
00256             thread_sleep_for(1);       
00257         }
00258         
00259         
00260         
00261         
00262         
00263         //Disable AFE
00264         cmd[0] = 0x44;
00265         cmd[1] = 0x00;
00266         cmd[2] = 0x00; 
00267         //MAYBE 4
00268         
00269         i2c.write(addr, cmd, 3);
00270         thread_sleep_for(250);
00271         
00272         cmd[0] = 0x00;
00273         i2c.read(addr, cmd, 1);
00274         printf("11: %x\n", cmd[0]);
00275         
00276         
00277         
00278         printf("Stop\n");
00279         
00280         
00281         
00282         //Disable Accelerometer
00283         cmd[0] = 0x44;
00284         cmd[1] = 0x04;
00285         cmd[2] = 0x00; 
00286         //MAYBE 4
00287         
00288         i2c.write(addr, cmd, 3);
00289         thread_sleep_for(20);
00290         
00291         cmd[0] = 0x00;
00292         i2c.read(addr, cmd, 1);
00293         printf("12: %x\n", cmd[0]);
00294 
00295         /*rst =! rst;
00296         mfio =! mfio;*/
00297         thread_sleep_for(BLINKING_RATE_MS);
00298         led = !led;
00299     }
00300 }