ADXL355.cpp

00001 #include <stdint.h>
00002 #include "mbed.h"
00003 #include "ADXL355.h"
00004 
00005 
00006 //DigitalOut int1;                ///< DigitalOut instance for the chipselect of the ADXL
00007 //DigitalOut int2;                ///< DigitalOut instance for the chipselect of the ADXL
00008 
00009 /** ----------------------------------- */
00010 /** SPI (MAX 10MHZ) and reset           */
00011 /** ----------------------------------- */
00012 ADXL355::ADXL355(PinName cs_pin, PinName MOSI, PinName MISO, PinName SCK): adxl355(MOSI, MISO, SCK), cs(cs_pin)
00013 {
00014     cs = 1;
00015     adxl355.format(8,_SPI_MODE);
00016     adxl355.lock();
00017     axis355_sens = 3.9e-6;
00018     axis357_sens = 19.5e-6;
00019     calib_data.S[0][0] = 3.9e-6;
00020     calib_data.S[1][1] = 3.9e-6;
00021     calib_data.S[2][2] = 3.9e-6;
00022 }
00023 void ADXL355::frequency(int hz)
00024 {
00025     adxl355.frequency(hz);
00026 }
00027 void ADXL355::reset(void)
00028 {
00029     adxl355.format(8, _SPI_MODE);
00030     cs = false;
00031     // Writing Code 0x52 (representing the letter, R, in ASCII or unicode) to this register immediately resets the ADXL362.
00032     write_reg(RESET, _RESET);
00033     cs = true;
00034     axis355_sens = 3.9e-6;
00035     axis357_sens = 19.5e-6;
00036 }
00037 /** ----------------------------------- */
00038 /** Writes the reg register with data   */
00039 /** ----------------------------------- */
00040 void ADXL355::write_reg(ADXL355_register_t reg, uint8_t data)
00041 {
00042     adxl355.format(8, _SPI_MODE);
00043     cs = false;
00044     adxl355.write(static_cast<uint8_t>(reg<<1) | _WRITE_REG_CMD);
00045     adxl355.write(data);
00046     cs = true;
00047 }
00048 void ADXL355::write_reg_u16(ADXL355_register_t reg, uint16_t data)
00049 {
00050     adxl355.format(8, _SPI_MODE);
00051     cs = false;
00052     adxl355.write(static_cast<uint8_t>(reg<<1) | _WRITE_REG_CMD);
00053     adxl355.write(static_cast<uint8_t>(data & 0xff));
00054     adxl355.write(static_cast<uint8_t>((data & 0xff00) >> 8));
00055     cs = true;
00056 }
00057 /** ----------------------------------- */
00058 /** Reads the reg register              */
00059 /** ----------------------------------- */
00060 uint8_t ADXL355::read_reg(ADXL355_register_t reg)
00061 {
00062     uint8_t ret_val;
00063     adxl355.format(8, _SPI_MODE);
00064     cs = false;
00065     adxl355.write(static_cast<uint8_t>(reg<<1) | _READ_REG_CMD);
00066     ret_val = adxl355.write(_DUMMY_BYTE);
00067     cs = true;
00068     return ret_val;
00069 }
00070 uint16_t ADXL355::read_reg_u16(ADXL355_register_t reg){
00071     uint16_t ret_val = 0;
00072     adxl355.format(8, _SPI_MODE);
00073     cs = false;
00074     adxl355.write(static_cast<uint8_t>(reg<<1) | _READ_REG_CMD);
00075     ret_val = adxl355.write(_DUMMY_BYTE);
00076     ret_val = (ret_val<<8) | adxl355.write(_DUMMY_BYTE);
00077     cs = true;
00078     return ret_val;
00079 }
00080 uint32_t ADXL355::read_reg_u20(ADXL355_register_t reg){
00081     uint32_t ret_val = 0;
00082     adxl355.format(8, _SPI_MODE);
00083     cs = false;
00084     adxl355.write((reg<<1) | _READ_REG_CMD);
00085     ret_val = 0x0f & adxl355.write(_DUMMY_BYTE);
00086     ret_val = (ret_val<<8) | adxl355.write(_DUMMY_BYTE);
00087     ret_val = (ret_val<<8) | adxl355.write(_DUMMY_BYTE);
00088     cs = true;
00089     return ret_val;
00090 }
00091 /** ----------------------------------- */
00092 /** Sets the CTL registers              */
00093 /** ----------------------------------- */
00094 void ADXL355::set_power_ctl_reg(uint8_t data){
00095      write_reg(POWER_CTL, data);
00096 }
00097 void ADXL355::set_filter_ctl_reg(ADXL355_filter_ctl_t hpf, ADXL355_filter_ctl_t odr){
00098     write_reg(FILTER, static_cast<uint8_t>(hpf|odr));
00099 }
00100 void ADXL355::set_clk(ADXL355_sync_ctl_t data) {
00101     write_reg(SYNC, static_cast<uint8_t>(data));
00102 }
00103 void ADXL355::set_device(ADXL355_range_ctl_t range) {
00104     write_reg(RANGE, static_cast<uint8_t>(range));
00105     switch(range){
00106         case 0x01:
00107             axis355_sens = 3.9e-6;
00108             axis357_sens = 19.5e-6;
00109             break;
00110         case 0x02:
00111             axis355_sens = 7.8e-6;
00112             axis357_sens = 39e-6;
00113             break;
00114         case 0x03:
00115             axis355_sens = 15.6e-6;
00116             axis357_sens = 78e-6;
00117             break;
00118         }
00119 }
00120 /** ----------------------------------- */
00121 /** Read the STATUS registers           */
00122 /** ----------------------------------- */
00123 uint8_t ADXL355::read_status(){
00124     return read_reg(STATUS);
00125 }
00126 /** ----------------------------------- */
00127 /** ADXL must be set in measurement     */
00128 /** mode to read the data registers     */
00129 /** ----------------------------------- */
00130 uint32_t ADXL355::scanx(){
00131     return read_reg_u20(XDATA3);
00132 }
00133 uint32_t ADXL355::scany(){
00134     return read_reg_u20(YDATA3);
00135 }
00136 uint32_t ADXL355::scanz(){
00137     return read_reg_u20(ZDATA3);
00138 }
00139 uint16_t ADXL355::scant(){
00140     return read_reg_u16(TEMP2);
00141 }
00142 /** ----------------------------------- */
00143 /** Activity SetUp - the measured       */
00144 /** acceleration on any axis is above   */ 
00145 /** the ACT_THRESH bits for ACT_COUNT   */
00146 /** consecutive measurements.           */
00147 /** ----------------------------------- */
00148 
00149 void ADXL355::set_activity_axis(ADXL355_act_ctl_t axis) {
00150     write_reg(ACT_EN, axis);
00151 }
00152 void ADXL355::set_activity_cnt(uint8_t count) {
00153     write_reg(ACT_COUNT, count);
00154 }
00155 void ADXL355::set_activity_threshold(uint8_t data_h, uint8_t data_l) {
00156     uint16_t ret_val = static_cast<uint16_t>((data_h<<8)|data_l);
00157     write_reg_u16(ACT_THRESH_H, ret_val);
00158 }
00159 void ADXL355::set_inactivity() {
00160     write_reg(ACT_EN, 0x00);
00161 }
00162 /** ----------------------------------- */
00163 /** ----------------------------------- */
00164 void ADXL355::set_interrupt1_pin(PinName in, ADXL355_intmap_ctl_t mode) {}
00165 void ADXL355::set_interrupt2_pin(PinName in, ADXL355_intmap_ctl_t mode) {}
00166 void ADXL355::enable_interrupt1() {}
00167 void ADXL355::enable_interrupt2() {}
00168 void ADXL355::disable_interrupt1() {}
00169 void ADXL355::disable_interrupt2() {}
00170 void ADXL355::set_polling_interrupt1_pin(uint8_t data) {}
00171 void ADXL355::set_polling_interrupt2_pin(uint8_t data) {}
00172 bool get_int1() {}
00173 bool get_int2() {}
00174 /** ----------------------------------- */
00175 /** FIFO set up and read operation      */
00176 /** ----------------------------------- */
00177 uint8_t ADXL355::fifo_read_nr_of_entries(){
00178     return read_reg(FIFO_ENTRIES);
00179 }
00180 void ADXL355::fifo_setup(uint8_t nr_of_entries){
00181     if (nr_of_entries > 0x60) {
00182         nr_of_entries = nr_of_entries;
00183     }
00184     write_reg(FIFO_SAMPLES, nr_of_entries);
00185 }    
00186 uint32_t ADXL355::fifo_read_u32() {
00187     uint32_t ret_val = 0;
00188     adxl355.format(8, _SPI_MODE);
00189     cs = false;
00190     adxl355.write(_READ_FIFO_CMD);
00191     ret_val = adxl355.write(_DUMMY_BYTE);
00192     ret_val = (ret_val<<8) | static_cast<uint8_t>(adxl355.write(_DUMMY_BYTE));
00193     ret_val = (ret_val<<4) | static_cast<uint8_t>(adxl355.write(_DUMMY_BYTE)>>4);
00194     cs = true;
00195     return ret_val;
00196     }
00197 uint64_t ADXL355::fifo_scan() {
00198     uint64_t ret_val = 0;
00199     uint32_t x = 0, y = 0, z = 0, dummy;
00200     adxl355.format(8, _SPI_MODE);
00201     cs = false;
00202     adxl355.write(_READ_FIFO_CMD);
00203     for(uint8_t i = 0; i < 3; i++) {
00204         dummy = adxl355.write(_DUMMY_BYTE);
00205         dummy = (dummy<<8) | static_cast<uint8_t>(adxl355.write(_DUMMY_BYTE));
00206         dummy = (dummy<<4) | static_cast<uint8_t>(adxl355.write(_DUMMY_BYTE)>>4);
00207         dummy = dummy & 0xffff;
00208         switch(i) {
00209             case 0: // x
00210                 x = dummy;
00211                 break;
00212             case 1: // y
00213                 y = dummy;
00214                 break;
00215             case 2: // z
00216                 z = dummy;
00217                 break;
00218         }
00219     } 
00220     cs = true;
00221     // format (24)xx(24)yy(24)zz
00222     ret_val = static_cast<uint64_t> (x) << 48;
00223     ret_val |= static_cast<uint64_t>(y) << 24;
00224     ret_val |= static_cast<uint64_t>(z) ;
00225     return ret_val;
00226 }
00227 /** ----------------------------------- */
00228 /** CALIBRATION AND CONVERSION          */
00229 /** ----------------------------------- */    
00230 float ADXL355::convert(uint32_t data){
00231     // If a positive value, return it
00232     if ((data & 0x80000) == 0)
00233     {
00234         return float(data);
00235     }
00236     //uint32_t rawValue = data<<(32-nbit);
00237     // Otherwise perform the 2's complement math on the value
00238     return float((~(data - 0x01)) & 0xfffff) * -1;
00239 }
00240 ADXL355::ADXL355_calibdata_t ADXL355::convert_2p(float angle[11][2], float meas[11][2])
00241 {
00242     ADXL355_calibdata_t res;
00243     for(int i=0; i<3; i++)
00244     { 
00245         res.S[i][i]= (angle[i][1]-angle[i][0])/(meas[i][1]-meas[i][0]);
00246         res.B[i][0]= (angle[i][0]*meas[i][1]-angle[i][1]*meas[i][0])/(meas[i][1]-meas[i][0]);
00247     }
00248     return res;
00249 }
00250 ADXL355::ADXL355_calibdata_t ADXL355::convert_3to8p(float angle[11][2], float meas[11][2], int count){}
00251 ADXL355::ADXL355_calibdata_t ADXL355::convert_12p(float angle[11][2], float meas[11][2]){}