main.cpp

00001 #include "mbed.h"
00002 
00003 // ACC Registers
00004 #define ID0 0x00
00005 #define STATUS 0x0b
00006 #define FIFO_EL 0x0c
00007 #define FIFO_EH 0x0d
00008 #define RESET 0x1f
00009 #define FIFO_CTL 0x28
00010 #define FIFO_SAM 0x29
00011 #define INTMAP1 0x2a
00012 #define INTMAP2 0x2b
00013 #define FILTER_CTL 0x2c
00014 #define POWER_CTL 0x2d
00015 
00016 #define WR_SPI 0x0a
00017 #define RD_SPI 0x0b
00018 #define RD_FIFO 0x0d
00019 #define DOWN 0
00020 #define UP 1
00021 
00022 #define SAMPLE_SET 128
00023 
00024 // function definitions
00025 void drSub();
00026 uint8_t ACC_ReadReg( uint8_t reg );
00027 void ACC_WriteReg( uint8_t reg, uint8_t reg );
00028 uint32_t drFlag;
00029 void ACC_GetXYZ12( int16_t *x, int16_t *y, int16_t *z);
00030 void ACC_GetXYZ8( int8_t *x, int8_t *y, int8_t *z);
00031 void ACC_GetFIFO(uint8_t *x, uint32_t samples);
00032 int16_t convertFIFOdata(uint8_t h, uint8_t l);
00033 
00034 // mbed hardware config
00035 SPI spi(p11, p12, p13); // mosi, miso, sclk
00036 DigitalOut cs(p14);
00037 InterruptIn dr(p15);
00038 Serial pc(USBTX, USBRX); // tx, rx
00039 
00040 
00041 int main()
00042 {
00043     // local variables
00044     uint8_t reg;
00045 
00046     int8_t x8 = 0;
00047     int8_t y8 = 0;
00048     int8_t z8 = 0;
00049 
00050     int16_t x12 = 0;
00051     int16_t y12 = 0;
00052     int16_t z12 = 0;
00053 
00054     //uint8_t fl;
00055     //uint8_t fh;
00056     //uint32_t fb;
00057 
00058     uint8_t xyz[1020];  // 6 bytes per 3x sample set
00059     for (uint32_t i = 0; i < 1020; i++) xyz[i] = 0;
00060 
00061      // mbed serial port config
00062     pc.baud(115200);
00063 
00064     // mbed spi config
00065     // spi 8 bits, mode 0, 1 MHz for adxl362
00066     spi.format(8,0);
00067     // 5 MHz, max for acc - works fine
00068     spi.frequency(5000000);
00069 
00070     // mbed interrupt config
00071     drFlag = 0;
00072     dr.mode(PullDown);
00073     dr.rise(&drSub);
00074     __disable_irq();
00075 
00076     // reset the adxl362
00077     wait_ms(100);
00078     ACC_WriteReg(RESET, 0x52);
00079     wait_ms(100);
00080 
00081     /*
00082     // read adxl362 registers
00083     printf("\r\n");
00084     // read id register
00085     reg = ACC_ReadReg(ID0);
00086     pc.printf("ID0 = 0x%X\r\n", reg);
00087     reg = ACC_ReadReg(FILTER_CTL);
00088     pc.printf("FILTER_CTL = 0x%X\r\n", reg);
00089     */
00090 
00091     // set FIFO
00092     ACC_WriteReg(FIFO_CTL,0x0A);  // stream mode, AH bit
00093     //ACC_WriteReg(FIFO_CTL,0x02);  // stream mode, no AH bit
00094     reg = ACC_ReadReg(FIFO_CTL);
00095     pc.printf("FIFO_CTL = 0x%X\r\n", reg);
00096 
00097     //ACC_WriteReg(FIFO_SAM,0xFF);   // fifo depth
00098     ACC_WriteReg(FIFO_SAM,SAMPLE_SET * 3);   // fifo depth
00099     reg = ACC_ReadReg(FIFO_SAM);
00100     pc.printf("FIFO_SAM = 0x%X\r\n", reg);
00101 
00102     // set adxl362 to 4g range, 25Hz
00103     //ACC_WriteReg(FILTER_CTL,0x51);
00104     // 2g, 25Hz
00105     ACC_WriteReg(FILTER_CTL,0x11);
00106     reg = ACC_ReadReg(FILTER_CTL);
00107     printf("FILTER_CTL = 0x%X\r\n", reg);
00108 
00109     // map adxl362 interrupts
00110     //ACC_WriteReg(INTMAP1,0x01); //data ready
00111     ACC_WriteReg(INTMAP1,0x04); //watermark
00112     reg = ACC_ReadReg(INTMAP1);
00113     pc.printf("INTMAP1 = 0x%X\r\n", reg);
00114 
00115     // set adxl362 to measurement mode, ultralow noise
00116     ACC_WriteReg(POWER_CTL,0x22);
00117     reg = ACC_ReadReg(POWER_CTL);
00118     pc.printf("POWER_CTL = 0x%X\r\n", reg);
00119 
00120 
00121     // start continuous processing adxl362 data
00122     __enable_irq();
00123 
00124     uint64_t j = 0;
00125 
00126     while(1) {
00127 
00128         if(drFlag == 1) {
00129 
00130 
00131             //fl = ACC_ReadReg(FIFO_EL);
00132             //fh = ACC_ReadReg(FIFO_EH);
00133             //fb =  (fh << 8) | fl;
00134             //pc.printf("\r\n%04X\r\n", fb);
00135 
00136             ACC_GetFIFO(&xyz[0],SAMPLE_SET);
00137 
00138             pc.printf("--%u------------------------------------------------------------\r\n", j);
00139 
00140             for (uint32_t i = 0; i < SAMPLE_SET * 6; i+=6) {
00141 
00142                 // useful use for testing
00143                 /*
00144                 uint8_t xAddr = (xyz[i+1] & 0xC0) >> 6;
00145                 uint8_t yAddr = (xyz[i+3] & 0xC0) >> 6;
00146                 uint8_t zAddr = (xyz[i+5] & 0xC0) >> 6;
00147                 pc.printf("%u %02x %02x %02x\r\n", j, xAddr, yAddr, zAddr);
00148                 */
00149 
00150                 int16_t x = convertFIFOdata(xyz[i+1], xyz[i]);
00151                 int16_t y = convertFIFOdata(xyz[i+3], xyz[i+2]);
00152                 int16_t z = convertFIFOdata(xyz[i+5], xyz[i+4]);
00153 
00154                 pc.printf("%+05d %+05d %+05d\r\n",x,y,z);
00155                 j++;
00156                 drFlag = 0;
00157             }
00158         }
00159 
00160         if(drFlag == 8) {
00161             ACC_GetXYZ8(&x8, &y8, &z8);
00162             pc.printf("%+04d %+04d %+04d\r\n", x8,y8,z8);
00163             drFlag = 0;
00164         }
00165 
00166         else if(drFlag == 12) {
00167             ACC_GetXYZ12(&x12, &y12, &z12);
00168             pc.printf ("%+05d %+05d %+05d\r\n",x12, y12, z12);
00169             //pc.printf("%04X, %04X, %04X\r\n", x12, y12, z12);
00170             drFlag = 0;
00171         }
00172 
00173     }
00174 }
00175 
00176 ////////////////////////////////////////////////////////////////////////////////////
00177 // convert fifo sample to unsigned int
00178 ////////////////////////////////////////////////////////////////////////////////////
00179 int16_t convertFIFOdata(uint8_t hiByte, uint8_t loByte)
00180 {
00181     /*
00182     //mask off type bits
00183     uint16_t x = ((h & 0x3F) << 8);
00184     // combine low byte
00185     x = x | l;
00186     // get sign bits, copy into B15, B14, combine
00187     x = ((x & 0x3000) << 2) | x;
00188     int16_t y = x;
00189     return (y);
00190     */
00191     //mask off id bits, combine low byte
00192     int16_t x = ((hiByte & 0x3F) << 8) | loByte;
00193     // get sign bits, copy into B15, B14, combine
00194     x = ((x & 0x3000) << 2) | x;
00195     return(x);
00196 }
00197 
00198 
00199 ////////////////////////////////////////////////////////////////////////////////////
00200 // read FIFO
00201 ////////////////////////////////////////////////////////////////////////////////////
00202 
00203 void ACC_GetFIFO(uint8_t *x, uint32_t samples)
00204 {
00205     cs = DOWN;
00206     spi.write(RD_FIFO);
00207     for(int i = 0; i < samples * 6; i++) {
00208         *x = spi.write(0x00);
00209         x++;
00210     }
00211 
00212     cs = UP;
00213 }
00214 
00215 ////////////////////////////////////////////////////////////////////////////////////
00216 // read 8-bit x,y,z data
00217 ////////////////////////////////////////////////////////////////////////////////////
00218 
00219 void ACC_GetXYZ8(int8_t* x, int8_t* y, int8_t* z)
00220 {
00221 
00222     cs = DOWN;
00223     spi.write(RD_SPI);
00224     spi.write(0x08);
00225 
00226     *x = spi.write(0x00);
00227     *y = spi.write(0x00);
00228     *z = spi.write(0x00);
00229 
00230     cs = UP;
00231 }
00232 
00233 ////////////////////////////////////////////////////////////////////////////////////
00234 // read 12-bit x,y,z data
00235 ////////////////////////////////////////////////////////////////////////////////////
00236 
00237 void ACC_GetXYZ12(int16_t* x, int16_t* y, int16_t* z)
00238 {
00239     int16_t xyzVal[6] = {0, 0, 0, 0, 0, 0};
00240 
00241     cs = DOWN;
00242     spi.write(RD_SPI);
00243     spi.write(0x0E);
00244 
00245     for (uint32_t i = 0; i < 6; i++) {
00246         xyzVal[i] = spi.write(0x00);
00247     }
00248 
00249     *x = (xyzVal[1] << 8) + xyzVal[0];
00250     *y = (xyzVal[3] << 8) + xyzVal[2];
00251     *z = (xyzVal[5] << 8) + xyzVal[4];
00252 
00253     cs = UP;
00254 }
00255 
00256 ////////////////////////////////////////////////////////////////////////////////////
00257 // read ACC 8-bit registers
00258 ////////////////////////////////////////////////////////////////////////////////////
00259 
00260 uint8_t ACC_ReadReg( uint8_t reg )
00261 {
00262     cs = DOWN;
00263     spi.write(RD_SPI);
00264     spi.write(reg);
00265     uint8_t val = spi.write(0x00);
00266     cs = UP;
00267     return (val);
00268 }
00269 
00270 ////////////////////////////////////////////////////////////////////////////////////
00271 // write ACC 8-bit register
00272 ////////////////////////////////////////////////////////////////////////////////////
00273 
00274 void ACC_WriteReg( uint8_t reg, uint8_t cmd )
00275 {
00276     cs = DOWN;
00277     spi.write(WR_SPI);
00278     spi.write(reg);
00279     spi.write(cmd);
00280     cs = UP;
00281 }
00282 
00283 ////////////////////////////////////////////////////////////////////////////////////
00284 // Handle data ready interrupt
00285 // just sets data ready flag
00286 ////////////////////////////////////////////////////////////////////////////////////
00287 
00288 void drSub()
00289 {
00290     drFlag = 1;
00291     //drFlag = 8;
00292     //drFlag = 12;
00293 }