/****************************************************************** * Senodia 6D IMU(Gyroscope+Accelerometer) SH3001 driver, By Senodia AE; * * * 1. unsigned char SH3001_init(void) : SH3001 initialize function * 2. void SH3001_GetImuData( ... ): SH3001 read gyro and accel data function * 3. float SH3001_GetTempData(void)£ºSH3001 read termperature function * 4. void SH3001_pre_INT_config(void): Before using other INT config functions, need to call the function * * For example: set accelerometer data ready INT * SH3001_pre_INT_config(); * * SH3001_INT_Config( SH3001_INT0_LEVEL_HIGH, * SH3001_INT_NO_LATCH, * SH3001_INT1_LEVEL_HIGH, * SH3001_INT_CLEAR_STATUS, * SH3001_INT1_NORMAL, * SH3001_INT0_NORMAL, * 3); * * SH3001_INT_Enable( SH3001_INT_ACC_READY, * SH3001_INT_ENABLE, * SH3001_INT_MAP_INT); * * 5. void SH3001_INT_Flat_Config( unsigned char flatTimeTH, unsigned char flatTanHeta2)£º * If using the function, need to config SH3001_INT_Orient_Config( ... ) function. * * 6. delay_ms(x): delay x millisecond. * * 7. New version SH3001: SH3001_CHIP_ID1(0xDF) = 0x61; * SH3001_CompInit(... ): initialize compensation coefficients; * SH3001_GetImuCompData( ... ): SH3001 read gyro and accel compensation data function * * ******************************************************************/ #include "app_config.h" #include "asm/clock.h" #include "asm/cpu.h" #include "generic/typedef.h" #include "generic/gpio.h" #include "typedef.h" #include "system/includes.h" #include "media/includes.h" #include "asm/iic_hw.h" #include "asm/iic_soft.h" #include "asm/timer.h" #include "sh3001.h" #include "imuSensor_manage.h" #if TCFG_SH3001_ENABLE /*************Betterlife ic debug***********/ #undef LOG_TAG_CONST #define LOG_TAG "[sh3001]" #define LOG_ERROR_ENABLE #define LOG_INFO_ENABLE #include "debug.h" void delay(volatile u32 t); void udelay(u32 us); #define MDELAY(n) mdelay(n) static sh3001_param *sh3001_info; // static SH3001_data SH3001_raw_data={0}; /****************************************************************** * Description: I2C or SPI bus interface functions and delay time function * * Parameters: * devAddr: I2C device address, modify the macro(SH3001_ADDRESS @SH3001.h) based on your I2C function. * If SPI interface, please ingnore the parameter. * regAddr: register address * readLen: data length to read * *readBuf: data buffer to read * writeLen: data length to write * *writeBuf: data buffer to write * ******************************************************************/ #if (SH3001_USER_INTERFACE==0) #if TCFG_SH3001_USER_IIC_TYPE #define iic_init(iic) hw_iic_init(iic) #define iic_uninit(iic) hw_iic_uninit(iic) #define iic_start(iic) hw_iic_start(iic) #define iic_stop(iic) hw_iic_stop(iic) #define iic_tx_byte(iic, byte) hw_iic_tx_byte(iic, byte) #define iic_rx_byte(iic, ack) hw_iic_rx_byte(iic, ack) #define iic_read_buf(iic, buf, len) hw_iic_read_buf(iic, buf, len) #define iic_write_buf(iic, buf, len) hw_iic_write_buf(iic, buf, len) #define iic_suspend(iic) hw_iic_suspend(iic) #define iic_resume(iic) hw_iic_resume(iic) #else #define iic_init(iic) soft_iic_init(iic) #define iic_uninit(iic) soft_iic_uninit(iic) #define iic_start(iic) soft_iic_start(iic) #define iic_stop(iic) soft_iic_stop(iic) #define iic_tx_byte(iic, byte) soft_iic_tx_byte(iic, byte) #define iic_rx_byte(iic, ack) soft_iic_rx_byte(iic, ack) #define iic_read_buf(iic, buf, len) soft_iic_read_buf(iic, buf, len) #define iic_write_buf(iic, buf, len) soft_iic_write_buf(iic, buf, len) #define iic_suspend(iic) soft_iic_suspend(iic) #define iic_resume(iic) soft_iic_resume(iic) #endif //return: readLen:ok, other:fail unsigned char I2C_Read_NBytes(unsigned char devAddr, unsigned char regAddr, unsigned char readLen, unsigned char *readBuf) { u8 i = 0; iic_start(sh3001_info->iic_hdl); if (0 == iic_tx_byte(sh3001_info->iic_hdl, devAddr)) { log_error("sh3001 iic read err1"); iic_stop(sh3001_info->iic_hdl); return 0; } delay(sh3001_info->iic_delay); if (0 == iic_tx_byte(sh3001_info->iic_hdl, regAddr)) { log_error("sh3001 iic read err2"); iic_stop(sh3001_info->iic_hdl); return 0; } delay(sh3001_info->iic_delay); iic_start(sh3001_info->iic_hdl); if (0 == iic_tx_byte(sh3001_info->iic_hdl, devAddr + 1)) { log_error("sh3001 iic read err3"); iic_stop(sh3001_info->iic_hdl); return 0; } for (i = 0; i < readLen; i++) { delay(sh3001_info->iic_delay); if (i == (readLen - 1)) { *readBuf++ = iic_rx_byte(sh3001_info->iic_hdl, 0); } else { *readBuf++ = iic_rx_byte(sh3001_info->iic_hdl, 1); } } iic_stop(sh3001_info->iic_hdl); return i; } unsigned char I2C_Write_NBytes(unsigned char devAddr, unsigned char regAddr, unsigned char writeLen, unsigned char *writeBuf) { u8 i; iic_start(sh3001_info->iic_hdl); if (0 == iic_tx_byte(sh3001_info->iic_hdl, devAddr)) { log_error("sh3001 iic write err1"); iic_stop(sh3001_info->iic_hdl); return 0; } delay(sh3001_info->iic_delay); if (0 == iic_tx_byte(sh3001_info->iic_hdl, regAddr)) { log_error("sh3001 iic write err2"); iic_stop(sh3001_info->iic_hdl); return 0; } for (i = 0; i < writeLen; i++) { delay(sh3001_info->iic_delay); if (0 == iic_tx_byte(sh3001_info->iic_hdl, writeBuf[i])) { log_error("sh3001 iic write err3:%d", i); iic_stop(sh3001_info->iic_hdl); return 0; } } iic_stop(sh3001_info->iic_hdl); return i; } IMU_read SH3001_read = I2C_Read_NBytes; IMU_write SH3001_write = I2C_Write_NBytes; #else #define spi_cs_init() \ do { \ gpio_write(sh3001_info->spi_cs_pin, 1); \ gpio_set_direction(sh3001_info->spi_cs_pin, 0); \ gpio_set_die(sh3001_info->spi_cs_pin, 1); \ } while (0) #define spi_cs_uninit() \ do { \ gpio_set_die(sh3001_info->spi_cs_pin, 0); \ gpio_set_direction(sh3001_info->spi_cs_pin, 1); \ gpio_set_pull_up(sh3001_info->spi_cs_pin, 0); \ gpio_set_pull_down(sh3001_info->spi_cs_pin, 0); \ } while (0) #define spi_cs_h() gpio_write(sh3001_info->spi_cs_pin, 1) #define spi_cs_l() gpio_write(sh3001_info->spi_cs_pin, 0) #define spi_read_byte() spi_recv_byte(sh3001_info->spi_hdl, NULL) #define spi_write_byte(x) spi_send_byte(sh3001_info->spi_hdl, x) #define spi_dma_read(x, y) spi_dma_recv(sh3001_info->spi_hdl, x, y) #define spi_dma_write(x, y) spi_dma_send(sh3001_info->spi_hdl, x, y) #define spi_set_width(x) spi_set_bit_mode(sh3001_info->spi_hdl, x) #define spi_init() spi_open(sh3001_info->spi_hdl) #define spi_closed() spi_close(sh3001_info->spi_hdl) #define spi_suspend() hw_spi_suspend(sh3001_info->spi_hdl) #define spi_resume() hw_spi_resume(sh3001_info->spi_hdl) unsigned char SPI_readNBytes(unsigned char devAddr, unsigned char regAddr, unsigned char readLen, unsigned char *readBuf) { unsigned char data; data = (regAddr > 0x7F) ? 0x01 : 0x00; spi_cs_l(); spi_write_byte(SH3001_SPI_REG_ACCESS); spi_write_byte(data); spi_cs_h(); delay(60); spi_cs_l(); spi_write_byte(regAddr | 0x80); spi_dma_read(readBuf, readLen); spi_cs_h(); //SPIWrite(SH3001_SPI_REG_ACCESS, &u8Data, 1); //SPIRead((regAddr | 0x80), readBuf, readLen); return (SH3001_TRUE); } unsigned char SPI_writeNBytes(unsigned char devAddr, unsigned char regAddr, unsigned char writeLen, unsigned char *writeBuf) { unsigned char data; data = (regAddr > 0x7F) ? 0x01 : 0x00; spi_cs_l(); spi_write_byte(SH3001_SPI_REG_ACCESS); spi_write_byte(data); spi_cs_h(); delay(60); spi_cs_l(); spi_write_byte(regAddr & 0x7F); spi_dma_write(writeBuf, writeLen); spi_cs_h(); //SPIWrite(SH3001_SPI_REG_ACCESS, &u8Data, 1); //SPIWrite((regAddr & 0x7F), writeBuf, writeLen); return (SH3001_TRUE); } IMU_read SH3001_read = SPI_readNBytes; IMU_write SH3001_write = SPI_writeNBytes; #endif void delay_ms(unsigned char mSecond) { //your delay code(mSecond: millisecond): MDELAY(mSecond); } /****************************************************************** * Description: Local Variable ******************************************************************/ static compCoefType compCoef; static unsigned char storeAccODR; /****************************************************************** * Description: Local Function Prototypes ******************************************************************/ static void SH3001_SoftReset(void); static void SH3001_ADCReset(void); static void SH3001_CVAReset(void); static void SH3001_DriveStart(void); static void SH3001_ModuleReset(void); static void SH3001_Acc_Config(unsigned char accODR, unsigned char accRange, unsigned char accCutOffRreq, unsigned char accFilterEnble); static void SH3001_Gyro_Config(unsigned char gyroODR, unsigned char gyroRangeX, unsigned char gyroRangeY, unsigned char gyroRangeZ, unsigned char gyroCutOffRreq, unsigned char gyroFilterEnble); static void SH3001_Temp_Config(unsigned char tempODR, unsigned char tempEnable); static void SH3001_CompInit(compCoefType *compCoef); /****************************************************************** * Description: reset Register; * * Parameters: void * * return: void * ******************************************************************/ static void SH3001_SoftReset(void) { unsigned char regData = 0; regData = 0x84; SH3001_write(SH3001_ADDRESS, 0xD4, 1, ®Data); delay_ms(1); regData = 0x04; SH3001_write(SH3001_ADDRESS, 0xD4, 1, ®Data); delay_ms(1); regData = 0x08; SH3001_write(SH3001_ADDRESS, 0x2F, 1, ®Data); delay_ms(1); regData = 0x73; SH3001_write(SH3001_ADDRESS, 0x00, 1, ®Data); delay_ms(50); } /****************************************************************** * Description: SH3001_DriveStart function; * * Parameters: void * * return: void * ******************************************************************/ static void SH3001_DriveStart(void) { unsigned char regAddr[3] = {0x2E, 0xC0, 0xC1}; unsigned char regData[3] = {0}; unsigned char regDataBack[3] = {0}; unsigned char i = 0; for (i = 0; i < 3; i++) { SH3001_read(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } regDataBack[0] = 0xBF; regDataBack[1] = 0x38; regDataBack[2] = 0xFF; for (i = 0; i < 3; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®DataBack[i]); } delay_ms(100); for (i = 0; i < 3; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]);; } delay_ms(50); } /****************************************************************** * Description: reset ADC; * * Parameters: void * * return: void * ******************************************************************/ static void SH3001_ADCReset(void) { unsigned char regAddr[2] = {0xD3, 0xD5}; unsigned char regData[2] = {0}; unsigned char i = 0; for (i = 0; i < 2; i++) { SH3001_read(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } regData[0] = (regData[0] & 0xFC) | 0x01; regData[1] = (regData[1] & 0xF9) | 0x02; SH3001_write(SH3001_ADDRESS, 0xD5, 1, ®Data[1]); SH3001_write(SH3001_ADDRESS, 0xD3, 1, ®Data[0]); delay_ms(1); regData[0] = (regData[0] & 0xFC) | 0x02; SH3001_write(SH3001_ADDRESS, 0xD3, 1, ®Data[0]); delay_ms(1); regData[1] = (regData[1] & 0xF9); SH3001_write(SH3001_ADDRESS, 0xD5, 1, ®Data[1]); delay_ms(50); } /****************************************************************** * Description: reset CVA; * * Parameters: void * * return: void * ******************************************************************/ static void SH3001_CVAReset(void) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, 0xD4, 1, ®Data); regData |= 0x08; SH3001_write(SH3001_ADDRESS, 0xD4, 1, ®Data); delay_ms(10); regData &= 0xF7; SH3001_write(SH3001_ADDRESS, 0xD4, 1, ®Data); } /****************************************************************** * Description: reset some internal modules; * * Parameters: void * * return: void * ******************************************************************/ static void SH3001_ModuleReset(void) { //unsigned char regData = 0; SH3001_SoftReset(); #if (SH3001_USER_INTERFACE) if (sh3001_info->spi_work_mode) { SH3001_SPI_Config(SH3001_SPI_3_WIRE); } else { SH3001_SPI_Config(SH3001_SPI_4_WIRE); } #endif SH3001_DriveStart(); SH3001_ADCReset(); SH3001_CVAReset(); //set INT and INT1 Pin to Open-drain, in order to measure chip current //regData = 0x00; //SH3001_write(SH3001_ADDRESS, 0x44, 1, ®Data); } /****************************************************************** * Description: 1.Switch SH3001 power mode; * 2.Normal mode: 1.65mA; Sleep mode: 162uA; Acc normal mode:393uA; * * Parameters: powerMode * SH3001_NORMAL_MODE * SH3001_SLEEP_MODE * SH3001_POWERDOWN_MODE * SH3001_ACC_NORMAL_MODE * * return: SH3001_FALSE or SH3001_TRUE * ******************************************************************/ unsigned char SH3001_SwitchPowerMode(unsigned char powerMode) { unsigned char regAddr[11] = {0xCF, 0x22, 0x2F, 0xCB, 0xCE, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8}; unsigned char regData[11] = {0}; unsigned char i = 0; unsigned char accODR = SH3001_ODR_1000HZ; if ((powerMode != SH3001_NORMAL_MODE) && (powerMode != SH3001_SLEEP_MODE) && (powerMode != SH3001_POWERDOWN_MODE) && (powerMode != SH3001_ACC_NORMAL_MODE)) { return (SH3001_FALSE); } for (i = 0; i < 11; i++) { SH3001_read(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } switch (powerMode) { case SH3001_NORMAL_MODE: // restore accODR SH3001_write(SH3001_ADDRESS, SH3001_ACC_CONF1, 1, &storeAccODR); regData[0] = (regData[0] & 0xF8); regData[1] = (regData[1] & 0x7F); regData[2] = (regData[2] & 0xF7); regData[3] = (regData[3] & 0xF7); regData[4] = (regData[4] & 0xFE); regData[5] = (regData[5] & 0xFC) | 0x02; regData[6] = (regData[6] & 0x9F); regData[7] = (regData[7] & 0xF9); regData[10] = (regData[10] & 0xF7); for (i = 0; i < 8; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } SH3001_write(SH3001_ADDRESS, regAddr[10], 1, ®Data[10]); regData[7] = (regData[7] & 0x87); regData[8] = (regData[8] & 0x1F); regData[9] = (regData[9] & 0x03); regData[10] = (regData[10] & 0x1F); for (i = 7; i < 11; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } SH3001_DriveStart(); SH3001_ADCReset(); SH3001_CVAReset(); return (SH3001_TRUE); case SH3001_SLEEP_MODE: // store current acc ODR SH3001_read(SH3001_ADDRESS, SH3001_ACC_CONF1, 1, &storeAccODR); // set acc ODR=1000Hz SH3001_write(SH3001_ADDRESS, SH3001_ACC_CONF1, 1, &accODR); regData[0] = (regData[0] & 0xF8) | 0x07; regData[1] = (regData[1] & 0x7F) | 0x80; regData[2] = (regData[2] & 0xF7) | 0x08; regData[3] = (regData[3] & 0xF7) | 0x08; regData[4] = (regData[4] & 0xFE); regData[5] = (regData[5] & 0xFC) | 0x01; regData[6] = (regData[6] & 0x9F); regData[7] = (regData[7] & 0xF9) | 0x06; regData[10] = (regData[10] & 0xF7); for (i = 0; i < 8; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } SH3001_write(SH3001_ADDRESS, regAddr[10], 1, ®Data[10]); regData[7] = (regData[7] & 0x87); regData[8] = (regData[8] & 0x1F); regData[9] = (regData[9] & 0x03); regData[10] = (regData[10] & 0x1F); for (i = 7; i < 11; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } return (SH3001_TRUE); case SH3001_POWERDOWN_MODE: regData[0] = (regData[0] & 0xF8); regData[1] = (regData[1] & 0x7F) | 0x80; regData[2] = (regData[2] & 0xF7) | 0x08; regData[3] = (regData[3] & 0xF7) | 0x08; regData[4] = (regData[4] & 0xFE); regData[5] = (regData[5] & 0xFC) | 0x01; regData[6] = (regData[6] & 0x9F) | 0x60; regData[7] = (regData[7] & 0xF9) | 0x06; regData[10] = (regData[10] & 0xF7); for (i = 0; i < 8; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } SH3001_write(SH3001_ADDRESS, regAddr[10], 1, ®Data[10]); regData[7] = (regData[7] & 0x87); regData[8] = (regData[8] & 0x1F); regData[9] = (regData[9] & 0x03); regData[10] = (regData[10] & 0x1F) | 0xE0; for (i = 7; i < 11; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } return (SH3001_TRUE); case SH3001_ACC_NORMAL_MODE: regData[0] = (regData[0] & 0xF8); regData[1] = (regData[1] & 0x7F); regData[2] = (regData[2] & 0xF7); regData[3] = (regData[3] & 0xF7); regData[4] = (regData[4] | 0x01); regData[5] = (regData[5] & 0xFC) | 0x01; regData[6] = (regData[6] & 0x9F); regData[7] = (regData[7] & 0xF9) | 0x06; regData[10] = (regData[10] & 0xF7); for (i = 0; i < 8; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } SH3001_write(SH3001_ADDRESS, regAddr[10], 1, ®Data[10]); regData[7] = (regData[7] & 0x87) | 0x78; regData[8] = (regData[8] & 0x1F) | 0xE0; regData[9] = (regData[9] & 0x03) | 0xFC; regData[10] = (regData[10] & 0x1F); for (i = 7; i < 11; i++) { SH3001_write(SH3001_ADDRESS, regAddr[i], 1, ®Data[i]); } return (SH3001_TRUE); default: return (SH3001_FALSE); } } /****************************************************************** * Description: 1.set accelerometer parameters; * 2.accCutOffRreq = accODR * 0.40 or accODR * 0.25 or accODR * 0.11 or accODR * 0.04; * * Parameters: accODR accRange accCutOffFreq accFilterEnble * SH3001_ODR_1000HZ SH3001_ACC_RANGE_16G SH3001_ACC_ODRX040 SH3001_ACC_FILTER_EN * SH3001_ODR_500HZ SH3001_ACC_RANGE_8G SH3001_ACC_ODRX025 SH3001_ACC_FILTER_DIS * SH3001_ODR_250HZ SH3001_ACC_RANGE_4G SH3001_ACC_ODRX011 * SH3001_ODR_125HZ SH3001_ACC_RANGE_2G SH3001_ACC_ODRX004 * SH3001_ODR_63HZ * SH3001_ODR_31HZ * SH3001_ODR_16HZ * SH3001_ODR_2000HZ * SH3001_ODR_4000HZ * SH3001_ODR_8000HZ * * return: void * ******************************************************************/ static void SH3001_Acc_Config(unsigned char accODR, unsigned char accRange, unsigned char accCutOffFreq, unsigned char accFilterEnble) { unsigned char regData = 0; // enable acc digital filter SH3001_read(SH3001_ADDRESS, SH3001_ACC_CONF0, 1, ®Data); regData |= 0x01; SH3001_write(SH3001_ADDRESS, SH3001_ACC_CONF0, 1, ®Data); // set acc ODR storeAccODR = accODR; SH3001_write(SH3001_ADDRESS, SH3001_ACC_CONF1, 1, &accODR); // set acc Range SH3001_write(SH3001_ADDRESS, SH3001_ACC_CONF2, 1, &accRange); // bypass acc low pass filter or not SH3001_read(SH3001_ADDRESS, SH3001_ACC_CONF3, 1, ®Data); regData &= 0x17; regData |= (accCutOffFreq | accFilterEnble); SH3001_write(SH3001_ADDRESS, SH3001_ACC_CONF3, 1, ®Data); } /****************************************************************** * Description: 1.set gyroscope parameters; * 2.gyroCutOffRreq is at Page 32 of SH3001 datasheet. * * Parameters: gyroODR gyroRangeX,Y,Z gyroCutOffFreq gyroFilterEnble * SH3001_ODR_1000HZ SH3001_GYRO_RANGE_125 SH3001_GYRO_ODRX00 SH3001_GYRO_FILTER_EN * SH3001_ODR_500HZ SH3001_GYRO_RANGE_250 SH3001_GYRO_ODRX01 SH3001_GYRO_FILTER_DIS * SH3001_ODR_250HZ SH3001_GYRO_RANGE_500 SH3001_GYRO_ODRX02 * SH3001_ODR_125HZ SH3001_GYRO_RANGE_1000 SH3001_GYRO_ODRX03 * SH3001_ODR_63HZ SH3001_GYRO_RANGE_2000 * SH3001_ODR_31HZ * SH3001_ODR_16HZ * SH3001_ODR_2000HZ * SH3001_ODR_4000HZ * SH3001_ODR_8000HZ * SH3001_ODR_16000HZ * SH3001_ODR_32000HZ * * return: void * ******************************************************************/ static void SH3001_Gyro_Config(unsigned char gyroODR, unsigned char gyroRangeX, unsigned char gyroRangeY, unsigned char gyroRangeZ, unsigned char gyroCutOffFreq, unsigned char gyroFilterEnble) { unsigned char regData = 0; // enable gyro digital filter SH3001_read(SH3001_ADDRESS, SH3001_GYRO_CONF0, 1, ®Data); regData |= 0x01; SH3001_write(SH3001_ADDRESS, SH3001_GYRO_CONF0, 1, ®Data); // set gyro ODR SH3001_write(SH3001_ADDRESS, SH3001_GYRO_CONF1, 1, &gyroODR); // set gyro X\Y\Z range SH3001_write(SH3001_ADDRESS, SH3001_GYRO_CONF3, 1, &gyroRangeX); SH3001_write(SH3001_ADDRESS, SH3001_GYRO_CONF4, 1, &gyroRangeY); SH3001_write(SH3001_ADDRESS, SH3001_GYRO_CONF5, 1, &gyroRangeZ); // bypass gyro low pass filter or not SH3001_read(SH3001_ADDRESS, SH3001_GYRO_CONF2, 1, ®Data); regData &= 0xE3; regData |= (gyroCutOffFreq | gyroFilterEnble); SH3001_write(SH3001_ADDRESS, SH3001_GYRO_CONF2, 1, ®Data); } /****************************************************************** * Description: set temperature parameters; * * Parameters: tempODR tempEnable * SH3001_TEMP_ODR_500 SH3001_TEMP_EN * SH3001_TEMP_ODR_250 SH3001_TEMP_DIS * SH3001_TEMP_ODR_125 * SH3001_TEMP_ODR_63 * * return: void * ******************************************************************/ static void SH3001_Temp_Config(unsigned char tempODR, unsigned char tempEnable) { unsigned char regData = 0; // enable temperature, set ODR SH3001_read(SH3001_ADDRESS, SH3001_TEMP_CONF0, 1, ®Data); regData &= 0x4F; regData |= (tempODR | tempEnable); SH3001_write(SH3001_ADDRESS, SH3001_TEMP_CONF0, 1, ®Data); } /****************************************************************** * Description: read temperature parameters; * * Parameters: void * * return: temperature data(deg); * ******************************************************************/ float SH3001_GetTempData(void) { unsigned char regData[2] = {0}; unsigned short int tempref[2] = {0}; // read temperature data, unsigned 12bits; SH3001_TEMP_CONF0..SH3001_TEMP_CONF1 SH3001_read(SH3001_ADDRESS, SH3001_TEMP_CONF0, 2, ®Data[0]); tempref[0] = ((unsigned short int)(regData[0] & 0x0F) << 8) | regData[1]; SH3001_read(SH3001_ADDRESS, SH3001_TEMP_ZL, 2, ®Data[0]); tempref[1] = ((unsigned short int)(regData[1] & 0x0F) << 8) | regData[0]; return ((((float)(tempref[1] - tempref[0])) / 16.0f) + 25.0f); } /****************************************************************** * Description: enable or disable INT, mapping interrupt to INT pin or INT1 pin * * Parameters: intType intEnable intPinSel * SH3001_INT_LOWG SH3001_INT_ENABLE SH3001_INT_MAP_INT * SH3001_INT_HIGHG SH3001_INT_DISABLE SH3001_INT_MAP_INT1 * SH3001_INT_INACT * SH3001_INT_ACT * SH3001_INT_DOUBLE_TAP * SH3001_INT_SINGLE_TAP * SH3001_INT_FLAT * SH3001_INT_ORIENTATION * SH3001_INT_FIFO_GYRO * SH3001_INT_GYRO_READY * SH3001_INT_ACC_FIFO * SH3001_INT_ACC_READY * SH3001_INT_FREE_FALL * SH3001_INT_UP_DOWN_Z * return: void * ******************************************************************/ void SH3001_INT_Enable(unsigned short int intType, unsigned char intEnable, unsigned char intPinSel) { unsigned char regData[2] = {0}; unsigned short int u16IntVal = 0, u16IntTemp = 0; // Z axis change between UP to DOWN if ((intType & 0x0040) == SH3001_INT_UP_DOWN_Z) { SH3001_read(SH3001_ADDRESS, SH3001_ORIEN_INTCONF0, 1, ®Data[0]); regData[0] = (intEnable == SH3001_INT_ENABLE) \ ? (regData[0] | 0x40) : (regData[0] & 0xBF); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INTCONF0, 1, ®Data[0]); } if ((intType & 0xFF1F)) { // enable or disable INT SH3001_read(SH3001_ADDRESS, SH3001_INT_ENABLE0, 2, ®Data[0]); u16IntVal = ((unsigned short int)regData[0] << 8) | regData[1]; u16IntVal = (intEnable == SH3001_INT_ENABLE) \ ? (u16IntVal | intType) : (u16IntVal & ~intType); regData[0] = (unsigned char)(u16IntVal >> 8); regData[1] = (unsigned char)(u16IntVal); SH3001_write(SH3001_ADDRESS, SH3001_INT_ENABLE0, 1, ®Data[0]); SH3001_write(SH3001_ADDRESS, SH3001_INT_ENABLE1, 1, ®Data[1]); // mapping interrupt to INT pin or INT1 pin SH3001_read(SH3001_ADDRESS, SH3001_INT_PIN_MAP0, 2, ®Data[0]); u16IntVal = ((unsigned short int)regData[0] << 8) | regData[1]; u16IntTemp = (intType << 1) & 0xE03E; u16IntTemp = u16IntTemp | (intType & 0x0F00); if (intType & SH3001_INT_LOWG) { u16IntTemp |= 0x0001; } u16IntVal = (intPinSel == SH3001_INT_MAP_INT1) \ ? (u16IntVal | u16IntTemp) : (u16IntVal & ~u16IntTemp); regData[0] = (unsigned char)(u16IntVal >> 8); regData[1] = (unsigned char)(u16IntVal); SH3001_write(SH3001_ADDRESS, SH3001_INT_PIN_MAP0, 1, ®Data[0]); SH3001_write(SH3001_ADDRESS, SH3001_INT_PIN_MAP1, 1, ®Data[1]); } } /****************************************************************** * Description: 1.config INT function * 2.intCount is valid only when intLatch is equal to SH3001_INT_NO_LATCH; * * Parameters: int0Level intLatch int1Level intClear * SH3001_INT0_LEVEL_HIGH SH3001_INT_NO_LATCH SH3001_INT1_LEVEL_HIGH SH3001_INT_CLEAR_ANY * SH3001_INT0_LEVEL_LOW SH3001_INT_LATCH SH3001_INT1_LEVEL_LOW SH3001_INT_CLEAR_STATUS * * * int1Mode int0Mode intTime * SH3001_INT1_NORMAL SH3001_INT0_NORMAL Unit: 2mS * SH3001_INT1_OD SH3001_INT0_OD * * return: void * ******************************************************************/ void SH3001_INT_Config(unsigned char int0Level, unsigned char intLatch, unsigned char int1Level, unsigned char intClear, unsigned char int1Mode, unsigned char int0Mode, unsigned char intTime) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_INT_CONF, 1, ®Data); regData = (int0Level == SH3001_INT0_LEVEL_LOW) \ ? (regData | SH3001_INT0_LEVEL_LOW) : (regData & SH3001_INT0_LEVEL_HIGH); regData = (intLatch == SH3001_INT_NO_LATCH) \ ? (regData | SH3001_INT_NO_LATCH) : (regData & SH3001_INT_LATCH); regData = (int1Level == SH3001_INT1_LEVEL_LOW) \ ? (regData | SH3001_INT1_LEVEL_LOW) : (regData & SH3001_INT1_LEVEL_HIGH); regData = (intClear == SH3001_INT_CLEAR_ANY) \ ? (regData | SH3001_INT_CLEAR_ANY) : (regData & SH3001_INT_CLEAR_STATUS); regData = (int1Mode == SH3001_INT1_NORMAL) \ ? (regData | SH3001_INT1_NORMAL) : (regData & SH3001_INT1_OD); regData = (int0Mode == SH3001_INT0_NORMAL) \ ? (regData | SH3001_INT0_NORMAL) : (regData & SH3001_INT0_OD); SH3001_write(SH3001_ADDRESS, SH3001_INT_CONF, 1, ®Data); if (intLatch == SH3001_INT_NO_LATCH) { if (intTime != 0) { regData = intTime; SH3001_write(SH3001_ADDRESS, SH3001_INT_LIMIT, 1, ®Data); } } } /****************************************************************** * Description: 1.lowG INT config; * 2.lowGThres: x=0.5mG@2G or x=1mG@4G or x=2mG@8G or x=4mG@16G * * Parameters: lowGEnDisIntAll lowGThres lowGTimsMs * SH3001_LOWG_ALL_INT_EN Unit: x mG Unit: 2mS * SH3001_LOWG_ALL_INT_DIS * * return: void * ******************************************************************/ void SH3001_INT_LowG_Config(unsigned char lowGEnDisIntAll, unsigned char lowGThres, unsigned char lowGTimsMs) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_HIGHLOW_G_INT_CONF, 1, ®Data); regData &= 0xFE; regData |= lowGEnDisIntAll; SH3001_write(SH3001_ADDRESS, SH3001_HIGHLOW_G_INT_CONF, 1, ®Data); regData = lowGThres; SH3001_write(SH3001_ADDRESS, SH3001_LOWG_INT_THRESHOLD, 1, ®Data); regData = lowGTimsMs; SH3001_write(SH3001_ADDRESS, SH3001_LOWG_INT_TIME, 1, ®Data); } /****************************************************************** * Description: 1.highG INT config; * 2.highGThres: x=0.5mG@2G, x=1mG@4G, x=2mG@8G, x=4mG@16G * * Parameters: highGEnDisIntX highGEnDisIntY highGEnDisIntZ * SH3001_HIGHG_X_INT_EN SH3001_HIGHG_Y_INT_EN SH3001_HIGHG_Z_INT_EN * SH3001_HIGHG_X_INT_DIS SH3001_HIGHG_Y_INT_DIS SH3001_HIGHG_Z_INT_DIS * * * highGEnDisIntAll highGThres highGTimsMs * SH3001_HIGHG_ALL_INT_EN Unit: x mG Unit: 2mS * SH3001_HIGHG_ALL_INT_DIS * * return: void * ******************************************************************/ void SH3001_INT_HighG_Config(unsigned char highGEnDisIntX, unsigned char highGEnDisIntY, unsigned char highGEnDisIntZ, unsigned char highGEnDisIntAll, unsigned char highGThres, unsigned char highGTimsMs) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_HIGHLOW_G_INT_CONF, 1, ®Data); regData &= 0x0F; regData |= highGEnDisIntX | highGEnDisIntY | highGEnDisIntZ | highGEnDisIntAll; SH3001_write(SH3001_ADDRESS, SH3001_HIGHLOW_G_INT_CONF, 1, ®Data); regData = highGThres; SH3001_write(SH3001_ADDRESS, SH3001_HIGHG_INT_THRESHOLD, 1, ®Data); regData = highGTimsMs; SH3001_write(SH3001_ADDRESS, SH3001_HIGHG_INT_TIME, 1, ®Data); } /****************************************************************** * Description: inactivity INT config; * * Parameters: inactEnDisIntX inactEnDisIntY inactEnDisIntZ * SH3001_INACT_X_INT_EN SH3001_INACT_Y_INT_EN SH3001_INACT_Z_INT_EN * SH3001_INACT_X_INT_DIS SH3001_INACT_Y_INT_DIS SH3001_INACT_Z_INT_DIS * * * inactIntMode inactLinkStatus inactTimeS * SH3001_INACT_AC_MODE SH3001_LINK_PRE_STA Unit: S * SH3001_INACT_DC_MODE SH3001_LINK_PRE_STA_NO * * * inactIntThres inactG1 * (3 Bytes) * * return: void * ******************************************************************/ void SH3001_INT_Inact_Config(unsigned char inactEnDisIntX, unsigned char inactEnDisIntY, unsigned char inactEnDisIntZ, unsigned char inactIntMode, unsigned char inactLinkStatus, unsigned char inactTimeS, unsigned int inactIntThres, unsigned short int inactG1) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_ACT_INACT_INT_CONF, 1, ®Data); regData &= 0xF0; regData |= inactEnDisIntX | inactEnDisIntY | inactEnDisIntZ | inactIntMode; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INACT_INT_CONF, 1, ®Data); regData = (unsigned char)inactIntThres; SH3001_write(SH3001_ADDRESS, SH3001_INACT_INT_THRESHOLDL, 1, ®Data); regData = (unsigned char)(inactIntThres >> 8); SH3001_write(SH3001_ADDRESS, SH3001_INACT_INT_THRESHOLDM, 1, ®Data); regData = (unsigned char)(inactIntThres >> 16); SH3001_write(SH3001_ADDRESS, SH3001_INACT_INT_THRESHOLDH, 1, ®Data); regData = inactTimeS; SH3001_write(SH3001_ADDRESS, SH3001_INACT_INT_TIME, 1, ®Data); regData = (unsigned char)inactG1; SH3001_write(SH3001_ADDRESS, SH3001_INACT_INT_1G_REFL, 1, ®Data); regData = (unsigned char)(inactG1 >> 8); SH3001_write(SH3001_ADDRESS, SH3001_INACT_INT_1G_REFH, 1, ®Data); SH3001_read(SH3001_ADDRESS, SH3001_ACT_INACT_INT_LINK, 1, ®Data); regData &= 0xFE; regData |= inactLinkStatus; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INACT_INT_LINK, 1, ®Data); } /****************************************************************** * Description: activity INT config; * actIntThres: 1 LSB is 0.24mg@+/-2G, 0.48mg@+/-4G, 0.97mg@+/-8G, 1.95mg@+/-16G * * Parameters: actEnDisIntX actEnDisIntY actEnDisIntZ * SH3001_ACT_X_INT_EN SH3001_ACT_Y_INT_EN SH3001_ACT_Z_INT_EN * SH3001_ACT_X_INT_DIS SH3001_ACT_Y_INT_DIS SH3001_ACT_Z_INT_DIS * * * actIntMode actTimeNum actIntThres actLinkStatus * SH3001_ACT_AC_MODE (1 Byte) (1 Byte) SH3001_LINK_PRE_STA * SH3001_ACT_DC_MODE SH3001_LINK_PRE_STA_NO * * return: void * ******************************************************************/ void SH3001_INT_Act_Config(unsigned char actEnDisIntX, unsigned char actEnDisIntY, unsigned char actEnDisIntZ, unsigned char actIntMode, unsigned char actTimeNum, unsigned char actIntThres, unsigned char actLinkStatus) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_ACT_INACT_INT_CONF, 1, ®Data); regData &= 0x0F; regData |= actEnDisIntX | actEnDisIntY | actEnDisIntZ | actIntMode; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INACT_INT_CONF, 1, ®Data); regData = actIntThres; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INT_THRESHOLD, 1, ®Data); regData = actTimeNum; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INT_TIME, 1, ®Data); SH3001_read(SH3001_ADDRESS, SH3001_ACT_INACT_INT_LINK, 1, ®Data); regData &= 0xFE; regData |= actLinkStatus; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INACT_INT_LINK, 1, ®Data); } /****************************************************************** * Description: 1.tap INT config; * 2.tapWaitTimeWindowMs is more than tapWaitTimeMs; * * Parameters: tapEnDisIntX tapEnDisIntY tapEnDisIntZ * SH3001_TAP_X_INT_EN SH3001_TAP_Y_INT_EN SH3001_TAP_Z_INT_EN * SH3001_TAP_X_INT_DIS SH3001_TAP_Y_INT_DIS SH3001_TAP_Z_INT_DIS * * * tapIntThres tapTimeMs tapWaitTimeMs tapWaitTimeWindowMs * (1 Byte) Unit: mS Unit: mS Unit: mS * * return: void * ******************************************************************/ void SH3001_INT_Tap_Config(unsigned char tapEnDisIntX, unsigned char tapEnDisIntY, unsigned char tapEnDisIntZ, unsigned char tapIntThres, unsigned char tapTimeMs, unsigned char tapWaitTimeMs, unsigned char tapWaitTimeWindowMs) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_ACT_INACT_INT_LINK, 1, ®Data); regData &= 0xF1; regData |= tapEnDisIntX | tapEnDisIntY | tapEnDisIntZ; SH3001_write(SH3001_ADDRESS, SH3001_ACT_INACT_INT_LINK, 1, ®Data); regData = tapIntThres; SH3001_write(SH3001_ADDRESS, SH3001_TAP_INT_THRESHOLD, 1, ®Data); regData = tapTimeMs; SH3001_write(SH3001_ADDRESS, SH3001_TAP_INT_DURATION, 1, ®Data); regData = tapWaitTimeMs; SH3001_write(SH3001_ADDRESS, SH3001_TAP_INT_LATENCY, 1, ®Data); regData = tapWaitTimeWindowMs; SH3001_write(SH3001_ADDRESS, SH3001_DTAP_INT_WINDOW, 1, ®Data); } /****************************************************************** * Description: flat INT time threshold, unit: mS; * * Parameters: flatTimeTH flatTanHeta2 * SH3001_FLAT_TIME_500MS 0 ~ 63 * SH3001_FLAT_TIME_1000MS * SH3001_FLAT_TIME_2000MS * * return: void * ******************************************************************/ void SH3001_INT_Flat_Config(unsigned char flatTimeTH, unsigned char flatTanHeta2) { unsigned char regData = 0; //SH3001_read(SH3001_ADDRESS, SH3001_FLAT_INT_CONF, 1, ®Data); regData = (flatTimeTH & 0xC0) | (flatTanHeta2 & 0x3F); SH3001_write(SH3001_ADDRESS, SH3001_FLAT_INT_CONF, 1, ®Data); } /****************************************************************** * Description: orientation config; * * Parameters: orientBlockMode orientMode orientTheta * SH3001_ORIENT_BLOCK_MODE0 SH3001_ORIENT_SYMM (1 Byte) * SH3001_ORIENT_BLOCK_MODE1 SH3001_ORIENT_HIGH_ASYMM * SH3001_ORIENT_BLOCK_MODE2 SH3001_ORIENT_LOW_ASYMM * SH3001_ORIENT_BLOCK_MODE3 * * orientG1point5 orientSlope orientHyst * (2 Bytes) (2 Bytes) (2 Bytes) * * return: void * ******************************************************************/ void SH3001_INT_Orient_Config(unsigned char orientBlockMode, unsigned char orientMode, unsigned char orientTheta, unsigned short orientG1point5, unsigned short orientSlope, unsigned short orientHyst) { unsigned char regData[2] = {0}; SH3001_read(SH3001_ADDRESS, SH3001_ORIEN_INTCONF0, 1, ®Data[0]); regData[0] |= (regData[0] & 0xC0) | (orientTheta & 0x3F); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INTCONF0, 1, ®Data[0]); SH3001_read(SH3001_ADDRESS, SH3001_ORIEN_INTCONF1, 1, ®Data[0]); regData[0] &= 0xF0; regData[0] |= (orientBlockMode & 0x0C) | (orientMode & 0x03); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INTCONF1, 1, ®Data[0]); regData[0] = (unsigned char)orientG1point5; regData[1] = (unsigned char)(orientG1point5 >> 8); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_LOW, 1, ®Data[0]); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_HIGH, 1, ®Data[1]); regData[0] = (unsigned char)orientSlope; regData[1] = (unsigned char)(orientSlope >> 8); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_SLOPE_LOW, 1, ®Data[0]); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_SLOPE_HIGH, 1, ®Data[1]); regData[0] = (unsigned char)orientHyst; regData[1] = (unsigned char)(orientHyst >> 8); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_HYST_LOW, 1, ®Data[0]); SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_HYST_HIGH, 1, ®Data[1]); } /****************************************************************** * Description: 1.freeFall INT config; * 2.freeFallThres: x=0.5mG@2G or x=1mG@4G or x=2mG@8G or x=4mG@16G * * Parameters: freeFallThres freeFallTimsMs * Unit: x mG Unit: 2mS * * return: void * ******************************************************************/ void SH3001_INT_FreeFall_Config(unsigned char freeFallThres, unsigned char freeFallTimsMs) { unsigned char regData = 0; regData = freeFallThres; SH3001_write(SH3001_ADDRESS, SH3001_FREEFALL_INT_THRES, 1, ®Data); regData = freeFallTimsMs; SH3001_write(SH3001_ADDRESS, SH3001_FREEFALL_INT_TIME, 1, ®Data); } /****************************************************************** * Description: 1.read INT status0 * * Parameters: void * * return: unsigned short * bit 11: Acc Data Ready Interrupt status * bit 10: Acc FIFO Watermark Interrupt status * bit 9: Gyro Ready Interrupt status * bit 8: Gyro FIFO Watermark Interrupt status * bit 7: Free-fall Interrupt status * bit 6: Orientation Interrupt status * bit 5: Flat Interrupt status * bit 4: Tap Interrupt status * bit 3: Single Tap Interrupt status * bit 2: Double Tap Interrupt status * bit 1: Activity Interrupt status * bit 0: Inactivity Interrupt status * 0: Not Active * 1: Active * ******************************************************************/ unsigned short SH3001_INT_Read_Status0(void) { unsigned char regData[2] = {0}; SH3001_read(SH3001_ADDRESS, SH3001_INT_STA0, 2, ®Data[0]); return (((unsigned short)(regData[1] & 0x0F) << 8) | regData[0]); } /****************************************************************** * Description: 1.read INT status2 * * Parameters: void * * return: unsigned char * bit 7: Sign of acceleration that trigger High-G Interrupt * 0: Positive * 1: Negative * bit 6: Whether High-G Interrupt is triggered by X axis * bit 5: Whether High-G Interrupt is triggered by Y axis * bit 4: Whether High-G Interrupt is triggered by Z axis * 0: No * 1: Yes * bit 3: Reserved * bit 2: Reserved * bit 1: Reserved * bit 0: Low-G Interrupt status * 0: Not Active * 1: Active * ******************************************************************/ unsigned char SH3001_INT_Read_Status2(void) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_INT_STA2, 1, ®Data); return ((regData & 0xF1)); } /****************************************************************** * Description: 1.read INT status3 * * Parameters: void * * return: unsigned char * bit 7: Sign of acceleration that trigger Activity or Inactivity Interrupt * 0: Positive * 1: Negative * bit 6: Whether Activity or Inactivity Interrupt is triggered by X axis * bit 5: Whether Activity or Inactivity Interrupt is triggered by Y axis * bit 4: Whether Activity or Inactivity Interrupt is triggered by Z axis * 0: No * 1: Yes * bit 3: Sign of acceleration that trigger Single or Double Tap Interrup * 0: Positive * 1: Negative * bit 2: Whether Single or Double Tap Interrupt is triggered by X axis * bit 1: Whether Single or Double Tap Interrupt is triggered by Y axis * bit 0: Whether Single or Double Tap Interrupt is triggered by Z axis * 0: No * 1: Yes ******************************************************************/ unsigned char SH3001_INT_Read_Status3(void) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_INT_STA3, 1, ®Data); return (regData); } /****************************************************************** * Description: 1.read INT status4 * * Parameters: void * * return: unsigned char * bit 7: Reserved * bit 6: Reserved * bit 5: Reserved * bit 4: Reserved * bit 3: Reserved * bit 2: Orientation Interrupt Value of Z-axis * 0: Upward * 1: Downward * bit 1..0: Orientation Interrupt Value of X and Y-axis * 00: Landscape left * 01: Landscape right * 10: Portrait upside down * 11: Portrait upright * ******************************************************************/ unsigned char SH3001_INT_Read_Status4(void) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_INT_STA4, 1, ®Data); return (regData & 0x07); } /****************************************************************** * Description: Before running other INT config functions, need to call SH3001_pre_INT_config(); * * Parameters: void * * return: void * * ******************************************************************/ void SH3001_pre_INT_config(void) { unsigned char regData = 0; regData = 0x20; SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INTCONF0, 1, ®Data); regData = 0x0A; SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INTCONF1, 1, ®Data); regData = 0x01; SH3001_write(SH3001_ADDRESS, SH3001_ORIEN_INT_HYST_HIGH, 1, ®Data); } /****************************************************************** * Description: reset FIFO controller; * * Parameters: fifoMode * SH3001_FIFO_MODE_DIS * SH3001_FIFO_MODE_FIFO * SH3001_FIFO_MODE_STREAM * SH3001_FIFO_MODE_TRIGGER * * return: void * ******************************************************************/ void SH3001_FIFO_Reset(unsigned char fifoMode) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_FIFO_CONF0, 1, ®Data); regData |= 0x80; SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF0, 1, ®Data); regData &= 0x7F; SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF0, 1, ®Data); regData = fifoMode & 0x03; SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF0, 1, ®Data); } /****************************************************************** * Description: 1.FIFO down sample frequency config; * 2.fifoAccFreq: accODR*1/2, *1/4, *1/8, *1/16, *1/32, *1/64, *1/128, *1/256 * 3.fifoGyroFreq: gyroODR*1/2, *1/4, *1/8, *1/16, *1/32, *1/64, *1/128, *1/256 * * Parameters: fifoAccDownSampleEnDis fifoAccFreq/fifoGyroFreq fifoGyroDownSampleEnDis * SH3001_FIFO_ACC_DOWNS_EN SH3001_FIFO_FREQ_X1_2 SH3001_FIFO_GYRO_DOWNS_EN * SH3001_FIFO_ACC_DOWNS_DIS SH3001_FIFO_FREQ_X1_4 SH3001_FIFO_GYRO_DOWNS_DIS * SH3001_FIFO_FREQ_X1_8 * SH3001_FIFO_FREQ_X1_16 * SH3001_FIFO_FREQ_X1_32 * SH3001_FIFO_FREQ_X1_64 * SH3001_FIFO_FREQ_X1_128 * SH3001_FIFO_FREQ_X1_256 * return: void * ******************************************************************/ void SH3001_FIFO_Freq_Config(unsigned char fifoAccDownSampleEnDis, unsigned char fifoAccFreq, unsigned char fifoGyroDownSampleEnDis, unsigned char fifoGyroFreq) { unsigned char regData = 0; regData |= fifoAccDownSampleEnDis | fifoGyroDownSampleEnDis; regData |= (fifoAccFreq << 4) | fifoGyroFreq; SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF4, 1, ®Data); } /****************************************************************** * Description: 1.data type config in FIFO; * 2.fifoWaterMarkLevel is less than or equal to 1024; * * Parameters: fifoMode fifoWaterMarkLevel * SH3001_FIFO_EXT_Z_EN <=1024 * SH3001_FIFO_EXT_Y_EN * SH3001_FIFO_EXT_X_EN * SH3001_FIFO_TEMPERATURE_EN * SH3001_FIFO_GYRO_Z_EN * SH3001_FIFO_GYRO_Y_EN * SH3001_FIFO_GYRO_X_EN * SH3001_FIFO_ACC_Z_EN * SH3001_FIFO_ACC_Y_EN * SH3001_FIFO_ACC_X_EN * SH3001_FIFO_ALL_DIS * * return: void * ******************************************************************/ void SH3001_FIFO_Data_Config(unsigned short fifoMode, unsigned short fifoWaterMarkLevel) { unsigned char regData = 0; if (fifoWaterMarkLevel > 1024) { fifoWaterMarkLevel = 1024; } SH3001_read(SH3001_ADDRESS, SH3001_FIFO_CONF2, 1, ®Data); regData = (regData & 0xC8) \ | ((unsigned char)(fifoMode >> 8) & 0x30) \ | (((unsigned char)(fifoWaterMarkLevel >> 8)) & 0x07); SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF2, 1, ®Data); regData = (unsigned char)fifoMode; SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF3, 1, ®Data); regData = (unsigned char)fifoWaterMarkLevel; SH3001_write(SH3001_ADDRESS, SH3001_FIFO_CONF1, 1, ®Data); } /****************************************************************** * Description: 1. read Fifo status and fifo entries count * * Parameters: *fifoEntriesCount, store fifo entries count, less than or equal to 1024; * * * return: unsigned char * bit 7: 0 * bit 6: 0 * bit 5: Whether FIFO Watermark has been reached * bit 4: Whether FIFO is full * bit 3: Whether FIFO is empty * 0: No * 1: Yes * bit 2: 0 * bit 1: 0 * bit 0: 0 * * ******************************************************************/ unsigned char SH3001_FIFO_Read_Status(unsigned short int *fifoEntriesCount) { unsigned char regData[2] = {0}; SH3001_read(SH3001_ADDRESS, SH3001_FIFO_STA0, 2, ®Data[0]); *fifoEntriesCount = ((unsigned short int)(regData[1] & 0x07) << 8) | regData[0]; return (regData[1] & 0x38); } /****************************************************************** * Description: 1. read Fifo data * * Parameters: *fifoReadData fifoDataLength * data data length * * return: void * * ******************************************************************/ void SH3001_FIFO_Read_Data(unsigned char *fifoReadData, unsigned short int fifoDataLength) { if (fifoDataLength > 1024) { fifoDataLength = 1024; } while (fifoDataLength--) { SH3001_read(SH3001_ADDRESS, SH3001_FIFO_DATA, 1, fifoReadData); fifoReadData++; } } /****************************************************************** * Description: reset Mater I2C; * * Parameters: void * * return: void * ******************************************************************/ void SH3001_MI2C_Reset(void) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); regData |= 0x80; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); regData &= 0x7F; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); } /****************************************************************** * Description: 1.master I2C config; * 2.master I2C clock frequency is (1MHz/(6+3*mi2cFreq));19.6k ~ 166.666k * 3.mi2cSlaveAddr: slave device address, 7 bits; * * * Parameters: mi2cReadMode mi2cODR mi2cFreq * SH3001_MI2C_READ_MODE_AUTO SH3001_MI2C_READ_ODR_200HZ <=15 * SH3001_MI2C_READ_MODE_MANUAL SH3001_MI2C_READ_ODR_100HZ * SH3001_MI2C_READ_ODR_50HZ * SH3001_MI2C_READ_ODR_25HZ * return: void * ******************************************************************/ void SH3001_MI2C_Bus_Config(unsigned char mi2cReadMode, unsigned char mi2cODR, unsigned char mi2cFreq) { unsigned char regData = 0; if (mi2cFreq > 15) { mi2cFreq = 15; } SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF1, 1, ®Data); regData = (regData & 0xC0) | (mi2cODR & 0x30) | mi2cFreq; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF1, 1, ®Data); SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); regData = (regData & 0xBF) | mi2cReadMode; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); } /****************************************************************** * Description: 1.master I2C address and command config; * 2.mi2cSlaveAddr: slave device address, 7 bits; * * Parameters: mi2cSlaveAddr mi2cSlaveCmd mi2cReadMode * (1 Byte) (1 Byte) SH3001_MI2C_READ_MODE_AUTO * SH3001_MI2C_READ_MODE_MANUAL * * return: void * ******************************************************************/ void SH3001_MI2C_Cmd_Config(unsigned char mi2cSlaveAddr, unsigned char mi2cSlaveCmd, unsigned char mi2cReadMode) { unsigned char regData = 0; SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); regData = (regData & 0xBF) | mi2cReadMode; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); regData = mi2cSlaveAddr << 1; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CMD0, 1, ®Data); SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CMD1, 1, &mi2cSlaveCmd); } /****************************************************************** * Description: 1.master I2C write data fucntion; * 2.mi2cWriteData: write data; * * Parameters: mi2cWriteData * * return: SH3001_TRUE or SH3001_FALSE * ******************************************************************/ unsigned char SH3001_MI2C_Write(unsigned char mi2cWriteData) { unsigned char regData = 0; unsigned char i = 0; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_WR, 1, &mi2cWriteData); //Master I2C enable, write-operation SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); regData = (regData & 0xFC) | 0x02; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); // wait write-operation to end while (i++ < 20) { SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); if (regData & 0x30) { break; } } if ((regData & 0x30) == SH3001_MI2C_SUCCESS) { return (SH3001_TRUE); } else { return (SH3001_FALSE); } } /****************************************************************** * Description: 1.master I2C read data fucntion; * 2.*mi2cReadData: read data; * * Parameters: *mi2cReadData * * return: SH3001_TRUE or SH3001_FALSE * ******************************************************************/ unsigned char SH3001_MI2C_Read(unsigned char *mi2cReadData) { unsigned char regData = 0; unsigned char i = 0; SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); if ((regData & 0x40) == 0) { //Master I2C enable, read-operation regData |= 0x03; SH3001_write(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); } // wait read-operation to end while (i++ < 20) { SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); if (regData & 0x30) { break; } } SH3001_read(SH3001_ADDRESS, SH3001_MI2C_CONF0, 1, ®Data); if ((regData & 0x30) == SH3001_MI2C_SUCCESS) { SH3001_read(SH3001_ADDRESS, SH3001_MI2C_RD, 1, ®Data); *mi2cReadData = regData; return (SH3001_TRUE); } else { return (SH3001_FALSE); } } /****************************************************************** * Description: 1.SPI interface config; Default: SH3001_SPI_4_WIRE * * Parameters: spiInterfaceMode * SH3001_SPI_3_WIRE * SH3001_SPI_4_WIRE * * return: void * ******************************************************************/ void SH3001_SPI_Config(unsigned char spiInterfaceMode) { unsigned char regData = spiInterfaceMode; SH3001_write(SH3001_ADDRESS, SH3001_SPI_CONF, 1, ®Data); } /****************************************************************** * Description: read some compensation coefficients * * Parameters: compCoefType * * return: void * ******************************************************************/ static void SH3001_CompInit(compCoefType *compCoef) { unsigned char coefData[2] = {0}; // Acc Cross SH3001_read(SH3001_ADDRESS, 0x81, 2, coefData); compCoef->cYX = (signed char)coefData[0]; compCoef->cZX = (signed char)coefData[1]; SH3001_read(SH3001_ADDRESS, 0x91, 2, coefData); compCoef->cXY = (signed char)coefData[0]; compCoef->cZY = (signed char)coefData[1]; SH3001_read(SH3001_ADDRESS, 0xA1, 2, coefData); compCoef->cXZ = (signed char)coefData[0]; compCoef->cYZ = (signed char)coefData[1]; // Gyro Zero SH3001_read(SH3001_ADDRESS, 0x60, 1, coefData); compCoef->jX = (signed char)coefData[0]; SH3001_read(SH3001_ADDRESS, 0x68, 1, coefData); compCoef->jY = (signed char)coefData[0]; SH3001_read(SH3001_ADDRESS, 0x70, 1, coefData); compCoef->jZ = (signed char)coefData[0]; SH3001_read(SH3001_ADDRESS, SH3001_GYRO_CONF3, 1, coefData); coefData[0] = coefData[0] & 0x07; compCoef->xMulti = ((coefData[0] < 2) || (coefData[0] >= 7)) ? 1 : (1 << (6 - coefData[0])); SH3001_read(SH3001_ADDRESS, SH3001_GYRO_CONF4, 1, coefData); coefData[0] = coefData[0] & 0x07; compCoef->yMulti = ((coefData[0] < 2) || (coefData[0] >= 7)) ? 1 : (1 << (6 - coefData[0])); SH3001_read(SH3001_ADDRESS, SH3001_GYRO_CONF5, 1, coefData); coefData[0] = coefData[0] & 0x07; compCoef->zMulti = ((coefData[0] < 2) || (coefData[0] >= 7)) ? 1 : (1 << (6 - coefData[0])); SH3001_read(SH3001_ADDRESS, 0x2E, 1, coefData); compCoef->paramP0 = coefData[0] & 0x1F; } /****************************************************************** * Description: SH3001 initialization function * * Parameters: void * * return: SH3001_TRUE or SH3001_FALSE * ******************************************************************/ unsigned char SH3001_init(void) //no fifo no int { unsigned char regData = 0; unsigned char i = 0; #if (SH3001_USER_INTERFACE) if (sh3001_info->spi_work_mode) { SH3001_SPI_Config(SH3001_SPI_3_WIRE); } else { SH3001_SPI_Config(SH3001_SPI_4_WIRE); } #endif // SH3001 chipID = 0x61; while ((regData != 0x61) && (i++ < 3)) { SH3001_read(SH3001_ADDRESS, SH3001_CHIP_ID, 1, ®Data); if ((i == 3) && (regData != 0x61)) { log_error("SH3001 init fail 0x%x\n", regData); return SH3001_FALSE; } } // reset internal module SH3001_ModuleReset(); // 500Hz, 16G, cut off Freq(BW)=500*0.25Hz=125Hz, enable filter; SH3001_Acc_Config(SH3001_ODR_500HZ, SH3001_ACC_RANGE_16G, SH3001_ACC_ODRX025, SH3001_ACC_FILTER_EN); // 500Hz, X\Y\Z 2000deg/s, cut off Freq(BW)=181Hz, enable filter; SH3001_Gyro_Config(SH3001_ODR_500HZ, SH3001_GYRO_RANGE_2000, SH3001_GYRO_RANGE_2000, SH3001_GYRO_RANGE_2000, SH3001_GYRO_ODRX00, SH3001_GYRO_FILTER_EN); // temperature ODR is 63Hz, enable temperature measurement SH3001_Temp_Config(SH3001_TEMP_ODR_63, SH3001_TEMP_EN); SH3001_read(SH3001_ADDRESS, SH3001_CHIP_ID1, 1, ®Data); if (regData == 0x61) { // read compensation coefficient SH3001_CompInit(&compCoef); } return SH3001_TRUE; } static u8 sh3001_int_pin = -1; //return:0:fail, 1:ok u8 SH3001_sensor_init(void *priv) { if (priv == NULL) { log_error("sh3001 init fail(no param)\n"); return SH3001_FALSE; } sh3001_info = (sh3001_param *)priv; #if (SH3001_USER_INTERFACE==0) //iic interface iic_init(sh3001_info->iic_hdl); #else//spi interface spi_cs_init(); spi_init(); #endif //int module io init gpio_set_die(sh3001_int_pin, 1); gpio_set_direction(sh3001_int_pin, 1); /* gpio_set_pull_up(sh3001_int_pin, 1); */ /* gpio_set_pull_down(sh3001_int_pin, 0); */ gpio_set_die(SH3001_INT_IO2, 1); gpio_set_direction(SH3001_INT_IO2, 1); /* gpio_set_pull_up(SH3001_INT_IO2, 1); */ /* gpio_set_pull_down(SH3001_INT_IO2, 0); */ return SH3001_init(); } /****************************************************************** * Description: Read SH3001 gyroscope and accelerometer data * * Parameters: accData[3]: acc X,Y,Z; gyroData[3]: gyro X,Y,Z; * * return: void * ******************************************************************/ void SH3001_GetImuData(short accData[3], short gyroData[3]) { unsigned char regData[12] = {0}; SH3001_read(SH3001_ADDRESS, SH3001_ACC_XL, 12, regData); accData[0] = ((short)regData[1] << 8) | regData[0]; accData[1] = ((short)regData[3] << 8) | regData[2]; accData[2] = ((short)regData[5] << 8) | regData[4]; gyroData[0] = ((short)regData[7] << 8) | regData[6]; gyroData[1] = ((short)regData[9] << 8) | regData[8]; gyroData[2] = ((short)regData[11] << 8) | regData[10]; log_info("sh3001:acc_x:%d acc_y:%d acc_z:%d gyro_x:%d gyro_y:%d gyro_z:%d", accData[0], accData[1], accData[2], gyroData[0], gyroData[1], gyroData[2]); } /****************************************************************** * Description: 1.Read SH3001 gyroscope and accelerometer data after compensation * 2.Only When the chipID is 0x61 at register 0xDF, can use SH3001_GetImuCompData() to get sensor data; * * Parameters: accData[3]: acc X,Y,Z; gyroData[3]: gyro X,Y,Z; * * * return: void * ******************************************************************/ void SH3001_GetImuCompData(short accData[3], short gyroData[3]) { unsigned char regData[15] = {0}; unsigned char paramP; int accTemp[3], gyroTemp[3]; SH3001_read(SH3001_ADDRESS, SH3001_ACC_XL, 15, regData); accData[0] = ((short)regData[1] << 8) | regData[0]; accData[1] = ((short)regData[3] << 8) | regData[2]; accData[2] = ((short)regData[5] << 8) | regData[4]; gyroData[0] = ((short)regData[7] << 8) | regData[6]; gyroData[1] = ((short)regData[9] << 8) | regData[8]; gyroData[2] = ((short)regData[11] << 8) | regData[10]; paramP = regData[14] & 0x1F; // Acc Cross accTemp[0] = (int)(accData[0] + \ accData[1] * ((float)compCoef.cXY / 1024.0f) + \ accData[2] * ((float)compCoef.cXZ / 1024.0f)); accTemp[1] = (int)(accData[0] * ((float)compCoef.cYX / 1024.0f) + \ accData[1] + \ accData[2] * ((float)compCoef.cYZ / 1024.0f)); accTemp[2] = (int)(accData[0] * ((float)compCoef.cZX / 1024.0f) + \ accData[1] * ((float)compCoef.cZY / 1024.0f) + \ accData[2]); if (accTemp[0] > 32767) { accTemp[0] = 32767; } else if (accTemp[0] < -32768) { accTemp[0] = -32768; } if (accTemp[1] > 32767) { accTemp[1] = 32767; } else if (accTemp[1] < -32768) { accTemp[1] = -32768; } if (accTemp[2] > 32767) { accTemp[2] = 32767; } else if (accTemp[2] < -32768) { accTemp[2] = -32768; } accData[0] = (short)accTemp[0]; accData[1] = (short)accTemp[1]; accData[2] = (short)accTemp[2]; gyroTemp[0] = gyroData[0] - (paramP - compCoef.paramP0) * compCoef.jX * compCoef.xMulti; gyroTemp[1] = gyroData[1] - (paramP - compCoef.paramP0) * compCoef.jY * compCoef.yMulti; gyroTemp[2] = gyroData[2] - (paramP - compCoef.paramP0) * compCoef.jZ * compCoef.zMulti; if (gyroTemp[0] > 32767) { gyroTemp[0] = 32767; } else if (gyroTemp[0] < -32768) { gyroTemp[0] = -32768; } if (gyroTemp[1] > 32767) { gyroTemp[1] = 32767; } else if (gyroTemp[1] < -32768) { gyroTemp[1] = -32768; } if (gyroTemp[2] > 32767) { gyroTemp[2] = 32767; } else if (gyroTemp[2] < -32768) { gyroTemp[2] = -32768; } // Gyro Zero gyroData[0] = (short)gyroTemp[0]; gyroData[1] = (short)gyroTemp[1]; gyroData[2] = (short)gyroTemp[2]; /* log_info("sh3001:acc_x:%d acc_y:%d acc_z:%d gyro_x:%d gyro_y:%d gyro_z:%d", accData[0], accData[1], accData[2], gyroData[0], gyroData[1], gyroData[2]); */ } static u8 init_flag = 0; static u8 imu_busy = 0; static sh3001_param sh3001_info_data; /********************int test*******************/ // For example: set accelerometer data ready INT void sh3001_int_mode() { SH3001_pre_INT_config(); SH3001_INT_Config(SH3001_INT0_LEVEL_HIGH, //低有效 SH3001_INT_NO_LATCH, //锁住中断,只有清中断才恢复 SH3001_INT1_LEVEL_HIGH, //高有效 SH3001_INT_CLEAR_STATUS, //读任意寄存器清中断 SH3001_INT1_NORMAL, //int pin 普通输出 SH3001_INT0_NORMAL, 3); SH3001_INT_Enable(SH3001_INT_ACC_READY, // SH3001_INT_ENABLE, SH3001_INT_MAP_INT); //该中断映射到INT0 PIN } void sh3001_int_callback() { if (init_flag == 0) { log_error("sh3001 init fail!"); return ; } if (imu_busy) { log_error("sh3001 busy!"); return ; } imu_busy = 1; short accData[3], gyroData[3]; float TempData; SH3001_GetImuCompData(accData, gyroData); TempData = SH3001_GetTempData(); /* SH3001_INT_Read_Status0(); */ imu_busy = 0; log_info("sh3001:acc_x:%d acc_y:%d acc_z:%d gyro_x:%d gyro_y:%d gyro_z:%d", accData[0], accData[1], accData[2], gyroData[0], gyroData[1], gyroData[2]); log_info("temp:%d.%d\n", (u16)TempData, (u16)(((u16)(TempData * 100)) % 100)); } s8 sh3001_dev_init(void *arg) { if (arg == NULL) { log_error("sh3001 init fail(no arg)\n"); return -1; } #if (SH3001_USER_INTERFACE==0) sh3001_info_data.iic_hdl = ((struct imusensor_platform_data *)arg)->peripheral_hdl; sh3001_info_data.iic_delay = ((struct imusensor_platform_data *)arg)->peripheral_param0; //这个延时并非影响iic的时钟频率，而是2Byte数据之间的延时 // u8 iic_clk; //iic_clk: <=400kHz #else sh3001_info_data.spi_hdl = ((struct imusensor_platform_data *)arg)->peripheral_hdl, //SPIx (role:master) sh3001_info_data.spi_cs_pin = ((struct imusensor_platform_data *)arg)->peripheral_param0; //IO_PORTA_05 sh3001_info_data.spi_work_mode = ((struct imusensor_platform_data *)arg)->peripheral_param1; //1:3wire(SPI_MODE_UNIDIR_1BIT) or 0:4wire(SPI_MODE_BIDIR_1BIT) (与spi结构体一样) // u8 port; //SPIx group:A,B,C,D (spi结构体) // U8 spi_clk; //spi_clk: <=1MHz (spi结构体) #endif sh3001_int_pin = ((struct imusensor_platform_data *)arg)->imu_sensor_int_io; if (imu_busy) { log_error("sh3001 busy!"); return -1; } imu_busy = 1; if (SH3001_sensor_init(&sh3001_info_data)) { //no fifo log_info("sh3001 init success!\n"); #if (TCFG_SH3001_USER_INT_EN==0) //定时读 //注册定时：sh3001_int_callback() #else //中断读 //开中断 sh3001_int_mode(); log_info("int mode en!"); /* port_wkup_enable(sh3001_int_pin, 0, sh3001_int_callback); //PA08-IO中断，0:上降沿触发，回调函数sh3001_int_callback*/ #ifdef CONFIG_CPU_BR23 io_ext_interrupt_init(sh3001_int_pin, 1, sh3001_int_callback); #elif defined(CONFIG_CPU_BR28) // br28外部中断回调函数，按照现在的外部中断注册方式 // io配置在板级，定义在板级头文件，这里只是注册回调函数 /* port_edge_wkup_set_callback_by_index(3, sh3001_int_callback); // 序号需要和板级配置中的wk_param对应上 */ port_edge_wkup_set_callback(sh3001_int_callback); #elif defined(CONFIG_CPU_BR27) port_edge_wkup_set_callback(sh3001_int_callback); #endif #endif init_flag = 1; imu_busy = 0; return 0; } else { log_error("sh3001 init fail!\n"); imu_busy = 0; return -1; } } int sh3001_dev_ctl(u8 cmd, void *arg); REGISTER_IMU_SENSOR(sh3001_sensor) = { .logo = "sh3001", .imu_sensor_init = sh3001_dev_init, .imu_sensor_check = NULL, .imu_sensor_ctl = sh3001_dev_ctl, }; int sh3001_dev_ctl(u8 cmd, void *arg) { int ret = -1; if (init_flag == 0) { log_error("sh3001 init fail!"); return ret;//0:ok,,<0:err } if (imu_busy) { log_error("sh3001 busy!"); return ret;//0:ok,,<0:err } imu_busy = 1; switch (cmd) { case IMU_GET_SENSOR_NAME: memcpy((u8 *)arg, &(sh3001_sensor.logo), 20); break; case IMU_SENSOR_ENABLE: /* cbuf_init(&hrsensor_cbuf, hrsensorcbuf, 24 * sizeof(int)); */ SH3001_init(); break; case IMU_SENSOR_DISABLE: /* cbuf_clear(&hrsensor_cbuf); */ break; case IMU_SENSOR_RESET: break; case IMU_SENSOR_SLEEP: break; case IMU_SENSOR_WAKEUP: break; case IMU_SENSOR_INT_DET://传感器中断状态检查 break; case IMU_SENSOR_DATA_READY://传感器数据准备就绪待读 sh3001_int_callback(); break; case IMU_SENSOR_CHECK_DATA://检查传感器缓存buf是否存满 break; case IMU_SENSOR_READ_DATA://默认读传感器所有数据 break; case IMU_GET_ACCEL_DATA://加速度数据 break; case IMU_GET_GYRO_DATA://陀螺仪数据 break; case IMU_GET_MAG_DATA://磁力计数据 break; case IMU_SENSOR_SEARCH://检查传感器id SH3001_read(SH3001_ADDRESS, SH3001_CHIP_ID, 1, (u8 *)arg); if (*(u8 *)arg == 0x61) { ret = 0; log_info("sh3001 online!\n"); } else { log_error("sh3001 offline!\n"); } break; default: log_error("--cmd err!\n"); break; } imu_busy = 0; return ret; } /***************************sh3001 test*******************************/ #if 0 //测试 static sh3001_param sh3001_info_test = { #if (SH3001_USER_INTERFACE==0) .iic_hdl = 0, .iic_delay = 0, //这个延时并非影响iic的时钟频率，而是2Byte数据之间的延时 // u8 iic_clk; //iic_clk: <=400kHz #else .spi_hdl = 1, //SPIx (role:master) .spi_cs_pin = IO_PORTA_05, // .spi_work_mode = 1, //1:3wire(SPI_MODE_UNIDIR_1BIT) or 0:4wire(SPI_MODE_BIDIR_1BIT) (与spi结构体一样) // u8 port; //SPIx group:A,B,C,D (spi结构体) // U8 spi_clk; //spi_clk: <=1MHz (spi结构体) #endif }; void sh3001_test() { short accData[3], gyroData[3]; float TempData; if (SH3001_sensor_init(&sh3001_info_test)) { //no fifo no int log_info("sh3001 init success!\n"); MDELAY(10); #if (TCFG_SH3001_USER_INT_EN==0) //定时读 SH3001_GetImuCompData(accData, gyroData); TempData = SH3001_GetTempData(); log_info("sh3001 temp:%d.%d", (u16)TempData, (u16)(((u16)(TempData * 100)) % 100)); #else //中断读 //开中断 sh3001_int_mode(); log_info("-------------------port wkup isr---------------------------"); /* port_wkup_enable(sh3001_int_pin, 0, sh3001_int_callback); //PA08-IO中断，0:上降沿触发，回调函数sh3001_int_callback*/ #ifdef CONFIG_CPU_BR23 io_ext_interrupt_init(sh3001_int_pin, 1, sh3001_int_callback); #elif defined(CONFIG_CPU_BR28) // br28外部中断回调函数，按照现在的外部中断注册方式 // io配置在板级，定义在板级头文件，这里只是注册回调函数 /* port_edge_wkup_set_callback_by_index(3, sh3001_int_callback); // 序号需要和板级配置中的wk_param对应上 */ port_edge_wkup_set_callback(sh3001_int_callback); #elif defined(CONFIG_CPU_BR27) port_edge_wkup_set_callback(sh3001_int_callback); #endif #endif } else { log_error("sh3001 init fail!\n"); } } #endif #endif