src/lib/GSENSOR/stk8baxx.cpp

   1 #include "targets.h"
   2
   3 #include <Wire.h>
   4 #include "stk8baxx.h"
   5 #include "logging.h"
   6
   7 #define PID_SIZE        16
   8 uint8_t chipid_temp = 0x00;
   9 uint8_t stk8xxx_pid_list[PID_SIZE] = {STK8xxx_CHIPID_VAL, STK8BA50_X_CHIPID_VAL, STK8BA5X_CHIPID_VAL, STK8327_CHIPID_VAL};
  10
  11 void STK8xxx::ReadAccRegister(uint8_t reg, uint8_t *data)
  12 {
  13     Wire.beginTransmission(STK8xxx_SLAVE_ADDRESS);
  14     Wire.write(reg);
  15     Wire.endTransmission();
  16
  17     Wire.requestFrom(STK8xxx_SLAVE_ADDRESS, 1);    // request 1 bytes from slave device
  18     *data = Wire.read(); // receive a byte
  19 }
  20
  21 void STK8xxx::WriteAccRegister(uint8_t reg, uint8_t data)
  22 {
  23     Wire.beginTransmission(STK8xxx_SLAVE_ADDRESS);
  24     Wire.write(reg);
  25     Wire.write(data);
  26     Wire.endTransmission();
  27 }
  28
  29 /*
  30  * Anymotion init register
  31  * Must be placed after the software reset
  32  *
  33  */
  34 void STK8xxx::STK8xxx_Anymotion_init()
  35 {
  36         unsigned char ARegAddr, ARegWriteValue;
  37
  38         /* Enable X Y Z-axis any-motion (slope) interrupt */
  39     ARegAddr       = STK8xxx_REG_INTEN1;
  40     ARegWriteValue = STK8xxx_VAL_SLP_EN_X | STK8xxx_VAL_SLP_EN_Y | STK8xxx_VAL_SLP_EN_Z;
  41     WriteAccRegister(ARegAddr, ARegWriteValue);
  42
  43         /* Set anymotion Interrupt trigger threshold */
  44     ARegAddr       = STK8xxx_REG_SLOPETHD;
  45     ARegWriteValue = STK8xxx_VAL_SLP_DFLT;
  46     WriteAccRegister(ARegAddr, ARegWriteValue);
  47
  48         /* Enable any-motion */
  49     ARegAddr       = STK8xxx_REG_SIGMOT2;
  50     ARegWriteValue = STK8xxx_VAL_ANY_MOT_EN;
  51     WriteAccRegister(ARegAddr, ARegWriteValue);
  52
  53         /* Map any-motion (slope) interrupt to INT1 */
  54     ARegAddr       = STK8xxx_REG_INTMAP1;
  55     ARegWriteValue = STK8xxx_VAL_ANYMOT2INT1;
  56     WriteAccRegister(ARegAddr, ARegWriteValue);
  57 }
  58
  59 /*
  60  * Sigmotion init register
  61  * Must be placed after the software reset
  62  *
  63  */
  64 void STK8xxx::STK8xxx_Sigmotion_init()
  65 {
  66         unsigned char SRegAddr, SRegWriteValue;
  67
  68         /* Enable X Y Z-axis sig-motion (slope) interrupt */
  69     SRegAddr       = STK8xxx_REG_INTEN1;
  70     SRegWriteValue = STK8xxx_VAL_SLP_EN_X | STK8xxx_VAL_SLP_EN_Y | STK8xxx_VAL_SLP_EN_Z;
  71     WriteAccRegister(SRegAddr, SRegWriteValue);
  72
  73         /* Set sig-motion Interrupt trigger threshold */
  74     SRegAddr       = STK8xxx_REG_SLOPETHD;
  75     SRegWriteValue = STK8xxx_VAL_SLP_DFLT;
  76     WriteAccRegister(SRegAddr, SRegWriteValue);
  77
  78         /* Enable significant motion */
  79     SRegAddr       = STK8xxx_REG_SIGMOT2;
  80     SRegWriteValue = STK8xxx_VAL_SIG_MOT_EN;
  81     WriteAccRegister(SRegAddr, SRegWriteValue);
  82
  83         /* Map significant motion interrupt to INT1 */
  84     SRegAddr       = STK8xxx_REG_INTMAP1;
  85     SRegWriteValue = STK8xxx_VAL_SIGMOT2INT1;
  86     WriteAccRegister(SRegAddr, SRegWriteValue);
  87 }
  88
  89 /*
  90  * Diable motion register
  91  * Must be placed after the software reset
  92  *
  93  */
  94 void STK8xxx::STK8xxx_Disable_Motion()
  95 {
  96         unsigned char ARegAddr, ARegWriteValue;
  97
  98         /* Disable X Y Z-axis motion (slope) interrupt */
  99     ARegAddr       = STK8xxx_REG_INTEN1;
 100     ARegWriteValue = 0x00;
 101     WriteAccRegister(ARegAddr, ARegWriteValue);
 102
 103         /* Disable motion */
 104     ARegAddr       = STK8xxx_REG_SIGMOT2;
 105     ARegWriteValue = 0x00;
 106     WriteAccRegister(ARegAddr, ARegWriteValue);
 107 }
 108
 109
 110 /* Disable Gsensor */
 111 void STK8xxx::STK8xxx_Suspend_mode()
 112 {
 113         unsigned char RegAddr, RegWriteValue;
 114
 115     /* suspend mode enable */
 116         RegAddr       = STK8xxx_REG_POWMODE;
 117     RegWriteValue = STK8xxx_VAL_SUSPEND;
 118     WriteAccRegister(RegAddr, RegWriteValue);
 119 }
 120
 121 bool STK8xxx::STK8xxx_Check_chipid()
 122 {
 123         uint8_t RegAddr = STK_REG_CHIPID;
 124     int i = 0, pid_num = (sizeof(stk8xxx_pid_list) / sizeof(stk8xxx_pid_list[0]));
 125
 126     ReadAccRegister(RegAddr, &chipid_temp);
 127     for (i = 0; i < pid_num; i++)
 128     {
 129         if (chipid_temp == stk8xxx_pid_list[i])
 130         {
 131                 DBGLN("read stkchip id ok, chip_id = 0x%x", chipid_temp);
 132             return true;
 133         }
 134     }
 135         ERRLN("read stkchip id fail!");
 136     return false;
 137 }
 138
 139 /*
 140  * Initializes an example function
 141  * The initial configuration is in active mode.
 142  * STK8xxx is in the gear of ODR=2000Hz, and the range is set to +/-4G
 143  *
 144  */
 145 int STK8xxx::STK8xxx_Initialization()
 146 {
 147     unsigned char RegAddr, RegWriteValue;
 148
 149         if(!STK8xxx_Check_chipid())
 150         {
 151                 return -1;
 152     }
 153
 154     /* soft-reset */
 155         RegAddr       = STK8xxx_REG_SWRST;
 156     RegWriteValue = STK8xxx_VAL_RST_DFLTS;
 157     WriteAccRegister(RegAddr, RegWriteValue);
 158         delay(50);//unit ms
 159
 160     /* set range, resolution */
 161     RegAddr       = STK8xxx_REG_RANGESEL;
 162     RegWriteValue = STK8xxx_RANGE_4G; // range = +/-4g
 163     WriteAccRegister(RegAddr, RegWriteValue);
 164
 165         /* set power mode */
 166         RegAddr           = STK8xxx_REG_POWMODE;
 167         RegWriteValue = STK8xxx_VAL_SLEEP_05;   // active mode
 168         WriteAccRegister(RegAddr, RegWriteValue);
 169
 170         /* set bandwidth */
 171     RegAddr       = STK8xxx_REG_BWSEL;
 172     RegWriteValue = STK8xxx_VAL_BW_1000; // bandwidth = 1000Hz
 173     WriteAccRegister(RegAddr, RegWriteValue);
 174
 175         //STK8xxx_Anymotion_init();
 176         //STK8xxx_Sigmotion_init();
 177
 178     /* set i2c watch dog */
 179     RegAddr       = STK8xxx_REG_INTFCFG;
 180     RegWriteValue = STK8xxx_VAL_I2C_WDT_EN; // enable watch dog
 181     WriteAccRegister(RegAddr, RegWriteValue);
 182
 183     /* int config */
 184     RegAddr       = STK8xxx_REG_INTCFG1;
 185     RegWriteValue = STK8xxx_VAL_INT_LV; // INT1/INT2 push-pull, active high
 186     WriteAccRegister(RegAddr, RegWriteValue);
 187
 188         return chipid_temp;
 189 }
 190
 191 int STK8xxx::STK8xxx_Get_Sensitivity()
 192 {
 193     int sensitivity = 0;
 194         if(0x86 == chipid_temp)
 195         {
 196            //resolution = 10 bit
 197        sensitivity = 1 << 9;
 198         }
 199     else
 200     {
 201        //resolution = 12 bit
 202        sensitivity = 1 << 11;
 203         }
 204     //range = +/-4g
 205     sensitivity = sensitivity / 4;
 206     return sensitivity;
 207 }
 208
 209 /* Read data from registers */
 210 void STK8xxx::STK8xxx_Getregister_data(float *X_DataOut, float *Y_DataOut, float *Z_DataOut)
 211 {
 212     uint8_t RegAddr, RegReadValue[2];
 213     int16_t x, y, z;
 214
 215     RegAddr             = STK8xxx_REG_XOUT1;
 216     RegReadValue[0] = 0x00;
 217         ReadAccRegister(RegAddr, &RegReadValue[0]);
 218     RegAddr             = STK8xxx_REG_XOUT2;
 219     RegReadValue[1] = 0x00;
 220         ReadAccRegister(RegAddr, &RegReadValue[1]);
 221         x = (short int)(RegReadValue[1] << 8 | RegReadValue[0]);
 222
 223         RegAddr         = STK8xxx_REG_YOUT1;
 224     RegReadValue[0] = 0x00;
 225         ReadAccRegister(RegAddr, &RegReadValue[0]);
 226     RegAddr             = STK8xxx_REG_YOUT2;
 227     RegReadValue[1] = 0x00;
 228         ReadAccRegister(RegAddr, &RegReadValue[1]);
 229         y = (short int)(RegReadValue[1] << 8 | RegReadValue[0]);
 230
 231         RegAddr         = STK8xxx_REG_ZOUT1;
 232     RegReadValue[0] = 0x00;
 233         ReadAccRegister(RegAddr, &RegReadValue[0]);
 234     RegAddr             = STK8xxx_REG_ZOUT2;
 235     RegReadValue[1] = 0x00;
 236         ReadAccRegister(RegAddr, &RegReadValue[1]);
 237         z = (short int)(RegReadValue[1] << 8 | RegReadValue[0]);
 238
 239         if(0x86 == chipid_temp)
 240         {
 241                 //resolution = 10 bit
 242         x >>= 6;
 243         *X_DataOut = (float) x / STK8xxx_Get_Sensitivity();
 244
 245         y >>= 6;
 246         *Y_DataOut = (float) y / STK8xxx_Get_Sensitivity();
 247
 248         z >>= 6;
 249         *Z_DataOut = (float) z / STK8xxx_Get_Sensitivity();
 250         }
 251     else
 252     {
 253         //resolution = 12 bit
 254         x >>= 4;
 255         *X_DataOut = (float) x / STK8xxx_Get_Sensitivity();
 256
 257         y >>= 4;
 258         *Y_DataOut = (float) y / STK8xxx_Get_Sensitivity();
 259
 260         z >>= 4;
 261         *Z_DataOut = (float) z / STK8xxx_Get_Sensitivity();
 262         }
 263 }