j3d1/Ai-Thinker-Open_RTL8710BX_ALIOS_SDK
1
0
Fork 0
mirror of https://github.com/Ai-Thinker-Open/Ai-Thinker-Open_RTL8710BX_ALIOS_SDK.git synced 2025-07-31 19:31:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

rel_1.6.0 init

Browse source
This commit is contained in:
guocheng.kgc 2020-06-18 20:06:52 +08:00 • committed by shengdong.dsd
commit 27b3e2883d
19359 changed files with 8093121 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

548
Living_SDK/device/sensor/drv/drv_acc_bosch_bma253.c Normal file
View file

@ -0,0 +1,548 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define BMA253_I2C_ADDR1 (0x18)
#define BMA253_I2C_ADDR2 (0x19)
#define BMA253_I2C_ADDR3 (0x10)
#define BMA253_I2C_ADDR4 (0x11)
#define BMA253_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMA253_I2C_ADDR BMA253_I2C_ADDR_TRANS(BMA253_I2C_ADDR1)
#define BMA253_INIT_VALUE (0)
#define BMA253_GEN_READ_WRITE_LENGTH (1)
#define BMA253_INTERFACE_IDLE_TIME_DELAY (1)
#define BMA253_LSB_MSB_READ_LENGTH (2)
#define BMA253_SHIFT_TWO_BITS (2)
#define BMA253_SHIFT_FOUR_BITS (4)
#define BMA253_SHIFT_FIVE_BITS (5)
#define BMA253_SHIFT_SIX_BITS (6)
#define BMA253_SHIFT_EIGHT_BITS (8)
#define BMA253_12_BIT_SHIFT (0xF0)
#define BMA253_FIFO_MODE_STATUS_RANGE (2)
#define BMA253_FIFO_DATA_SELECT_RANGE (4)
#define BMA253_FIFO_MODE_RANGE (4)
#define BMA253_FIFO_WML_RANGE (32)
#define BMA253_FIFO_XYZ_DATA_ENABLED (0x00)
#define BMA253_FIFO_X_DATA_ENABLED (0x01)
#define BMA253_FIFO_Y_DATA_ENABLED (0x02)
#define BMA253_FIFO_Z_DATA_ENABLED (0x03)
#define BMA253_FIFO_DATA_ENABLED_MASK (0x03)
#define BMA253_FIFO_XYZ_AXES_FRAME_SIZE (6)
#define BMA253_FIFO_SINGLE_AXIS_FRAME_SIZE (2)
#define BMA253_ACCEL_BW_MIN_RANGE (7)
#define BMA253_ACCEL_BW_1000HZ_RANGE (15)
#define BMA253_ACCEL_BW_MAX_RANGE (16)
#define BMA253_SLEEP_DURN_MIN_RANGE (4)
#define BMA253_SLEEP_TIMER_MODE_RANGE (2)
#define BMA253_SLEEP_DURN_MAX_RANGE (16)
#define BMA253_POWER_MODE_RANGE (6)
#define BMA253_SELF_TEST_AXIS_RANGE (4)
#define BMA253_SELF_TEST_SIGN_RANGE (2)
#define BMA253_EEP_OFFSET (0x16)
#define BMA253_IMAGE_BASE (0x38)
#define BMA253_IMAGE_LEN (22)
#define BMA253_CHIP_ID_ADDR (0x00)
#define BMA253_CHIP_ID_VALUE (0xFA)
#define BMA253_X_AXIS_LSB_ADDR (0x02)
#define BMA253_X_AXIS_MSB_ADDR (0x03)
#define BMA253_Y_AXIS_LSB_ADDR (0x04)
#define BMA253_Y_AXIS_MSB_ADDR (0x05)
#define BMA253_Z_AXIS_LSB_ADDR (0x06)
#define BMA253_Z_AXIS_MSB_ADDR (0x07)
#define BMA253_TEMP_ADDR (0x08)
#define BMA253_STAT1_ADDR (0x09)
#define BMA253_STAT2_ADDR (0x0A)
#define BMA253_STAT_TAP_SLOPE_ADDR (0x0B)
#define BMA253_STAT_ORIENT_HIGH_ADDR (0x0C)
#define BMA253_STAT_FIFO_ADDR (0x0E)
#define BMA253_RANGE_SELECT_ADDR (0x0F)
#define BMA253_BW_SELECT_ADDR (0x10)
#define BMA253_MODE_CTRL_ADDR (0x11)
#define BMA253_LOW_NOISE_CTRL_ADDR (0x12)
#define BMA253_DATA_CTRL_ADDR (0x13)
#define BMA253_RST_ADDR (0x14)
#define BMA253_INTR_ENABLE1_ADDR (0x16)
#define BMA253_INTR_ENABLE2_ADDR (0x17)
#define BMA253_INTR_SLOW_NO_MOTION_ADDR (0x18)
#define BMA253_INTR1_PAD_SELECT_ADDR (0x19)
#define BMA253_INTR_DATA_SELECT_ADDR (0x1A)
#define BMA253_INTR2_PAD_SELECT_ADDR (0x1B)
#define BMA253_INTR_SOURCE_ADDR (0x1E)
#define BMA253_INTR_SET_ADDR (0x20)
#define BMA253_INTR_CTRL_ADDR (0x21)
#define BMA253_LOW_DURN_ADDR (0x22)
#define BMA253_LOW_THRES_ADDR (0x23)
#define BMA253_LOW_HIGH_HYST_ADDR (0x24)
#define BMA253_HIGH_DURN_ADDR (0x25)
#define BMA253_HIGH_THRES_ADDR (0x26)
#define BMA253_SLOPE_DURN_ADDR (0x27)
#define BMA253_SLOPE_THRES_ADDR (0x28)
#define BMA253_SLOW_NO_MOTION_THRES_ADDR (0x29)
#define BMA253_TAP_PARAM_ADDR (0x2A)
#define BMA253_TAP_THRES_ADDR (0x2B)
#define BMA253_ORIENT_PARAM_ADDR (0x2C)
#define BMA253_THETA_BLOCK_ADDR (0x2D)
#define BMA253_THETA_FLAT_ADDR (0x2E)
#define BMA253_FLAT_HOLD_TIME_ADDR (0x2F)
#define BMA253_SELFTEST_ADDR (0x32)
#define BMA253_EEPROM_CTRL_ADDR (0x33)
#define BMA253_SERIAL_CTRL_ADDR (0x34)
#define BMA253_OFFSET_CTRL_ADDR (0x36)
#define BMA253_OFFSET_PARAMS_ADDR (0x37)
#define BMA253_OFFSET_X_AXIS_ADDR (0x38)
#define BMA253_OFFSET_Y_AXIS_ADDR (0x39)
#define BMA253_OFFSET_Z_AXIS_ADDR (0x3A)
#define BMA253_GP0_ADDR (0x3B)
#define BMA253_GP1_ADDR (0x3C)
#define BMA253_FIFO_MODE_ADDR (0x3E)
#define BMA253_FIFO_DATA_OUTPUT_ADDR (0x3F)
#define BMA253_FIFO_WML_TRIG (0x30)
#define BMA253_12_RESOLUTION (0)
#define BMA253_10_RESOLUTION (1)
#define BMA253_14_RESOLUTION (2)
#define BMA253_ENABLE_SOFT_RESET_VALUE (0xB6)
#define BMA253_RANGE_SELECT_POS (0)
#define BMA253_RANGE_SELECT_LEN (4)
#define BMA253_RANGE_SELECT_MSK (0x0F)
#define BMA253_RANGE_SELECT_REG BMA253_RANGE_SELECT_ADDR
#define BMA253_RANGE_2G (3)
#define BMA253_RANGE_4G (5)
#define BMA253_RANGE_8G (8)
#define BMA253_RANGE_16G (12)
#define BMA253_BW_15_63 (15)
#define BMA253_BW_31_25 (31)
#define BMA253_BW_62_5 (62)
#define BMA253_BW_125 (125)
#define BMA253_BW_250 (250)
#define BMA253_BW_500 (500)
#define BMA253_BW_1000 (1000)
#define BMA253_BW_7_81HZ (0x08)
#define BMA253_BW_15_63HZ (0x09)
#define BMA253_BW_31_25HZ (0x0A)
#define BMA253_BW_62_50HZ (0x0B)
#define BMA253_BW_125HZ (0x0C)
#define BMA253_BW_250HZ (0x0D)
#define BMA253_BW_500HZ (0x0E)
#define BMA253_BW_1000HZ (0x0F)
#define BMA253_BW_BIT_MASK (~0x0F)
#define BMA253_SLEEP_DURN_0_5MS (0x05)
#define BMA253_SLEEP_DURN_1MS (0x06)
#define BMA253_SLEEP_DURN_2MS (0x07)
#define BMA253_SLEEP_DURN_4MS (0x08)
#define BMA253_SLEEP_DURN_6MS (0x09)
#define BMA253_SLEEP_DURN_10MS (0x0A)
#define BMA253_SLEEP_DURN_25MS (0x0B)
#define BMA253_SLEEP_DURN_50MS (0x0C)
#define BMA253_SLEEP_DURN_100MS (0x0D)
#define BMA253_SLEEP_DURN_500MS (0x0E)
#define BMA253_SLEEP_DURN_1S (0x0F)
#define BMA253_SLEEP_DURN_POS (1)
#define BMA253_SLEEP_DURN_LEN (4)
#define BMA253_SLEEP_DURN_MSK (0x1E)
#define BMA253_SLEEP_DURN_REG BMA253_MODE_CTRL_ADDR
#define BMA253_SLEEP_MODE (0x40)
#define BMA253_DEEP_SUSPEND_MODE (0x20)
#define BMA253_SUSPEND_MODE (0x80)
#define BMA253_NORMAL_MODE (0x40)
#define BMA253_LOWPOWER_MODE (0x40)
#define BMA253_MODE_CTRL_POS (5)
#define BMA253_MODE_CTRL_LEN (3)
#define BMA253_MODE_CTRL_MSK (0xE0)
#define BMA253_MODE_CTRL_REG BMA253_MODE_CTRL_ADDR
#define BMA253_LOW_POWER_MODE_POS (6)
#define BMA253_LOW_POWER_MODE_LEN (1)
#define BMA253_LOW_POWER_MODE_MSK (0x40)
#define BMA253_LOW_POWER_MODE_REG BMA253_LOW_NOISE_CTRL_ADDR
#define BMA253_DEFAULT_ODR_100HZ (100)
//bma253 sensitivity factor table, the unit is LSB/g
static uint32_t bma253_factor[4] = { 1024, 512, 256,128 };
static uint32_t current_factor = 0;
#define BMA253_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define BMA253_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
i2c_dev_t bma253_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMA253_I2C_ADDR,
};
static int drv_acc_bosch_bma253_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
ret = sensor_i2c_write(drv, BMA253_RST_ADDR, BMA253_ENABLE_SOFT_RESET_VALUE, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_bosch_bma253_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, BMA253_CHIP_ID_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_bosch_bma253_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value,value1 = 0x00;
int ret = 0;
uint8_t buf[4];
ret = sensor_i2c_read(drv, BMA253_MODE_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
if((value & BMA253_MODE_CTRL_MSK) == BMA253_NORMAL_MODE){
return 0;
}
value |= BMA253_NORMAL_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
if((value & BMA253_MODE_CTRL_MSK) == BMA253_DEEP_SUSPEND_MODE){
return 0;
}
value |= BMA253_DEEP_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
if((value & BMA253_MODE_CTRL_MSK) == BMA253_SLEEP_MODE){
return 0;
}
value |= BMA253_SLEEP_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SUSPEND:{
if((value & BMA253_MODE_CTRL_MSK) == BMA253_SUSPEND_MODE){
return 0;
}
value |= BMA253_SUSPEND_MODE;
ret = sensor_i2c_write(drv, BMA253_MODE_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_acc_bosch_bma253_set_odr(i2c_dev_t* drv, uint32_t odr)
{
int ret = 0;
uint8_t value = 0x00;
uint32_t bw = odr/2;
ret = sensor_i2c_read(drv, BMA253_BW_SELECT_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if(bw >= BMA253_BW_1000){
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_1000HZ;
}
else if(bw >= BMA253_BW_500){
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_500HZ;
}
else if(bw >= BMA253_BW_250){
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_250HZ;
}
else if(bw >= BMA253_BW_125){
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_125HZ;
}
else if(bw >= BMA253_BW_62_5){
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_62_50HZ;
}
else if(bw >= BMA253_BW_31_25){
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_31_25HZ;
}
else{
value &= BMA253_BW_BIT_MASK;
value |= BMA253_BW_15_63HZ;
}
ret = sensor_i2c_write(drv, BMA253_BW_SELECT_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_bosch_bma253_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, BMA253_RANGE_SELECT_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
value = BMA253_SET_BITSLICE(value,BMA253_RANGE_SELECT,BMA253_RANGE_2G);
}break;
case ACC_RANGE_4G:{
value = BMA253_SET_BITSLICE(value,BMA253_RANGE_SELECT,BMA253_RANGE_4G);
}break;
case ACC_RANGE_8G:{
value = BMA253_SET_BITSLICE(value,BMA253_RANGE_SELECT,BMA253_RANGE_8G);
}break;
case ACC_RANGE_16G:{
value = BMA253_SET_BITSLICE(value,BMA253_RANGE_SELECT,BMA253_RANGE_16G);
}break;
default:break;
}
/* Write the range register 0x0F*/
ret = sensor_i2c_write(drv, BMA253_RANGE_SELECT_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
current_factor = bma253_factor[range];
}
return 0;
}
static void drv_acc_bosch_bma253_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_bosch_bma253_open(void)
{
int ret = 0;
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_bosch_bma253_close(void)
{
int ret = 0;
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_bosch_bma253_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&bma253_ctx, BMA253_X_AXIS_LSB_ADDR, &reg[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_X_AXIS_MSB_ADDR, &reg[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Y_AXIS_LSB_ADDR, &reg[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Y_AXIS_MSB_ADDR, &reg[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Z_AXIS_LSB_ADDR, &reg[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&bma253_ctx, BMA253_Z_AXIS_MSB_ADDR, &reg[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int32_t)((((int32_t)((int8_t)reg[1]))<< BMA253_SHIFT_EIGHT_BITS)|(reg[0] &BMA253_12_BIT_SHIFT));
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] >> BMA253_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Y] = (int32_t)((((int32_t)((int8_t)reg[3]))<< BMA253_SHIFT_EIGHT_BITS)|(reg[2] &BMA253_12_BIT_SHIFT));
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] >> BMA253_SHIFT_FOUR_BITS;
accel->data[DATA_AXIS_Z] = (int32_t)((((int32_t)((int8_t)reg[5]))<< BMA253_SHIFT_EIGHT_BITS)|(reg[4]&BMA253_12_BIT_SHIFT));
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] >> BMA253_SHIFT_FOUR_BITS;
if(current_factor != 0){
// the unit of acc is mg, 1000 mg = 1 g.
accel->data[DATA_AXIS_X] = accel->data[DATA_AXIS_X] * ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Y] = accel->data[DATA_AXIS_Y] * ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
accel->data[DATA_AXIS_Z] = accel->data[DATA_AXIS_Z] * ACCELEROMETER_UNIT_FACTOR / (int32_t)current_factor;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_bosch_bma253_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_bosch_bma253_set_odr(&bma253_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_bosch_bma253_set_range(&bma253_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMA253";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_bosch_bma253_init(void){
int ret = 0;
sensor_obj_t sensor;
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_bosch_bma253_open;
sensor.close = drv_acc_bosch_bma253_close;
sensor.read = drv_acc_bosch_bma253_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_bosch_bma253_ioctl;
sensor.irq_handle = drv_acc_bosch_bma253_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_bosch_bma253_validate_id(&bma253_ctx, BMA253_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_bosch_bma253_soft_reset(&bma253_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_bosch_bma253_set_range(&bma253_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
//set odr is 100hz, and will update
ret = drv_acc_bosch_bma253_set_odr(&bma253_ctx, BMA253_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_bosch_bma253_set_power_mode(&bma253_ctx, DEV_SLEEP);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

844
Living_SDK/device/sensor/drv/drv_acc_gyro_st_lsm6dsl.c Normal file
View file

@ -0,0 +1,844 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define LSM6DSL_I2C_ADDR1 (0x6A)
#define LSM6DSL_I2C_ADDR2 (0x6B)
#define LSM6DSL_I2C_ADDR_TRANS(n) ((n)<<1)
#define LSM6DSL_I2C_ADDR LSM6DSL_I2C_ADDR_TRANS(LSM6DSL_I2C_ADDR1)
#define LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS 0x01
#define LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME 0x04
#define LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO 0x05
#define LSM6DSL_ACC_GYRO_FIFO_CTRL1 0x06
#define LSM6DSL_ACC_GYRO_FIFO_CTRL2 0x07
#define LSM6DSL_ACC_GYRO_FIFO_CTRL3 0x08
#define LSM6DSL_ACC_GYRO_FIFO_CTRL4 0x09
#define LSM6DSL_ACC_GYRO_FIFO_CTRL5 0x0A
#define LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G 0x0B
#define LSM6DSL_ACC_GYRO_INT1_CTRL 0x0D
#define LSM6DSL_ACC_GYRO_INT2_CTRL 0x0E
#define LSM6DSL_ACC_GYRO_WHO_AM_I_REG 0x0F
#define LSM6DSL_ACC_GYRO_CTRL1_XL 0x10
#define LSM6DSL_ACC_GYRO_CTRL2_G 0x11
#define LSM6DSL_ACC_GYRO_CTRL3_C 0x12
#define LSM6DSL_ACC_GYRO_CTRL4_C 0x13
#define LSM6DSL_ACC_GYRO_CTRL5_C 0x14
#define LSM6DSL_ACC_GYRO_CTRL6_C 0x15
#define LSM6DSL_ACC_GYRO_CTRL7_G 0x16
#define LSM6DSL_ACC_GYRO_CTRL8_XL 0x17
#define LSM6DSL_ACC_GYRO_CTRL9_XL 0x18
#define LSM6DSL_ACC_GYRO_CTRL10_C 0x19
#define LSM6DSL_ACC_GYRO_MASTER_CONFIG 0x1A
#define LSM6DSL_ACC_GYRO_WAKE_UP_SRC 0x1B
#define LSM6DSL_ACC_GYRO_TAP_SRC 0x1C
#define LSM6DSL_ACC_GYRO_D6D_SRC 0x1D
#define LSM6DSL_ACC_GYRO_STATUS_REG 0x1E
#define LSM6DSL_ACC_GYRO_OUT_TEMP_L 0x20
#define LSM6DSL_ACC_GYRO_OUT_TEMP_H 0x21
#define LSM6DSL_ACC_GYRO_OUTX_L_G 0x22
#define LSM6DSL_ACC_GYRO_OUTX_H_G 0x23
#define LSM6DSL_ACC_GYRO_OUTY_L_G 0x24
#define LSM6DSL_ACC_GYRO_OUTY_H_G 0x25
#define LSM6DSL_ACC_GYRO_OUTZ_L_G 0x26
#define LSM6DSL_ACC_GYRO_OUTZ_H_G 0x27
#define LSM6DSL_ACC_GYRO_OUTX_L_XL 0x28
#define LSM6DSL_ACC_GYRO_OUTX_H_XL 0x29
#define LSM6DSL_ACC_GYRO_OUTY_L_XL 0x2A
#define LSM6DSL_ACC_GYRO_OUTY_H_XL 0x2B
#define LSM6DSL_ACC_GYRO_OUTZ_L_XL 0x2C
#define LSM6DSL_ACC_GYRO_OUTZ_H_XL 0x2D
#define LSM6DSL_ACC_GYRO_SENSORHUB1_REG 0x2E
#define LSM6DSL_ACC_GYRO_SENSORHUB2_REG 0x2F
#define LSM6DSL_ACC_GYRO_SENSORHUB3_REG 0x30
#define LSM6DSL_ACC_GYRO_SENSORHUB4_REG 0x31
#define LSM6DSL_ACC_GYRO_SENSORHUB5_REG 0x32
#define LSM6DSL_ACC_GYRO_SENSORHUB6_REG 0x33
#define LSM6DSL_ACC_GYRO_SENSORHUB7_REG 0x34
#define LSM6DSL_ACC_GYRO_SENSORHUB8_REG 0x35
#define LSM6DSL_ACC_GYRO_SENSORHUB9_REG 0x36
#define LSM6DSL_ACC_GYRO_SENSORHUB10_REG 0x37
#define LSM6DSL_ACC_GYRO_SENSORHUB11_REG 0x38
#define LSM6DSL_ACC_GYRO_SENSORHUB12_REG 0x39
#define LSM6DSL_ACC_GYRO_FIFO_STATUS1 0x3A
#define LSM6DSL_ACC_GYRO_FIFO_STATUS2 0x3B
#define LSM6DSL_ACC_GYRO_FIFO_STATUS3 0x3C
#define LSM6DSL_ACC_GYRO_FIFO_STATUS4 0x3D
#define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L 0x3E
#define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_H 0x3F
#define LSM6DSL_ACC_GYRO_TIMESTAMP0_REG 0x40
#define LSM6DSL_ACC_GYRO_TIMESTAMP1_REG 0x41
#define LSM6DSL_ACC_GYRO_TIMESTAMP2_REG 0x42
#define LSM6DSL_ACC_GYRO_TIMESTAMP_L 0x49
#define LSM6DSL_ACC_GYRO_TIMESTAMP_H 0x4A
#define LSM6DSL_ACC_GYRO_STEP_COUNTER_L 0x4B
#define LSM6DSL_ACC_GYRO_STEP_COUNTER_H 0x4C
#define LSM6DSL_ACC_GYRO_SENSORHUB13_REG 0x4D
#define LSM6DSL_ACC_GYRO_SENSORHUB14_REG 0x4E
#define LSM6DSL_ACC_GYRO_SENSORHUB15_REG 0x4F
#define LSM6DSL_ACC_GYRO_SENSORHUB16_REG 0x50
#define LSM6DSL_ACC_GYRO_SENSORHUB17_REG 0x51
#define LSM6DSL_ACC_GYRO_SENSORHUB18_REG 0x52
#define LSM6DSL_ACC_GYRO_FUNC_SRC 0x53
#define LSM6DSL_ACC_GYRO_TAP_CFG1 0x58
#define LSM6DSL_ACC_GYRO_TAP_THS_6D 0x59
#define LSM6DSL_ACC_GYRO_INT_DUR2 0x5A
#define LSM6DSL_ACC_GYRO_WAKE_UP_THS 0x5B
#define LSM6DSL_ACC_GYRO_WAKE_UP_DUR 0x5C
#define LSM6DSL_ACC_GYRO_FREE_FALL 0x5D
#define LSM6DSL_ACC_GYRO_MD1_CFG 0x5E
#define LSM6DSL_ACC_GYRO_MD2_CFG 0x5F
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_L 0x66
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_H 0x67
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_L 0x68
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_H 0x69
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_L 0x6A
#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_H 0x6B
#define LSM6DSL_ACC_GYRO_X_OFS_USR 0x73
#define LSM6DSL_ACC_GYRO_Y_OFS_USR 0x74
#define LSM6DSL_ACC_GYRO_Z_OFS_USR 0x75
#define LSM6DSL_CHIP_ID_VALUE (0x6A)
#define LSM6DSL_RESET_VALUE (0x1)
#define LSM6DSL_RESET_MSK (0X1)
#define LSM6DSL_RESET_POS (0)
#define LSM6DSL_ACC_ODR_POWER_DOWN (0X00)
#define LSM6DSL_ACC_ODR_1_6_HZ (0X0B)
#define LSM6DSL_ACC_ODR_12_5_HZ (0x01)
#define LSM6DSL_ACC_ODR_26_HZ (0x02)
#define LSM6DSL_ACC_ODR_52_HZ (0x03)
#define LSM6DSL_ACC_ODR_104_HZ (0x04)
#define LSM6DSL_ACC_ODR_208_HZ (0x05)
#define LSM6DSL_ACC_ODR_416_HZ (0x06)
#define LSM6DSL_ACC_ODR_833_HZ (0x07)
#define LSM6DSL_ACC_ODR_1_66_KHZ (0x08)
#define LSM6DSL_ACC_ODR_3_33_KHZ (0x09)
#define LSM6DSL_ACC_ODR_6_66_KHZ (0x0A)
#define LSM6DSL_ACC_ODR_MSK (0XF0)
#define LSM6DSL_ACC_ODR_POS (4)
#define LSM6DSL_GYRO_ODR_POWER_DOWN (0X00)
#define LSM6DSL_GYRO_ODR_12_5_HZ (0x01)
#define LSM6DSL_GYRO_ODR_26_HZ (0x02)
#define LSM6DSL_GYRO_ODR_52_HZ (0x03)
#define LSM6DSL_GYRO_ODR_104_HZ (0x04)
#define LSM6DSL_GYRO_ODR_208_HZ (0x05)
#define LSM6DSL_GYRO_ODR_416_HZ (0x06)
#define LSM6DSL_GYRO_ODR_833_HZ (0x07)
#define LSM6DSL_GYRO_ODR_1_66_KHZ (0x08)
#define LSM6DSL_GYRO_ODR_3_33_KHZ (0x09)
#define LSM6DSL_GYRO_ODR_6_66_KHZ (0x0A)
#define LSM6DSL_GYRO_ODR_MSK (0XF0)
#define LSM6DSL_GYRO_ODR_POS (4)
#define LSM6DSL_ACC_RANGE_2G (0x0)
#define LSM6DSL_ACC_RANGE_4G (0x2)
#define LSM6DSL_ACC_RANGE_8G (0x3)
#define LSM6DSL_ACC_RANGE_16G (0x1)
#define LSM6DSL_ACC_RANGE_MSK (0X0C)
#define LSM6DSL_ACC_RANGE_POS (2)
#define LSM6DSL_ACC_SENSITIVITY_2G (61)
#define LSM6DSL_ACC_SENSITIVITY_4G (122)
#define LSM6DSL_ACC_SENSITIVITY_8G (244)
#define LSM6DSL_ACC_SENSITIVITY_16G (488)
#define LSM6DSL_GYRO_RANGE_245 (0x0)
#define LSM6DSL_GYRO_RANGE_500 (0x1)
#define LSM6DSL_GYRO_RANGE_1000 (0x2)
#define LSM6DSL_GYRO_RANGE_2000 (0x3)
#define LSM6DSL_GYRO_RANGE_MSK (0X0C)
#define LSM6DSL_GYRO_RANGE_POS (2)
#define LSM6DSL_GYRO_SENSITIVITY_245DPS (8750)
#define LSM6DSL_GYRO_SENSITIVITY_500DPS (17500)
#define LSM6DSL_GYRO_SENSITIVITY_1000DPS (35000)
#define LSM6DSL_GYRO_SENSITIVITY_2000DPS (70000)
#define LSM6DSL_SHIFT_EIGHT_BITS (8)
#define LSM6DSL_16_BIT_SHIFT (0xFF)
#define LSM6DSL_ACC_MUL (1000)
#define LSM6DSL_GYRO_MUL (1)
#define LSM6DSL_ACC_DEFAULT_ODR_100HZ (100)
#define LSM6DSL_GYRO_DEFAULT_ODR_100HZ (100)
#define LSM6DSL_GET_BITSLICE(regvar, bitname)\
((regvar & bitname##_MSK) >> bitname##_POS)
#define LSM6DSL_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK))
static int32_t lsm6dsl_acc_factor[ACC_RANGE_MAX] = { LSM6DSL_ACC_SENSITIVITY_2G, LSM6DSL_ACC_SENSITIVITY_4G,
LSM6DSL_ACC_SENSITIVITY_8G, LSM6DSL_ACC_SENSITIVITY_16G };
static int32_t lsm6dsl_gyro_factor[GYRO_RANGE_MAX] = {0, LSM6DSL_GYRO_SENSITIVITY_245DPS, LSM6DSL_GYRO_SENSITIVITY_500DPS,
LSM6DSL_GYRO_SENSITIVITY_1000DPS, LSM6DSL_GYRO_SENSITIVITY_2000DPS };
static int32_t cur_acc_factor = 0;
static int32_t cur_gyro_factor = 0;
static int32_t g_lsm6dslflag = 0;
i2c_dev_t lsm6dsl_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LSM6DSL_I2C_ADDR,
};
static int drv_acc_gyro_st_lsm6dsl_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0x00;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value |= LSM6DSL_RESET_VALUE;
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL3_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_gyro_st_lsm6dsl_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsl_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value,value1 = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_ACC_ODR,LSM6DSL_ACC_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_acc_st_lsm6dsl_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSL_ACC_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSL_ACC_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSL_ACC_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSL_ACC_ODR_833_HZ;
else if(hz > 208)
return LSM6DSL_ACC_ODR_416_HZ;
else if(hz > 104)
return LSM6DSL_ACC_ODR_208_HZ;
else if(hz > 52)
return LSM6DSL_ACC_ODR_104_HZ;
else if(hz > 26)
return LSM6DSL_ACC_ODR_52_HZ;
else if(hz > 13)
return LSM6DSL_ACC_ODR_26_HZ;
else if(hz >= 2)
return LSM6DSL_ACC_ODR_12_5_HZ;
else
return LSM6DSL_ACC_ODR_1_6_HZ;
}
static int drv_acc_st_lsm6dsl_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_acc_st_lsm6dsl_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_ACC_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_acc_st_lsm6dsl_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case ACC_RANGE_2G:{
tmp = LSM6DSL_ACC_RANGE_2G;
}break;
case ACC_RANGE_4G:{
tmp = LSM6DSL_ACC_RANGE_4G;
}break;
case ACC_RANGE_8G:{
tmp = LSM6DSL_ACC_RANGE_8G;
}break;
case ACC_RANGE_16G:{
tmp = LSM6DSL_ACC_RANGE_16G;
}break;
default:break;
}
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_ACC_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= ACC_RANGE_2G)&&(range <= ACC_RANGE_16G)){
cur_acc_factor = lsm6dsl_acc_factor[range];
}
return 0;
}
static void drv_acc_st_lsm6dsl_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_st_lsm6dsl_open(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsl_set_range(&lsm6dsl_ctx, ACC_RANGE_8G);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsl_set_odr(&lsm6dsl_ctx, LSM6DSL_ACC_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsl_close(void)
{
int ret = 0;
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_acc_st_lsm6dsl_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
accel_data_t *accel = (accel_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_L_XL, &reg[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_H_XL, &reg[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_L_XL, &reg[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_H_XL, &reg[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_L_XL, &reg[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_H_XL, &reg[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
accel->data[DATA_AXIS_X] = (int16_t)((((int16_t)((int8_t)reg[1]))<< LSM6DSL_SHIFT_EIGHT_BITS)|(reg[0]));
accel->data[DATA_AXIS_Y] = (int16_t)((((int16_t)((int8_t)reg[3]))<< LSM6DSL_SHIFT_EIGHT_BITS)|(reg[2]));
accel->data[DATA_AXIS_Z] = (int16_t)((((int16_t)((int8_t)reg[5]))<< LSM6DSL_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_acc_factor != 0){
accel->data[DATA_AXIS_X] = (accel->data[DATA_AXIS_X] * cur_acc_factor)/LSM6DSL_ACC_MUL;
accel->data[DATA_AXIS_Y] = (accel->data[DATA_AXIS_Y] * cur_acc_factor)/LSM6DSL_ACC_MUL;
accel->data[DATA_AXIS_Z] = (accel->data[DATA_AXIS_Z] * cur_acc_factor)/LSM6DSL_ACC_MUL;
}
accel->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_st_lsm6dsl_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_acc_st_lsm6dsl_set_odr(&lsm6dsl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_acc_st_lsm6dsl_set_range(&lsm6dsl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t*)arg;
info->model = "LSM6DSL";
info->range_max = 16;
info->range_min = 2;
info->unit = mg;
}break;
default:break;
}
return 0;
}
int drv_acc_st_lsm6dsl_init(void){
int ret = 0;
sensor_obj_t sensor;
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.open = drv_acc_st_lsm6dsl_open;
sensor.close = drv_acc_st_lsm6dsl_close;
sensor.read = drv_acc_st_lsm6dsl_read;
sensor.write = NULL;
sensor.ioctl = drv_acc_st_lsm6dsl_ioctl;
sensor.irq_handle = drv_acc_st_lsm6dsl_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsl_validate_id(&lsm6dsl_ctx, LSM6DSL_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_lsm6dslflag)
{
ret = drv_acc_gyro_st_lsm6dsl_soft_reset(&lsm6dsl_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
g_lsm6dslflag = 1;
}
else
{
LOG("%s %s acc do not need reset\n", SENSOR_STR, __func__);
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_gyro_st_lsm6dsl_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value,value1 = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_POWER_DOWN);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_SLEEP:{
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_GYRO_ODR,LSM6DSL_GYRO_ODR_12_5_HZ);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_gyro_st_lsm6dsl_hz2odr(uint32_t hz)
{
if(hz > 3330)
return LSM6DSL_GYRO_ODR_6_66_KHZ;
else if(hz > 1660)
return LSM6DSL_GYRO_ODR_3_33_KHZ;
else if(hz > 833)
return LSM6DSL_GYRO_ODR_1_66_KHZ;
else if(hz > 416)
return LSM6DSL_GYRO_ODR_833_HZ;
else if(hz > 208)
return LSM6DSL_GYRO_ODR_416_HZ;
else if(hz > 104)
return LSM6DSL_GYRO_ODR_208_HZ;
else if(hz > 52)
return LSM6DSL_GYRO_ODR_104_HZ;
else if(hz > 26)
return LSM6DSL_GYRO_ODR_52_HZ;
else if(hz > 13)
return LSM6DSL_GYRO_ODR_26_HZ;
else
return LSM6DSL_GYRO_ODR_12_5_HZ;
}
static int drv_gyro_st_lsm6dsl_set_odr(i2c_dev_t* drv, uint32_t hz)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t odr = drv_gyro_st_lsm6dsl_hz2odr(hz);
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_GYRO_ODR,odr);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_gyro_st_lsm6dsl_set_range(i2c_dev_t* drv, uint32_t range)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t tmp = 0;
ret = sensor_i2c_read(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch (range){
case GYRO_RANGE_250DPS:{
tmp = LSM6DSL_GYRO_RANGE_245;
}break;
case GYRO_RANGE_500DPS:{
tmp = LSM6DSL_GYRO_RANGE_500;
}break;
case GYRO_RANGE_1000DPS:{
tmp = LSM6DSL_GYRO_RANGE_1000;
}break;
case GYRO_RANGE_2000DPS:{
tmp = LSM6DSL_GYRO_RANGE_2000;
}break;
default:break;
}
value = LSM6DSL_SET_BITSLICE(value,LSM6DSL_GYRO_RANGE,tmp);
ret = sensor_i2c_write(drv, LSM6DSL_ACC_GYRO_CTRL2_G, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){
cur_gyro_factor = lsm6dsl_gyro_factor[range];
}
return 0;
}
static void drv_gyro_st_lsm6dsl_irq_handle(void)
{
/* no handle so far */
}
static int drv_gyro_st_lsm6dsl_open(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsl_set_range(&lsm6dsl_ctx, GYRO_RANGE_1000DPS);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsl_set_odr(&lsm6dsl_ctx, LSM6DSL_GYRO_DEFAULT_ODR_100HZ);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsl_close(void)
{
int ret = 0;
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_gyro_st_lsm6dsl_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg[6];
gyro_data_t *gyro = (gyro_data_t *)buf;
if(buf == NULL){
return -1;
}
size = sizeof(gyro_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_L_G, &reg[0], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTX_H_G, &reg[1], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_L_G, &reg[2], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTY_H_G, &reg[3], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_L_G, &reg[4], I2C_REG_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lsm6dsl_ctx, LSM6DSL_ACC_GYRO_OUTZ_H_G, &reg[5], I2C_REG_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< LSM6DSL_SHIFT_EIGHT_BITS)|(reg[0]));
gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< LSM6DSL_SHIFT_EIGHT_BITS)|(reg[2]));
gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< LSM6DSL_SHIFT_EIGHT_BITS)|(reg[4]));
if(cur_gyro_factor != 0){
gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor)/LSM6DSL_GYRO_MUL;
gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor)/LSM6DSL_GYRO_MUL;
gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor)/LSM6DSL_GYRO_MUL;
}
gyro->timestamp = aos_now_ms();
return (int)size;
}
static int drv_gyro_st_lsm6dsl_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
ret = drv_gyro_st_lsm6dsl_set_odr(&lsm6dsl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_RANGE_SET:{
ret = drv_gyro_st_lsm6dsl_set_range(&lsm6dsl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LSM6DSL";
info->range_max = 2000;
info->range_min = 125;
info->unit = udps;
}break;
default:break;
}
return 0;
}
int drv_gyro_st_lsm6dsl_init(void){
int ret = 0;
sensor_obj_t sensor;
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_GYRO;
sensor.path = dev_gyro_path;
sensor.open = drv_gyro_st_lsm6dsl_open;
sensor.close = drv_gyro_st_lsm6dsl_close;
sensor.read = drv_gyro_st_lsm6dsl_read;
sensor.write = NULL;
sensor.ioctl = drv_gyro_st_lsm6dsl_ioctl;
sensor.irq_handle = drv_gyro_st_lsm6dsl_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_acc_gyro_st_lsm6dsl_validate_id(&lsm6dsl_ctx, LSM6DSL_CHIP_ID_VALUE);
if(unlikely(ret)){
return -1;
}
if(0 == g_lsm6dslflag){
ret = drv_acc_gyro_st_lsm6dsl_soft_reset(&lsm6dsl_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_gyro_st_lsm6dsl_set_power_mode(&lsm6dsl_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
g_lsm6dslflag = 1;
}
else{
LOG("%s %s gyro do not need reset\n", SENSOR_STR, __func__);
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

429
Living_SDK/device/sensor/drv/drv_acc_mir3_da217.c Normal file
View file

@ -0,0 +1,429 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_NEWDATA_FLAG 0x0A
#define NSA_REG_STEPS_MSB 0x0D
#define NSA_REG_STEPS_LSB 0x0E
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_FIFO_CTRL 0x14
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_TAP_DURATION 0x2A
#define NSA_REG_TAP_THRESHOLD 0x2B
#define NSA_REG_STEP_CONGIF1 0x2F
#define NSA_REG_STEP_CONGIF2 0x30
#define NSA_REG_STEP_CONGIF3 0x31
#define NSA_REG_STEP_CONGIF4 0x32
#define NSA_REG_STEP_FILTER 0x33
#define NSA_REG_CUSTOM_OFFSET_X 0x38
#define NSA_REG_CUSTOM_OFFSET_Y 0x39
#define NSA_REG_CUSTOM_OFFSET_Z 0x3a
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENSITIVITY_TRIM_X 0x80
#define NSA_REG_SENSITIVITY_TRIM_Y 0x81
#define NSA_REG_SENSITIVITY_TRIM_Z 0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X 0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y 0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z 0x85
#define NSA_REG_FINE_OFFSET_TRIM_X 0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y 0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z 0x88
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_SENS_COARSE_TRIM 0xd1
#define DA217_NORMAL_MODE 0x00
#define DA217_SUSPEND_MODE 0x01
#define DA217_I2C_SLAVE_ADDR_LOW (0x26)
#define DA217_I2C_SLAVE_ADDR_HIGN (0x27)
#define DA217_ACC_DATA_SIZE 6
#define DA217_CHIP_ID_VAL 0x13
#define DA217_ADDR_TRANS(n) ((n) << 1)
#define DA217_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define DA217_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
i2c_dev_t da217_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = DA217_ADDR_TRANS(DA217_I2C_SLAVE_ADDR_HIGN)
};
static int drv_acc_mir3_da217_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, NSA_REG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_acc_mir3_da217_open_step_counter(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x01;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF1,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x62;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x46;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF3,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x32;
ret = sensor_i2c_write(drv, NSA_REG_STEP_CONGIF4,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xa2;
ret = sensor_i2c_write(drv, NSA_REG_STEP_FILTER,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da217_close_step_counter(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x22;
ret = sensor_i2c_write(drv, NSA_REG_STEP_FILTER,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da217_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)0x80;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)0x30;
break;
}
default:return -1;
}
ret = sensor_i2c_write(drv, NSA_REG_POWERMODE_BW, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_acc_mir3_da217_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = 0x83;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x69;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0xbd;
ret = sensor_i2c_write(drv, NSA_REG_ENGINEERING_MODE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
if (value == 0) {
value = 0x50;
ret = sensor_i2c_write(drv, 0x8e, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
}
value = 0x40;
ret = sensor_i2c_write(drv, NSA_REG_G_RANGE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x00;
ret = sensor_i2c_write(drv, NSA_REG_INT_PIN_CONFIG,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da217_set_power_mode(drv, DEV_SLEEP);
if (unlikely(ret)) {
return ret;
}
value = 0x07;
ret = sensor_i2c_write(drv, NSA_REG_ODR_AXIS_DISABLE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = drv_acc_mir3_da217_close_step_counter(drv);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_MAPPING2,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0x04;
ret = sensor_i2c_write(drv, NSA_REG_INTERRUPT_SETTINGS0,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_acc_mir3_da217_irq_handle(void)
{
/* no handle so far */
}
static int drv_acc_mir3_da217_open(void)
{
int ret = 0;
ret = drv_acc_mir3_da217_set_power_mode(&da217_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da217_open_step_counter(&da217_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da217_close(void)
{
int ret = 0;
ret = drv_acc_mir3_da217_close_step_counter(&da217_ctx);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da217_set_power_mode(&da217_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_acc_mir3_da217_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t acc_raw[DA217_ACC_DATA_SIZE] = {0};
accel_data_t* pdata = (accel_data_t*)buf;
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
uint8_t step_raw[2] = {0};
#endif
if(buf == NULL){
return -1;
}
size = sizeof(accel_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&da217_ctx, NSA_REG_ACC_X_LSB, acc_raw, DA217_ACC_DATA_SIZE, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->data[0] = (int32_t)((int16_t)(acc_raw[1] << 8 | acc_raw[0]) >> 4);
pdata->data[1] = (int32_t)((int16_t)(acc_raw[3] << 8 | acc_raw[2]) >> 4);
pdata->data[2] = (int32_t)((int16_t)(acc_raw[5] << 8 | acc_raw[4]) >> 4);
#ifdef AOS_SENSOR_ACC_SUPPORT_STEP
ret = sensor_i2c_read(&da217_ctx, NSA_REG_STEPS_MSB, step_raw, 2, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->step = ((uint16_t)((step_raw[0] << 8 | step_raw[1]))) / 2;
#endif
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_acc_mir3_da217_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_acc_mir3_da217_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_acc_mir3_da217_set_power_mode(&da217_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "DA217";
info->unit = mg;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_acc_mir3_da217_init(void)
{
int ret = 0;
sensor_obj_t sensor;
uint16_t addr_val = 0;
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_ACC;
sensor.path = dev_acc_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_acc_mir3_da217_open;
sensor.close = drv_acc_mir3_da217_close;
sensor.read = drv_acc_mir3_da217_read;
sensor.write = drv_acc_mir3_da217_write;
sensor.ioctl = drv_acc_mir3_da217_ioctl;
sensor.irq_handle = drv_acc_mir3_da217_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da217_validate_id(&da217_ctx, DA217_CHIP_ID_VAL);
if(unlikely(ret)) {
return -1;
}
ret = drv_acc_mir3_da217_set_default_config(&da217_ctx);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

676
Living_SDK/device/sensor/drv/drv_als_ps_liteon_ltr553.c Normal file
View file

@ -0,0 +1,676 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define LTR553_ALS_CONTR 0x80 /* ALS operation mode, SW reset */
#define LTR553_PS_CONTR 0x81 /* PS operation mode */
#define LTR553_PS_LED 0x82 /* LED pulse freq, current duty, peak current */
#define LTR553_PS_MEAS_RATE 0x84 /* measurement rate*/
#define LTR553_ALS_MEAS_RATE 0x85 /* ALS integ time, measurement rate*/
#define LTR553_PART_ID 0x86
#define LTR553_MANUFAC_ID 0x87
#define LTR553_ALS_DATA1_L 0x88
#define LTR553_ALS_DATA1_H 0x89
#define LTR553_ALS_DATA0_L 0x8a
#define LTR553_ALS_DATA0_H 0x8b
#define LTR553_ALS_PS_STATUS 0x8c
#define LTR553_PS_DATA_L 0x8d
#define LTR553_PS_DATA_H 0x8e
#define LTR553_INTR 0x8f /* output mode, polarity, mode */
#define LTR553_PS_THRESH_UP 0x90 /* 11 bit, ps upper threshold */
#define LTR553_PS_THRESH_LOW 0x92 /* 11 bit, ps lower threshold */
#define LTR553_ALS_THRESH_UP 0x97 /* 16 bit, ALS upper threshold */
#define LTR553_ALS_THRESH_LOW 0x99 /* 16 bit, ALS lower threshold */
#define LTR553_INTR_PRST 0x9e /* ps thresh, als thresh */
#define LTR553_MAX_REG 0x9f
#define LTR553_I2C_SLAVE_ADDR 0x23
#define LTR553_ADDR_TRANS(n) ((n) << 1)
#define LTR553_I2C_ADDR LTR553_ADDR_TRANS(LTR553_I2C_SLAVE_ADDR)
#define LTR553_PART_ID_VAL 0x92
#define LTR553_MANUFAC_ID_VAL 0x05
#define LTR553_ALS_CONTR_REG_ALS_GAIN__POS (2)
#define LTR553_ALS_CONTR_REG_ALS_GAIN__MSK (0x1c)
#define LTR553_ALS_CONTR_REG_ALS_GAIN__REG (LTR553_ALS_CONTR)
#define LTR553_ALS_CONTR_REG_ALS_MODE__POS (0)
#define LTR553_ALS_CONTR_REG_ALS_MODE__MSK (0x01)
#define LTR553_ALS_CONTR_REG_ALS_MODE__REG (LTR553_ALS_CONTR)
#define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__POS (3)
#define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__MSK (0x38)
#define LTR553_ALS_MEAS_RATE_REG_INTEG_TIME__REG (LTR553_ALS_MEAS_RATE)
#define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07)
#define LTR553_ALS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_ALS_MEAS_RATE)
#define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__POS (2)
#define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__MSK (0x04)
#define LTR553_ALS_PS_STATUS_REG_ALS_STATUS__REG (LTR553_ALS_PS_STATUS)
#define LTR553_PS_CONTR_REG_PS_GAIN__POS (2)
#define LTR553_PS_CONTR_REG_PS_GAIN__MSK (0x0c)
#define LTR553_PS_CONTR_REG_PS_GAIN__REG (LTR553_PS_CONTR)
#define LTR553_PS_CONTR_REG_PS_MODE__POS (0)
#define LTR553_PS_CONTR_REG_PS_MODE__MSK (0x03)
#define LTR553_PS_CONTR_REG_PS_MODE__REG (LTR553_PS_CONTR)
#define LTR553_PS_LED_REG_PLUSE_FREQ__POS (5)
#define LTR553_PS_LED_REG_PLUSE_FREQ__MSK (0xe0)
#define LTR553_PS_LED_REG_PLUSE_FREQ__REG (LTR553_PS_LED)
#define LTR553_PS_LED_REG_CURRENT_DUTY__POS (3)
#define LTR553_PS_LED_REG_CURRENT_DUTY__MSK (0x18)
#define LTR553_PS_LED_REG_CURRENT_DUTY__REG (LTR553_PS_LED)
#define LTR553_PS_LED_REG_CURRENT__POS (0)
#define LTR553_PS_LED_REG_CURRENT__MSK (0x07)
#define LTR553_PS_LED_REG_CURRENT__REG (LTR553_PS_LED)
#define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__POS (0)
#define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x0F)
#define LTR553_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR553_PS_MEAS_RATE)
#define LTR553_ALS_PS_STATUS_REG_PS_STATUS__POS (0)
#define LTR553_ALS_PS_STATUS_REG_PS_STATUS__MSK (0x01)
#define LTR553_ALS_PS_STATUS_REG_PS_STATUS__REG (LTR553_ALS_PS_STATUS)
#define LTR553_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define LTR553_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
#define LTR553_WAIT_TIME_PER_CHECK (10)
#define LTR553_WAIT_TIME_TOTAL (1000)
typedef enum {
AG_GAIN_1X = 0x0, /* 1 lux to 64k lux (default) */
AG_GAIN_2X = 0x1, /* 0.5 lux to 32k lux */
AG_GAIN_4X = 0x2, /* 0.25 lux to 16k lux */
AG_GAIN_8X = 0x3, /* 0.125 lux to 8k lux */
AG_GAIN_48X = 0x6, /* 0.02 lux to 1.3k lux */
AG_GAIN_96X = 0x7, /* 0.01 lux to 600 lux */
} CFG_ALS_Gain;
typedef enum {
PG_GAIN_X16 = 0x0, /* X16 (default) */
PG_GAIN_X32 = 0x2, /* X32 */
PG_GAIN_X64 = 0x3, /* X64 */
} CFG_PS_Gain;
typedef enum {
LPMF_PERIOD_30K = 0x0, /* LED pulse period = 30kHz */
LPMF_PERIOD_40K = 0x1, /* LED pulse period = 40kHz */
LPMF_PERIOD_50K = 0x2, /* LED pulse period = 50kHz */
LPMF_PERIOD_60K = 0x3, /* LED pulse period = 60kHz(default) */
LPMF_PERIOD_70K = 0x4, /* LED pulse period = 70kHz */
LPMF_PERIOD_80K = 0x5, /* LED pulse period = 80kHz */
LPMF_PERIOD_90K = 0x6, /* LED pulse period = 90kHz */
LPMF_PERIOD_100K = 0x7, /* LED pulse period = 100kHz */
} CFG_LED_pulse_Modulation_Frequency;
typedef enum {
LCD_PER_25 = 0x0, /* DUTY = 25% */
LCD_PER_50 = 0x1, /* DUTY = 50% */
LCD_PER_75 = 0x2, /* DUTY = 75% */
LCD_PER_100 = 0x3, /* DUTY = 100%(default) */
} CFG_LED_Current_DUTY;
typedef enum {
LC_LEVEL_5 = 0x0, /* LED pulse current level = 5mA */
LC_LEVEL_10 = 0x1, /* LED pulse current level = 10mA */
LC_LEVEL_20 = 0x2, /* LED pulse current level = 20mA */
LC_LEVEL_50 = 0x3, /* LED pulse current level = 50mA */
LC_LEVEL_100 = 0x4, /* LED pulse current level = 100mA(default) */
} CFG_LED_Current;
typedef enum {
PMR_RATE_50 = 0x0, /* PS Measurement Repeat Rate = 50ms */
PMR_RATE_70 = 0x1, /* PS Measurement Repeat Rate = 70ms */
PMR_RATE_100 = 0x2, /* PS Measurement Repeat Rate = 100ms(default) */
PMR_RATE_200 = 0x3, /* PS Measurement Repeat Rate = 200ms */
PMR_RATE_500 = 0x4, /* PS Measurement Repeat Rate = 500ms */
PMR_RATE_1000 = 0x5, /* PS Measurement Repeat Rate = 1000ms */
PMR_RATE_2000 = 0x6, /* PS Measurement Repeat Rate = 2000ms */
PMR_RATE_10 = 0x8, /* PS Measurement Repeat Rate = 10ms */
} CFG_PS_measurement_rate;
typedef enum {
AIT_TIME_100 = 0x0, /* ALS integration_time = 100ms(default) */
AIT_TIME_50 = 0x1, /* ALS integration_time = 50ms */
AIT_TIME_200 = 0x2, /* ALS integration_time = 200ms */
AIT_TIME_400 = 0x3, /* ALS integration_time = 400ms */
AIT_TIME_150 = 0x4, /* ALS integration_time = 150ms */
AIT_TIME_250 = 0x5, /* ALS integration_time = 250ms */
AIT_TIME_300 = 0x6, /* ALS integration_time = 300ms */
AIT_TIME_350 = 0x7, /* ALS integration_time = 350ms */
} CFG_ALS_integration_time;
typedef enum {
AMR_RATE_50 = 0x0, /* ALS Measurement Repeat Rate = 50ms */
AMR_RATE_100 = 0x1, /* ALS Measurement Repeat Rate = 100ms */
AMR_RATE_200 = 0x2, /* ALS Measurement Repeat Rate = 200ms */
AMR_RATE_500 = 0x3, /* ALS Measurement Repeat Rate = 500ms(default) */
AMR_RATE_1000 = 0x4, /* ALS Measurement Repeat Rate = 1000ms */
AMR_RATE_2000 = 0x5, /* ALS Measurement Repeat Rate = 2000ms */
} CFG_ALS_measurement_rate;
typedef enum {
PM_MODE_STANDBY = 0,
PM_MODE_ACTIVE = 3,
} CFG_PS_mode;
typedef enum {
AM_MODE_STANDBY = 0,
AM_MODE_ACTIVE = 1,
} CFG_ALS_mode;
typedef enum {
ADS_STATUS_OLD = 0,
ADS_STATUS_NEW = 1,
} CFG_ALS_data_status;
typedef enum {
PDS_STATUS_OLD = 0,
PDS_STATUS_NEW = 1,
} CFG_PS_data_status;
typedef enum {
FLAG_INIT_ALS = 0,
FLAG_INIT_PS,
} FLAG_INIT_BIT;
i2c_dev_t ltr553_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = LTR553_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
static int drv_als_ps_liteon_ltr553_validate_id(i2c_dev_t* drv, uint8_t part_id, uint8_t manufac_id)
{
int ret = 0;
uint8_t part_id_value = 0;
uint8_t manufac_id_value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LTR553_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR553_MANUFAC_ID, &manufac_id_value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
if (part_id_value != part_id || manufac_id_value != manufac_id) {
return -1;
}
return 0;
}
static int drv_als_liteon_ltr553_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
int wait_time = 0;
ret = sensor_i2c_read(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR553_SET_BITSLICE(dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR553_SET_BITSLICE(dev_mode, LTR553_ALS_CONTR_REG_ALS_MODE, AM_MODE_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR553_ALS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr553_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t dev_mode = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:
dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE, PM_MODE_STANDBY);
break;
case DEV_POWER_ON:
dev_mode = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_MODE, PM_MODE_ACTIVE);
break;
default:
return -1;
}
ret = sensor_i2c_write(drv, LTR553_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_als_liteon_ltr553_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_ALS_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_ALS_STATUS) == ADS_STATUS_NEW) ? 1 : 0;
return ret;
}
static int drv_ps_liteon_ltr553_is_ready(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
ret = sensor_i2c_read(drv, LTR553_ALS_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return 0;
}
ret = (LTR553_GET_BITSLICE(value, LTR553_ALS_PS_STATUS_REG_PS_STATUS) == PDS_STATUS_NEW) ? 1 : 0;
return ret;
}
static int drv_als_liteon_ltr553_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_INTEG_TIME, AIT_TIME_100);
value = LTR553_SET_BITSLICE(value, LTR553_ALS_MEAS_RATE_REG_MEAS_RATE, AMR_RATE_100);
ret = sensor_i2c_write(drv, LTR553_ALS_MEAS_RATE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR553_ALS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR553_SET_BITSLICE(value, LTR553_ALS_CONTR_REG_ALS_GAIN, AG_GAIN_1X);
ret = sensor_i2c_write(drv, LTR553_ALS_CONTR,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static int drv_ps_liteon_ltr553_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
uint8_t value = 0;
value = LTR553_SET_BITSLICE(value, LTR553_PS_MEAS_RATE_REG_MEAS_RATE, PMR_RATE_100);
ret = sensor_i2c_write(drv, LTR553_PS_MEAS_RATE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = 0;
value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_PLUSE_FREQ, LPMF_PERIOD_60K);
value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT_DUTY, LCD_PER_100);
value = LTR553_SET_BITSLICE(value, LTR553_PS_LED_REG_CURRENT, LC_LEVEL_100);
ret = sensor_i2c_write(drv, LTR553_PS_MEAS_RATE,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
ret = sensor_i2c_read(drv, LTR553_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
value = LTR553_SET_BITSLICE(value, LTR553_PS_CONTR_REG_PS_GAIN, PG_GAIN_X16);
ret = sensor_i2c_write(drv, LTR553_PS_CONTR,
&value, I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return ret;
}
return 0;
}
static void drv_als_liteon_ltr553_irq_handle(void)
{
/* no handle so far */
}
static int drv_als_liteon_ltr553_open(void)
{
int ret = 0;
ret = drv_als_liteon_ltr553_set_power_mode(&ltr553_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr553_close(void)
{
int ret = 0;
ret = drv_als_liteon_ltr553_set_power_mode(&ltr553_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_als_liteon_ltr553_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint16_t als_raw[2] = {0};
uint8_t reg_ch0[2] = {0};
uint8_t reg_ch1[2] = {0};
als_data_t* pdata = (als_data_t*)buf;
int wait_time = 0;
if(buf == NULL){
return -1;
}
size = sizeof(als_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&ltr553_ctx, LTR553_ALS_DATA1_L, &reg_ch1[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(&ltr553_ctx, LTR553_ALS_DATA1_H, &reg_ch1[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(&ltr553_ctx, LTR553_ALS_DATA0_L, &reg_ch0[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(&ltr553_ctx, LTR553_ALS_DATA0_H, &reg_ch0[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
als_raw[0] = (uint16_t)reg_ch0[1] << 8 | reg_ch0[0];
als_raw[1] = (uint16_t)reg_ch1[1] << 8 | reg_ch1[0];
pdata->lux = (uint32_t)((als_raw[0] + als_raw[1]) >> 1);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_als_liteon_ltr553_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_als_liteon_ltr553_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_als_liteon_ltr553_set_power_mode(&ltr553_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LTR553";
info->unit = lux;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_ps_liteon_ltr553_irq_handle(void)
{
/* no handle so far */
}
static int drv_ps_liteon_ltr553_open(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr553_set_power_mode(&ltr553_ctx, DEV_POWER_ON);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr553_close(void)
{
int ret = 0;
ret = drv_ps_liteon_ltr553_set_power_mode(&ltr553_ctx, DEV_POWER_OFF);
if(unlikely(ret)) {
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_ps_liteon_ltr553_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t reg_data[2] = {0};
proximity_data_t* pdata = (proximity_data_t*)buf;
int wait_time = 0;
if(buf == NULL){
return -1;
}
size = sizeof(proximity_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&ltr553_ctx, LTR553_PS_DATA_L, &reg_data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
ret = sensor_i2c_read(&ltr553_ctx, LTR553_PS_DATA_H, &reg_data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
if (unlikely(ret)) {
return -1;
}
pdata->present = (uint32_t)(reg_data[1] << 8 | reg_data[0]);
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_ps_liteon_ltr553_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_ps_liteon_ltr553_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case SENSOR_IOCTL_SET_POWER:{
ret = drv_ps_liteon_ltr553_set_power_mode(&ltr553_ctx, arg);
if(unlikely(ret)) {
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LTR553";
info->unit = cm;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_als_liteon_ltr553_init(void)
{
int ret = 0;
sensor_obj_t sensor_als;
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr553_validate_id(&ltr553_ctx, LTR553_PART_ID_VAL, LTR553_MANUFAC_ID_VAL);
if(unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << FLAG_INIT_ALS))) {
/* fill the sensor_als obj parameters here */
sensor_als.tag = TAG_DEV_ALS;
sensor_als.path = dev_als_path;
sensor_als.io_port = I2C_PORT;
sensor_als.open = drv_als_liteon_ltr553_open;
sensor_als.close = drv_als_liteon_ltr553_close;
sensor_als.read = drv_als_liteon_ltr553_read;
sensor_als.write = drv_als_liteon_ltr553_write;
sensor_als.ioctl = drv_als_liteon_ltr553_ioctl;
sensor_als.irq_handle = drv_als_liteon_ltr553_irq_handle;
ret = sensor_create_obj(&sensor_als);
if(unlikely(ret)) {
return -1;
}
ret = drv_als_liteon_ltr553_set_default_config(&ltr553_ctx);
if(unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << FLAG_INIT_ALS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_ps_liteon_ltr553_init(void)
{
int ret = 0;
sensor_obj_t sensor_ps;
if (!g_init_bitwise) {
ret = drv_als_ps_liteon_ltr553_validate_id(&ltr553_ctx, LTR553_PART_ID_VAL, LTR553_MANUFAC_ID_VAL);
if(unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << FLAG_INIT_PS))) {
/* fill the sensor_ps obj parameters here */
sensor_ps.tag = TAG_DEV_PS;
sensor_ps.path = dev_ps_path;
sensor_ps.io_port = I2C_PORT;
sensor_ps.open = drv_ps_liteon_ltr553_open;
sensor_ps.close = drv_ps_liteon_ltr553_close;
sensor_ps.read = drv_ps_liteon_ltr553_read;
sensor_ps.write = drv_ps_liteon_ltr553_write;
sensor_ps.ioctl = drv_ps_liteon_ltr553_ioctl;
sensor_ps.irq_handle = drv_ps_liteon_ltr553_irq_handle;
ret = sensor_create_obj(&sensor_ps);
if(unlikely(ret)) {
return -1;
}
ret = drv_ps_liteon_ltr553_set_default_config(&ltr553_ctx);
if(unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << FLAG_INIT_PS;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

847
Living_SDK/device/sensor/drv/drv_baro_bosch_bmp280.c Normal file
View file

@ -0,0 +1,847 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define BMP280_TEMPERATURE_CALIB_DIG_T1_LSB_REG (0x88)
#define BMP280_TEMPERATURE_CALIB_DIG_T1_MSB_REG (0x89)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_LSB_REG (0x8A)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_MSB_REG (0x8B)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_LSB_REG (0x8C)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_MSB_REG (0x8D)
#define BMP280_PRESSURE_CALIB_DIG_P1_LSB_REG (0x8E)
#define BMP280_PRESSURE_CALIB_DIG_P1_MSB_REG (0x8F)
#define BMP280_PRESSURE_CALIB_DIG_P2_LSB_REG (0x90)
#define BMP280_PRESSURE_CALIB_DIG_P2_MSB_REG (0x91)
#define BMP280_PRESSURE_CALIB_DIG_P3_LSB_REG (0x92)
#define BMP280_PRESSURE_CALIB_DIG_P3_MSB_REG (0x93)
#define BMP280_PRESSURE_CALIB_DIG_P4_LSB_REG (0x94)
#define BMP280_PRESSURE_CALIB_DIG_P4_MSB_REG (0x95)
#define BMP280_PRESSURE_CALIB_DIG_P5_LSB_REG (0x96)
#define BMP280_PRESSURE_CALIB_DIG_P5_MSB_REG (0x97)
#define BMP280_PRESSURE_CALIB_DIG_P6_LSB_REG (0x98)
#define BMP280_PRESSURE_CALIB_DIG_P6_MSB_REG (0x99)
#define BMP280_PRESSURE_CALIB_DIG_P7_LSB_REG (0x9A)
#define BMP280_PRESSURE_CALIB_DIG_P7_MSB_REG (0x9B)
#define BMP280_PRESSURE_CALIB_DIG_P8_LSB_REG (0x9C)
#define BMP280_PRESSURE_CALIB_DIG_P8_MSB_REG (0x9D)
#define BMP280_PRESSURE_CALIB_DIG_P9_LSB_REG (0x9E)
#define BMP280_PRESSURE_CALIB_DIG_P9_MSB_REG (0x9F)
#define BMP280_CHIP_ID_REG (0xD0)
#define BMP280_RST_REG (0xE0)
#define BMP280_STAT_REG (0xF3)
#define BMP280_CTRL_MEAS_REG (0xF4)
#define BMP280_CONFIG_REG (0xF5)
#define BMP280_PRESSURE_MSB_REG (0xF7)
#define BMP280_PRESSURE_LSB_REG (0xF8)
#define BMP280_PRESSURE_XLSB_REG (0xF9)
#define BMP280_TEMPERATURE_MSB_REG (0xFA)
#define BMP280_TEMPERATURE_LSB_REG (0xFB)
#define BMP280_TEMPERATURE_XLSB_REG (0xFC)
#define BMP280_SHIFT_BY_01_BIT (1)
#define BMP280_SHIFT_BY_02_BITS (2)
#define BMP280_SHIFT_BY_03_BITS (3)
#define BMP280_SHIFT_BY_04_BITS (4)
#define BMP280_SHIFT_BY_05_BITS (5)
#define BMP280_SHIFT_BY_08_BITS (8)
#define BMP280_SHIFT_BY_11_BITS (11)
#define BMP280_SHIFT_BY_12_BITS (12)
#define BMP280_SHIFT_BY_13_BITS (13)
#define BMP280_SHIFT_BY_14_BITS (14)
#define BMP280_SHIFT_BY_15_BITS (15)
#define BMP280_SHIFT_BY_16_BITS (16)
#define BMP280_SHIFT_BY_17_BITS (17)
#define BMP280_SHIFT_BY_18_BITS (18)
#define BMP280_SHIFT_BY_19_BITS (19)
#define BMP280_SHIFT_BY_25_BITS (25)
#define BMP280_SHIFT_BY_31_BITS (31)
#define BMP280_SHIFT_BY_33_BITS (33)
#define BMP280_SHIFT_BY_35_BITS (35)
#define BMP280_SHIFT_BY_47_BITS (47)
#define BMP280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH (24)
#define BMP280_GEN_READ_WRITE_DATA_LENGTH (1)
#define BMP280_REGISTER_READ_DELAY (1)
#define BMP280_TEMPERATURE_DATA_LENGTH (3)
#define BMP280_PRESSURE_DATA_LENGTH (3)
#define BMP280_ALL_DATA_FRAME_LENGTH (6)
#define BMP280_INIT_VALUE (0)
#define BMP280_CHIP_ID_READ_COUNT (5)
#define BMP280_CHIP_ID_READ_SUCCESS (0)
#define BMP280_CHIP_ID_READ_FAIL ((int8_t)-1)
#define BMP280_INVALID_DATA (0)
#define BMP280_TEMPERATURE_DATA_SIZE (3)
#define BMP280_PRESSURE_DATA_SIZE (3)
#define BMP280_DATA_FRAME_SIZE (6)
#define BMP280_CALIB_DATA_SIZE (24)
#define BMP280_TEMPERATURE_MSB_DATA (0)
#define BMP280_TEMPERATURE_LSB_DATA (1)
#define BMP280_TEMPERATURE_XLSB_DATA (2)
#define BMP280_I2C_ADDRESS1 (0x76)
#define BMP280_I2C_ADDRESS2 (0x77)
#define BMP280_SLEEP_MODE (0x00)
#define BMP280_FORCED_MODE (0x01)
#define BMP280_NORMAL_MODE (0x03)
#define BMP280_SOFT_RESET_CODE (0xB6)
#define BMP280_STANDBY_TIME_1_MS (0x00)
#define BMP280_STANDBY_TIME_63_MS (0x01)
#define BMP280_STANDBY_TIME_125_MS (0x02)
#define BMP280_STANDBY_TIME_250_MS (0x03)
#define BMP280_STANDBY_TIME_500_MS (0x04)
#define BMP280_STANDBY_TIME_1000_MS (0x05)
#define BMP280_STANDBY_TIME_2000_MS (0x06)
#define BMP280_STANDBY_TIME_4000_MS (0x07)
#define BMP280_OVERSAMP_SKIPPED (0x00)
#define BMP280_OVERSAMP_1X (0x01)
#define BMP280_OVERSAMP_2X (0x02)
#define BMP280_OVERSAMP_4X (0x03)
#define BMP280_OVERSAMP_8X (0x04)
#define BMP280_OVERSAMP_16X (0x05)
#define BMP280_FILTER_COEFF_OFF (0x00)
#define BMP280_FILTER_COEFF_2 (0x01)
#define BMP280_FILTER_COEFF_4 (0x02)
#define BMP280_FILTER_COEFF_8 (0x03)
#define BMP280_FILTER_COEFF_16 (0x04)
#define BMP280_ULTRA_LOW_POWER_MODE (0x00)
#define BMP280_LOW_POWER_MODE (0x01)
#define BMP280_STANDARD_RESOLUTION_MODE (0x02)
#define BMP280_HIGH_RESOLUTION_MODE (0x03)
#define BMP280_ULTRA_HIGH_RESOLUTION_MODE (0x04)
#define BMP280_ULTRALOWPOWER_OVERSAMP_PRESSURE BMP280_OVERSAMP_1X
#define BMP280_ULTRALOWPOWER_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_LOWPOWER_OVERSAMP_PRESSURE BMP280_OVERSAMP_2X
#define BMP280_LOWPOWER_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_STANDARDRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_4X
#define BMP280_STANDARDRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_HIGHRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_8X
#define BMP280_HIGHRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_1X
#define BMP280_ULTRAHIGHRESOLUTION_OVERSAMP_PRESSURE BMP280_OVERSAMP_16X
#define BMP280_ULTRAHIGHRESOLUTION_OVERSAMP_TEMPERATURE BMP280_OVERSAMP_2X
#define BMP280_STATUS_REG_MEASURING__POS (3)
#define BMP280_STATUS_REG_MEASURING__MSK (0x08)
#define BMP280_STATUS_REG_MEASURING__LEN (1)
#define BMP280_STATUS_REG_MEASURING__REG (BMP280_STAT_REG)
#define BMP280_STATUS_REG_IM_UPDATE__POS (0)
#define BMP280_STATUS_REG_IM_UPDATE__MSK (0x01)
#define BMP280_STATUS_REG_IM_UPDATE__LEN (1)
#define BMP280_STATUS_REG_IM_UPDATE__REG (BMP280_STAT_REG)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__POS (5)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__MSK (0xE0)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__LEN (3)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__REG (BMP280_CTRL_MEAS_REG)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__POS (2)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__MSK (0x1C)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__LEN (3)
#define BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__REG (BMP280_CTRL_MEAS_REG)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__POS (0)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__MSK (0x03)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__LEN (2)
#define BMP280_CTRL_MEAS_REG_POWER_MODE__REG (BMP280_CTRL_MEAS_REG)
#define BMP280_CONFIG_REG_STANDBY_DURN__POS (5)
#define BMP280_CONFIG_REG_STANDBY_DURN__MSK (0xE0)
#define BMP280_CONFIG_REG_STANDBY_DURN__LEN (3)
#define BMP280_CONFIG_REG_STANDBY_DURN__REG (BMP280_CONFIG_REG)
#define BMP280_CONFIG_REG_FILTER__POS (2)
#define BMP280_CONFIG_REG_FILTER__MSK (0x1C)
#define BMP280_CONFIG_REG_FILTER__LEN (3)
#define BMP280_CONFIG_REG_FILTER__REG (BMP280_CONFIG_REG)
#define BMP280_CONFIG_REG_SPI3_ENABLE__POS (0)
#define BMP280_CONFIG_REG_SPI3_ENABLE__MSK (0x01)
#define BMP280_CONFIG_REG_SPI3_ENABLE__LEN (1)
#define BMP280_CONFIG_REG_SPI3_ENABLE__REG (BMP280_CONFIG_REG)
#define BMP280_PRESSURE_XLSB_REG_DATA__POS (4)
#define BMP280_PRESSURE_XLSB_REG_DATA__MSK (0xF0)
#define BMP280_PRESSURE_XLSB_REG_DATA__LEN (4)
#define BMP280_PRESSURE_XLSB_REG_DATA__REG (BMP280_PRESSURE_XLSB_REG)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__POS (4)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__MSK (0xF0)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__LEN (4)
#define BMP280_TEMPERATURE_XLSB_REG_DATA__REG (BMP280_TEMPERATURE_XLSB_REG)
#define BMP280_TEMPERATURE_MSB_DATA (0)
#define BMP280_TEMPERATURE_LSB_DATA (1)
#define BMP280_TEMPERATURE_XLSB_DATA (2)
#define BMP280_PRESSURE_MSB_DATA (0)
#define BMP280_PRESSURE_LSB_DATA (1)
#define BMP280_PRESSURE_XLSB_DATA (2)
#define BMP280_DATA_FRAME_PRESSURE_MSB_BYTE (0)
#define BMP280_DATA_FRAME_PRESSURE_LSB_BYTE (1)
#define BMP280_DATA_FRAME_PRESSURE_XLSB_BYTE (2)
#define BMP280_DATA_FRAME_TEMPERATURE_MSB_BYTE (3)
#define BMP280_DATA_FRAME_TEMPERATURE_LSB_BYTE (4)
#define BMP280_DATA_FRAME_TEMPERATURE_XLSB_BYTE (5)
#define BMP280_TEMPERATURE_CALIB_DIG_T1_LSB (0)
#define BMP280_TEMPERATURE_CALIB_DIG_T1_MSB (1)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_LSB (2)
#define BMP280_TEMPERATURE_CALIB_DIG_T2_MSB (3)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_LSB (4)
#define BMP280_TEMPERATURE_CALIB_DIG_T3_MSB (5)
#define BMP280_PRESSURE_CALIB_DIG_P1_LSB (6)
#define BMP280_PRESSURE_CALIB_DIG_P1_MSB (7)
#define BMP280_PRESSURE_CALIB_DIG_P2_LSB (8)
#define BMP280_PRESSURE_CALIB_DIG_P2_MSB (9)
#define BMP280_PRESSURE_CALIB_DIG_P3_LSB (10)
#define BMP280_PRESSURE_CALIB_DIG_P3_MSB (11)
#define BMP280_PRESSURE_CALIB_DIG_P4_LSB (12)
#define BMP280_PRESSURE_CALIB_DIG_P4_MSB (13)
#define BMP280_PRESSURE_CALIB_DIG_P5_LSB (14)
#define BMP280_PRESSURE_CALIB_DIG_P5_MSB (15)
#define BMP280_PRESSURE_CALIB_DIG_P6_LSB (16)
#define BMP280_PRESSURE_CALIB_DIG_P6_MSB (17)
#define BMP280_PRESSURE_CALIB_DIG_P7_LSB (18)
#define BMP280_PRESSURE_CALIB_DIG_P7_MSB (19)
#define BMP280_PRESSURE_CALIB_DIG_P8_LSB (20)
#define BMP280_PRESSURE_CALIB_DIG_P8_MSB (21)
#define BMP280_PRESSURE_CALIB_DIG_P9_LSB (22)
#define BMP280_PRESSURE_CALIB_DIG_P9_MSB (23)
#define BMP280_SOFT_RESRT_VALUE (0XB6)
#define BMP280_I2C_SLAVE_ADDR_LOW (0X76)
#define BMP280_I2C_SLAVE_ADDR_HIGN (0X77)
#define BMP280_DEFAULT_ODR_1HZ (1)
#define BMP280_BIT(x) ((uint8_t)(x))
#define BMP280_CHIP_ID_VAL BMP280_BIT(0X58)
#define BMP280_I2C_ADDR_TRANS(n) ((n)<<1)
#define BMP280_I2C_ADDR BMP280_I2C_ADDR_TRANS(BMP280_I2C_SLAVE_ADDR_LOW)
#define BMP280_GET_BITSLICE(regvar, bitname) ((regvar & bitname##__MSK) >> bitname##__POS)
#define BMP280_SET_BITSLICE(regvar, bitname, val) ((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
typedef struct bmp280_calib_param_t {
uint16_t dig_T1;
int16_t dig_T2;
int16_t dig_T3;
uint16_t dig_P1;
int16_t dig_P2;
int16_t dig_P3;
int16_t dig_P4;
int16_t dig_P5;
int16_t dig_P6;
int16_t dig_P7;
int16_t dig_P8;
int16_t dig_P9;
int t_fine;
}bmp280_calib_param_t;
typedef struct bmp280_device_cfg_t {
uint8_t odr;
uint8_t mode_filter;
uint8_t mode_baro;
uint8_t mode_temp;
uint8_t mode_power;
uint8_t oversamp_temp;
uint8_t oversamp_baro;
}bmp280_device_cfg_t;
static bmp280_device_cfg_t g_bmp280_dev_cfg;
static bmp280_calib_param_t g_bmp280_calib_table;
i2c_dev_t bmp280_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BMP280_I2C_ADDR,
};
static int drv_baro_bosch_bmp280_get_calib_param(i2c_dev_t* drv)
{
int ret = 0;
uint8_t a_data_u8[BMP280_CALIB_DATA_SIZE] = {0};
ret = sensor_i2c_read(drv,BMP280_TEMPERATURE_CALIB_DIG_T1_LSB_REG,
a_data_u8,BMP280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH,I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_bmp280_calib_table.dig_T1 = (uint16_t)((((uint16_t)((uint8_t)a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T1_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T1_LSB]);
g_bmp280_calib_table.dig_T2 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T2_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T2_LSB]);
g_bmp280_calib_table.dig_T3 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T3_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_TEMPERATURE_CALIB_DIG_T3_LSB]);
g_bmp280_calib_table.dig_P1 = (uint16_t)((((uint16_t)((uint8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P1_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P1_LSB]);
g_bmp280_calib_table.dig_P2 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P2_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P2_LSB]);
g_bmp280_calib_table.dig_P3 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P3_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P3_LSB]);
g_bmp280_calib_table.dig_P4 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P4_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P4_LSB]);
g_bmp280_calib_table.dig_P5 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P5_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P5_LSB]);
g_bmp280_calib_table.dig_P6 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P6_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P6_LSB]);
g_bmp280_calib_table.dig_P7 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P7_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P7_LSB]);
g_bmp280_calib_table.dig_P8 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P8_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P8_LSB]);
g_bmp280_calib_table.dig_P9 = (int16_t)((((int16_t)((int8_t)a_data_u8[BMP280_PRESSURE_CALIB_DIG_P9_MSB]))
<< BMP280_SHIFT_BY_08_BITS) | a_data_u8[BMP280_PRESSURE_CALIB_DIG_P9_LSB]);
return 0;
}
static int drv_baro_bosch_bmp280_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
int ret = 0;
uint8_t value = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, BMP280_CHIP_ID_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_baro_bosch_bmp280_set_work_mode(i2c_dev_t* drv,uint8_t mode)
{
uint8_t ret = 0;
uint8_t value = 0;
uint8_t temp = 0;
uint8_t baro = 0;
switch (mode) {
case BMP280_ULTRA_LOW_POWER_MODE:
temp = BMP280_OVERSAMP_1X;
baro = BMP280_OVERSAMP_1X;
break;
case BMP280_LOW_POWER_MODE:
temp = BMP280_OVERSAMP_2X;
baro = BMP280_OVERSAMP_2X;
break;
case BMP280_STANDARD_RESOLUTION_MODE:
temp = BMP280_OVERSAMP_4X;
baro = BMP280_OVERSAMP_4X;
break;
case BMP280_HIGH_RESOLUTION_MODE:
temp = BMP280_OVERSAMP_8X;
baro = BMP280_OVERSAMP_8X;
break;
case BMP280_ULTRA_HIGH_RESOLUTION_MODE:
temp = BMP280_OVERSAMP_16X;
baro = BMP280_OVERSAMP_16X;
break;
default:
return -1;
}
ret = sensor_i2c_read(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = BMP280_SET_BITSLICE(value,BMP280_CTRL_MEAS_REG_OVERSAMP_PRESSURE,baro);
value = BMP280_SET_BITSLICE(value,BMP280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE,temp);
ret = sensor_i2c_write(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return ret;
}
static int drv_baro_bosch_bmp280_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
int ret = 0;
uint8_t value = 0x00;
uint8_t dev_mode;
switch(mode){
case DEV_POWER_OFF:
case DEV_SLEEP:{
dev_mode = (uint8_t)BMP280_SLEEP_MODE;
break;
}
case DEV_POWER_ON:{
dev_mode = (uint8_t)BMP280_NORMAL_MODE;
break;
}
default:return -1;
}
ret = sensor_i2c_read(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = BMP280_SET_BITSLICE(value,BMP280_CTRL_MEAS_REG_POWER_MODE,dev_mode);
ret = sensor_i2c_write(drv, BMP280_CTRL_MEAS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static uint8_t drv_baro_bosch_bmp280_hz2odr(int hz)
{
if(hz > 80)
return BMP280_STANDBY_TIME_1_MS;
else if(hz > 13)
return BMP280_STANDBY_TIME_63_MS;
else if(hz > 7)
return BMP280_STANDBY_TIME_125_MS;
else if(hz > 3)
return BMP280_STANDBY_TIME_250_MS;
else
return BMP280_STANDBY_TIME_500_MS;
}
static int drv_baro_bosch_bmp280_set_odr(i2c_dev_t* drv, uint8_t odr)
{
int ret = 0;
uint8_t v_data_u8 = 0;
ret = sensor_i2c_read(drv,BMP280_CONFIG_REG_STANDBY_DURN__REG,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
v_data_u8 = BMP280_SET_BITSLICE(v_data_u8,BMP280_CONFIG_REG_STANDBY_DURN,odr);
ret = sensor_i2c_write(drv,BMP280_CONFIG_REG_STANDBY_DURN__REG,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return ret;
}
static int drv_baro_bosch_bmp280_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
uint8_t v_data_u8 = BMP280_SOFT_RESRT_VALUE;
ret = sensor_i2c_write(drv,BMP280_RST_REG,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return ret;
}
static int drv_baro_bosch_bmp280_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_baro_bosch_bmp280_set_power_mode(drv, DEV_SLEEP);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_bosch_bmp280_set_odr(drv, BMP280_DEFAULT_ODR_1HZ);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_bosch_bmp280_read_uncomp_baro(i2c_dev_t* drv, barometer_data_t* pdata)
{
int ret = 0;
uint8_t data[BMP280_PRESSURE_DATA_SIZE] = {0};
ret = sensor_i2c_read(drv, BMP280_PRESSURE_MSB_REG, data, BMP280_PRESSURE_DATA_SIZE, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
pdata->p = (int)((((uint32_t)(data[BMP280_PRESSURE_MSB_DATA]))<< BMP280_SHIFT_BY_12_BITS)
| (((uint32_t)(data[BMP280_PRESSURE_LSB_DATA]))<< BMP280_SHIFT_BY_04_BITS)
| ((uint32_t)data[BMP280_PRESSURE_XLSB_DATA]>> BMP280_SHIFT_BY_04_BITS));
return ret;
}
static int drv_baro_bosch_bmp280_compensate_baro( barometer_data_t* pdata)
{
int v_x1_u32r = 0;
int v_x2_u32r = 0;
uint32_t comp_baro = 0;
v_x1_u32r = (((int)g_bmp280_calib_table.t_fine)
>>BMP280_SHIFT_BY_01_BIT) - (int)64000;
v_x2_u32r = (((v_x1_u32r >> BMP280_SHIFT_BY_02_BITS)
* (v_x1_u32r >> BMP280_SHIFT_BY_02_BITS))
>> BMP280_SHIFT_BY_11_BITS)
* ((int)g_bmp280_calib_table.dig_P6);
v_x2_u32r = v_x2_u32r + ((v_x1_u32r *
((int)g_bmp280_calib_table.dig_P5))
<< BMP280_SHIFT_BY_01_BIT);
v_x2_u32r = (v_x2_u32r >> BMP280_SHIFT_BY_02_BITS)
+ (((int)g_bmp280_calib_table.dig_P4)
<< BMP280_SHIFT_BY_16_BITS);
v_x1_u32r = (((g_bmp280_calib_table.dig_P3
* (((v_x1_u32r
>> BMP280_SHIFT_BY_02_BITS) * (v_x1_u32r
>> BMP280_SHIFT_BY_02_BITS))
>> BMP280_SHIFT_BY_13_BITS))
>> BMP280_SHIFT_BY_03_BITS)
+ ((((int)g_bmp280_calib_table.dig_P2)
* v_x1_u32r)
>> BMP280_SHIFT_BY_01_BIT))
>> BMP280_SHIFT_BY_18_BITS;
v_x1_u32r = ((((32768 + v_x1_u32r))
* ((int)g_bmp280_calib_table.dig_P1))
>> BMP280_SHIFT_BY_15_BITS);
comp_baro = (((uint32_t)(((int)1048576) - pdata->p)
- (v_x2_u32r >> BMP280_SHIFT_BY_12_BITS)))
* 3125;
if (comp_baro < 0x80000000){
if (v_x1_u32r != 0){
comp_baro = (comp_baro
<< BMP280_SHIFT_BY_01_BIT)
/ ((uint32_t)v_x1_u32r);
}
else{
return -1;
}
}
else if (v_x1_u32r != 0){
comp_baro = (comp_baro / (uint32_t)v_x1_u32r) * 2;
}
else{
return -1;
}
v_x1_u32r = (((int)g_bmp280_calib_table.dig_P9) * ((int)(
((comp_baro >> BMP280_SHIFT_BY_03_BITS)
* (comp_baro >> BMP280_SHIFT_BY_03_BITS))
>> BMP280_SHIFT_BY_13_BITS)))
>> BMP280_SHIFT_BY_12_BITS;
v_x2_u32r = (((int)(comp_baro >>
BMP280_SHIFT_BY_02_BITS))
* ((int)g_bmp280_calib_table.dig_P8))
>> BMP280_SHIFT_BY_13_BITS;
comp_baro = (uint32_t)((int)comp_baro + ((v_x1_u32r + v_x2_u32r
+ g_bmp280_calib_table.dig_P7)
>> BMP280_SHIFT_BY_04_BITS));
pdata->p = comp_baro;
return 0;
}
static int drv_baro_bosch_bmp280_read_baro(i2c_dev_t* drv, barometer_data_t* pdata)
{
int ret = 0;
ret = drv_baro_bosch_bmp280_read_uncomp_baro(drv, pdata);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_bosch_bmp280_compensate_baro(pdata);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_bosch_bmp280_comp_temp(temperature_data_t* pdata)
{
int v_x1_u32r = 0;
int v_x2_u32r = 0;
v_x1_u32r = ((((pdata->t >> BMP280_SHIFT_BY_03_BITS)
- ((int)g_bmp280_calib_table.dig_T1
<< BMP280_SHIFT_BY_01_BIT)))
* ((int)g_bmp280_calib_table.dig_T2))
>> BMP280_SHIFT_BY_11_BITS;
v_x2_u32r = (((((pdata->t >> BMP280_SHIFT_BY_04_BITS)
- ((int)g_bmp280_calib_table.dig_T1))
* ((pdata->t >> BMP280_SHIFT_BY_04_BITS)
- ((int)g_bmp280_calib_table.dig_T1)))
>> BMP280_SHIFT_BY_12_BITS)
* ((int)g_bmp280_calib_table.dig_T3))
>> BMP280_SHIFT_BY_14_BITS;
g_bmp280_calib_table.t_fine = v_x1_u32r + v_x2_u32r;
pdata->t = (g_bmp280_calib_table.t_fine * 5 + 128) >> BMP280_SHIFT_BY_08_BITS;
return 0;
}
static int drv_baro_bosch_bmp280_cali_temp(i2c_dev_t* drv)
{
int ret = 0;
uint8_t data[BMP280_TEMPERATURE_DATA_SIZE] = {0};
temperature_data_t temp;
ret = sensor_i2c_read(drv, BMP280_TEMPERATURE_MSB_REG, data, BMP280_TEMPERATURE_DATA_SIZE, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
temp.t = (int)((((uint32_t)(data[BMP280_TEMPERATURE_MSB_DATA]))<< BMP280_SHIFT_BY_12_BITS)
| (((uint32_t)(data[BMP280_TEMPERATURE_LSB_DATA]))<< BMP280_SHIFT_BY_04_BITS)
| ((uint32_t)data[BMP280_TEMPERATURE_XLSB_DATA]>> BMP280_SHIFT_BY_04_BITS));
ret = drv_baro_bosch_bmp280_comp_temp(&temp);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_baro_bosch_bmp280_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_bosch_bmp280_open(void)
{
int ret = 0;
/* set the default config for the sensor here */
ret = drv_baro_bosch_bmp280_set_work_mode(&bmp280_ctx,BMP280_ULTRA_LOW_POWER_MODE);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_bosch_bmp280_set_power_mode(&bmp280_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_bosch_bmp280_close(void)
{
int ret = 0;
ret = drv_baro_bosch_bmp280_set_power_mode(&bmp280_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_bosch_bmp280_read(void *buf, size_t len)
{
int ret = 0;
size_t size = 0;
barometer_data_t* pdata = (barometer_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(barometer_data_t);
if(len < size){
return -1;
}
ret = drv_baro_bosch_bmp280_cali_temp(&bmp280_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_bosch_bmp280_read_baro(&bmp280_ctx, pdata);
if(unlikely(ret)){
return -1;
}
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_bosch_bmp280_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_baro_bosch_bmp280_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
uint8_t odr = drv_baro_bosch_bmp280_hz2odr(arg);
ret = drv_baro_bosch_bmp280_set_odr(&bmp280_ctx, odr);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_baro_bosch_bmp280_set_power_mode(&bmp280_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BMP280";
info->range_max = 1100;
info->range_min = 300;
info->unit = pa;
}break;
default:break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_bosch_bmp280_init(void)
{
int ret = 0;
sensor_obj_t sensor;
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_bosch_bmp280_open;
sensor.close = drv_baro_bosch_bmp280_close;
sensor.read = drv_baro_bosch_bmp280_read;
sensor.write = drv_baro_bosch_bmp280_write;
sensor.ioctl = drv_baro_bosch_bmp280_ioctl;
sensor.irq_handle = drv_baro_bosch_bmp280_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_bosch_bmp280_validate_id(&bmp280_ctx, BMP280_CHIP_ID_VAL);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_bosch_bmp280_soft_reset(&bmp280_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_bosch_bmp280_set_default_config(&bmp280_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_bosch_bmp280_get_calib_param(&bmp280_ctx);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

419
Living_SDK/device/sensor/drv/drv_baro_st_lps22hb.c Normal file
View file

@ -0,0 +1,419 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
/* ST BARO SENSOR REGISTER MAP */
#define LPS22HB_BIT(x) ((uint8_t)x)
#define LPS22HB_ADDRESS (uint8_t)0xB8
#define LPS22HB_DriverVersion_Major (uint8_t)1
#define LPS22HB_DriverVersion_Minor (uint8_t)0
#define LPS22HB_DriverVersion_Point (uint8_t)0
#define LPS22HB_WHO_AM_I_REG (uint8_t)0x0F
#define LPS22HB_WHO_AM_I_VAL (uint8_t)0xB1
#define LPS22HB_REF_P_XL_REG (uint8_t)0x15
#define LPS22HB_REF_P_L_REG (uint8_t)0x16
#define LPS22HB_REF_P_H_REG (uint8_t)0x17
#define LPS22HB_RES_CONF_REG (uint8_t)0x1A
#define LPS22HB_RES_CONF_REG (uint8_t)0x1A
#define LPS22HB_RES_CONF_REG (uint8_t)0x1A
#define LPS22HB_LCEN_MASK (uint8_t)0x01
#define LPS22HB_LCEN_POWERON (uint8_t)0x00
#define LPS22HB_LCEN_LOWPOWER (uint8_t)0x01
#define LPS22HB_CTRL_REG1 (uint8_t)0x10
#define LPS22HB_ODR_MASK (uint8_t)0x70
#define LPS22HB_LPFP_MASK (uint8_t)0x08
#define LPS22HB_LPFP_CUTOFF_MASK (uint8_t)0x04
#define LPS22HB_BDU_MASK (uint8_t)0x02
#define LPS22HB_SIM_MASK (uint8_t)0x01
#define LPS22HB_LPFP_BIT LPS22HB_BIT(3)
#define LPS22HB_CTRL_REG2 (uint8_t)0x11
#define LPS22HB_BOOT_BIT LPS22HB_BIT(7)
#define LPS22HB_FIFO_EN_BIT LPS22HB_BIT(6)
#define LPS22HB_WTM_EN_BIT LPS22HB_BIT(5)
#define LPS22HB_ADD_INC_BIT LPS22HB_BIT(4)
#define LPS22HB_I2C_BIT LPS22HB_BIT(3)
#define LPS22HB_SW_RESET_BIT LPS22HB_BIT(2)
#define LPS22HB_FIFO_EN_MASK (uint8_t)0x40
#define LPS22HB_WTM_EN_MASK (uint8_t)0x20
#define LPS22HB_ADD_INC_MASK (uint8_t)0x10
#define LPS22HB_I2C_MASK (uint8_t)0x08
#define LPS22HB_ONE_SHOT_MASK (uint8_t)0x01
#define LPS22HB_CTRL_REG3 (uint8_t)0x12
#define LPS22HB_PP_OD_BIT LPS22HB_BIT(6)
#define LPS22HB_FIFO_FULL_BIT LPS22HB_BIT(5)
#define LPS22HB_FIFO_FTH_BIT LPS22HB_BIT(4)
#define LPS22HB_FIFO_OVR_BIT LPS22HB_BIT(3)
#define LPS22HB_DRDY_BIT LPS22HB_BIT(2)
#define LPS22HB_INT_H_L_MASK (uint8_t)0x80
#define LPS22HB_PP_OD_MASK (uint8_t)0x40
#define LPS22HB_FIFO_FULL_MASK (uint8_t)0x20
#define LPS22HB_FIFO_FTH_MASK (uint8_t)0x10
#define LPS22HB_FIFO_OVR_MASK (uint8_t)0x08
#define LPS22HB_DRDY_MASK (uint8_t)0x04
#define LPS22HB_INT_S12_MASK (uint8_t)0x03
#define LPS22HB_INTERRUPT_CFG_REG (uint8_t)0x0B
#define LPS22HB_DIFF_EN_BIT LPS22HB_BIT(3)
#define LPS22HB_LIR_BIT LPS22HB_BIT(2)
#define LPS22HB_PLE_BIT LPS22HB_BIT(1)
#define LPS22HB_PHE_BIT LPS22HB_BIT(0)
#define LPS22HB_AUTORIFP_MASK (uint8_t)0x80
#define LPS22HB_RESET_ARP_MASK (uint8_t)0x40
#define LPS22HB_AUTOZERO_MASK (uint8_t)0x20
#define LPS22HB_RESET_AZ_MASK (uint8_t)0x10
#define LPS22HB_DIFF_EN_MASK (uint8_t)0x08
#define LPS22HB_LIR_MASK (uint8_t)0x04
#define LPS22HB_PLE_MASK (uint8_t)0x02
#define LPS22HB_PHE_MASK (uint8_t)0x01
#define LPS22HB_INTERRUPT_SOURCE_REG (uint8_t)0x25
#define LPS22HB_BOOT_STATUS_BIT LPS22HB_BIT(7)
#define LPS22HB_IA_BIT LPS22HB_BIT(2)
#define LPS22HB_PL_BIT LPS22HB_BIT(1)
#define LPS22HB_PH_BIT LPS22HB_BIT(0)
#define LPS22HB_BOOT_STATUS_MASK (uint8_t)0x80
#define LPS22HB_IA_MASK (uint8_t)0x04
#define LPS22HB_PL_MASK (uint8_t)0x02
#define LPS22HB_PH_MASK (uint8_t)0x01
#define LPS22HB_STATUS_REG (uint8_t)0x27
#define LPS22HB_TOR_BIT LPS22HB_BIT(5)
#define LPS22HB_POR_BIT LPS22HB_BIT(4)
#define LPS22HB_TDA_BIT LPS22HB_BIT(1)
#define LPS22HB_PDA_BIT LPS22HB_BIT(0)
#define LPS22HB_TOR_MASK (uint8_t)0x20
#define LPS22HB_POR_MASK (uint8_t)0x10
#define LPS22HB_TDA_MASK (uint8_t)0x02
#define LPS22HB_PDA_MASK (uint8_t)0x01
#define LPS22HB_PRESS_OUT_XL_REG (uint8_t)0x28
#define LPS22HB_PRESS_OUT_L_REG (uint8_t)0x29
#define LPS22HB_PRESS_OUT_H_REG (uint8_t)0x2A
#define LPS22HB_TEMP_OUT_L_REG (uint8_t)0x2B
#define LPS22HBH_TEMP_OUT_H_REG (uint8_t)0x2C
#define LPS22HB_THS_P_LOW_REG (uint8_t)0x0C
#define LPS22HB_THS_P_HIGH_REG (uint8_t)0x0D
#define LPS22HB_CTRL_FIFO_REG (uint8_t)0x14
#define LPS22HB_FIFO_MODE_MASK (uint8_t)0xE0
#define LPS22HB_WTM_POINT_MASK (uint8_t)0x1F
#define LPS22HB_STATUS_FIFO_REG (uint8_t)0x26
#define LPS22HB_FTH_FIFO_BIT LPS22HB_BIT(7)
#define LPS22HB_OVR_FIFO_BIT LPS22HB_BIT(6)
#define LPS22HB_FTH_FIFO_MASK (uint8_t)0x80
#define LPS22HB_OVR_FIFO_MASK (uint8_t)0x40
#define LPS22HB_LEVEL_FIFO_MASK (uint8_t)0x3F
#define LPS22HB_FIFO_EMPTY (uint8_t)0x00
#define LPS22HB_FIFO_FULL (uint8_t)0x18
#define LPS22HB_RPDS_H_REG (uint8_t)0x19
#define LPS22HB_CLOCK_TREE_CONFIG (uint8_t)0x43
#define LPS22HB_CTE_MASK (uint8_t)0x20
#define LPS22HB_I2C_ADDR1_R (uint8_t)0xB9
#define LPS22HB_I2C_ADDR1_W (uint8_t)0xB8
#define LPS22HB_I2C_ADDR2_R (uint8_t)0xBB
#define LPS22HB_I2C_ADDR2_W (uint8_t)0xBZ
#define LPS22HB_I2C_ADDR1 (0x5C)
#define LPS22HB_I2C_ADDR2 (0x5D)
#define LPS22HB_I2C_ADDR_TRANS(n) ((n)<<1)
#define LPS22HB_I2C_ADDR LPS22HB_I2C_ADDR_TRANS(LPS22HB_I2C_ADDR2)
typedef enum {
LPS22HB_ODR_ONE_SHOT = (uint8_t)0x00, /*!< Output Data Rate: one shot */
LPS22HB_ODR_1HZ = (uint8_t)0x10, /*!< Output Data Rate: 1Hz */
LPS22HB_ODR_10HZ = (uint8_t)0x20, /*!< Output Data Rate: 10Hz */
LPS22HB_ODR_25HZ = (uint8_t)0x30, /*!< Output Data Rate: 25Hz */
LPS22HB_ODR_50HZ = (uint8_t)0x40, /*!< Output Data Rate: 50Hz */
LPS22HB_ODR_75HZ = (uint8_t)0x50 /*!< Output Data Rate: 75Hz */
} lps22hb_odr_e;
typedef enum {
LPS22HB_BDU_CONTINUOUS_UPDATE = (uint8_t)0x00, /*!< Data updated continuously */
LPS22HB_BDU_NO_UPDATE = (uint8_t)0x02 /*!< Data updated after a read operation */
} lps22hb_bdu_e;
i2c_dev_t lps22hb_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = LPS22HB_I2C_ADDR,
};
static lps22hb_odr_e drv_baro_st_lps22hb_hz2odr(int hz)
{
if(hz > 50)
return LPS22HB_ODR_75HZ;
else if(hz > 25)
return LPS22HB_ODR_50HZ;
else if(hz > 10)
return LPS22HB_ODR_25HZ;
else if(hz > 1)
return LPS22HB_ODR_10HZ;
else
return LPS22HB_ODR_1HZ;
}
static int drv_baro_st_lps22hb_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, LPS22HB_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_baro_st_lps22hb_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS22HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
value &= ~LPS22HB_LCEN_MASK;
value |= LPS22HB_LCEN_POWERON;
ret = sensor_i2c_write(drv, LPS22HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:{
value |= LPS22HB_LCEN_LOWPOWER;
ret = sensor_i2c_write(drv, LPS22HB_RES_CONF_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static int drv_baro_st_lps22hb_set_odr(i2c_dev_t* drv, lps22hb_odr_e odr)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LPS22HB_ODR_MASK;
value |= (uint8_t)odr;
ret = sensor_i2c_write(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps22hb_set_bdu(i2c_dev_t* drv, lps22hb_bdu_e bdu)
{
uint8_t value = 0x00;
int ret = 0;
ret = sensor_i2c_read(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value &= ~LPS22HB_BDU_MASK;
value |= (uint8_t)bdu;
ret = sensor_i2c_write(drv, LPS22HB_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_baro_st_lps22hb_set_default_config(i2c_dev_t* drv)
{
uint8_t value = 0x00;
int ret = 0;
ret = drv_baro_st_lps22hb_set_power_mode(drv, DEV_POWER_OFF);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps22hb_set_odr(drv, LPS22HB_ODR_25HZ);
if(unlikely(ret)){
return ret;
}
ret = drv_baro_st_lps22hb_set_bdu(drv, LPS22HB_BDU_NO_UPDATE);
if(unlikely(ret)){
return ret;
}
/* you also can set the low-pass filter and cut off config here */
return 0;
}
static void drv_baro_st_lps22hb_irq_handle(void)
{
/* no handle so far */
}
static int drv_baro_st_lps22hb_open(void)
{
int ret = 0;
ret = drv_baro_st_lps22hb_set_power_mode(&lps22hb_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps22hb_close(void)
{
int ret = 0;
ret = drv_baro_st_lps22hb_set_power_mode(&lps22hb_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_baro_st_lps22hb_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
uint8_t data[3];
barometer_data_t* pdata = (barometer_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(barometer_data_t);
if(len < size){
return -1;
}
ret = sensor_i2c_read(&lps22hb_ctx, LPS22HB_PRESS_OUT_XL_REG, &data[0], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps22hb_ctx, LPS22HB_PRESS_OUT_L_REG, &data[1], I2C_DATA_LEN, I2C_OP_RETRIES);
ret |= sensor_i2c_read(&lps22hb_ctx, LPS22HB_PRESS_OUT_H_REG, &data[2], I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
/* hatch the baro data here*/
for(int i=0; i<3; i++){
pdata->p |= (((uint32_t)data[i]) << (8*i));
}
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if((pdata->p & 0x00800000) != 0){
pdata->p |= 0xFF000000;
}
pdata->p = ((pdata->p)*100)/4096;
//pdata->p = pdata->p/100;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_baro_st_lps22hb_write(const void *buf, size_t len)
{
return 0;
}
static int drv_baro_st_lps22hb_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
lps22hb_odr_e odr = drv_baro_st_lps22hb_hz2odr(arg);
ret = drv_baro_st_lps22hb_set_odr(&lps22hb_ctx, odr);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_baro_st_lps22hb_set_power_mode(&lps22hb_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "LPS22HB";
info->range_max = 1260;
info->range_min = 260;
info->unit = pa;
}break;
default:break;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_baro_st_lps22hb_init(void){
int ret = 0;
sensor_obj_t sensor;
/* fill the sensor obj parameters here */
sensor.tag = TAG_DEV_BARO;
sensor.path = dev_baro_path;
sensor.io_port = I2C_PORT;
sensor.open = drv_baro_st_lps22hb_open;
sensor.close = drv_baro_st_lps22hb_close;
sensor.read = drv_baro_st_lps22hb_read;
sensor.write = drv_baro_st_lps22hb_write;
sensor.ioctl = drv_baro_st_lps22hb_ioctl;
sensor.irq_handle = drv_baro_st_lps22hb_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_baro_st_lps22hb_validate_id(&lps22hb_ctx, LPS22HB_WHO_AM_I_VAL);
if(unlikely(ret)){
return -1;
}
/* set the default config for the sensor here */
ret = drv_baro_st_lps22hb_set_default_config(&lps22hb_ctx);
if(unlikely(ret)){
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

1018
Living_SDK/device/sensor/drv/drv_gyro_bosch_bmg160.c Normal file
View file

File diff suppressed because it is too large Load diff

746
Living_SDK/device/sensor/drv/drv_humi_bosch_bme280.c Normal file
View file

@ -0,0 +1,746 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define BME280_I2C_ADDR_PRIM (0x76)
#define BME280_I2C_ADDR_SEC (0x77)
#define BME280_CHIP_ID (0x60)
#define BME280_SOFT_RESET (0xB6)
#define BME280_CHIP_ID_ADDR (0xD0)
#define BME280_RESET_ADDR (0xE0)
#define BME280_TEMP_PRESS_CALIB_DATA_ADDR (0x88)
#define BME280_HUMIDITY_CALIB_DATA_ADDR (0xE1)
#define BME280_PWR_CTRL_ADDR (0xF4)
#define BME280_CTRL_HUM_ADDR (0xF2)
#define BME280_CTRL_MEAS_ADDR (0xF4)
#define BME280_CONFIG_ADDR (0xF5)
#define BME280_TEMP_DATA_ADDR (0xFA)
#define BME280_HUMI_DATA_ADDR (0xFD)
#define BME280_TEMP_PRESS_CALIB_DATA_LEN (26)
#define BME280_HUMIDITY_CALIB_DATA_LEN (7)
#define BME280_HUMI_DATA_LEN (2)
#define BME280_TEMP_DATA_LEN (3)
#define BME280_SLEEP_MODE (0x00)
#define BME280_FORCED_MODE (0x01)
#define BME280_NORMAL_MODE (0x03)
#define BME280_POWER_BIT_MASK (0x03)
#define BME280_PRESS (1)
#define BME280_TEMP (1 << 1)
#define BME280_HUM (1 << 2)
#define BME280_ALL (0x07)
#define BME280_OSR_PRESS_SEL (1)
#define BME280_OSR_TEMP_SEL (1 << 1)
#define BME280_OSR_HUM_SEL (1 << 2)
#define BME280_FILTER_SEL (1 << 3)
#define BME280_STANDBY_SEL (1 << 4)
#define BME280_ALL_SETTINGS_SEL (0x1F)
#define BME280_NO_OVERSAMPLING (0x00)
#define BME280_OVERSAMPLING_1X (0x01)
#define BME280_OVERSAMPLING_2X (0x02)
#define BME280_OVERSAMPLING_4X (0x03)
#define BME280_OVERSAMPLING_8X (0x04)
#define BME280_OVERSAMPLING_16X (0x05)
#define BME280_STANDBY_TIME_1_MS (0x00)
#define BME280_STANDBY_TIME_62_5_MS (0x01)
#define BME280_STANDBY_TIME_125_MS (0x02)
#define BME280_STANDBY_TIME_250_MS (0x03)
#define BME280_STANDBY_TIME_500_MS (0x04)
#define BME280_STANDBY_TIME_1000_MS (0x05)
#define BME280_STANDBY_TIME_10_MS (0x06)
#define BME280_STANDBY_TIME_20_MS (0x07)
#define BME280_FILTER_COEFF_OFF (0x00)
#define BME280_FILTER_COEFF_2 (0x01)
#define BME280_FILTER_COEFF_4 (0x02)
#define BME280_FILTER_COEFF_8 (0x03)
#define BME280_FILTER_COEFF_16 (0x04)
#define BME280_ULTRA_LOW_POWER_MODE (0x00)
#define BME280_LOW_POWER_MODE (0x01)
#define BME280_STANDARD_RESOLUTION_MODE (0x02)
#define BME280_HIGH_RESOLUTION_MODE (0x03)
#define BME280_ULTRA_HIGH_RESOLUTION_MODE (0x04)
#define BME280_OVERSAMP_SKIPPED (0x00)
#define BME280_OVERSAMP_1X (0x01)
#define BME280_OVERSAMP_2X (0x02)
#define BME280_OVERSAMP_4X (0x03)
#define BME280_OVERSAMP_8X (0x04)
#define BME280_OVERSAMP_16X (0x05)
#define BME280_SENSOR_MODE_MSK (0x03)
#define BME280_SENSOR_MODE_POS (0x00)
#define BME280_CTRL_HUM_MSK (0x07)
#define BME280_CTRL_HUM_POS (0x00)
#define BME280_CTRL_PRESS_MSK (0x1C)
#define BME280_CTRL_PRESS_POS (0x02)
#define BME280_CTRL_TEMP_MSK (0xE0)
#define BME280_CTRL_TEMP_POS (0x05)
#define BME280_FILTER_MSK (0x1C)
#define BME280_FILTER_POS (0x02)
#define BME280_STANDBY_MSK (0xE0)
#define BME280_STANDBY_POS (0x05)
#define BME280_SHIFT_BY_01_BITS (1)
#define BME280_SHIFT_BY_02_BITS (2)
#define BME280_SHIFT_BY_03_BITS (3)
#define BME280_SHIFT_BY_04_BITS (4)
#define BME280_SHIFT_BY_05_BITS (5)
#define BME280_SHIFT_BY_08_BITS (8)
#define BME280_SHIFT_BY_11_BITS (11)
#define BME280_SHIFT_BY_12_BITS (12)
#define BME280_SHIFT_BY_13_BITS (13)
#define BME280_SHIFT_BY_14_BITS (14)
#define BME280_SHIFT_BY_15_BITS (15)
#define BME280_SHIFT_BY_16_BITS (16)
#define BME280_SHIFT_BY_17_BITS (17)
#define BME280_SHIFT_BY_18_BITS (18)
#define BME280_SHIFT_BY_19_BITS (19)
#define BME280_SHIFT_BY_25_BITS (25)
#define BME280_SHIFT_BY_31_BITS (31)
#define BME280_I2C_SLAVE_ADDR_LOW (0X76)
#define BME280_I2C_SLAVE_ADDR_HIGN (0X77)
#define BME280_HUMI_UNIT_RATIO_10 (100)
#define BME280_HUMI_UNIT_RATIO_1024 (1024)
#define BME280_DEFAULT_ODR_1HZ (1)
#define BME280_I2C_ADDR_TRANS(n) ((n)<<1)
#define BME280_I2C_ADDR BME280_I2C_ADDR_TRANS(BME280_I2C_SLAVE_ADDR_LOW)
#define BME280_CONCAT_BYTES(msb, lsb) (((uint16_t)msb << 8) | (uint16_t)lsb)
#define BME280_SET_BITS(reg_data, bitname, data) ((reg_data & ~(bitname##_MSK)) | ((data << bitname##_POS) & bitname##_MSK))
#define BME280_SET_BITS_POS_0(reg_data, bitname, data) ((reg_data & ~(bitname##_MSK)) | (data & bitname##_MSK))
#define BME280_GET_BITS(reg_data, bitname) ((reg_data & (bitname##_MSK)) >> (bitname##_POS))
#define BME280_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK))
typedef struct _bme280_cali_table_t {
uint16_t dig_T1;
int16_t dig_T2;
int16_t dig_T3;
uint16_t dig_P1;
int16_t dig_P2;
int16_t dig_P3;
int16_t dig_P4;
int16_t dig_P5;
int16_t dig_P6;
int16_t dig_P7;
int16_t dig_P8;
int16_t dig_P9;
uint8_t dig_H1;
int16_t dig_H2;
uint8_t dig_H3;
int16_t dig_H4;
int16_t dig_H5;
int8_t dig_H6;
int32_t t_fine;
}bme280_cali_table_t;
typedef struct _bme280_config_t {
uint8_t osr_p;
uint8_t osr_t;
uint8_t osr_h;
uint8_t filter;
uint8_t standby_time;
}bme280_config_t;
static bme280_cali_table_t g_cali_table;
static bme280_config_t g_bme280_config;
i2c_dev_t bme280_ctx = {
.port = 1,
.config.address_width = 8,
.config.freq = 400000,
.config.dev_addr = BME280_I2C_ADDR,
};
static int drv_humi_bosch_bme280_get_cali_temp(i2c_dev_t* drv)
{
int ret;
uint8_t calib_data[BME280_TEMP_PRESS_CALIB_DATA_LEN] = {0};
ret = sensor_i2c_read(drv, BME280_TEMP_PRESS_CALIB_DATA_ADDR, calib_data, BME280_TEMP_PRESS_CALIB_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_cali_table.dig_T1 = BME280_CONCAT_BYTES(calib_data[1], calib_data[0]);
g_cali_table.dig_T2 = (int16_t)BME280_CONCAT_BYTES(calib_data[3], calib_data[2]);
g_cali_table.dig_T3 = (int16_t)BME280_CONCAT_BYTES(calib_data[5], calib_data[4]);
g_cali_table.dig_P1 = BME280_CONCAT_BYTES(calib_data[7], calib_data[6]);
g_cali_table.dig_P2 = (int16_t)BME280_CONCAT_BYTES(calib_data[9], calib_data[8]);
g_cali_table.dig_P3 = (int16_t)BME280_CONCAT_BYTES(calib_data[11], calib_data[10]);
g_cali_table.dig_P4 = (int16_t)BME280_CONCAT_BYTES(calib_data[13], calib_data[12]);
g_cali_table.dig_P5 = (int16_t)BME280_CONCAT_BYTES(calib_data[15], calib_data[14]);
g_cali_table.dig_P6 = (int16_t)BME280_CONCAT_BYTES(calib_data[17], calib_data[16]);
g_cali_table.dig_P7 = (int16_t)BME280_CONCAT_BYTES(calib_data[19], calib_data[18]);
g_cali_table.dig_P8 = (int16_t)BME280_CONCAT_BYTES(calib_data[21], calib_data[20]);
g_cali_table.dig_P9 = (int16_t)BME280_CONCAT_BYTES(calib_data[23], calib_data[22]);
g_cali_table.dig_H1 = calib_data[25];
return 0;
}
static int drv_humi_bosch_bme280_get_cali_humi(i2c_dev_t* drv)
{
int ret = 0;
int16_t dig_H4_lsb;
int16_t dig_H4_msb;
int16_t dig_H5_lsb;
int16_t dig_H5_msb;
uint8_t table[BME280_HUMIDITY_CALIB_DATA_LEN] = {0};
ret = sensor_i2c_read(drv, BME280_HUMIDITY_CALIB_DATA_ADDR, table, BME280_HUMIDITY_CALIB_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
g_cali_table.dig_H2 = (int16_t)BME280_CONCAT_BYTES(table[1], table[0]);
g_cali_table.dig_H3 = table[2];
dig_H4_msb = (int16_t)(int8_t)table[3] * 16;
dig_H4_lsb = (int16_t)(table[4] & 0x0F);
g_cali_table.dig_H4 = dig_H4_msb | dig_H4_lsb;
dig_H5_msb = (int16_t)(int8_t)table[5] * 16;
dig_H5_lsb = (int16_t)(table[4] >> 4);
g_cali_table.dig_H5 = dig_H5_msb | dig_H5_lsb;
g_cali_table.dig_H6 = (int8_t)table[6];
return 0;
}
static int drv_humi_bosch_bme280_get_cali_parm(i2c_dev_t* drv)
{
int ret = 0;
uint8_t table[BME280_HUMIDITY_CALIB_DATA_LEN] = {0};
ret = drv_humi_bosch_bme280_get_cali_temp(drv);
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_get_cali_humi(drv);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_humi_bosch_bme280_soft_reset(i2c_dev_t* drv)
{
int ret = 0;
ret = sensor_i2c_write(drv, BME280_RESET_ADDR, BME280_SOFT_RESET, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_humi_bosch_bme280_validate_id(i2c_dev_t* drv, uint8_t id_value)
{
uint8_t value = 0x00;
int ret = 0;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, BME280_CHIP_ID_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
if (id_value != value){
return -1;
}
return 0;
}
static int drv_humi_bosch_bme280_enter_sleep_mode(i2c_dev_t* drv)
{
int ret = 0;
uint8_t ctrl_hum;
uint8_t ctrl_meas;
uint8_t data[4];
uint8_t reg_addr = BME280_CTRL_HUM_ADDR;
if(drv == NULL){
return -1;
}
ret = sensor_i2c_read(drv, BME280_CTRL_HUM_ADDR, data, 4, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
g_bme280_config.osr_h = BME280_GET_BITS_POS_0(data[0], BME280_CTRL_HUM);
g_bme280_config.osr_p = BME280_GET_BITS(data[2], BME280_CTRL_PRESS);
g_bme280_config.osr_t = BME280_GET_BITS(data[2], BME280_CTRL_TEMP);
g_bme280_config.filter = BME280_GET_BITS(data[3], BME280_FILTER);
g_bme280_config.standby_time = BME280_GET_BITS(data[3], BME280_STANDBY);
ret = drv_humi_bosch_bme280_soft_reset(&bme280_ctx);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_humi_bosch_bme280_set_work_mode(i2c_dev_t* drv,uint8_t mode)
{
uint8_t ret = 0;
uint8_t value = 0;
uint8_t temp = 0;
uint8_t baro = 0;
uint8_t humi = 0;
switch (mode) {
case BME280_ULTRA_LOW_POWER_MODE:
temp = BME280_OVERSAMP_1X;
baro = BME280_OVERSAMP_1X;
humi = BME280_OVERSAMP_1X;
break;
case BME280_LOW_POWER_MODE:
temp = BME280_OVERSAMP_2X;
baro = BME280_OVERSAMP_2X;
humi = BME280_OVERSAMP_2X;
break;
case BME280_STANDARD_RESOLUTION_MODE:
temp = BME280_OVERSAMP_4X;
baro = BME280_OVERSAMP_4X;
humi = BME280_OVERSAMP_4X;
break;
case BME280_HIGH_RESOLUTION_MODE:
temp = BME280_OVERSAMP_8X;
baro = BME280_OVERSAMP_8X;
humi = BME280_OVERSAMP_8X;
break;
case BME280_ULTRA_HIGH_RESOLUTION_MODE:
temp = BME280_OVERSAMP_16X;
baro = BME280_OVERSAMP_16X;
humi = BME280_OVERSAMP_16X;
break;
default:
return -1;
}
ret = sensor_i2c_read(drv, BME280_CTRL_HUM_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = BME280_SET_BITS(value,BME280_CTRL_HUM,humi);
ret = sensor_i2c_write(drv, BME280_CTRL_HUM_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = 0;
ret = sensor_i2c_read(drv, BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
value = BME280_SET_BITS(value,BME280_CTRL_PRESS,baro);
value = BME280_SET_BITS(value,BME280_CTRL_TEMP,temp);
ret = sensor_i2c_write(drv, BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return ret;
}
static int drv_humi_bosch_bme280_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
{
uint8_t value = 0x00;
int ret = 0;
uint8_t buf[4];
ret = sensor_i2c_read(drv, BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
switch(mode){
case DEV_POWER_ON:{
if((value & BME280_POWER_BIT_MASK) == BME280_NORMAL_MODE){
return 0;
}
value |= BME280_NORMAL_MODE;
ret = sensor_i2c_write(drv, BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
case DEV_POWER_OFF:
case DEV_SLEEP:{
if((value & BME280_POWER_BIT_MASK) == BME280_SLEEP_MODE){
return 0;
}
value &= (~BME280_POWER_BIT_MASK);
ret = sensor_i2c_write(drv, BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
}break;
default:break;
}
return 0;
}
static uint8_t drv_humi_bosch_bme280_hz2odr(int hz)
{
if(hz > 80)
return BME280_STANDBY_TIME_1_MS;
else if(hz > 13)
return BME280_STANDBY_TIME_62_5_MS;
else if(hz > 7)
return BME280_STANDBY_TIME_125_MS;
else if(hz > 3)
return BME280_STANDBY_TIME_250_MS;
else
return BME280_STANDBY_TIME_500_MS;
}
static int drv_humi_bosch_bme280_set_odr(i2c_dev_t* drv, uint8_t odr)
{
int ret = 0;
uint8_t v_data_u8 = 0;
ret = sensor_i2c_read(drv,BME280_CONFIG_ADDR,&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
v_data_u8 = BME280_SET_BITS(v_data_u8,BME280_STANDBY,odr);
ret = sensor_i2c_write(drv,BME280_CONFIG_ADDR,
&v_data_u8,I2C_DATA_LEN,I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
return ret;
}
static int drv_humi_bosch_bme280_set_default_config(i2c_dev_t* drv)
{
int ret = 0;
ret = drv_humi_bosch_bme280_set_power_mode(drv, DEV_SLEEP);
if(unlikely(ret)){
return ret;
}
ret = drv_humi_bosch_bme280_set_odr(drv, BME280_DEFAULT_ODR_1HZ);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_humi_bosch_bme280_comp_temp(temperature_data_t *uncomp_data)
{
int32_t var1;
int32_t var2;
int32_t temperature;
int32_t temperature_min = -4000;
int32_t temperature_max = 8500;
var1 = (int32_t)((uncomp_data->t / 8) - ((int32_t)g_cali_table.dig_T1 * 2));
var1 = (var1 * ((int32_t)g_cali_table.dig_T2)) / 2048;
var2 = (int32_t)((uncomp_data->t / 16) - ((int32_t)g_cali_table.dig_T1));
var2 = (((var2 * var2) / 4096) * ((int32_t)g_cali_table.dig_T3)) / 16384;
g_cali_table.t_fine = var1 + var2;
temperature = (g_cali_table.t_fine * 5 + 128) / 256;
if (temperature < temperature_min)
temperature = temperature_min;
else if (temperature > temperature_max)
temperature = temperature_max;
uncomp_data->t = temperature;
return 0;
}
static int drv_humi_bosch_bme280_comp_humi(humidity_data_t* pdata)
{
int32_t var1 = 0;
int32_t var2 = 0;
int32_t var3 = 0;
int32_t var4 = 0;
int32_t var5 = 0;
uint32_t humidity = 0;
uint32_t humidity_max = 100000;
var1 = g_cali_table.t_fine - ((int32_t)76800);
var2 = (int32_t)((pdata->h) * 16384);
var3 = (int32_t)(((int32_t)g_cali_table.dig_H4) * 1048576);
var4 = ((int32_t)g_cali_table.dig_H5) * var1;
var5 = (((var2 - var3) - var4) + (int32_t)16384) / 32768;
var2 = (var1 * ((int32_t)g_cali_table.dig_H6)) / 1024;
var3 = (var1 * ((int32_t)g_cali_table.dig_H3)) / 2048;
var4 = ((var2 * (var3 + (int32_t)32768)) / 1024) + (int32_t)2097152;
var2 = ((var4 * ((int32_t)g_cali_table.dig_H2)) + 8192) / 16384;
var3 = var5 * var2;
var4 = ((var3 / 32768) * (var3 / 32768)) / 128;
var5 = var3 - ((var4 * ((int32_t)g_cali_table.dig_H1)) / 16);
var5 = (var5 < 0 ? 0 : var5);
var5 = (var5 > 419430400 ? 419430400 : var5);
humidity = (uint32_t)(var5 / 4096);
if (humidity > humidity_max){
humidity = humidity_max;
}
pdata->h = (humidity * BME280_HUMI_UNIT_RATIO_10)/BME280_HUMI_UNIT_RATIO_1024;
return 0;
}
static int drv_humi_bosch_bme280_cali_temp(void)
{
int ret = 0;
uint8_t data[BME280_TEMP_DATA_LEN] = {0};
temperature_data_t temp;
ret = sensor_i2c_read(&bme280_ctx, BME280_TEMP_DATA_ADDR, data, BME280_TEMP_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
temp.t = (int32_t)((uint32_t)data[0]<<BME280_SHIFT_BY_12_BITS) | ((uint32_t)data[1]<<BME280_SHIFT_BY_04_BITS) |((uint32_t)data[0]>>BME280_SHIFT_BY_04_BITS);
ret = drv_humi_bosch_bme280_comp_temp(&temp);
if(unlikely(ret)){
return ret;
}
return 0;
}
static int drv_humi_bosch_bme280_read_humi(humidity_data_t* pdata)
{
int ret = 0;
uint8_t data[BME280_HUMI_DATA_LEN] = {0};
uint32_t data_lsb;
uint32_t data_msb;
ret = sensor_i2c_read(&bme280_ctx, BME280_HUMI_DATA_ADDR, data, BME280_HUMI_DATA_LEN, I2C_OP_RETRIES);
if(unlikely(ret)){
return ret;
}
data_lsb = (uint32_t)data[0] << 8;
data_msb = (uint32_t)data[1];
pdata->h = data_msb | data_lsb;
ret = drv_humi_bosch_bme280_comp_humi(pdata);
if(unlikely(ret)){
return ret;
}
return 0;
}
static void drv_humi_bosch_bme280_irq_handle(void)
{
/* no handle so far */
}
static int drv_humi_bosch_bme280_open(void)
{
int ret = 0;
ret = drv_humi_bosch_bme280_set_work_mode(&bme280_ctx, BME280_STANDARD_RESOLUTION_MODE);
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_set_power_mode(&bme280_ctx, DEV_POWER_ON);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_humi_bosch_bme280_close(void)
{
int ret = 0;
ret = drv_humi_bosch_bme280_set_power_mode(&bme280_ctx, DEV_POWER_OFF);
if(unlikely(ret)){
return -1;
}
return 0;
}
static int drv_humi_bosch_bme280_read(void *buf, size_t len)
{
int ret = 0;
size_t size = 0;
uint8_t data[BME280_TEMP_DATA_LEN] = {0};
uint32_t data_lsb;
uint32_t data_msb;
humidity_data_t* pdata = (humidity_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(humidity_data_t);
if(len < size){
return -1;
}
ret = drv_humi_bosch_bme280_cali_temp();
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_read_humi(pdata);
if(unlikely(ret)){
return -1;
}
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_humi_bosch_bme280_ioctl(int cmd, unsigned long arg)
{
int ret = 0;
switch(cmd){
case SENSOR_IOCTL_ODR_SET:{
uint8_t odr = drv_humi_bosch_bme280_hz2odr(arg);
ret = drv_humi_bosch_bme280_set_odr(&bme280_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_SET_POWER:{
ret = drv_humi_bosch_bme280_set_power_mode(&bme280_ctx, arg);
if(unlikely(ret)){
return -1;
}
}break;
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "BME280";
info->range_max = 16;
info->range_min = 4;
info->unit = permillage;
}break;
default:break;
}
return 0;
}
int drv_humi_bosch_bme280_init(void){
int ret = 0;
sensor_obj_t sensor;
/* fill the sensor obj parameters here */
sensor.io_port = I2C_PORT;
sensor.tag = TAG_DEV_HUMI;
sensor.path = dev_humi_path;
sensor.open = drv_humi_bosch_bme280_open;
sensor.close = drv_humi_bosch_bme280_close;
sensor.read = drv_humi_bosch_bme280_read;
sensor.write = NULL;
sensor.ioctl = drv_humi_bosch_bme280_ioctl;
sensor.irq_handle = drv_humi_bosch_bme280_irq_handle;
ret = sensor_create_obj(&sensor);
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_validate_id(&bme280_ctx, BME280_CHIP_ID);
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_soft_reset(&bme280_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_set_default_config(&bme280_ctx);
if(unlikely(ret)){
return -1;
}
ret = drv_humi_bosch_bme280_get_cali_parm(&bme280_ctx);
if(unlikely(ret)){
return -1;
}
/* update the phy sensor info to sensor hal */
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

406
Living_SDK/device/sensor/drv/drv_temp_humi_sensirion_shtc1.c Normal file
View file

@ -0,0 +1,406 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include <hal/base.h>
#include "common.h"
#include "hal/sensor.h"
#define SHTC1_I2C_SLAVE_ADDR 0x70
#define SHTC1_ADDR_TRANS(n) ((n) << 1)
#define SHTC1_I2C_ADDR SHTC1_ADDR_TRANS(SHTC1_I2C_SLAVE_ADDR)
/* delays for non-blocking i2c commands, both in ms */
#define SHTC1_NONBLOCKING_WAIT_TIME_HPM 15
#define SHTC1_NONBLOCKING_WAIT_TIME_LPM 1
#define SHTC1_CHIP_ID_VAL 0x07
#define SHTC1_ID_REG_MASK 0x1f
#define SHTC1_CMD_LENGTH 2
#define SHTC1_RESPONSE_LENGTH 6
#define SHTC1_DATA_READ_MIN_INTERVAL 200 /* in millisecond */
typedef enum {
FLAG_INIT_TEMP = 0,
FLAG_INIT_HUMI,
} FLAG_INIT_BIT;
i2c_dev_t shtc1_ctx = {
.port = 2,
.config.address_width = 8,
.config.freq = 100000,
.config.dev_addr = SHTC1_I2C_ADDR,
};
static uint8_t g_init_bitwise = 0;
typedef struct {
int32_t temperature;
uint32_t humidity;
} shtc1_sensor_data;
/* shtc1 configration */
static int g_is_blocking_io = 1;
static int g_is_high_precision = 1;
shtc1_sensor_data g_data_new = {0};
static const uint8_t shtc1_cmd_list[][SHTC1_CMD_LENGTH] = {
{0xef, 0xc8}, /* read id reg */
{0x7c, 0xa2}, /* measure blocking hpm */
{0x78, 0x66}, /* measure nonblocking hpm */
{0x64, 0x58}, /* measure blocking lpm */
{0x60, 0x9c}, /* measure nonblocking lpm */
};
typedef enum {
SHTC1_CMD_read_id_reg,
SHTC1_CMD_measure_blocking_hpm,
SHTC1_CMD_measure_nonblocking_hpm,
SHTC1_CMD_measure_blocking_lpm,
SHTC1_CMD_measure_nonblocking_lpm,
SHTC1_CMD_END
} CMD_SHTC1_ENUM;
static int drv_shtc1_cmd_write(i2c_dev_t* drv, CMD_SHTC1_ENUM cmd)
{
int ret = 0;
if (cmd < SHTC1_CMD_read_id_reg || cmd >= SHTC1_CMD_END)
return -1;
return hal_i2c_master_send(drv, drv->config.dev_addr, shtc1_cmd_list[cmd], SHTC1_CMD_LENGTH, AOS_WAIT_FOREVER);
}
static int drv_shtc1_result_read(i2c_dev_t* drv, uint8_t *data, uint16_t size)
{
if (data == NULL || size == 0)
return -1;
return hal_i2c_master_recv(drv, drv->config.dev_addr, data, size, AOS_WAIT_FOREVER);
}
static int drv_shtc1_read_raw_data(i2c_dev_t* drv, uint8_t *data)
{
int ret = 0;
CMD_SHTC1_ENUM readcmd;
int nonblocking_wait_time = 0;
if (data == NULL)
return -1;
if (g_is_high_precision) {
readcmd = g_is_blocking_io ? SHTC1_CMD_measure_blocking_hpm : SHTC1_CMD_measure_nonblocking_hpm;
nonblocking_wait_time = SHTC1_NONBLOCKING_WAIT_TIME_HPM;
} else {
readcmd = g_is_blocking_io ? SHTC1_CMD_measure_blocking_lpm : SHTC1_CMD_measure_nonblocking_lpm;
nonblocking_wait_time = SHTC1_NONBLOCKING_WAIT_TIME_LPM;
}
ret = drv_shtc1_cmd_write(drv, readcmd);
if (unlikely(ret)) {
return ret;
}
if (!g_is_blocking_io)
krhino_task_sleep(krhino_ms_to_ticks(nonblocking_wait_time));
ret = drv_shtc1_result_read(drv, data, SHTC1_RESPONSE_LENGTH);
if (unlikely(ret)) {
return ret;
}
return ret;
}
static int drv_shtc1_read_temp_and_humi(i2c_dev_t* drv, int32_t *temperature, uint32_t *humidity)
{
int ret = 0;
uint8_t data[SHTC1_RESPONSE_LENGTH] = {0};
int temp_raw = 0;
int humi_raw = 0;
if (temperature == NULL && humidity == NULL)
return -1;
ret = drv_shtc1_read_raw_data(drv, data);
if (unlikely(ret)) {
return ret;
}
temp_raw = (int)(data[0] << 8 | data[1]);
humi_raw = (int)(data[3] << 8 | data[4]);
if (temperature != NULL)
*temperature = (int32_t)((21875 * temp_raw) >> 13) - 45000;
if (humidity != NULL)
*humidity = (uint32_t)((12500 * humi_raw) >> 13);
return 0;
}
static int drv_shtc1_update_data(i2c_dev_t* drv)
{
static uint32_t prev_update_tick = 0;
uint32_t now_tick = 0;
int ret = 0;
now_tick = HAL_GetTick();
if (now_tick - prev_update_tick > SHTC1_DATA_READ_MIN_INTERVAL) {
ret = drv_shtc1_read_temp_and_humi(drv, &g_data_new.temperature, &g_data_new.humidity);
if (ret != 0) {
return ret;
}
prev_update_tick = now_tick;
}
return 0;
}
static int drv_temp_humi_sensirion_shtc1_validate_id(i2c_dev_t* drv, uint8_t id_value, uint8_t id_mask)
{
int ret = 0;
uint8_t value[2] = {0};
if(drv == NULL){
return -1;
}
ret = drv_shtc1_cmd_write(drv, SHTC1_CMD_read_id_reg);
if (unlikely(ret)) {
return ret;
}
ret = drv_shtc1_result_read(drv, value, 2);
if (unlikely(ret)) {
return ret;
}
if ((value[1] & id_mask) != id_value) {
return -1;
}
return 0;
}
static void drv_temp_sensirion_shtc1_irq_handle(void)
{
/* no handle so far */
}
static int drv_temp_sensirion_shtc1_open(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_temp_sensirion_shtc1_close(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_temp_sensirion_shtc1_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
temperature_data_t* pdata = (temperature_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(temperature_data_t);
if(len < size){
return -1;
}
ret = drv_shtc1_update_data(&shtc1_ctx);
if (ret != 0)
return -1;
pdata->t = g_data_new.temperature;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_temp_sensirion_shtc1_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_temp_sensirion_shtc1_ioctl(int cmd, unsigned long arg)
{
switch (cmd) {
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "SHTC1";
info->unit = dCelsius;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static void drv_humi_sensirion_shtc1_irq_handle(void)
{
/* no handle so far */
}
static int drv_humi_sensirion_shtc1_open(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_humi_sensirion_shtc1_close(void)
{
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
static int drv_humi_sensirion_shtc1_read(void *buf, size_t len)
{
int ret = 0;
size_t size;
humidity_data_t* pdata = (humidity_data_t*)buf;
if(buf == NULL){
return -1;
}
size = sizeof(humidity_data_t);
if(len < size){
return -1;
}
ret = drv_shtc1_update_data(&shtc1_ctx);
if (ret != 0)
return -1;
pdata->h = g_data_new.humidity;
pdata->timestamp = aos_now_ms();
return (int)size;
}
static int drv_humi_sensirion_shtc1_write(const void *buf, size_t len)
{
(void)buf;
(void)len;
return 0;
}
static int drv_humi_sensirion_shtc1_ioctl(int cmd, unsigned long arg)
{
switch (cmd) {
case SENSOR_IOCTL_GET_INFO:{
/* fill the dev info here */
dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
info->model = "SHTC1";
info->unit = permillage;
}break;
default:
return -1;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_temp_sensirion_shtc1_init(void)
{
int ret = 0;
sensor_obj_t sensor_temp;
if (!g_init_bitwise) {
ret = drv_temp_humi_sensirion_shtc1_validate_id(&shtc1_ctx, SHTC1_CHIP_ID_VAL, SHTC1_ID_REG_MASK);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << FLAG_INIT_TEMP))) {
/* fill the sensor_temp obj parameters here */
sensor_temp.tag = TAG_DEV_TEMP;
sensor_temp.path = dev_temp_path;
sensor_temp.io_port = I2C_PORT;
sensor_temp.open = drv_temp_sensirion_shtc1_open;
sensor_temp.close = drv_temp_sensirion_shtc1_close;
sensor_temp.read = drv_temp_sensirion_shtc1_read;
sensor_temp.write = drv_temp_sensirion_shtc1_write;
sensor_temp.ioctl = drv_temp_sensirion_shtc1_ioctl;
sensor_temp.irq_handle = drv_temp_sensirion_shtc1_irq_handle;
ret = sensor_create_obj(&sensor_temp);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << FLAG_INIT_TEMP;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}
int drv_humi_sensirion_shtc1_init(void)
{
int ret = 0;
sensor_obj_t sensor_humi;
if (!g_init_bitwise) {
ret = drv_temp_humi_sensirion_shtc1_validate_id(&shtc1_ctx, SHTC1_CHIP_ID_VAL, SHTC1_ID_REG_MASK);
if (unlikely(ret)) {
return -1;
}
}
if (!(g_init_bitwise & (1 << FLAG_INIT_HUMI))) {
/* fill the sensor_humi obj parameters here */
sensor_humi.tag = TAG_DEV_HUMI;
sensor_humi.path = dev_humi_path;
sensor_humi.io_port = I2C_PORT;
sensor_humi.open = drv_humi_sensirion_shtc1_open;
sensor_humi.close = drv_humi_sensirion_shtc1_close;
sensor_humi.read = drv_humi_sensirion_shtc1_read;
sensor_humi.write = drv_humi_sensirion_shtc1_write;
sensor_humi.ioctl = drv_humi_sensirion_shtc1_ioctl;
sensor_humi.irq_handle = drv_humi_sensirion_shtc1_irq_handle;
ret = sensor_create_obj(&sensor_humi);
if (unlikely(ret)) {
return -1;
}
g_init_bitwise |= 1 << FLAG_INIT_HUMI;
}
LOG("%s %s successfully \n", SENSOR_STR, __func__);
return 0;
}

30
Living_SDK/device/sensor/hal/sensor_drv_api.c Normal file
View file

@ -0,0 +1,30 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <aos/aos.h>
#include "hal/soc/soc.h"
#include "hal/soc/i2c.h"
#include "hal/sensor.h"
int32_t sensor_i2c_read(i2c_dev_t *i2c, uint16_t reg, uint8_t *data, uint16_t size, uint32_t timeout)
{
int32_t ret = 0;
if(i2c == NULL){
return -1;
}
ret = hal_i2c_mem_read(i2c, i2c->config.dev_addr, reg, I2C_REG_LEN, data, size, AOS_WAIT_FOREVER);
return ret;
}
int32_t sensor_i2c_write(i2c_dev_t *i2c, uint16_t reg, uint8_t *data, uint16_t size, uint32_t timeout)
{
int32_t ret = 0;
if(i2c == NULL){
return -1;
}
ret = hal_i2c_mem_write(i2c, i2c->config.dev_addr, reg, I2C_REG_LEN, data, size, AOS_WAIT_FOREVER);
return ret;
}

368
Living_SDK/device/sensor/hal/sensor_hal.c Normal file
View file

@ -0,0 +1,368 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aos/aos.h>
#include <hal/base.h>
#include <vfs_conf.h>
#include <vfs_err.h>
#include <vfs_register.h>
#include "common.h"
#include "hal/sensor.h"
static int sensor_open(inode_t *node, file_t *file);
static int sensor_close(file_t *file);
static ssize_t sensor_read(file_t *f, void *buf, size_t len);
static ssize_t sensor_write(file_t *f, const void *buf, size_t len);
static int sensor_ioctl(file_t *f, int cmd, unsigned long arg);
static int sensor_poll(file_t *f, bool setup, poll_notify_t notify, struct pollfd *fd, void *opa);
file_ops_t sensor_fops = {
.open = sensor_open,
.close = sensor_close,
.read = sensor_read,
.write = sensor_write,
.ioctl = sensor_ioctl,
};
i2c_dev_t i2c = {
.port = 1,
.config.address_width = 7,
.config.freq = 400000,
.config.dev_addr = 0x00, /* the dev addr will be update in the sensor driver */
};
static sensor_obj_t *g_sensor_obj[TAG_DEV_SENSOR_NUM_MAX];
static uint32_t g_sensor_cnt = 0;
static void sensor_set_power_mode(dev_power_mode_e power, int index)
{
g_sensor_obj[index]->power = power;
}
static void sensor_irq_handle(void *arg)
{
// will implement later
return;
}
static int sensor_register_irq(int index )
{
// will implement later
return 0;
}
static int find_selected_sensor(char* path )
{
int i = 0;
if(path == NULL){
return -1;
}
for(i = 0; i < g_sensor_cnt; i++){
if(strncmp(g_sensor_obj[i]->path, path, strlen(path)) == 0){
return i;
}
}
return -1;
}
static int load_sensor_config(int index )
{
int ret = 0;
g_sensor_obj[index] = (sensor_obj_t*)aos_malloc(sizeof(sensor_obj_t));
if(g_sensor_obj[index] == NULL){
return -1;
}
return 0;
}
static int sensor_io_bus_init(i2c_dev_t *i2c)
{
int ret = 0;
/* plan to add the other bus register here like spi */
ret = hal_i2c_init(i2c);
if (ret != 0) {
return -1;
}
return 0;
}
static int sensor_obj_register(int index )
{
int ret = 0;
if((g_sensor_obj[index]->mode == DEV_INT)||(g_sensor_obj[index]->mode == DEV_DATA_READY)){
ret = sensor_register_irq(index);
if (ret != 0) {
return -1;
}
}
ret = aos_register_driver(g_sensor_obj[index]->path, &sensor_fops, NULL);
if (ret != 0) {
return -1;
}
return 0;
}
int sensor_create_obj(sensor_obj_t* sensor)
{
int ret = 0;
g_sensor_obj[g_sensor_cnt] = (sensor_obj_t*)aos_malloc(sizeof(sensor_obj_t));
if(g_sensor_obj[g_sensor_cnt] == NULL){
return -1;
}
memset(g_sensor_obj[g_sensor_cnt], 0, sizeof(sensor_obj_t));
/* install the phy sensor info into the sensor object datebase here */
g_sensor_obj[g_sensor_cnt]->io_port = sensor->io_port;
g_sensor_obj[g_sensor_cnt]->path = sensor->path;
g_sensor_obj[g_sensor_cnt]->tag = sensor->tag;
g_sensor_obj[g_sensor_cnt]->open = sensor->open;
g_sensor_obj[g_sensor_cnt]->close = sensor->close;
g_sensor_obj[g_sensor_cnt]->ioctl = sensor->ioctl;
g_sensor_obj[g_sensor_cnt]->read = sensor->read;
g_sensor_obj[g_sensor_cnt]->write = sensor->write;
g_sensor_obj[g_sensor_cnt]->irq_handle = sensor->irq_handle;
g_sensor_obj[g_sensor_cnt]->mode = sensor->mode;
g_sensor_obj[g_sensor_cnt]->power = DEV_POWER_OFF; // will update the status later
g_sensor_obj[g_sensor_cnt]->ref = 0; // count the ref of this sensor
/* register the sensor object into the irq list and vfs */
ret = sensor_obj_register(g_sensor_cnt);
if (ret != 0) {
goto error;
}
//ret = sensor_io_bus_init((sensor->bus));
//if (ret != 0) {
// goto error;
//}
g_sensor_cnt++;
LOGD(SENSOR_STR, "%s successfully \n", __func__);
return 0;
error:
free(g_sensor_obj[g_sensor_cnt]);
return -1;
}
static int sensor_hal_get_dev_list(void* buf)
{
sensor_list_t* list = buf;
if(buf == NULL)
return -1;
/* load the sensor count and tag list here */
if (list->cnt >= TAG_DEV_SENSOR_NUM_MAX){
printf("list->cnt == %d %d\n",list->cnt,TAG_DEV_SENSOR_NUM_MAX);
return -1;
}
for(int index = 0; index < g_sensor_cnt; index++){
list->list[list->cnt+index] = g_sensor_obj[index]->tag;
}
list->cnt += g_sensor_cnt;
return 0;
}
static int sensor_open(inode_t *node, file_t *file)
{
int index = 0;
if((node == NULL)||(file == NULL)){
return -1;
}
/* just open the /dev/sensor node here */
if(strncmp(sensor_node_path, node->i_name, strlen(node->i_name)) == 0){
return 0;
}
index = find_selected_sensor(node->i_name);
if(( g_sensor_obj[index]->open == NULL)||(index < 0)){
return -1;
}
if(g_sensor_obj[index]->ref == 0){
g_sensor_obj[index]->open();
}
g_sensor_obj[index]->ref++;
LOGD(SENSOR_STR, "%s successfully \n", __func__);
return 0;
}
static int sensor_close(file_t *file)
{
int index = 0;
/* just close the /dev/sensor node here */
if(strncmp(sensor_node_path, (file->node->i_name), strlen(file->node->i_name)) == 0){
return 0;
}
index = find_selected_sensor(file->node->i_name);
if(( g_sensor_obj[index]->close == NULL)||(index < 0)){
return -1;
}
//if the ref counter is less than 2, then close the sensor
if(g_sensor_obj[index]->ref < 2){
g_sensor_obj[index]->close();
}
if(g_sensor_obj[index]->ref > 0){
g_sensor_obj[index]->ref--;
}
return 0;
}
static ssize_t sensor_read(file_t *f, void *buf, size_t len)
{
int index = 0;
int ret = 0;
if(f == NULL){
return -1;
}
index = find_selected_sensor(f->node->i_name);
if(( g_sensor_obj[index]->read == NULL)||(index < 0)){
goto error;
}
if(buf == NULL){
goto error;
}
ret = g_sensor_obj[index]->read(buf, len);
if(ret < 0){
goto error;
}
return ret;
error:
return -1;
}
static ssize_t sensor_write(file_t *f, const void *buf, size_t len)
{
/* no need this functionality recently */
return 0;
}
static int sensor_ioctl(file_t *f, int cmd, unsigned long arg)
{
int ret = 0;
int index = 0;
if(f == NULL){
return -1;
}
if(cmd == SENSOR_IOCTL_GET_SENSOR_LIST){
ret = sensor_hal_get_dev_list((void *)arg);
if(ret != 0){
return -1;
}
return 0;
}
index = find_selected_sensor(f->node->i_name);
if(( g_sensor_obj[index]->ioctl == NULL)||(index < 0)){
return -1;
}
ret = g_sensor_obj[index]->ioctl(cmd, arg);
if(ret != 0){
return -1;
}
LOGD(SENSOR_STR, "%s successfully \n", __func__);
return 0;
}
static int sensor_hal_register(void)
{
int ret = 0;
ret = aos_register_driver(sensor_node_path, &sensor_fops, NULL);
if (ret != 0) {
return -1;
}
return 0;
}
int sensor_init(void){
int ret = 0;
int index = 0;
g_sensor_cnt = 0 ;
sensor_io_bus_init(&i2c);
#ifdef AOS_SENSOR_HUMI_BOSCH_BME280
drv_humi_bosch_bme280_init();
#endif /* AOS_SENSOR_HUMI_BOSCH_BME280 */
#ifdef AOS_SENSOR_ACC_BOSCH_BMA253
drv_acc_bosch_bma253_init();
#endif /* AOS_SENSOR_ACC_BOSCH_BMA253 */
#ifdef AOS_SENSOR_BARO_BOSCH_BMP280
drv_baro_bosch_bmp280_init();
#endif /* AOS_SENSOR_BARO_BOSCH_BMP280 */
#ifdef AOS_SENSOR_ACC_ST_LSM6DSL
drv_acc_st_lsm6dsl_init();
#endif /* AOS_SENSOR_ACC_ST_LSM6DSL */
#ifdef AOS_SENSOR_GYRO_ST_LSM6DSL
drv_gyro_st_lsm6dsl_init();
#endif /* AOS_SENSOR_GYRO_ST_LSM6DSL */
#ifdef AOS_SENSOR_BARO_ST_LPS22HB
drv_baro_st_lps22hb_init();
#endif /* AOS_SENSOR_BARO_ST_LPS22HB */
#ifdef AOS_SENSOR_ACC_MIR3_DA217
drv_acc_mir3_da217_init();
#endif /* AOS_SENSOR_ACC_MIR3_DA217 */
#ifdef AOS_SENSOR_ALS_LITEON_LTR553
drv_als_liteon_ltr553_init();
#endif /* AOS_SENSOR_ALS_LITEON_LTR553 */
#ifdef AOS_SENSOR_PS_LITEON_LTR553
drv_ps_liteon_ltr553_init();
#endif /* AOS_SENSOR_PS_LITEON_LTR553 */
#ifdef AOS_SENSOR_TEMP_SENSIRION_SHTC1
drv_temp_sensirion_shtc1_init();
#endif /* AOS_SENSOR_TEMP_SENSIRION_SHTC1 */
#ifdef AOS_SENSOR_HUMI_SENSIRION_SHTC1
drv_humi_sensirion_shtc1_init();
#endif /* AOS_SENSOR_HUMI_SENSIRION_SHTC1 */
ret = sensor_hal_register();
if(ret != 0){
return -1;
}
LOGD(SENSOR_STR, "%s successfully \n", __func__);
return 0;
}

11
Living_SDK/device/sensor/hal/sensor_hal.h Normal file
View file

@ -0,0 +1,11 @@
/*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#ifndef SENSOR_HAL_H
#define SENSOR_HAL_H
extern int sensor_hal_init(void);
#endif /* SENSOR_HAL_H */

36
Living_SDK/device/sensor/sensor.mk Normal file
View file

@ -0,0 +1,36 @@
NAME := sensor
$(NAME)_TYPE := kernel
$(NAME)_SOURCES += \
hal/sensor_hal.c \
hal/sensor_drv_api.c \
drv/drv_humi_bosch_bme280.c \
drv/drv_acc_bosch_bma253.c \
drv/drv_baro_bosch_bmp280.c \
drv/drv_acc_gyro_st_lsm6dsl.c\
drv/drv_baro_st_lps22hb.c \
drv/drv_acc_mir3_da217.c \
drv/drv_als_ps_liteon_ltr553.c \
drv/drv_temp_humi_sensirion_shtc1.c
GLOBAL_INCLUDES += .
GLOBAL_DEFINES += AOS_SENSOR
#GLOBAL_DEFINES += AOS_SENSOR_HUMI_BOSCH_BME280
#GLOBAL_DEFINES += AOS_SENSOR_ACC_BOSCH_BMA253
#GLOBAL_DEFINES += AOS_SENSOR_BARO_BOSCH_BMP280
#GLOBAL_DEFINES += AOS_SENSOR_ACC_ST_LSM6DSL
#GLOBAL_DEFINES += AOS_SENSOR_GYRO_ST_LSM6DSL
#GLOBAL_DEFINES += AOS_SENSOR_BARO_ST_LPS22HB
#GLOBAL_DEFINES += AOS_SENSOR_ACC_SUPPORT_STEP
#GLOBAL_DEFINES += AOS_SENSOR_ACC_MIR3_DA217
#GLOBAL_DEFINES += AOS_SENSOR_ALS_LITEON_LTR553
#GLOBAL_DEFINES += AOS_SENSOR_PS_LITEON_LTR553
#GLOBAL_DEFINES += AOS_SENSOR_TEMP_SENSIRION_SHTC1
#GLOBAL_DEFINES += AOS_SENSOR_HUMI_SENSIRION_SHTC1

29
Living_SDK/device/sensor/ucube.py Normal file
View file

@ -0,0 +1,29 @@
src =Split('''
hal/sensor_hal.c
hal/sensor_drv_api.c
drv/drv_humi_bosch_bme280.c
drv/drv_acc_bosch_bma253.c
drv/drv_baro_bosch_bmp280.c
drv/drv_acc_gyro_st_lsm6dsl.c
drv/drv_baro_st_lps22hb.c
drv/drv_acc_mir3_da217.c
drv/drv_als_ps_liteon_ltr553.c
drv/drv_temp_humi_sensirion_shtc1.c
''')
component =aos_component('sensor', src)
global_includes =Split('''
.
''')
for i in global_includes:
component.add_global_includes(i)
global_macros =Split('''
AOS_SENSOR
''')
for i in global_macros:
component.add_global_macros(i)