P422_Labs / Mbed OS accel

Dependencies:   ADXL362

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "ADXL362.h"
00003 DigitalOut led1(LED1);
00004  
00005 // Interface pulled from ADXL362.cpp
00006 // ADXL362::ADXL362(PinName CS, PinName MOSI, PinName MISO, PinName SCK) :
00007 ADXL362 adxl362(PA_0,PA_7,PA_6,PA_1);
00008 
00009 
00010 
00011 int adxl362_reg_print(int start, int length){
00012     typedef enum {
00013         DEVID_AD = 0x00,
00014         DEVID_MST = 0x01,
00015         PARTID = 0x02,
00016         REVID = 0x03,
00017         XDATA = 0x08,
00018         YDATA = 0x09,
00019         ZDATA = 0x0A,
00020         STATUS = 0x0B,
00021         FIFO_ENTRIES_L = 0x0C,
00022         FIFO_ENTRIES_H = 0x0D,
00023         XDATA_L = 0x0E,
00024         XDATA_H = 0x0F,
00025         YDATA_L = 0x10,
00026         YDATA_H = 0x11,
00027         ZDATA_L = 0x12,
00028         ZDATA_H = 0x13,
00029         TEMP_L = 0x14,
00030         TEMP_H = 0x15,
00031         // Reserved = 0x16;
00032         // Reserved = 0x17;
00033         SOFT_RESET = 0x1F,
00034         THRESH_ACT_L = 0x20,
00035         THRESH_ACT_H = 0x21,
00036         TIME_ACT = 0x22,
00037         THRESH_INACT_L = 0x23,
00038         THRESH_INACT_H = 0x24,
00039         TIME_INACT_L = 0x25,
00040         TIME_INACT_H = 0x26,
00041         ACT_INACT_CTL = 0x27,
00042         FIFO_CONTROL = 0x28,
00043         FIFO_SAMPLES = 0x29,
00044         INTMAP1 = 0x2A,
00045         INTMAP2 = 0x2B,
00046         FILTER_CTL = 0x2C,
00047         POWER_CTL = 0x2D,
00048         SELF_TEST = 0x2E,
00049     } ADXL362_register_t;
00050     
00051      char *regnames[34] = {"DEVID_AD","DEVID_MST","PARTID","REVID","XDATA","YDATA","ZDATA","STATUS","FIFO_ENTRIES_L",
00052                            "FIFO_ENTRIES_H","XDATA_L","XDATA_H","YDATA_L","YDATA_H","ZDATA_L","ZDATA_H","TEMP_L",
00053                            "TEMP_H","SOFT_RESET","THRESH_ACT_L","THRESH_ACT_H","TIME_ACT","THRESH_INACT_L","THRESH_INACT_H","TIME_INACT_L","TIME_INACT_H",
00054                            "ACT_INACT_CTL","FIFO_CONTROL","FIFO_SAMPLES","INTMAP1","INTMAP2","FILTER_CTL","POWER_CTL",
00055                            "SELF_TEST"};
00056      int val1[34] = { 0x00, 0x01,0x02,0x03,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E};
00057      if(0x00<=start && start <=0x2E){
00058          if(length>0){
00059              int j = 0;
00060              //uint8_t adreg = read_reg(ADXL362::DEVID_AD);
00061              for(int x = start; x<=length; x++){
00062                 int val = val1[x];
00063                 switch(val){
00064                     case(ADXL362::DEVID_AD):
00065                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x],val);
00066                         break;
00067                     case(ADXL362::DEVID_MST):
00068                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00069                         break;
00070                     case(ADXL362::PARTID):
00071                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00072                         break;
00073                     case(ADXL362::REVID):
00074                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00075                         break;
00076                     case(ADXL362::XDATA):
00077                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00078                         break;
00079                     case(ADXL362::YDATA):
00080                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00081                         break;
00082                     case(ADXL362::ZDATA):
00083                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00084                         break;
00085                     case(ADXL362::STATUS):
00086                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00087                         break;
00088                     case(ADXL362::FIFO_ENTRIES_L):
00089                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00090                         break;
00091                     case(ADXL362::FIFO_ENTRIES_H):
00092                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00093                         break;
00094                     case(ADXL362::XDATA_L):
00095                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00096                         break;
00097                     case(ADXL362::XDATA_H):
00098                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00099                         break;
00100                     case(ADXL362::YDATA_L):
00101                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00102                         break;
00103                     case(ADXL362::YDATA_H):
00104                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00105                         break;
00106                     case(ADXL362::ZDATA_L):
00107                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00108                         break;
00109                     case(ADXL362::ZDATA_H):
00110                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00111                         break;
00112                     case(ADXL362::TEMP_L):
00113                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00114                         break;
00115                     case(ADXL362::TEMP_H):
00116                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00117                         break;
00118                     case(ADXL362::SOFT_RESET):
00119                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00120                         break;
00121                     case(ADXL362::THRESH_ACT_L):
00122                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00123                         break;
00124                     case(ADXL362::THRESH_ACT_H):
00125                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00126                         break;
00127                     case(ADXL362::TIME_ACT):
00128                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00129                         break;
00130                     case(ADXL362::THRESH_INACT_L):
00131                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00132                         break;
00133                     case(ADXL362::THRESH_INACT_H):
00134                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00135                         break;
00136                     case(ADXL362::TIME_INACT_L):
00137                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00138                         break;
00139                     case(ADXL362::TIME_INACT_H):
00140                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00141                         break;
00142                     case(ADXL362::ACT_INACT_CTL):
00143                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00144                         break;
00145                     case(ADXL362::INTMAP1):
00146                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00147                         break;
00148                     case(ADXL362::INTMAP2):
00149                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00150                         break;
00151                     case(ADXL362::FILTER_CTL):
00152                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00153                         break;
00154                     case(ADXL362::POWER_CTL):
00155                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00156                         break;
00157                     case(ADXL362::SELF_TEST):
00158                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00159                         break;
00160                     case(ADXL362::FIFO_CONTROL):
00161                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00162                         break;
00163                     case(ADXL362::FIFO_SAMPLES):
00164                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00165                         break;
00166                     default: printf("test%0x", val);
00167                 }
00168                 j++;
00169             } 
00170          }
00171          else if(length==0){
00172             int j = 0;
00173             //uint8_t adreg = read_reg(ADXL362::DEVID_AD);
00174             for(int x = start; x<34; x++){
00175                           int val=val1[x];
00176                 //printf("> %0x: %s=%0x \n\r", x, regnames[x],val);
00177                 switch(val){
00178                     case(ADXL362::DEVID_AD):
00179                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x],val);
00180                         break;
00181                     case(ADXL362::DEVID_MST):
00182                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00183                         break;
00184                     case(ADXL362::PARTID):
00185                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00186                         break;
00187                     case(ADXL362::REVID):
00188                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00189                         break;
00190                     case(ADXL362::XDATA):
00191                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00192                         break;
00193                     case(ADXL362::YDATA):
00194                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00195                         break;
00196                     case(ADXL362::ZDATA):
00197                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00198                         break;
00199                     case(ADXL362::STATUS):
00200                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00201                         break;
00202                     case(ADXL362::FIFO_ENTRIES_L):
00203                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00204                         break;
00205                     case(ADXL362::FIFO_ENTRIES_H):
00206                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00207                         break;
00208                     case(ADXL362::XDATA_L):
00209                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00210                         break;
00211                     case(ADXL362::XDATA_H):
00212                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00213                         break;
00214                     case(ADXL362::YDATA_L):
00215                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00216                         break;
00217                     case(ADXL362::YDATA_H):
00218                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00219                         break;
00220                     case(ADXL362::ZDATA_L):
00221                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00222                         break;
00223                     case(ADXL362::ZDATA_H):
00224                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00225                         break;
00226                     case(ADXL362::TEMP_L):
00227                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00228                         break;
00229                     case(ADXL362::TEMP_H):
00230                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00231                         break;
00232                     case(ADXL362::SOFT_RESET):
00233                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00234                         break;
00235                     case(ADXL362::THRESH_ACT_L):
00236                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00237                         break;
00238                     case(ADXL362::THRESH_ACT_H):
00239                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00240                         break;
00241                     case(ADXL362::TIME_ACT):
00242                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00243                         break;
00244                     case(ADXL362::THRESH_INACT_L):
00245                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00246                         break;
00247                     case(ADXL362::THRESH_INACT_H):
00248                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00249                         break;
00250                     case(ADXL362::TIME_INACT_L):
00251                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00252                         break;
00253                     case(ADXL362::TIME_INACT_H):
00254                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00255                         break;
00256                     case(ADXL362::ACT_INACT_CTL):
00257                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00258                         break;
00259                     case(ADXL362::INTMAP1):
00260                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00261                         break;
00262                     case(ADXL362::INTMAP2):
00263                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00264                         break;
00265                     case(ADXL362::FILTER_CTL):
00266                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00267                         break;
00268                     case(ADXL362::POWER_CTL):
00269                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00270                         break;
00271                     case(ADXL362::SELF_TEST):
00272                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00273                         break;
00274                     case(ADXL362::FIFO_CONTROL):
00275                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00276                         break;
00277                     case(ADXL362::FIFO_SAMPLES):
00278                         printf("0x%0x: %s=0x%0x \n\r", j, regnames[x], val);
00279                         break;
00280                         
00281                      default: printf("MISSING: test%0x\n\r", val);
00282                 }
00283                 j++;
00284              }
00285          }
00286          else{
00287             free(regnames);
00288             return 1;
00289          }
00290          free(regnames);
00291          return 0;
00292      }
00293      else{
00294          free(regnames);
00295          return 1;
00296      }
00297      
00298 }
00299 
00300 
00301 int main() {
00302     adxl362.reset();
00303     wait_ms(600); // we need to wait at least 500ms after ADXL362 reset
00304     adxl362.set_mode(ADXL362::MEASUREMENT);
00305     int8_t x,y,z; 
00306     
00307     int8_t current [3] = {0,0,0};
00308     int8_t accel [3] = {0,0,0};
00309     int8_t currAdd;
00310     int8_t diffAdd;
00311     float threshold = 2;
00312     float val;
00313     int knock_counter = 0;
00314     
00315         while(1) {
00316             x=adxl362.scanx_u8();
00317             y=adxl362.scany_u8();
00318             z=adxl362.scanz_u8();
00319              current [0] = x; 
00320              current [1] = y; 
00321              current [2] = z; 
00322              currAdd = abs(current[0] + current [1] + current [2]);
00323             wait_ms(10);
00324             x=adxl362.scanx_u8();
00325             y=adxl362.scany_u8();
00326             z=adxl362.scanz_u8();
00327                 accel[0] = x;
00328                 accel[1] = y;
00329                 accel[2] = z;
00330                 diffAdd = abs(accel[0] + accel [1] + accel [2]);
00331             wait_ms(10);
00332             val = abs(currAdd - diffAdd);
00333             
00334             if(val > threshold){
00335             printf("\n\r A knock has been heard ma dude\r\n");
00336             printf("Knocks = %d\r\n" , knock_counter);
00337              knock_counter ++;
00338              led1 = 1;
00339              wait_ms(2000);
00340              led1 = 0;
00341              }
00342           //  printf("x = %d y = %d z = %d\r\n",x,y,z);
00343         //wait_ms(1000);
00344         
00345        // adxl362_reg_print(0, 0);
00346     }
00347 }