Datasets:
nyuuzyou
/
gitcode-code

Dataset card Data Studio Files
xet
Community
code
stringlengths
1
1.05M
repo_name
stringlengths
6
83
path
stringlengths
3
242
language
stringclasses
222 values
license
stringclasses
20 values
size
int64
1
1.05M
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define BMG160_I2C_ADDR1 (0x68 << 1) #define BMG160_I2C_ADDR2 (0x69 << 1) #define BMG160_CHIP_ID_ADDR (0x00) #define BMG160_CHIP_ID_VALUE (0x0F) #define BMG160_RATE_X_LSB_ADDR (0x02) #define BMG160_RATE_X_MSB_ADDR (0x03) #define BMG160_RATE_Y_LSB_ADDR (0x04) #define BMG160_RATE_Y_MSB_ADDR (0x05) #define BMG160_RATE_Z_LSB_ADDR (0x06) #define BMG160_RATE_Z_MSB_ADDR (0x07) #define BMG160_TEMP_ADDR (0x08) #define BMG160_INTR_STAT0_ADDR (0x09) #define BMG160_INTR_STAT1_ADDR (0x0A) #define BMG160_INTR_STAT2_ADDR (0x0B) #define BMG160_INTR_STAT3_ADDR (0x0C) #define BMG160_FIFO_STAT_ADDR (0x0E) #define BMG160_RANGE_ADDR (0x0F) #define BMG160_BW_ADDR (0x10) #define BMG160_MODE_LPM1_ADDR (0x11) #define BMG160_MODE_LPM2_ADDR (0x12) #define BMG160_HIGH_BW_ADDR (0x13) #define BMG160_BGW_SOFT_RST_ADDR (0x14) #define BMG160_INTR_ENABLE0_ADDR (0x15) #define BMG160_INTR_ENABLE1_ADDR (0x16) #define BMG160_INTR_MAP_ZERO_ADDR (0x17) #define BMG160_INTR_MAP_ONE_ADDR (0x18) #define BMG160_INTR_MAP_TWO_ADDR (0x19) #define BMG160_INTR_ZERO_ADDR (0x1A) #define BMG160_INTR_ONE_ADDR (0x1B) #define BMG160_INTR_TWO_ADDR (0x1C) #define BMG160_INTR_4_ADDR (0x1E) #define BMG160_RST_LATCH_ADDR (0x21) #define BMG160_HIGHRATE_THRES_X_ADDR (0x22) #define BMG160_HIGHRATE_DURN_X_ADDR (0x23) #define BMG160_HIGHRATE_THRES_Y_ADDR (0x24) #define BMG160_HIGHRATE_DURN_Y_ADDR (0x25) #define BMG160_HIGHRATE_THRES_Z_ADDR (0x26) #define BMG160_HIGHRATE_DURN_Z_ADDR (0x27) #define BMG160_SOC_ADDR (0x31) #define BMG160_A_FOC_ADDR (0x32) #define BMG160_TRIM_NVM_CTRL_ADDR (0x33) #define BMG160_BGW_SPI3_WDT_ADDR (0x34) #define BMG160_OFFSET_OFC1_ADDR (0x36) #define BMG160_OFC2_ADDR (0x37) #define BMG160_OFC3_ADDR (0x38) #define BMG160_OFC4_ADDR (0x39) #define BMG160_TRIM_GP0_ADDR (0x3A) #define BMG160_TRIM_GP1_ADDR (0x3B) #define BMG160_SELFTEST_ADDR (0x3C) #define BMG160_FIFO_CGF1_ADDR (0x3D) #define BMG160_FIFO_CGF0_ADDR (0x3E) #define BMG160_FIFO_DATA_ADDR (0x3F) #define BMG160_RATE_X_LSB_BIT_POS (0) #define BMG160_RATE_X_LSB_BIT_LEN (8) #define BMG160_RATE_X_LSB_BIT_MSK (0xFF) #define BMG160_RATE_X_LSB_BIT_REG (BMG160_RATE_X_LSB_ADDR) #define BMG160_RATE_Y_LSB_BIT_POS (0) #define BMG160_RATE_Y_LSB_BIT_LEN (8) #define BMG160_RATE_Y_LSB_BIT_MSK (0xFF) #define BMG160_RATE_Y_LSB_BIT_REG (BMG160_RATE_Y_LSB_ADDR) #define BMG160_RATE_Z_LSB_BIT_POS (0) #define BMG160_RATE_Z_LSB_BIT_LEN (8) #define BMG160_RATE_Z_LSB_BIT_MSK (0xFF) #define BMG160_RATE_Z_LSB_BIT_REG (BMG160_RATE_Z_LSB_ADDR) #define BMG160_INTR_STAT0_ANY_MOTION_INTR_POS (2) #define BMG160_INTR_STAT0_ANY_MOTION_INTR_LEN (1) #define BMG160_INTR_STAT0_ANY_MOTION_INTR_MSK (0x04) #define BMG160_INTR_STAT0_ANY_MOTION_INTR_REG (BMG160_INTR_STAT0_ADDR) #define BMG160_INTR_STAT0_HIGHRATE_INTR_POS (1) #define BMG160_INTR_STAT0_HIGHRATE_INTR_LEN (1) #define BMG160_INTR_STAT0_HIGHRATE_INTR_MSK (0x02) #define BMG160_INTR_STAT0_HIGHRATE_INTR_REG (BMG160_INTR_STAT0_ADDR) #define BMG160_INTR_STAT_ZERO_POS (1) #define BMG160_INTR_STAT_ZERO_LEN (2) #define BMG160_INTR_STAT_ZERO_MSK (0x06) #define BMG160_INTR_STAT_ZERO_REG (BMG160_INTR_STAT0_ADDR) #define BMG160_INTR_STAT1_DATA_INTR_POS (7) #define BMG160_INTR_STAT1_DATA_INTR_LEN (1) #define BMG160_INTR_STAT1_DATA_INTR_MSK (0x80) #define BMG160_INTR_STAT1_DATA_INTR_REG (BMG160_INTR_STAT1_ADDR) #define BMG160_INTR_STAT1_AUTO_OFFSET_INTR_POS (6) #define BMG160_INTR_STAT1_AUTO_OFFSET_INTR_LEN (1) #define BMG160_INTR_STAT1_AUTO_OFFSET_INTR_MSK (0x40) #define BMG160_INTR_STAT1_AUTO_OFFSET_INTR_REG (BMG160_INTR_STAT1_ADDR) #define BMG160_INTR_STAT1_FAST_OFFSET_INTR_POS (5) #define BMG160_INTR_STAT1_FAST_OFFSET_INTR_LEN (1) #define BMG160_INTR_STAT1_FAST_OFFSET_INTR_MSK (0x20) #define BMG160_INTR_STAT1_FAST_OFFSET_INTR_REG (BMG160_INTR_STAT1_ADDR) #define BMG160_INTR_STAT1_FIFO_INTR_POS (4) #define BMG160_INTR_STAT1_FIFO_INTR_LEN (1) #define BMG160_INTR_STAT1_FIFO_INTR_MSK (0x10) #define BMG160_INTR_STAT1_FIFO_INTR_REG (BMG160_INTR_STAT1_ADDR) #define BMG160_INTR_STAT_ONE_POS (4) #define BMG160_INTR_STAT_ONE_LEN (4) #define BMG160_INTR_STAT_ONE_MSK (0xF0) #define BMG160_INTR_STAT_ONE_REG (BMG160_INTR_STAT1_ADDR) #define BMG160_INTR_STAT2_ANY_MOTION_SIGN_INTR_POS (3) #define BMG160_INTR_STAT2_ANY_MOTION_SIGN_INTR_LEN (1) #define BMG160_INTR_STAT2_ANY_MOTION_SIGN_INTR_MSK (0x08) #define BMG160_INTR_STAT2_ANY_MOTION_SIGN_INTR_REG (BMG160_INTR_STAT2_ADDR) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTZ_INTR_POS (2) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTZ_INTR_LEN (1) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTZ_INTR_MSK (0x04) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTZ_INTR_REG (BMG160_INTR_STAT2_ADDR) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTY_INTR_POS (1) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTY_INTR_LEN (1) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTY_INTR_MSK (0x02) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTY_INTR_REG (BMG160_INTR_STAT2_ADDR) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTX_INTR_POS (0) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTX_INTR_LEN (1) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTX_INTR_MSK (0x01) #define BMG160_INTR_STAT2_ANY_MOTION_FIRSTX_INTR_REG (BMG160_INTR_STAT2_ADDR) #define BMG160_INTR_STAT_TWO_POS (0) #define BMG160_INTR_STAT_TWO_LEN (4) #define BMG160_INTR_STAT_TWO_MSK (0x0F) #define BMG160_INTR_STAT_TWO_REG (BMG160_INTR_STAT2_ADDR) #define BMG160_INTR_STAT3_HIGHRATE_SIGN_INTR_POS (3) #define BMG160_INTR_STAT3_HIGHRATE_SIGN_INTR_LEN (1) #define BMG160_INTR_STAT3_HIGHRATE_SIGN_INTR_MSK (0x08) #define BMG160_INTR_STAT3_HIGHRATE_SIGN_INTR_REG (BMG160_INTR_STAT3_ADDR) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTZ_INTR_POS (2) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTZ_INTR_LEN (1) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTZ_INTR_MSK (0x04) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTZ_INTR_REG (BMG160_INTR_STAT3_ADDR) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTY_INTR_POS (1) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTY_INTR_LEN (1) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTY_INTR_MSK (0x02) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTY_INTR_REG (BMG160_INTR_STAT3_ADDR) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTX_INTR_POS (0) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTX_INTR_LEN (1) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTX_INTR_MSK (0x01) #define BMG160_INTR_STAT3_HIGHRATE_FIRSTX_INTR_REG (BMG160_INTR_STAT3_ADDR) #define BMG160_INTR_STAT_THREE_POS (0) #define BMG160_INTR_STAT_THREE_LEN (4) #define BMG160_INTR_STAT_THREE_MSK (0x0F) #define BMG160_INTR_STAT_THREE_REG (BMG160_INTR_STAT3_ADDR) #define BMG160_FIFO_STAT_OVERRUN_POS (7) #define BMG160_FIFO_STAT_OVERRUN_LEN (1) #define BMG160_FIFO_STAT_OVERRUN_MSK (0x80) #define BMG160_FIFO_STAT_OVERRUN_REG (BMG160_FIFO_STAT_ADDR) #define BMG160_FIFO_STAT_FRAME_COUNTER_POS (0) #define BMG160_FIFO_STAT_FRAME_COUNTER_LEN (7) #define BMG160_FIFO_STAT_FRAME_COUNTER_MSK (0x7F) #define BMG160_FIFO_STAT_FRAME_COUNTER_REG (BMG160_FIFO_STAT_ADDR) #define BMG160_RANGE_RANGE_2000DPS (0x00) #define BMG160_RANGE_RANGE_1000DPS (0x01) #define BMG160_RANGE_RANGE_500DPS (0x02) #define BMG160_RANGE_RANGE_250DPS (0x03) #define BMG160_RANGE_RANGE_125DPS (0x04) #define BMG160_RANGE_ADDR_RANGE_POS (0) #define BMG160_RANGE_ADDR_RANGE_LEN (3) #define BMG160_RANGE_ADDR_RANGE_MSK (0x07) #define BMG160_RANGE_ADDR_RANGE_REG (BMG160_RANGE_ADDR) #define BMG160_BW_ADDR_POS (0) #define BMG160_BW_ADDR_LEN (3) #define BMG160_BW_ADDR_MSK (0x07) #define BMG160_BW_ADDR_REG (BMG160_BW_ADDR) #define BMG160_MODE_LPM1_POS (5) #define BMG160_MODE_LPM1_LEN (3) #define BMG160_MODE_LPM1_MSK (0xA0) #define BMG160_MODE_LPM1_REG (BMG160_MODE_LPM1_ADDR) #define BMG160_MODELPM1_ADDR_SLEEP_DURN_POS (1) #define BMG160_MODELPM1_ADDR_SLEEP_DURN_LEN (3) #define BMG160_MODELPM1_ADDR_SLEEP_DURN_MSK (0x0E) #define BMG160_MODELPM1_ADDR_SLEEP_DURN_REG (BMG160_MODE_LPM1_ADDR) #define BMG160_MODE_LPM2_ADDR_FAST_POWERUP_POS (7) #define BMG160_MODE_LPM2_ADDR_FAST_POWERUP_LEN (1) #define BMG160_MODE_LPM2_ADDR_FAST_POWERUP_MSK (0x80) #define BMG160_MODE_LPM2_ADDR_FAST_POWERUP_REG (BMG160_MODE_LPM2_ADDR) #define BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING_POS (6) #define BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING_LEN (1) #define BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING_MSK (0x40) #define BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING_REG (BMG160_MODE_LPM2_ADDR) #define BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT_POS (4) #define BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT_LEN (2) #define BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT_MSK (0x30) #define BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT_REG (BMG160_MODE_LPM2_ADDR) #define BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN_POS (0) #define BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN_LEN (3) #define BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN_MSK (0x07) #define BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN_REG (BMG160_MODE_LPM2_ADDR) #define BMG160_HIGH_BW_POS (7) #define BMG160_HIGH_BW_LEN (1) #define BMG160_HIGH_BW_MSK (0x80) #define BMG160_HIGH_BW_REG (BMG160_HIGH_BW_ADDR) #define BMG160_SHADOW_DIS_POS (6) #define BMG160_SHADOW_DIS_LEN (1) #define BMG160_SHADOW_DIS_MSK (0x40) #define BMG160_SHADOW_DIS_REG (BMG160_HIGH_BW_ADDR) #define BMG160_INTR_ENABLE0_DATA_POS (7) #define BMG160_INTR_ENABLE0_DATA_LEN (1) #define BMG160_INTR_ENABLE0_DATA_MSK (0x80) #define BMG160_INTR_ENABLE0_DATA_REG (BMG160_INTR_ENABLE0_ADDR) #define BMG160_INTR_ENABLE0_FIFO_POS (6) #define BMG160_INTR_ENABLE0_FIFO_LEN (1) #define BMG160_INTR_ENABLE0_FIFO_MSK (0x40) #define BMG160_INTR_ENABLE0_FIFO_REG (BMG160_INTR_ENABLE0_ADDR) #define BMG160_INTR_ENABLE0_AUTO_OFFSET_POS (2) #define BMG160_INTR_ENABLE0_AUTO_OFFSET_LEN (1) #define BMG160_INTR_ENABLE0_AUTO_OFFSET_MSK (0x04) #define BMG160_INTR_ENABLE0_AUTO_OFFSET_REG (BMG160_INTR_ENABLE0_ADDR) #define BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE_POS (3) #define BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE_LEN (1) #define BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE_MSK (0x08) #define BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE_REG (BMG160_INTR_ENABLE1_ADDR) #define BMG160_INTR_ENABLE1_IT2_LEVEL_POS (2) #define BMG160_INTR_ENABLE1_IT2_LEVEL_LEN (1) #define BMG160_INTR_ENABLE1_IT2_LEVEL_MSK (0x04) #define BMG160_INTR_ENABLE1_IT2_LEVEL_REG (BMG160_INTR_ENABLE1_ADDR) #define BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE_POS (1) #define BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE_LEN (1) #define BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE_MSK (0x02) #define BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE_REG (BMG160_INTR_ENABLE1_ADDR) #define BMG160_INTR_ENABLE1_IT1_LEVEL_POS (0) #define BMG160_INTR_ENABLE1_IT1_LEVEL_LEN (1) #define BMG160_INTR_ENABLE1_IT1_LEVEL_MSK (0x01) #define BMG160_INTR_ENABLE1_IT1_LEVEL_REG (BMG160_INTR_ENABLE1_ADDR) #define BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE_POS (3) #define BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE_LEN (1) #define BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE_MSK (0x08) #define BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE_REG (BMG160_INTR_MAP_ZERO_ADDR) #define BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION_POS (1) #define BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION_LEN (1) #define BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION_MSK (0x02) #define BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION_REG (BMG160_INTR_MAP_ZERO_ADDR) #define BMG160_MAP_ONE_INTR2_DATA_POS (7) #define BMG160_MAP_ONE_INTR2_DATA_LEN (1) #define BMG160_MAP_ONE_INTR2_DATA_MSK (0x80) #define BMG160_MAP_ONE_INTR2_DATA_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR2_FAST_OFFSET_POS (6) #define BMG160_MAP_ONE_INTR2_FAST_OFFSET_LEN (1) #define BMG160_MAP_ONE_INTR2_FAST_OFFSET_MSK (0x40) #define BMG160_MAP_ONE_INTR2_FAST_OFFSET_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR2_FIFO_POS (5) #define BMG160_MAP_ONE_INTR2_FIFO_LEN (1) #define BMG160_MAP_ONE_INTR2_FIFO_MSK (0x20) #define BMG160_MAP_ONE_INTR2_FIFO_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR2_AUTO_OFFSET_POS (4) #define BMG160_MAP_ONE_INTR2_AUTO_OFFSET_LEN (1) #define BMG160_MAP_ONE_INTR2_AUTO_OFFSET_MSK (0x10) #define BMG160_MAP_ONE_INTR2_AUTO_OFFSET_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR1_AUTO_OFFSET_POS (3) #define BMG160_MAP_ONE_INTR1_AUTO_OFFSET_LEN (1) #define BMG160_MAP_ONE_INTR1_AUTO_OFFSET_MSK (0x08) #define BMG160_MAP_ONE_INTR1_AUTO_OFFSET_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR1_FIFO_POS (2) #define BMG160_MAP_ONE_INTR1_FIFO_LEN (1) #define BMG160_MAP_ONE_INTR1_FIFO_MSK (0x04) #define BMG160_MAP_ONE_INTR1_FIFO_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR1_FAST_OFFSET_POS (1) #define BMG160_MAP_ONE_INTR1_FAST_OFFSET_LEN (1) #define BMG160_MAP_ONE_INTR1_FAST_OFFSET_MSK (0x02) #define BMG160_MAP_ONE_INTR1_FAST_OFFSET_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_MAP_ONE_INTR1_DATA_POS (0) #define BMG160_MAP_ONE_INTR1_DATA_LEN (1) #define BMG160_MAP_ONE_INTR1_DATA_MSK (0x01) #define BMG160_MAP_ONE_INTR1_DATA_REG (BMG160_INTR_MAP_ONE_ADDR) #define BMG160_INTR_MAP_TWO_INTR2_HIGHRATE_POS (3) #define BMG160_INTR_MAP_TWO_INTR2_HIGHRATE_LEN (1) #define BMG160_INTR_MAP_TWO_INTR2_HIGHRATE_MSK (0x08) #define BMG160_INTR_MAP_TWO_INTR2_HIGHRATE_REG (BMG160_INTR_MAP_TWO_ADDR) #define BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION_POS (1) #define BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION_LEN (1) #define BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION_MSK (0x02) #define BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION_REG (BMG160_INTR_MAP_TWO_ADDR) #define BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT_POS (5) #define BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT_LEN (1) #define BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT_MSK (0x20) #define BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT_REG (BMG160_INTR_ZERO_ADDR) #define BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA_POS (3) #define BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA_LEN (1) #define BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA_MSK (0x08) #define BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA_REG (BMG160_INTR_ZERO_ADDR) #define BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA_POS (1) #define BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA_LEN (1) #define BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA_MSK (0x02) #define BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA_REG (BMG160_INTR_ZERO_ADDR) #define BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT_POS (7) #define BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT_LEN (1) #define BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT_MSK (0x80) #define BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT_REG (BMG160_INTR_ONE_ADDR) #define BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES_POS (0) #define BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES_LEN (7) #define BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES_MSK (0x7F) #define BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES_REG (BMG160_INTR_ONE_ADDR) #define BMG160_INTR_TWO_ADDR_AWAKE_DURN_POS (6) #define BMG160_INTR_TWO_ADDR_AWAKE_DURN_LEN (2) #define BMG160_INTR_TWO_ADDR_AWAKE_DURN_MSK (0xC0) #define BMG160_INTR_TWO_ADDR_AWAKE_DURN_REG (BMG160_INTR_TWO_ADDR) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE_POS (4) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE_LEN (2) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE_MSK (0x30) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE_REG (BMG160_INTR_TWO_ADDR) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z_POS (2) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z_LEN (1) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z_MSK (0x04) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z_REG (BMG160_INTR_TWO_ADDR) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y_POS (1) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y_LEN (1) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y_MSK (0x02) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y_REG (BMG160_INTR_TWO_ADDR) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X_POS (0) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X_LEN (1) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X_MSK (0x01) #define BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X_REG (BMG160_INTR_TWO_ADDR) #define BMG160_INTR_4_FIFO_WM_ENABLE_POS (7) #define BMG160_INTR_4_FIFO_WM_ENABLE_LEN (1) #define BMG160_INTR_4_FIFO_WM_ENABLE_MSK (0x80) #define BMG160_INTR_4_FIFO_WM_ENABLE_REG (BMG160_INTR_4_ADDR) #define BMG160_RST_LATCH_ADDR_RST_INTR_POS (7) #define BMG160_RST_LATCH_ADDR_RST_INTR_LEN (1) #define BMG160_RST_LATCH_ADDR_RST_INTR_MSK (0x80) #define BMG160_RST_LATCH_ADDR_RST_INTR_REG (BMG160_RST_LATCH_ADDR) #define BMG160_RST_LATCH_ADDR_OFFSET_RST_POS (6) #define BMG160_RST_LATCH_ADDR_OFFSET_RST_LEN (1) #define BMG160_RST_LATCH_ADDR_OFFSET_RST_MSK (0x40) #define BMG160_RST_LATCH_ADDR_OFFSET_RST_REG (BMG160_RST_LATCH_ADDR) #define BMG160_RST_LATCH_ADDR_LATCH_STAT_POS (4) #define BMG160_RST_LATCH_ADDR_LATCH_STAT_LEN (1) #define BMG160_RST_LATCH_ADDR_LATCH_STAT_MSK (0x10) #define BMG160_RST_LATCH_ADDR_LATCH_STAT_REG (BMG160_RST_LATCH_ADDR) #define BMG160_RST_LATCH_ADDR_LATCH_INTR_POS (0) #define BMG160_RST_LATCH_ADDR_LATCH_INTR_LEN (4) #define BMG160_RST_LATCH_ADDR_LATCH_INTR_MSK (0x0F) #define BMG160_RST_LATCH_ADDR_LATCH_INTR_REG (BMG160_RST_LATCH_ADDR) #define BMG160_HIGHRATE_HYST_X_POS (6) #define BMG160_HIGHRATE_HYST_X_LEN (2) #define BMG160_HIGHRATE_HYST_X_MSK (0xC0) #define BMG160_HIGHRATE_HYST_X_REG (BMG160_HIGHRATE_THRES_X_ADDR) #define BMG160_HIGHRATE_THRES_X_POS (1) #define BMG160_HIGHRATE_THRES_X_LEN (5) #define BMG160_HIGHRATE_THRES_X_MSK (0x3E) #define BMG160_HIGHRATE_THRES_X_REG (BMG160_HIGHRATE_THRES_X_ADDR) #define BMG160_HIGHRATE_ENABLE_X_POS (0) #define BMG160_HIGHRATE_ENABLE_X_LEN (1) #define BMG160_HIGHRATE_ENABLE_X_MSK (0x01) #define BMG160_HIGHRATE_ENABLE_X_REG (BMG160_HIGHRATE_THRES_X_ADDR) #define BMG160_HIGHRATE_HYST_Y_POS (6) #define BMG160_HIGHRATE_HYST_Y_LEN (2) #define BMG160_HIGHRATE_HYST_Y_MSK (0xC0) #define BMG160_HIGHRATE_HYST_Y_REG (BMG160_HIGHRATE_THRES_Y_ADDR) #define BMG160_HIGHRATE_THRES_Y_POS (1) #define BMG160_HIGHRATE_THRES_Y_LEN (5) #define BMG160_HIGHRATE_THRES_Y_MSK (0x3E) #define BMG160_HIGHRATE_THRES_Y_REG (BMG160_HIGHRATE_THRES_Y_ADDR) #define BMG160_HIGHRATE_ENABLE_Y_POS (0) #define BMG160_HIGHRATE_ENABLE_Y_LEN (1) #define BMG160_HIGHRATE_ENABLE_Y_MSK (0x01) #define BMG160_HIGHRATE_ENABLE_Y_REG (BMG160_HIGHRATE_THRES_Y_ADDR) #define BMG160_HIGHRATE_HYST_Z_POS (6) #define BMG160_HIGHRATE_HYST_Z_LEN (2) #define BMG160_HIGHRATE_HYST_Z_MSK (0xC0) #define BMG160_HIGHRATE_HYST_Z_REG (BMG160_HIGHRATE_THRES_Z_ADDR) #define BMG160_HIGHRATE_THRES_Z_POS (1) #define BMG160_HIGHRATE_THRES_Z_LEN (5) #define BMG160_HIGHRATE_THRES_Z_MSK (0x3E) #define BMG160_HIGHRATE_THRES_Z_REG (BMG160_HIGHRATE_THRES_Z_ADDR) #define BMG160_HIGHRATE_ENABLE_Z_POS (0) #define BMG160_HIGHRATE_ENABLE_Z_LEN (1) #define BMG160_HIGHRATE_ENABLE_Z_MSK (0x01) #define BMG160_HIGHRATE_ENABLE_Z_REG (BMG160_HIGHRATE_THRES_Z_ADDR) #define BMG160_SLOW_OFFSET_THRES_POS (6) #define BMG160_SLOW_OFFSET_THRES_LEN (2) #define BMG160_SLOW_OFFSET_THRES_MSK (0xC0) #define BMG160_SLOW_OFFSET_THRES_REG (BMG160_SOC_ADDR) #define BMG160_SLOW_OFFSET_DURN_POS (3) #define BMG160_SLOW_OFFSET_DURN_LEN (3) #define BMG160_SLOW_OFFSET_DURN_MSK (0x38) #define BMG160_SLOW_OFFSET_DURN_REG (BMG160_SOC_ADDR) #define BMG160_SLOW_OFFSET_ENABLE_Z_POS (2) #define BMG160_SLOW_OFFSET_ENABLE_Z_LEN (1) #define BMG160_SLOW_OFFSET_ENABLE_Z_MSK (0x04) #define BMG160_SLOW_OFFSET_ENABLE_Z_REG (BMG160_SOC_ADDR) #define BMG160_SLOW_OFFSET_ENABLE_Y_POS (1) #define BMG160_SLOW_OFFSET_ENABLE_Y_LEN (1) #define BMG160_SLOW_OFFSET_ENABLE_Y_MSK (0x02) #define BMG160_SLOW_OFFSET_ENABLE_Y_REG (BMG160_SOC_ADDR) #define BMG160_SLOW_OFFSET_ENABLE_X_POS (0) #define BMG160_SLOW_OFFSET_ENABLE_X_LEN (1) #define BMG160_SLOW_OFFSET_ENABLE_X_MSK (0x01) #define BMG160_SLOW_OFFSET_ENABLE_X_REG (BMG160_SOC_ADDR) #define BMG160_AUTO_OFFSET_WORD_LENGHTH_POS (6) #define BMG160_AUTO_OFFSET_WORD_LENGHTH_LEN (2) #define BMG160_AUTO_OFFSET_WORD_LENGHTH_MSK (0xC0) #define BMG160_AUTO_OFFSET_WORD_LENGHTH_REG (BMG160_A_FOC_ADDR) #define BMG160_FAST_OFFSET_WORD_LENGHTH_POS (4) #define BMG160_FAST_OFFSET_WORD_LENGHTH_LEN (2) #define BMG160_FAST_OFFSET_WORD_LENGHTH_MSK (0x30) #define BMG160_FAST_OFFSET_WORD_LENGHTH_REG (BMG160_A_FOC_ADDR) #define BMG160_FAST_OFFSET_ENABLE_POS (3) #define BMG160_FAST_OFFSET_ENABLE_LEN (1) #define BMG160_FAST_OFFSET_ENABLE_MSK (0x08) #define BMG160_FAST_OFFSET_ENABLE_REG (BMG160_A_FOC_ADDR) #define BMG160_FAST_OFFSET_ENABLE_Z_POS (2) #define BMG160_FAST_OFFSET_ENABLE_Z_LEN (1) #define BMG160_FAST_OFFSET_ENABLE_Z_MSK (0x04) #define BMG160_FAST_OFFSET_ENABLE_Z_REG (BMG160_A_FOC_ADDR) #define BMG160_FAST_OFFSET_ENABLE_Y_POS (1) #define BMG160_FAST_OFFSET_ENABLE_Y_LEN (1) #define BMG160_FAST_OFFSET_ENABLE_Y_MSK (0x02) #define BMG160_FAST_OFFSET_ENABLE_Y_REG (BMG160_A_FOC_ADDR) #define BMG160_FAST_OFFSET_ENABLE_X_POS (0) #define BMG160_FAST_OFFSET_ENABLE_X_LEN (1) #define BMG160_FAST_OFFSET_ENABLE_X_MSK (0x01) #define BMG160_FAST_OFFSET_ENABLE_X_REG (BMG160_A_FOC_ADDR) #define BMG160_FAST_OFFSET_ENABLE_XYZ_POS (0) #define BMG160_FAST_OFFSET_ENABLE_XYZ_LEN (3) #define BMG160_FAST_OFFSET_ENABLE_XYZ_MSK (0x07) #define BMG160_FAST_OFFSET_ENABLE_XYZ_REG (BMG160_A_FOC_ADDR) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_REMAIN_POS (4) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_REMAIN_LEN (4) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_REMAIN_MSK (0xF0) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_REMAIN_REG (BMG160_TRIM_NVM_CTRL_ADDR) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD_POS (3) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD_LEN (1) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD_MSK (0x08) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD_REG (BMG160_TRIM_NVM_CTRL_ADDR) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_RDY_POS (2) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_RDY_LEN (1) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_RDY_MSK (0x04) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_RDY_REG (BMG160_TRIM_NVM_CTRL_ADDR) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG_POS (1) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG_LEN (1) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG_MSK (0x02) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG_REG (BMG160_TRIM_NVM_CTRL_ADDR) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE_POS (0) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE_LEN (1) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE_MSK (0x01) #define BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE_REG (BMG160_TRIM_NVM_CTRL_ADDR) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE_POS (2) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE_LEN (1) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE_MSK (0x04) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE_REG (BMG160_BGW_SPI3_WDT_ADDR) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT_POS (1) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT_LEN (1) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT_MSK (0x02) #define BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT_REG (BMG160_BGW_SPI3_WDT_ADDR) #define BMG160_BGW_SPI3_WDT_ADDR_SPI3_POS (0) #define BMG160_BGW_SPI3_WDT_ADDR_SPI3_LEN (1) #define BMG160_BGW_SPI3_WDT_ADDR_SPI3_MSK (0x01) #define BMG160_BGW_SPI3_WDT_ADDR_SPI3_REG (BMG160_BGW_SPI3_WDT_ADDR) #define BMG160_SELFTEST_ADDR_RATEOK_POS (4) #define BMG160_SELFTEST_ADDR_RATEOK_LEN (1) #define BMG160_SELFTEST_ADDR_RATEOK_MSK (0x10) #define BMG160_SELFTEST_ADDR_RATEOK_REG (BMG160_SELFTEST_ADDR) #define BMG160_SELFTEST_ADDR_BISTFAIL_POS (2) #define BMG160_SELFTEST_ADDR_BISTFAIL_LEN (1) #define BMG160_SELFTEST_ADDR_BISTFAIL_MSK (0x04) #define BMG160_SELFTEST_ADDR_BISTFAIL_REG (BMG160_SELFTEST_ADDR) #define BMG160_SELFTEST_ADDR_BISTRDY_POS (1) #define BMG160_SELFTEST_ADDR_BISTRDY_LEN (1) #define BMG160_SELFTEST_ADDR_BISTRDY_MSK (0x02) #define BMG160_SELFTEST_ADDR_BISTRDY_REG (BMG160_SELFTEST_ADDR) #define BMG160_SELFTEST_ADDR_TRIGBIST_POS (0) #define BMG160_SELFTEST_ADDR_TRIGBIST_LEN (1) #define BMG160_SELFTEST_ADDR_TRIGBIST_MSK (0x01) #define BMG160_SELFTEST_ADDR_TRIGBIST_REG (BMG160_SELFTEST_ADDR) #define BMG160_FIFO_CGF1_ADDR_TAG_POS (7) #define BMG160_FIFO_CGF1_ADDR_TAG_LEN (1) #define BMG160_FIFO_CGF1_ADDR_TAG_MSK (0x80) #define BMG160_FIFO_CGF1_ADDR_TAG_REG (BMG160_FIFO_CGF1_ADDR) #define BMG160_FIFO_CGF1_ADDR_WML_POS (0) #define BMG160_FIFO_CGF1_ADDR_WML_LEN (7) #define BMG160_FIFO_CGF1_ADDR_WML_MSK (0x7F) #define BMG160_FIFO_CGF1_ADDR_WML_REG (BMG160_FIFO_CGF1_ADDR) #define BMG160_FIFO_CGF0_ADDR_MODE_POS (6) #define BMG160_FIFO_CGF0_ADDR_MODE_LEN (2) #define BMG160_FIFO_CGF0_ADDR_MODE_MSK (0xC0) #define BMG160_FIFO_CGF0_ADDR_MODE_REG (BMG160_FIFO_CGF0_ADDR) #define BMG160_FIFO_CGF0_ADDR_DATA_SELECT_POS (0) #define BMG160_FIFO_CGF0_ADDR_DATA_SELECT_LEN (2) #define BMG160_FIFO_CGF0_ADDR_DATA_SELECT_MSK (0x03) #define BMG160_FIFO_CGF0_ADDR_DATA_SELECT_REG (BMG160_FIFO_CGF0_ADDR) #define BMG160_OFC1_ADDR_OFFSET_X_POS (6) #define BMG160_OFC1_ADDR_OFFSET_X_LEN (2) #define BMG160_OFC1_ADDR_OFFSET_X_MSK (0xC0) #define BMG160_OFC1_ADDR_OFFSET_X_REG (BMG160_OFFSET_OFC1_ADDR) #define BMG160_OFC1_ADDR_OFFSET_Y_POS (3) #define BMG160_OFC1_ADDR_OFFSET_Y_LEN (3) #define BMG160_OFC1_ADDR_OFFSET_Y_MSK (0x38) #define BMG160_OFC1_ADDR_OFFSET_Y_REG (BMG160_OFFSET_OFC1_ADDR) #define BMG160_OFC1_ADDR_OFFSET_Z_POS (0) #define BMG160_OFC1_ADDR_OFFSET_Z_LEN (3) #define BMG160_OFC1_ADDR_OFFSET_Z_MSK (0x07) #define BMG160_OFC1_ADDR_OFFSET_Z_REG (BMG160_OFFSET_OFC1_ADDR) #define BMG160_TRIM_GP0_ADDR_GP0_POS (4) #define BMG160_TRIM_GP0_ADDR_GP0_LEN (4) #define BMG160_TRIM_GP0_ADDR_GP0_MSK (0xF0) #define BMG160_TRIM_GP0_ADDR_GP0_REG (BMG160_TRIM_GP0_ADDR) #define BMG160_TRIM_GP0_ADDR_OFFSET_X_POS (2) #define BMG160_TRIM_GP0_ADDR_OFFSET_X_LEN (2) #define BMG160_TRIM_GP0_ADDR_OFFSET_X_MSK (0x0C) #define BMG160_TRIM_GP0_ADDR_OFFSET_X_REG (BMG160_TRIM_GP0_ADDR) #define BMG160_TRIM_GP0_ADDR_OFFSET_Y_POS (1) #define BMG160_TRIM_GP0_ADDR_OFFSET_Y_LEN (1) #define BMG160_TRIM_GP0_ADDR_OFFSET_Y_MSK (0x02) #define BMG160_TRIM_GP0_ADDR_OFFSET_Y_REG (BMG160_TRIM_GP0_ADDR) #define BMG160_TRIM_GP0_ADDR_OFFSET_Z_POS (0) #define BMG160_TRIM_GP0_ADDR_OFFSET_Z_LEN (1) #define BMG160_TRIM_GP0_ADDR_OFFSET_Z_MSK (0x01) #define BMG160_TRIM_GP0_ADDR_OFFSET_Z_REG (BMG160_TRIM_GP0_ADDR) #define BMG160_MODE_NORMAL (0) #define BMG160_MODE_DEEPSUSPEND (1) #define BMG160_MODE_SUSPEND (2) #define BMG160_MODE_FASTPOWERUP (3) #define BMG160_MODE_ADVANCEDPOWERSAVING (4) #define BMG160_GET_BITSLICE(regvar, bitname) \ ((regvar & bitname##_MSK) >> bitname##_POS) #define BMG160_SET_BITSLICE(regvar, bitname, val) \ ((regvar & ~bitname##_MSK) | ((val << bitname##_POS) & bitname##_MSK)) #define BMG160_X_DATA_SIZE (2) #define BMG160_Y_DATA_SIZE (2) #define BMG160_Z_DATA_SIZE (2) #define BMG160_XYZ_DATA_SIZE (6) #define BMG160_XYZ_INTR_DATA_SIZE (12) #define BMG160_X_LSB_DATA (0) #define BMG160_X_MSB_DATA (1) #define BMG160_Y_LSB_DATA (0) #define BMG160_Y_MSB_DATA (1) #define BMG160_Z_LSB_DATA (0) #define BMG160_Z_MSB_DATA (1) #define BMG160_INTR0_STAT (0) #define BMG160_INTR1_STAT (1) #define BMG160_INTR2_STAT (2) #define BMG160_INTR3_STAT (3) #define BMG160_INTR4_STAT (4) #define BMG160_DATA_FRAME_X_LSB_BYTE (0) #define BMG160_DATA_FRAME_X_MSB_BYTE (1) #define BMG160_DATA_FRAME_Y_LSB_BYTE (2) #define BMG160_DATA_FRAME_Y_MSB_BYTE (3) #define BMG160_DATA_FRAME_Z_LSB_BYTE (4) #define BMG160_DATA_FRAME_Z_MSB_BYTE (5) #define BMG160_DATA_FRAME_INTR0_BYTE (7) #define BMG160_DATA_FRAME_INTR1_BYTE (8) #define BMG160_DATA_FRAME_INTR2_BYTE (9) #define BMG160_DATA_FRAME_INTR3_BYTE (10) #define BMG160_DATA_FRAME_INTR4_BYTE (11) #define BMG160_ODR_100 (100) #define BMG160_ODR_200 (200) #define BMG160_ODR_400 (400) #define BMG160_ODR_1000 (1000) #define BMG160_ODR_2000 (2000) #define BMG160_ODR_100_REG (0x07) #define BMG160_ODR_200_REG (0x06) #define BMG160_ODR_400_REG (0x03) #define BMG160_ODR_1000_REG (0x02) #define BMG160_ODR_2000_REG (0x01) #define BMG160_POWER_BIT_MASK (0xA0) #define BMG160_POWER_NORMAL_REG (0x00) #define BMG160_POWER_SLEEP_REG (0x80) #define BMG160_POWER_DEEP_SUSPEND_REG (0x20) #define BMG160_SHIFT_EIGHT_BITS (8) // bmg160 sensitivity factor table, the unit is LSB/°/s static uint32_t bmg160_factor[5] = { 2624, 1312, 656, 328, 164 }; //(LSB/°/s) * 10 static uint32_t current_factor = 0; i2c_dev_t bmg160_ctx = { .port = 1, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = BMG160_I2C_ADDR1, }; int drv_gyro_bosch_bmg160_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, BMG160_CHIP_ID_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (id_value != value) { return -1; } return 0; } int drv_gyro_bosch_bmg160_set_power_mode(i2c_dev_t * drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, BMG160_MODE_LPM1_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (mode) { case DEV_POWER_ON: { if ((value & BMG160_POWER_BIT_MASK) == BMG160_POWER_NORMAL_REG) { return 0; } value &= (~BMG160_POWER_BIT_MASK); value |= BMG160_POWER_NORMAL_REG; ret = sensor_i2c_write(drv, BMG160_MODE_LPM1_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; case DEV_POWER_OFF: { if ((value & BMG160_POWER_BIT_MASK) == BMG160_POWER_DEEP_SUSPEND_REG) { return 0; } value &= (~BMG160_POWER_BIT_MASK); value |= BMG160_POWER_DEEP_SUSPEND_REG; ret = sensor_i2c_write(drv, BMG160_MODE_LPM1_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; case DEV_SLEEP: { if ((value & BMG160_POWER_BIT_MASK) == BMG160_POWER_SLEEP_REG) { return 0; } value &= (~BMG160_POWER_BIT_MASK); value |= BMG160_POWER_SLEEP_REG; ret = sensor_i2c_write(drv, BMG160_MODE_LPM1_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; default: break; } return 0; } int drv_gyro_bosch_bmg160_set_odr(i2c_dev_t *drv, uint32_t odr) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, BMG160_BW_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (odr >= BMG160_ODR_2000) { value &= BMG160_BW_ADDR_MSK; value |= BMG160_ODR_2000_REG; } else if (odr >= BMG160_ODR_1000) { value &= BMG160_BW_ADDR_MSK; value |= BMG160_ODR_1000_REG; } else if (odr >= BMG160_ODR_400) { value &= BMG160_BW_ADDR_MSK; value |= BMG160_ODR_400_REG; } else if (odr >= BMG160_ODR_200) { value &= BMG160_BW_ADDR_MSK; value |= BMG160_ODR_200_REG; } else { value &= BMG160_BW_ADDR_MSK; value |= BMG160_ODR_100_REG; } /* Write the range register 0x0F*/ ret = sensor_i2c_write(drv, BMG160_BW_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } int drv_gyro_bosch_bmg160_set_range(i2c_dev_t *drv, uint32_t range) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, BMG160_RANGE_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (range) { case GYRO_RANGE_125DPS: { value &= BMG160_RANGE_ADDR_RANGE_MSK; value |= BMG160_RANGE_RANGE_125DPS; } break; case GYRO_RANGE_250DPS: { value &= BMG160_RANGE_ADDR_RANGE_MSK; value |= BMG160_RANGE_RANGE_250DPS; } break; case GYRO_RANGE_500DPS: { value &= BMG160_RANGE_ADDR_RANGE_MSK; value |= BMG160_RANGE_RANGE_500DPS; } break; case GYRO_RANGE_1000DPS: { value &= BMG160_RANGE_ADDR_RANGE_MSK; value |= BMG160_RANGE_RANGE_1000DPS; } break; case GYRO_RANGE_2000DPS: { value &= BMG160_RANGE_ADDR_RANGE_MSK; value |= BMG160_RANGE_RANGE_2000DPS; } break; default: break; } /* Write the range register 0x0F*/ ret = sensor_i2c_write(drv, BMG160_RANGE_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if ((range >= GYRO_RANGE_125DPS) && (range <= GYRO_RANGE_2000DPS)) { current_factor = bmg160_factor[range]; } return 0; } void drv_gyro_bosch_bmg160_irq_handle(void) { /* no handle so far */ } int drv_gyro_bosch_bmg160_open(void) { int ret = 0; ret = drv_gyro_bosch_bmg160_set_power_mode(&bmg160_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_gyro_bosch_bmg160_close(void) { int ret = 0; ret = drv_gyro_bosch_bmg160_set_power_mode(&bmg160_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } return 0; } int drv_gyro_bosch_bmg160_read(void *buf, size_t len) { int ret = 0; size_t size = 0; 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(&bmg160_ctx, BMG160_RATE_X_LSB_ADDR, &reg[0], I2C_REG_LEN, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bmg160_ctx, BMG160_RATE_X_MSB_ADDR, &reg[1], I2C_REG_LEN, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bmg160_ctx, BMG160_RATE_Y_LSB_ADDR, &reg[2], I2C_REG_LEN, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bmg160_ctx, BMG160_RATE_Y_MSB_ADDR, &reg[3], I2C_REG_LEN, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bmg160_ctx, BMG160_RATE_Z_LSB_ADDR, &reg[4], I2C_REG_LEN, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bmg160_ctx, BMG160_RATE_Z_MSB_ADDR, &reg[5], I2C_REG_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } gyro->data[DATA_AXIS_X] = (int32_t)( (((int32_t)((int8_t)reg[1])) << BMG160_SHIFT_EIGHT_BITS) | reg[0]); gyro->data[DATA_AXIS_Y] = (int32_t)( (((int32_t)((int8_t)reg[3])) << BMG160_SHIFT_EIGHT_BITS) | reg[2]); gyro->data[DATA_AXIS_Z] = (int32_t)( (((int32_t)((int8_t)reg[5])) << BMG160_SHIFT_EIGHT_BITS) | reg[4]); if (current_factor != 0) { // the unit of gyro is uDPS, 1000 000 uDPS = 1 DPS gyro->data[DATA_AXIS_X] = (int32_t)((int64_t)gyro->data[DATA_AXIS_X] * GYROSCOPE_UNIT_FACTOR * 10 / current_factor); gyro->data[DATA_AXIS_Y] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Y] * GYROSCOPE_UNIT_FACTOR * 10 / current_factor); gyro->data[DATA_AXIS_Z] = (int32_t)((int64_t)gyro->data[DATA_AXIS_Z] * GYROSCOPE_UNIT_FACTOR * 10 / current_factor); } gyro->timestamp = aos_now_ms(); return (int)size; } static int drv_gyro_bosch_bmg160_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { ret = drv_gyro_bosch_bmg160_set_odr(&bmg160_ctx, arg); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_RANGE_SET: { ret = drv_gyro_bosch_bmg160_set_range(&bmg160_ctx, arg); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_gyro_bosch_bmg160_set_power_mode(&bmg160_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 = "BMG160"; info->range_max = 2000; info->range_min = 125; info->unit = udps; } break; default: break; } return 0; } int drv_gyro_bosch_bmg160_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(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_bosch_bmg160_open; sensor.close = drv_gyro_bosch_bmg160_close; sensor.read = drv_gyro_bosch_bmg160_read; sensor.write = NULL; sensor.ioctl = drv_gyro_bosch_bmg160_ioctl; sensor.irq_handle = drv_gyro_bosch_bmg160_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } ret = drv_gyro_bosch_bmg160_validate_id(&bmg160_ctx, BMG160_CHIP_ID_VALUE); if (unlikely(ret)) { return -1; } ret = drv_gyro_bosch_bmg160_set_range(&bmg160_ctx, GYRO_RANGE_2000DPS); if (unlikely(ret)) { return -1; } ret = drv_gyro_bosch_bmg160_set_odr(&bmg160_ctx, BMG160_ODR_200); if (unlikely(ret)) { return -1; } ret = drv_gyro_bosch_bmg160_set_power_mode(&bmg160_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_gyro_bosch_bmg160_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_gyro_bosch_bmg160.c
C
apache-2.0
37,957
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define A3G4250D_I2C_ADDR1 (0x68) #define A3G4250D_I2C_ADDR2 (0x69) #define A3G4250D_I2C_ADDR_TRANS(n) ((n)<<1) #define A3G4250D_I2C_ADDR A3G4250D_I2C_ADDR_TRANS(A3G4250D_I2C_ADDR1) #define A3G4250D_GYRO_WHO_AM_I_REG 0x0F #define A3G4250D_GYRO_CTRL1 0x20 #define A3G4250D_GYRO_CTRL2 0x21 #define A3G4250D_GYRO_CTRL3 0x22 #define A3G4250D_GYRO_CTRL4 0x23 #define A3G4250D_GYRO_CTRL5 0x24 #define A3G4250D_GYRO_OUT_TEMP 0x26 #define A3G4250D_GYRO_STATUS 0x27 #define A3G4250D_GYRO_OUTX_L 0x28 #define A3G4250D_GYRO_OUTX_H 0x29 #define A3G4250D_GYRO_OUTY_L 0x2A #define A3G4250D_GYRO_OUTY_H 0x2B #define A3G4250D_GYRO_OUTZ_L 0x2C #define A3G4250D_GYRO_OUTZ_H 0x2D #define A3G4250D_CHIP_ID_VALUE (0xD3) #define A3G4250D_GYRO_ODR_POWER_DOWN (0x00) #define A3G4250D_GYRO_ODR_100_HZ (0x0F) #define A3G4250D_GYRO_ODR_200_HZ (0x4F) #define A3G4250D_GYRO_ODR_400_HZ (0x8F) #define A3G4250D_GYRO_ODR_800_HZ (0xCF) #define A3G4250D_GYRO_POWER_ON (0x0F) #define A3G4250D_GYRO_SLEEP (0x08) #define A3G4250D_GYRO_SLEEP_MASK (0x0F) #define A3G4250D_GYRO_RANGE_250 (0x0) #define A3G4250D_GYRO_SENSITIVITY_250DPS 8750 #define A3G4250D_GYRO_MUL 1000 #define A3G4250D_SHIFT_EIGHT_BITS (8) #define A3G4250D_GYRO_DEFAULT_ODR_100HZ (100) #define A3G4250D_GET_BITSLICE(regvar, bitname)\ ((regvar & bitname##_MSK) >> bitname##_POS) #define A3G4250D_SET_BITSLICE(regvar, bitname, val)\ ((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK)) static int32_t a3g4250d_gyro_factor[GYRO_RANGE_MAX] = {0, A3G4250D_GYRO_SENSITIVITY_250DPS, 0, 0, 0 }; static int32_t cur_gyro_factor = 0; i2c_dev_t a3g4250d_ctx = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = A3G4250D_I2C_ADDR, }; UNUSED static int drv_gyro_st_a3g4250d_soft_reset(i2c_dev_t* drv) { return 0; } static int drv_gyro_st_a3g4250d_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, A3G4250D_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_gyro_st_a3g4250d_set_bdu(i2c_dev_t* drv) { return 0; } static int drv_gyro_st_a3g4250d_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, A3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } switch(mode){ case DEV_POWER_ON:{ value |= A3G4250D_GYRO_POWER_ON; ret = sensor_i2c_write(drv, A3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_POWER_OFF:{ value &= ~A3G4250D_GYRO_POWER_ON; ret = sensor_i2c_write(drv, A3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_SLEEP:{ value &= ~A3G4250D_GYRO_SLEEP_MASK; value |= A3G4250D_GYRO_SLEEP; ret = sensor_i2c_write(drv, A3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; default:break; } return 0; } static uint8_t drv_gyro_st_a3g4250d_hz2odr(uint32_t hz) { if(hz > 400) return A3G4250D_GYRO_ODR_800_HZ; else if(hz > 200) return A3G4250D_GYRO_ODR_400_HZ; else if(hz > 100) return A3G4250D_GYRO_ODR_200_HZ; else return A3G4250D_GYRO_ODR_100_HZ; } static int drv_gyro_st_a3g4250d_set_odr(i2c_dev_t* drv, uint32_t hz) { int ret = 0; uint8_t odr = drv_gyro_st_a3g4250d_hz2odr(hz); ret = sensor_i2c_write(drv, A3G4250D_GYRO_CTRL1, &odr, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_gyro_st_a3g4250d_set_range(i2c_dev_t* drv, uint32_t range) { if(range == GYRO_RANGE_250DPS){ cur_gyro_factor = a3g4250d_gyro_factor[range]; } return 0; } static void drv_gyro_st_a3g4250d_irq_handle(void) { /* no handle so far */ } static int drv_gyro_st_a3g4250d_open(void) { int ret = 0; ret = drv_gyro_st_a3g4250d_set_power_mode(&a3g4250d_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_set_bdu(&a3g4250d_ctx); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_set_range(&a3g4250d_ctx, GYRO_RANGE_250DPS); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_set_odr(&a3g4250d_ctx, A3G4250D_GYRO_DEFAULT_ODR_100HZ); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_a3g4250d_close(void) { int ret = 0; ret = drv_gyro_st_a3g4250d_set_power_mode(&a3g4250d_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_a3g4250d_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(&a3g4250d_ctx, (A3G4250D_GYRO_OUTX_L | 0x80), reg, 6, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< A3G4250D_SHIFT_EIGHT_BITS)|(reg[0])); gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< A3G4250D_SHIFT_EIGHT_BITS)|(reg[2])); gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< A3G4250D_SHIFT_EIGHT_BITS)|(reg[4])); // LOG("A3G4250D X: %x; Y: %x; Z: %x\n",gyro->data[DATA_AXIS_X], gyro->data[DATA_AXIS_Y], gyro->data[DATA_AXIS_Z]); if(cur_gyro_factor != 0){ gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor); gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor); gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor); } gyro->timestamp = aos_now_ms(); return (int)size; } static int drv_gyro_st_a3g4250d_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ ret = drv_gyro_st_a3g4250d_set_odr(&a3g4250d_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_RANGE_SET:{ ret = drv_gyro_st_a3g4250d_set_range(&a3g4250d_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_SET_POWER:{ ret = drv_gyro_st_a3g4250d_set_power_mode(&a3g4250d_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 = "A3G4250D"; info->range_max = 250; info->range_min = 250; info->unit = udps; }break; default:break; } return 0; } int drv_gyro_st_a3g4250d_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(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_a3g4250d_open; sensor.close = drv_gyro_st_a3g4250d_close; sensor.read = drv_gyro_st_a3g4250d_read; sensor.write = NULL; sensor.ioctl = drv_gyro_st_a3g4250d_ioctl; sensor.irq_handle = drv_gyro_st_a3g4250d_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_validate_id(&a3g4250d_ctx, A3G4250D_CHIP_ID_VALUE); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_set_range(&a3g4250d_ctx, GYRO_RANGE_250DPS); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_set_odr(&a3g4250d_ctx, A3G4250D_GYRO_ODR_100_HZ); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_a3g4250d_set_power_mode(&a3g4250d_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_gyro_st_a3g4250d_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_gyro_st_a3g4250d.c
C
apache-2.0
9,248
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define I3G4250D_I2C_ADDR1 (0x68) #define I3G4250D_I2C_ADDR2 (0x69) #define I3G4250D_I2C_ADDR_TRANS(n) ((n)<<1) #define I3G4250D_I2C_ADDR I3G4250D_I2C_ADDR_TRANS(I3G4250D_I2C_ADDR1) #define I3G4250D_GYRO_WHO_AM_I_REG 0x0F #define I3G4250D_GYRO_CTRL1 0x20 #define I3G4250D_GYRO_CTRL2 0x21 #define I3G4250D_GYRO_CTRL3 0x22 #define I3G4250D_GYRO_CTRL4 0x23 #define I3G4250D_GYRO_CTRL5 0x24 #define I3G4250D_GYRO_OUT_TEMP 0x26 #define I3G4250D_GYRO_STATUS 0x27 #define I3G4250D_GYRO_OUTX_L 0x28 #define I3G4250D_GYRO_OUTX_H 0x29 #define I3G4250D_GYRO_OUTY_L 0x2A #define I3G4250D_GYRO_OUTY_H 0x2B #define I3G4250D_GYRO_OUTZ_L 0x2C #define I3G4250D_GYRO_OUTZ_H 0x2D #define I3G4250D_CHIP_ID_VALUE (0xD3) #define I3G4250D_GYRO_ODR_POWER_DOWN (0x00) #define I3G4250D_GYRO_ODR_100_HZ (0x0F) #define I3G4250D_GYRO_ODR_200_HZ (0x4F) #define I3G4250D_GYRO_ODR_400_HZ (0x8F) #define I3G4250D_GYRO_ODR_800_HZ (0xCF) #define I3G4250D_GYRO_POWER_ON (0x0F) #define I3G4250D_GYRO_SLEEP (0x08) #define I3G4250D_GYRO_SLEEP_MASK (0x0F) #define I3G4250D_GYRO_RANGE_245 (0x0) #define I3G4250D_GYRO_RANGE_500 (0x1) #define I3G4250D_GYRO_RANGE_2000 (0x2) #define I3G4250D_GYRO_RANGE_MSK (0x30) #define I3G4250D_GYRO_RANGE_POS (4) #define I3G4250D_GYRO_SENSITIVITY_245DPS 8750 #define I3G4250D_GYRO_SENSITIVITY_500DPS 17500 #define I3G4250D_GYRO_SENSITIVITY_2000DPS 70000 #define I3G4250D_GYRO_MUL 1000 #define I3G4250D_SHIFT_EIGHT_BITS (8) #define I3G4250D_GYRO_DEFAULT_ODR_100HZ (100) #define I3G4250D_GET_BITSLICE(regvar, bitname)\ ((regvar & bitname##_MSK) >> bitname##_POS) #define I3G4250D_SET_BITSLICE(regvar, bitname, val)\ ((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK)) static int32_t i3g4250d_gyro_factor[GYRO_RANGE_MAX] = {0, I3G4250D_GYRO_SENSITIVITY_245DPS, I3G4250D_GYRO_SENSITIVITY_500DPS, 0, I3G4250D_GYRO_SENSITIVITY_2000DPS }; static int32_t cur_gyro_factor = 0; i2c_dev_t i3g4250d_ctx = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = I3G4250D_I2C_ADDR, }; UNUSED static int drv_gyro_st_i3g4250d_soft_reset(i2c_dev_t* drv) { return 0; } static int drv_gyro_st_i3g4250d_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, I3G4250D_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_gyro_st_i3g4250d_set_bdu(i2c_dev_t* drv) { return 0; } static int drv_gyro_st_i3g4250d_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, I3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } switch(mode){ case DEV_POWER_ON:{ value |= I3G4250D_GYRO_POWER_ON; ret = sensor_i2c_write(drv, I3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_POWER_OFF:{ value &= ~I3G4250D_GYRO_POWER_ON; ret = sensor_i2c_write(drv, I3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_SLEEP:{ value &= ~I3G4250D_GYRO_SLEEP_MASK; value |= I3G4250D_GYRO_SLEEP; ret = sensor_i2c_write(drv, I3G4250D_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; default:break; } return 0; } static uint8_t drv_gyro_st_i3g4250d_hz2odr(uint32_t hz) { if(hz > 400) return I3G4250D_GYRO_ODR_800_HZ; else if(hz > 200) return I3G4250D_GYRO_ODR_400_HZ; else if(hz > 100) return I3G4250D_GYRO_ODR_200_HZ; else return I3G4250D_GYRO_ODR_100_HZ; } static int drv_gyro_st_i3g4250d_set_odr(i2c_dev_t* drv, uint32_t hz) { int ret = 0; uint8_t odr = drv_gyro_st_i3g4250d_hz2odr(hz); ret = sensor_i2c_write(drv, I3G4250D_GYRO_CTRL1, &odr, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_gyro_st_i3g4250d_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, I3G4250D_GYRO_CTRL4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } switch (range){ case GYRO_RANGE_250DPS:{ tmp = I3G4250D_GYRO_RANGE_245; }break; case GYRO_RANGE_500DPS:{ tmp = I3G4250D_GYRO_RANGE_500; }break; case GYRO_RANGE_2000DPS:{ tmp = I3G4250D_GYRO_RANGE_2000; }break; default:break; } value = I3G4250D_SET_BITSLICE(value,I3G4250D_GYRO_RANGE,tmp); ret = sensor_i2c_write(drv, I3G4250D_GYRO_CTRL4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){ cur_gyro_factor = i3g4250d_gyro_factor[range]; } return 0; } static void drv_gyro_st_i3g4250d_irq_handle(void) { /* no handle so far */ } static int drv_gyro_st_i3g4250d_open(void) { int ret = 0; ret = drv_gyro_st_i3g4250d_set_power_mode(&i3g4250d_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_set_bdu(&i3g4250d_ctx); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_set_range(&i3g4250d_ctx, GYRO_RANGE_2000DPS); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_set_odr(&i3g4250d_ctx, I3G4250D_GYRO_DEFAULT_ODR_100HZ); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_i3g4250d_close(void) { int ret = 0; ret = drv_gyro_st_i3g4250d_set_power_mode(&i3g4250d_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_i3g4250d_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(&i3g4250d_ctx, (I3G4250D_GYRO_OUTX_L | 0x80), reg, 6, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< I3G4250D_SHIFT_EIGHT_BITS)|(reg[0])); gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< I3G4250D_SHIFT_EIGHT_BITS)|(reg[2])); gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< I3G4250D_SHIFT_EIGHT_BITS)|(reg[4])); if(cur_gyro_factor != 0){ gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor); gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor); gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor); } gyro->timestamp = aos_now_ms(); return (int)size; } static int drv_gyro_st_i3g4250d_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ ret = drv_gyro_st_i3g4250d_set_odr(&i3g4250d_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_RANGE_SET:{ ret = drv_gyro_st_i3g4250d_set_range(&i3g4250d_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_SET_POWER:{ ret = drv_gyro_st_i3g4250d_set_power_mode(&i3g4250d_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 = "I3G4250D"; info->range_max = 2000; info->range_min = 245; info->unit = udps; }break; default:break; } return 0; } int drv_gyro_st_i3g4250d_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(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_i3g4250d_open; sensor.close = drv_gyro_st_i3g4250d_close; sensor.read = drv_gyro_st_i3g4250d_read; sensor.write = NULL; sensor.ioctl = drv_gyro_st_i3g4250d_ioctl; sensor.irq_handle = drv_gyro_st_i3g4250d_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_validate_id(&i3g4250d_ctx, I3G4250D_CHIP_ID_VALUE); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_set_range(&i3g4250d_ctx, GYRO_RANGE_2000DPS); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_set_odr(&i3g4250d_ctx, I3G4250D_GYRO_ODR_100_HZ); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_i3g4250d_set_power_mode(&i3g4250d_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_gyro_st_i3g4250d_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_gyro_st_i3g4250d.c
C
apache-2.0
10,279
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define L3GD20H_I2C_ADDR1 (0x6A) #define L3GD20H_I2C_ADDR2 (0x6B) #define L3GD20H_I2C_ADDR_TRANS(n) ((n)<<1) #define L3GD20H_I2C_ADDR L3GD20H_I2C_ADDR_TRANS(L3GD20H_I2C_ADDR1) #define L3GD20H_GYRO_WHO_AM_I_REG 0x0F #define L3GD20H_GYRO_CTRL1 0x20 #define L3GD20H_GYRO_CTRL2 0x21 #define L3GD20H_GYRO_CTRL3 0x22 #define L3GD20H_GYRO_CTRL4 0x23 #define L3GD20H_GYRO_CTRL5 0x24 #define L3GD20H_GYRO_OUT_TEMP 0x26 #define L3GD20H_GYRO_STATUS 0x27 #define L3GD20H_GYRO_OUTX_L 0x28 #define L3GD20H_GYRO_OUTX_H 0x29 #define L3GD20H_GYRO_OUTY_L 0x2A #define L3GD20H_GYRO_OUTY_H 0x2B #define L3GD20H_GYRO_OUTZ_L 0x2C #define L3GD20H_GYRO_OUTZ_H 0x2D #define L3GD20H_GYRO_LOW_ODR 0x39 #define L3GD20H_CHIP_ID_VALUE (0xD7) #define L3GD20H_ENABLE_SOFT_RESET_VALUE (0x04) #define L3GD20H_BDU_ENABLE (0x80) #define L3GD20H_GYRO_ODR_POWER_DOWN (0x00) #define L3GD20H_GYRO_ODR_12_5_HZ (0x0F) #define L3GD20H_GYRO_ODR_25_HZ (0x4F) #define L3GD20H_GYRO_ODR_50_HZ (0x8F) #define L3GD20H_GYRO_ODR_100_HZ (0x0F) #define L3GD20H_GYRO_ODR_200_HZ (0x4F) #define L3GD20H_GYRO_ODR_400_HZ (0x8F) #define L3GD20H_GYRO_ODR_800_HZ (0xCF) #define L3GD20H_LOW_ODR_ENABLE (0x01) #define L3GD20H_GYRO_POWER_ON (0x08) #define L3GD20H_GYRO_SLEEP (0x08) #define L3GD20H_GYRO_SLEEP_MASK (0x0F) #define L3GD20H_GYRO_RANGE_245 (0x0) #define L3GD20H_GYRO_RANGE_500 (0x1) #define L3GD20H_GYRO_RANGE_2000 (0x2) #define L3GD20H_GYRO_RANGE_MSK (0x30) #define L3GD20H_GYRO_RANGE_POS (4) #define L3GD20H_GYRO_SENSITIVITY_245DPS 87500 #define L3GD20H_GYRO_SENSITIVITY_500DPS 175000 #define L3GD20H_GYRO_SENSITIVITY_2000DPS 700000 #define L3GD20H_GYRO_MUL 1000 #define L3GD20H_SHIFT_EIGHT_BITS (8) #define L3GD20H_GYRO_DEFAULT_ODR_100HZ (100) #define L3GD20H_GET_BITSLICE(regvar, bitname)\ ((regvar & bitname##_MSK) >> bitname##_POS) #define L3GD20H_SET_BITSLICE(regvar, bitname, val)\ ((regvar & ~bitname##_MSK) | ((val<<bitname##_POS)&bitname##_MSK)) static int32_t l3gd20h_gyro_factor[GYRO_RANGE_MAX] = {0, L3GD20H_GYRO_SENSITIVITY_245DPS, L3GD20H_GYRO_SENSITIVITY_500DPS, 0, L3GD20H_GYRO_SENSITIVITY_2000DPS }; static int32_t cur_gyro_factor = 0; i2c_dev_t l3gd20h_ctx = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = L3GD20H_I2C_ADDR, }; UNUSED static int drv_gyro_st_l3gd20h_soft_reset(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, L3GD20H_GYRO_LOW_ODR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value |= L3GD20H_ENABLE_SOFT_RESET_VALUE; ret = sensor_i2c_write(drv, L3GD20H_GYRO_LOW_ODR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_l3gd20h_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, L3GD20H_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_gyro_st_l3gd20h_set_bdu(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, L3GD20H_GYRO_CTRL4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (value & L3GD20H_BDU_ENABLE) return 0; value |= L3GD20H_BDU_ENABLE; ret = sensor_i2c_write(drv, L3GD20H_GYRO_CTRL4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_l3gd20h_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, L3GD20H_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } switch(mode){ case DEV_POWER_ON:{ value |= L3GD20H_GYRO_POWER_ON; ret = sensor_i2c_write(drv, L3GD20H_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_POWER_OFF:{ value &= ~L3GD20H_GYRO_POWER_ON; ret = sensor_i2c_write(drv, L3GD20H_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_SLEEP:{ value &= ~L3GD20H_GYRO_SLEEP_MASK; value |= L3GD20H_GYRO_SLEEP; ret = sensor_i2c_write(drv, L3GD20H_GYRO_CTRL1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; default:break; } return 0; } static uint8_t drv_gyro_st_l3gd20h_hz2odr(uint32_t hz) { if(hz > 400) return L3GD20H_GYRO_ODR_800_HZ; else if(hz > 200) return L3GD20H_GYRO_ODR_400_HZ; else if(hz > 100) return L3GD20H_GYRO_ODR_200_HZ; else if(hz > 50) return L3GD20H_GYRO_ODR_100_HZ; else if(hz > 25) return L3GD20H_GYRO_ODR_50_HZ; else if(hz > 13) return L3GD20H_GYRO_ODR_25_HZ; else return L3GD20H_GYRO_ODR_12_5_HZ; } static int drv_gyro_st_l3gd20h_set_odr(i2c_dev_t* drv, uint32_t hz) { int ret = 0; uint8_t value = 0x00; uint8_t odr = drv_gyro_st_l3gd20h_hz2odr(hz); if(hz < 100){ ret = sensor_i2c_read(drv, L3GD20H_GYRO_LOW_ODR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value |= L3GD20H_LOW_ODR_ENABLE; ret = sensor_i2c_write(drv, L3GD20H_GYRO_LOW_ODR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }else{ ret = sensor_i2c_read(drv, L3GD20H_GYRO_LOW_ODR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value &= ~L3GD20H_LOW_ODR_ENABLE; ret = sensor_i2c_write(drv, L3GD20H_GYRO_LOW_ODR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } } ret = sensor_i2c_write(drv, L3GD20H_GYRO_CTRL1, &odr, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_gyro_st_l3gd20h_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, L3GD20H_GYRO_CTRL4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } switch (range){ case GYRO_RANGE_250DPS:{ tmp = L3GD20H_GYRO_RANGE_245; }break; case GYRO_RANGE_500DPS:{ tmp = L3GD20H_GYRO_RANGE_500; }break; case GYRO_RANGE_2000DPS:{ tmp = L3GD20H_GYRO_RANGE_2000; }break; default:break; } value = L3GD20H_SET_BITSLICE(value,L3GD20H_GYRO_RANGE,tmp); ret = sensor_i2c_write(drv, L3GD20H_GYRO_CTRL4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if((range >= GYRO_RANGE_250DPS)&&(range <= GYRO_RANGE_2000DPS)){ cur_gyro_factor = l3gd20h_gyro_factor[range]; } return 0; } static void drv_gyro_st_l3gd20h_irq_handle(void) { /* no handle so far */ } static int drv_gyro_st_l3gd20h_open(void) { int ret = 0; ret = drv_gyro_st_l3gd20h_set_power_mode(&l3gd20h_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_set_bdu(&l3gd20h_ctx); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_set_range(&l3gd20h_ctx, GYRO_RANGE_2000DPS); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_set_odr(&l3gd20h_ctx, L3GD20H_GYRO_DEFAULT_ODR_100HZ); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_l3gd20h_close(void) { int ret = 0; ret = drv_gyro_st_l3gd20h_set_power_mode(&l3gd20h_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } return 0; } static int drv_gyro_st_l3gd20h_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(&l3gd20h_ctx, (L3GD20H_GYRO_OUTX_L | 0x80), reg, 6, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } gyro->data[DATA_AXIS_X] = (int16_t)((((int32_t)((int8_t)reg[1]))<< L3GD20H_SHIFT_EIGHT_BITS)|(reg[0])); gyro->data[DATA_AXIS_Y] = (int16_t)((((int32_t)((int8_t)reg[3]))<< L3GD20H_SHIFT_EIGHT_BITS)|(reg[2])); gyro->data[DATA_AXIS_Z] = (int16_t)((((int32_t)((int8_t)reg[5]))<< L3GD20H_SHIFT_EIGHT_BITS)|(reg[4])); if(cur_gyro_factor != 0){ gyro->data[DATA_AXIS_X] = (gyro->data[DATA_AXIS_X] * cur_gyro_factor); gyro->data[DATA_AXIS_Y] = (gyro->data[DATA_AXIS_Y] * cur_gyro_factor); gyro->data[DATA_AXIS_Z] = (gyro->data[DATA_AXIS_Z] * cur_gyro_factor); } gyro->timestamp = aos_now_ms(); return (int)size; } static int drv_gyro_st_l3gd20h_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ ret = drv_gyro_st_l3gd20h_set_odr(&l3gd20h_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_RANGE_SET:{ ret = drv_gyro_st_l3gd20h_set_range(&l3gd20h_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_SET_POWER:{ ret = drv_gyro_st_l3gd20h_set_power_mode(&l3gd20h_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 = "L3GD20H"; info->range_max = 2000; info->range_min = 245; info->unit = udps; }break; default:break; } return 0; } int drv_gyro_st_l3gd20h_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(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_l3gd20h_open; sensor.close = drv_gyro_st_l3gd20h_close; sensor.read = drv_gyro_st_l3gd20h_read; sensor.write = NULL; sensor.ioctl = drv_gyro_st_l3gd20h_ioctl; sensor.irq_handle = drv_gyro_st_l3gd20h_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_validate_id(&l3gd20h_ctx, L3GD20H_CHIP_ID_VALUE); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_set_range(&l3gd20h_ctx, GYRO_RANGE_2000DPS); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_set_odr(&l3gd20h_ctx, L3GD20H_GYRO_ODR_100_HZ); if(unlikely(ret)){ return -1; } ret = drv_gyro_st_l3gd20h_set_power_mode(&l3gd20h_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_gyro_st_l3gd20h_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_gyro_st_l3gd20h.c
C
apache-2.0
12,202
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_hal.h" void sensor_drv_init() { #if AOS_SENSOR_TEMP_SI_SI7006 drv_temp_si_si7006_init(); #endif #if AOS_SENSOR_HUMI_SI_SI7006 drv_humi_si_si7006_init(); #endif #if AOS_SENSOR_ACC_ADI_ADXL372 drv_acc_adi_adxl372_init(); #endif #if AOS_SENSOR_ACC_ADI_ADXL345 drv_acc_adi_adxl345_init(); #endif #if AOS_SENSOR_ACC_ADI_ADXL355 drv_acc_adi_adxl355_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMA253 drv_acc_bosch_bma253_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMA280 drv_acc_bosch_bma280_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMA421 drv_acc_bosch_bma421_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMA422 drv_acc_bosch_bma422_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMA455 drv_acc_bosch_bma455_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMA456 drv_acc_bosch_bma456_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMI055 drv_acc_bosch_bmi055_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMI088 drv_acc_bosch_bmi088_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMI120 drv_acc_bosch_bmi120_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMI160 drv_acc_bosch_bmi160_init(); #endif #if AOS_SENSOR_ACC_BOSCH_BMI260 drv_acc_bosch_bmi260_init(); #endif #if AOS_SENSOR_ACC_SENODIA_SH200L drv_acc_senodia_sh200l_init(); #endif #if AOS_SENSOR_ACC_SENODIA_SH200Q drv_acc_senodia_sh200q_init(); #endif #if AOS_SENSOR_ACC_ST_LSM6DS3 drv_acc_st_lsm6ds3_init(); #endif #if AOS_SENSOR_ACC_ST_LSM6DS3TR_C drv_acc_st_lsm6ds3tr_c_init(); #endif #if AOS_SENSOR_ACC_ST_LSM6DSL drv_acc_st_lsm6dsl_init(); #endif #if AOS_SENSOR_ACC_ST_LSM6DSM drv_acc_st_lsm6dsm_init(); #endif #if AOS_SENSOR_ACC_ST_LSM6DSOQ drv_acc_st_lsm6dsoq_init(); #endif #if AOS_SENSOR_ACC_ST_LSM6DSR drv_acc_st_lsm6dsr_init(); #endif #if AOS_SENSOR_ACC_ST_LSM303AGR drv_acc_st_lsm303agr_init(); #endif #if AOS_SENSOR_ACC_MIR3_DA213B drv_acc_mir3_da213B_init(); #endif #if AOS_SENSOR_ACC_MIR3_DA215 drv_acc_mir3_da215_init(); #endif #if AOS_SENSOR_ACC_MIR3_DA217 drv_acc_mir3_da217_init(); #endif #if AOS_SENSOR_ACC_MIR3_DA270 drv_acc_mir3_da270_init(); #endif #if AOS_SENSOR_ACC_MIR3_DA312B drv_acc_mir3_da213B_init(); #endif #if AOS_SENSOR_ACC_MIR3_DA380B drv_acc_mir3_da380B_init(); #endif #if AOS_SENSOR_ACC_ST_AIS328DQ drv_acc_st_ais328dq_init(); #endif #if AOS_SENSOR_ACC_ST_H3LIS100DL drv_acc_st_h3lis100dl_init(); #endif #if AOS_SENSOR_ACC_ST_H3LIS331DL drv_acc_st_h3lis331dl_init(); #endif #if AOS_SENSOR_ACC_ST_LIS2DH12 drv_acc_st_lis2dh12_init(); #endif #if AOS_SENSOR_ACC_ST_LIS2DW12 drv_acc_st_lis2dw12_init(); #endif #if AOS_SENSOR_ACC_ST_LIS2HH12 drv_acc_st_lis2hh12_init(); #endif #if AOS_SENSOR_ACC_ST_LIS3DH drv_acc_st_lis3dh_init(); #endif #if AOS_SENSOR_ACC_ST_LIS331HH drv_acc_st_lis331hh_init(); #endif #if AOS_SENSOR_ACC_ST_N2DM drv_acc_st_n2dm_init(); #endif #if AOS_SENSOR_GYRO_BOSCH_BMI055 drv_gyro_bosch_bmi055_init(); #endif #if AOS_SENSOR_GYRO_BOSCH_BMI088 drv_gyro_bosch_bmi088_init(); #endif #if AOS_SENSOR_GYRO_BOSCH_BMI120 drv_gyro_bosch_bmi120_init(); #endif #if AOS_SENSOR_GYRO_BOSCH_BMI160 drv_gyro_bosch_bmi160_init(); #endif #if AOS_SENSOR_GYRO_BOSCH_BMI260 drv_gyro_bosch_bmi260_init(); #endif #if AOS_SENSOR_GYRO_SENODIA_SH200L drv_gyro_senodia_sh200l_init(); #endif #if AOS_SENSOR_GYRO_SENODIA_SH200Q drv_gyro_senodia_sh200q_init(); #endif #if AOS_SENSOR_GYRO_ST_LSM6DS3 drv_gyro_st_lsm6ds3_init(); #endif #if AOS_SENSOR_GYRO_ST_LSM6DS3TR_C drv_gyro_st_lsm6ds3tr_c_init(); #endif #if AOS_SENSOR_GYRO_ST_LSM6DSL drv_gyro_st_lsm6dsl_init(); #endif #if AOS_SENSOR_GYRO_ST_LSM6DSM drv_gyro_st_lsm6dsm_init(); #endif #if AOS_SENSOR_GYRO_ST_LSM6DSOQ drv_gyro_st_lsm6dsoq_init(); #endif #if AOS_SENSOR_GYRO_ST_LSM6DSR drv_gyro_st_lsm6dsr_init(); #endif #if AOS_SENSOR_GYRO_BOSCH_BMG160 drv_gyro_bosch_bmg160_init(); #endif #if AOS_SENSOR_GYRO_ST_A3G4250D drv_gyro_st_a3g4250d_init(); #endif #if AOS_SENSOR_GYRO_ST_I3G4250D drv_gyro_st_i3g4250d_init(); #endif #if AOS_SENSOR_GYRO_ST_L3GD20H drv_gyro_st_l3gd20h_init(); #endif #if AOS_SENSOR_MAG_BOSCH_BMM150 drv_mag_bosch_bmm150_init(); #endif #if AOS_SENSOR_MAG_ST_LSM303AGR drv_mag_st_lsm303agr_init(); #endif #if AOS_SENSOR_MAG_AKM_AK09917 drv_mag_akm_ak09917_init(); #endif #if AOS_SENSOR_MAG_AKM_AK09918 drv_mag_akm_ak09918_init(); #endif #if AOS_SENSOR_MAG_AKM_AK09940 drv_mag_akm_ak09940_init(); #endif #if AOS_SENSOR_MAG_ROHM_BM1422A drv_mag_rohm_bm1422a_init(); #endif #if AOS_SENSOR_MAG_SENODIA_ST350 drv_mag_sen_st350_init(); #endif #if AOS_SENSOR_MAG_SENODIA_ST480 drv_mag_sen_st480_init(); #endif #if AOS_SENSOR_MAG_ST_LIS2MDL drv_mag_st_lis2mdl_init(); #endif #if AOS_SENSOR_MAG_ST_LIS3MDL drv_mag_st_lis3mdl_init(); #endif #if AOS_SENSOR_MAG_MEMSIC_MMC3680KJ drv_mag_memsic_mmc3680kj_init(); #endif #if AOS_SENSOR_ALS_AMS_TCS3400 drv_als_ams_tcs3400_init(); #endif #if AOS_SENSOR_ALS_AMS_TMD2725 drv_als_ams_tmd2725_init(); #endif #if AOS_SENSOR_ALS_LITEON_LTR303 drv_als_liteon_ltr303_init(); #endif #if AOS_SENSOR_ALS_LITEON_LTR568 drv_als_liteon_ltr568_init(); #endif #if AOS_SENSOR_ALS_LITEON_LTR507 drv_als_liteon_ltr507_init(); #endif #if AOS_SENSOR_ALS_LITEON_LTR553 drv_als_liteon_ltr553_init(); #endif #if AOS_SENSOR_ALS_LITEON_LTR559 drv_als_liteon_ltr559_init(); #endif #if AOS_SENSOR_ALS_ROHM_BH1730 drv_als_rohm_bh1730_init(); #endif #if AOS_SENSOR_PS_AMS_TMD2725 drv_ps_ams_tmd2725_init(); #endif #if AOS_SENSOR_PS_LITEON_LTR507 drv_ps_liteon_ltr507_init(); #endif #if AOS_SENSOR_PS_LITEON_LTR553 drv_ps_liteon_ltr553_init(); #endif #if AOS_SENSOR_PS_LITEON_LTR559 drv_ps_liteon_ltr559_init(); #endif #if AOS_SENSOR_PS_LITEON_LTR659 drv_ps_liteon_ltr659_init(); #endif #if AOS_SENSOR_PS_LITEON_LTR690 drv_ps_liteon_ltr690_init(); #endif #if AOS_SENSOR_PS_LITEON_LTR706 drv_ps_liteon_ltr706_init(); #endif #if AOS_SENSOR_BARO_IFX_DSP310 drv_baro_ifx_dps310_init(); #endif #if AOS_SENSOR_BARO_BOSCH_BMP280 drv_baro_bosch_bmp280_init(); #endif #if AOS_SENSOR_BARO_BOSCH_BMP380 drv_baro_bosch_bmp380_init(); #endif #if AOS_SENSOR_BARO_ROHM_BM1383A drv_baro_rohm_bm1383a_init(); #endif #if AOS_SENSOR_BARO_ST_LPS22HB drv_baro_st_lps22hb_init(); #endif #if AOS_SENSOR_BARO_ST_LPS33HB drv_baro_st_lps33hb_init(); #endif #if AOS_SENSOR_BARO_ST_LPS35HB drv_baro_st_lps35hb_init(); #endif #if AOS_SENSOR_BARO_BOSCH_BME280 drv_humi_bosch_bme280_init(); #endif #if AOS_SENSOR_GESTURE_PIXART_PAJ7620 drv_gs_pixart_paj7620_init(); #endif #if AOS_SENSOR_IR_AKM_AK9754 drv_ir_akm_ak9754_init(); #endif #if AOS_SENSOR_RGB_LITEON_LTR381 drv_rgb_liteon_ltr381_init(); #endif #if AOS_SENSOR_RTC_MAXIM_DS1307 drv_rtc_maxim_ds1307_init(); #endif #if AOS_SENSOR_UV_LITEON_LTR390 drv_uv_liteon_ltr390_init(); #endif #if AOS_SENSOR_TEMP_AMS_ENS210 drv_temp_ams_ens210_init(); #endif #if AOS_SENSOR_TEMP_ADI_ADT7410 drv_temp_adi_adt7410_init(); #endif #if AOS_SENSOR_TEMP_BOSCH_BME280 drv_temp_bosch_bme280_init(); #endif #if AOS_SENSOR_TEMP_SENSIRION_SHT30 drv_temp_sensirion_sht30_init(); #endif #if AOS_SENSOR_TEMP_SENSIRION_SHT31 drv_temp_sensirion_sht31_init(); #endif #if AOS_SENSOR_TEMP_SENSIRION_SHTC1 drv_temp_sensirion_shtc1_init(); #endif #if AOS_SENSOR_TEMP_ST_HTS221 drv_temp_st_hts221_init(); #endif #if AOS_SENSOR_HUMI_AMS_ENS210 drv_humi_ams_ens210_init(); #endif #if AOS_SENSOR_HUMI_BOSCH_BME280 drv_baro_bosch_bme280_init(); #endif #if AOS_SENSOR_HUMI_SENSIRION_SHT30 drv_humi_sensirion_sht30_init(); #endif #if AOS_SENSOR_HUMI_SENSIRION_SHT31 drv_humi_sensirion_sht31_init(); #endif #if AOS_SENSOR_HUMI_SENSIRION_SHTC1 drv_humi_sensirion_shtc1_init(); #endif #if AOS_SENSOR_HUMI_ST_HTS221 drv_humi_st_hts221_init(); #endif #if AOS_SENSOR_CO2_SENSIRION_SCD30 drv_co2_sensirion_scd30_init(); #endif #if AOS_SENSOR_ECG_ADI_ADPD188GG drv_ecg_adi_adpd188gg_init(); #endif #if AOS_SENSOR_TVOC_SENSIRION_SGP30 drv_tvoc_sensirion_sgp30_init(); #endif #if AOS_SENSOR_TVOC_AMS_CCS811 drv_voc_ams_ccs811_init(); #endif #if AOS_SENSOR_HUMI_BME280_SPI drv_humi_bosch_bme280_init(); #endif #if AOS_SENSOR_BARO_BME280_SPI drv_baro_bosch_bme280_init(); #endif #if AOS_SENSOR_TEMP_BME280_SPI drv_temp_bosch_bme280_init(); #endif #if AOS_SENSOR_CANBUS_INV_MPU9250 drv_canbus_acc_inv_mpu9250_init(); #endif #if AOS_SENSOR_PS_ST_VL53L0X drv_ps_st_vl53l0x_init(); #endif }
YifuLiu/AliOS-Things
components/sensor/drv/drv_init.c
C
apache-2.0
8,684
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include <aos/kernel.h> #include "sensor_drv_api.h" #include "sensor_hal.h" /* AK9754 Register definitions */ #define AK9754_WIA1_REG 0x00 /* Company code */ #define AK9754_WIA2_REG 0x01 /* Device ID */ #define AK9754_INFO1_REG 0x02 /* Unused informatiln */ #define AK9754_INFO2_REG 0x03 /* Unused informatiln */ #define AK9754_ST1_REG 0x04 /* Status 1 */ #define AK9754_IRDL_REG 0x05 /* IR sensor data (lower) */ #define AK9754_IRDH_REG 0x06 /* IR sensor data (upper) */ #define AK9754_TMPL_REG 0x07 /* Integrated temperature sensor data (lower) */ #define AK9754_TMPH_REG 0x08 /* Integrated temperature sensor data (upper) */ #define AK9754_ST2_REG 0x09 /* Status 2 */ #define AK9754_ST3_REG 0x0A /* Status 3 */ #define AK9754_SB0L_REG 0x0B /* latest IR sensor data (lower) */ #define AK9754_SB0H_REG 0x0C /* latest IR sensor data (upper) */ #define AK9754_SB1L_REG 0x0D /* previous IR sensor data (lower) */ #define AK9754_SB1H_REG 0x0E /* previous IR sensor data (upper) */ #define AK9754_SB2L_REG 0x0F /* 2 previous IR sensor data (lower) */ #define AK9754_SB2H_REG 0x10 /* 2 previous IR sensor data (upper) */ #define AK9754_SB3L_REG 0x11 /* 3 previous IR sensor data (lower) */ #define AK9754_SB3H_REG 0x12 /* 3 previous IR sensor data (upper) */ #define AK9754_SB4L_REG 0x13 /* 4 previous IR sensor data (lower) */ #define AK9754_SB4H_REG 0x14 /* 4 previous IR sensor data (upper) */ #define AK9754_SB5L_REG 0x15 /* 5 previous IR sensor data (lower) */ #define AK9754_SB5H_REG 0x16 /* 5 previous IR sensor data (upper) */ #define AK9754_SB6L_REG 0x17 /* 6 previous IR sensor data (lower) */ #define AK9754_SB6H_REG 0x18 /* 6 previous IR sensor data (upper) */ #define AK9754_SB7L_REG 0x19 /* 7 previous IR sensor data (lower) */ #define AK9754_SB7H_REG 0x1A /* 7 previous IR sensor data (upper) */ #define AK9754_SB8L_REG 0x1B /* 8 previous IR sensor data (lower) */ #define AK9754_SB8H_REG 0x1C /* 8 previous IR sensor data (upper) */ #define AK9754_SB9L_REG 0x1D /* oldest IR sensor data (lower) */ #define AK9754_SB9H_REG 0x1E /* oldest IR sensor data (lower) */ #define AK9754_ST4_REG 0x1F /* Status 4 */ #define AK9754_CTRL1_REG 0x20 /* Software reset */ #define AK9754_CTRL2_REG 0x21 /* Sync mode setting */ #define AK9754_CTRL3_REG 0x22 /* Lownoise mode / odr / tmp_fc / ird_fc settings */ #define AK9754_CTRL4_REG 0x23 /* Track mode settings */ #define AK9754_CTRL5_REG 0x24 /* TMP offset settings */ #define AK9754_CTRL6_REG 0x25 /* IRD gain settings */ #define AK9754_CTRL7_REG 0x26 /* Invert mode / wait time settings */ #define AK9754_CTRL8_REG 0x27 /* NSAMPLE settings */ #define AK9754_CTRL9_REG 0x28 /* Threshold level settings (lower) */ #define AK9754_CTRL10_REG 0x29 /* Threshold level settings (upper) */ #define AK9754_CTRL11_REG 0x2A /* Enable/Disable settings */ #define AK9754_CTRL12_REG 0x2B /* Mode */ /* Register helper values */ #define AK9754_COMPANY_ID 0x48 /* Company ID of AKM */ #define AK9754_DEVICE_ID 0x15 /* Device ID of AK9754 */ #define AK9754_WIA_VAL 0x1548 #define AK9754_ST1_DRDY 0x01 /* bit mask of DRDY for ST1 */ #define AK9754_ST1_HBD_ONCE 0x10 /* bit mask of HBD_ONCE for ST1 */ #define AK9754_CTRL1_SRST 1 /* bit mask of SRST for CTRL1 */ #define AK9754_CTRL3_IRD_FC_SHIFT 0 #define AK9754_CTRL3_TMP_FC_SHIFT 2 #define AK9754_CTRL3_ODR_SHIFT 4 #define AK9754_CTRL3_LOWNOISEMODE_SHIFT 6 /* helper function to make CTRL3 register's value */ #define AK9754_CTRL3(lnmode, odr, tmpfc, irdfc) \ ((lnmode) << (AK9754_CTRL3_LOWNOISEMODE_SHIFT) | \ (odr) << (AK9754_CTRL3_ODR_SHIFT) | \ (tmpfc) << (AK9754_CTRL3_TMP_FC_SHIFT) | \ (irdfc) << (AK9754_CTRL3_IRD_FC_SHIFT)) #define AK9754_CTRL7_HBD_INVERT_SHIFT 3 #define AK9754_CTRL7_HBD_WAITTIME_SHIFT 0 /* helper function to make CTRL7 register's value */ #define AK9754_CTRL7(invert, waittime) \ ((invert) << (AK9754_CTRL7_HBD_INVERT_SHIFT) | \ (waittime) << (AK9754_CTRL7_HBD_WAITTIME_SHIFT)) /* helper function to make CTRL9 / CTRL10 register's value */ #define AK9754_CTRL9(thld) ((thld) & 0xff) #define AK9754_CTRL10(thld) (((thld) & 0xff00) >> 8) #define AK9754_CNTL11_INT_ENABLE_DRDY 0x01 #define AK9754_CNTL11_INT_ENABLE_HBD 0x02 #define AK9754_CNTL11_SB_ENABLE 0x04 #define AK9754_CNTL11_SB_STOP_ON_HBD 0x08 #define AK9754_CNTL11_HBD_ENABLE 0x10 #define AK9754_CTRL12_MODE_STANDBY 0x00 /* Standby mode */ #define AK9754_CTRL12_MODE_MEASURE 0x01 /* Continuous measurement mode */ #define AK9754_SUPPORTED_ODR_POWER_DOWN 0 #define AK9754_SUPPORTED_ODR_1HZ 1 #define AK9754_SUPPORTED_ODR_2HZ 2 #define AK9754_SUPPORTED_ODR_10HZ 10 #define AK9754_SUPPORTED_ODR_50HZ 50 /* * The values below are generate automatically */ /* CNTL3 values */ /* LOWNOISEMODE bit: valid value is 1 or 0 */ #define AK9754_LOWNOISEMODE_VAL 1 /* ODR bit: valid rang is [0x00, 0x03] 00 1Hz 01 2Hz 02 10Hz 03 50Hz*/ #define AK9754_ODR_VAL 0x02 /* TMP_FC bit: valid rang is [0x00, 0x02] */ #define AK9754_TMP_FC_VAL 0x01 /* IRD_FC bit: valid rang is [0x00, 0x02] */ #define AK9754_IRD_FC_VAL 0x01 /* CNTL4 valus */ /* TRACKMODE bit: valid rang is [0x00, 0x07] */ #define AK9754_TRACKMODE_VAL 0x00 /* CNTL5 values */ /* TMP_OFFSET bit: valid rang is [0xc0, 0x3f] ([-64, 63]) */ #define AK9754_TMP_OFFSET_VAL 0x80 /* CNTL6 values */ /* IRD_GAIN bit: valid rang is [0xf0, 0x0f] ([-16, 15]) */ #define AK9754_IRD_GAIN_VAL 0xfa /* CNTL7 values */ /* HBD_INVERT bit: valid value is 1 or 0 */ #define AK9754_INVERT_VAL 0 /* HBD_WAITTIME bit: valid range is [0x00, 0x07] */ #define AK9754_WAITTIME_VAL 0 /* CNTL8 values */ /* HBD_NSAMPLE bit: valid range is [0x00, 0x7f] */ #define AK9754_NSAMPLE_VAL 0x01 /* CNTL9, 10 values */ /* HBD_THLD bit: valid range is [0x0000, 0x7fff] ([0, 32767]) */ #define AK9754_THLD_VAL 75 #define AK9754_DEVICE_NAME "AK9754" #define AKM_SUCCESS (0) #define AKM_ERROR (-1) #define MEASURE_WAIT_TIME (20) #define AK9754_DEFAULT_MODE AK9754_CTRL3(AK9754_LOWNOISEMODE_VAL, AK9754_ODR_VAL, AK9754_TMP_FC_VAL, AK9754_IRD_FC_VAL) /* Default 10Hz */ #define AKM_DEVICE_NAME AK9754_DEVICE_NAME #define AKM_LOG(format, ...) LOG("%s %s %s " format, SENSOR_STR, \ AKM_DEVICE_NAME, __func__, \ ## __VA_ARGS__) /************************************************* CAD1 CAD0 Slave Address VSS VSS 60H VSS non-connected 61H VSS VDD 62H non-connected VSS 64H non-connected non-connected 65H non-connected VDD 66H VDD VSS 68H VDD non-connected 69H VDD VDD Do Not Use ************************************************/ i2c_dev_t ak9754_dev = { .port = 3, .config.address_width = 8, .config.dev_addr = 0x60 << 1, .config.freq = 100, }; static int16_t drv_ir_akm_ak9754_set_mode( i2c_dev_t *dev, const uint8_t mode) { int16_t ret = 0; uint8_t i2c_data = mode; ret = sensor_i2c_write(dev, AK9754_CTRL12_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } static int drv_ir_akm_ak9754_soft_reset(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data = AK9754_CTRL1_SRST; ret = sensor_i2c_write(dev, AK9754_CTRL1_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_ir_akm_ak9754_valid_id(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data[2]; uint16_t id = 0; ret = sensor_i2c_read(dev, AK9754_WIA1_REG, i2c_data, 2, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } id = (uint16_t)(((uint16_t)i2c_data[1] << 8) | i2c_data[0]); if (AK9754_WIA_VAL != id) { AKM_LOG("invalid device.\n"); return AKM_ERROR; } return 0; } static void drv_ir_akm_ak9754_irq_handle(void) { /* no handle so far */ } static int drv_ir_akm_ak9754_open(void) { int16_t ret = 0; i2c_dev_t *dev = &ak9754_dev; ret = drv_ir_akm_ak9754_set_mode(dev, AK9754_CTRL12_MODE_MEASURE); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_ir_akm_ak9754_close(void) { int16_t ret = 0; i2c_dev_t *dev = &ak9754_dev; ret = drv_ir_akm_ak9754_set_mode(dev, AK9754_CTRL12_MODE_STANDBY); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_ir_akm_ak9754_read( void *buf, size_t len) { //ir_data_t *ir_data = (ir_data_t *)buf; ir_data_t *ir_data = (ir_data_t *)buf; i2c_dev_t *dev = &ak9754_dev; size_t size; uint8_t i2c_data[6]; int16_t ret = 0; if (NULL == buf) { return AKM_ERROR; } size = sizeof(ir_data_t); if (len < size) { return AKM_ERROR; } /* Get measurement data from AK9754 * ST1 + (IRDL + IRDH) + (TMPL+ TMPH) + ST2 = 6bytes */ ret = sensor_i2c_read(dev, AK9754_ST1_REG, i2c_data, 6, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } //ir_data->ir = (uint32_t)((int16_t)(i2c_data[1] | (((uint16_t)i2c_data[2]) << 8) + 32767); ir_data->ir = (uint32_t)((int16_t)(i2c_data[1] | ((uint16_t)i2c_data[2] << 8)) + 32767); ir_data->timestamp = aos_now_ms(); return (int)size; } static int drv_ir_akm_ak9754_write( const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_ir_akm_ak9754_set_odr( i2c_dev_t *dev, const uint32_t odr) { uint8_t ODR_VAL = 0; int ret; if (odr == AK9754_SUPPORTED_ODR_POWER_DOWN) { ret = drv_ir_akm_ak9754_close(); if (unlikely(ret)) { return ret; } } else if (odr <= AK9754_SUPPORTED_ODR_1HZ) { ODR_VAL = AK9754_CTRL3(AK9754_LOWNOISEMODE_VAL, 0x00, AK9754_TMP_FC_VAL, AK9754_IRD_FC_VAL); } else if (odr <= AK9754_SUPPORTED_ODR_2HZ) { ODR_VAL = AK9754_CTRL3(AK9754_LOWNOISEMODE_VAL, 0x01, AK9754_TMP_FC_VAL, AK9754_IRD_FC_VAL); } else if (odr <= AK9754_SUPPORTED_ODR_10HZ) { ODR_VAL = AK9754_CTRL3(AK9754_LOWNOISEMODE_VAL, AK9754_ODR_VAL, AK9754_TMP_FC_VAL, AK9754_IRD_FC_VAL); } else if (odr <= AK9754_SUPPORTED_ODR_50HZ) { ODR_VAL = AK9754_CTRL3(AK9754_LOWNOISEMODE_VAL, 0x03, AK9754_TMP_FC_VAL, AK9754_IRD_FC_VAL); } else { AKM_LOG("unsupported ODR : %d, set to default mode\n", odr); ODR_VAL = AK9754_DEFAULT_MODE; } ret = sensor_i2c_write(dev, AK9754_CTRL3_REG, &ODR_VAL, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = drv_ir_akm_ak9754_open(); if (unlikely(ret)) { return ret; } return 0; } static void drv_ir_akm_ak9754_get_info(dev_sensor_info_t *info) { info->vendor = DEV_SENSOR_VENDOR_AKM; info->model = AKM_DEVICE_NAME; info->unit = cm; info->range_max = 15000; info->range_min = -15000; return; } static int16_t drv_ir_akm_ak9754_set_default_config(i2c_dev_t *dev) { int16_t ret = 0; /* * setup measurement conditions (CTRL3 ~ CTRL6) */ /* CTRL3 : Lownoise mode / odr / tmpfc / irdfc settings */ uint8_t i2c_data = AK9754_CTRL3(AK9754_LOWNOISEMODE_VAL, AK9754_ODR_VAL, AK9754_TMP_FC_VAL, AK9754_IRD_FC_VAL); ret = sensor_i2c_write(dev, AK9754_CTRL3_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* CTRL4 : Track mode settings */ i2c_data = AK9754_TRACKMODE_VAL; ret = sensor_i2c_write(dev, AK9754_CTRL4_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* CTRL5 : TMP offset settings */ i2c_data = AK9754_TMP_OFFSET_VAL; ret = sensor_i2c_write(dev, AK9754_CTRL5_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* CTRL6 : IRD gain settings */ i2c_data = AK9754_IRD_GAIN_VAL; ret = sensor_i2c_write(dev, AK9754_CTRL6_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* * setup parameteres for human body detection (CTRL7 ~ CTRL10) */ /* CTRL7 : Invert mode / waittime settings */ i2c_data = AK9754_CTRL7(AK9754_INVERT_VAL, AK9754_WAITTIME_VAL); ret = sensor_i2c_write(dev, AK9754_CTRL7_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* CTRL8 : NSAMPLE settings */ i2c_data = AK9754_NSAMPLE_VAL; ret = sensor_i2c_write(dev, AK9754_CTRL8_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* CTRL9 : Threshold level settings (lower) */ i2c_data = AK9754_CTRL9(AK9754_THLD_VAL); ret = sensor_i2c_write(dev, AK9754_CTRL9_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* CTRL10 : Threshold level settings (upper) */ i2c_data = AK9754_CTRL10(AK9754_THLD_VAL); ret = sensor_i2c_write(dev, AK9754_CTRL10_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } /* * device interrupt settings * In this codes, AK9754 rise interrupts when human is detected */ /* CTRL11 : function's Enable / Disable settings */ i2c_data = AK9754_CNTL11_HBD_ENABLE | AK9754_CNTL11_INT_ENABLE_HBD; ret = sensor_i2c_write(dev, AK9754_CTRL11_REG, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } int drv_ir_akm_ak9754_ioctl( int cmd, unsigned long arg) { int ret = 0; dev_sensor_info_t *info = (dev_sensor_info_t *) arg; switch (cmd) { case SENSOR_IOCTL_ODR_SET: ret = drv_ir_akm_ak9754_set_odr(&ak9754_dev, (int)arg); if (unlikely(ret)) { return AKM_ERROR; } break; case SENSOR_IOCTL_RANGE_SET: break; case SENSOR_IOCTL_GET_INFO: drv_ir_akm_ak9754_get_info(info); break; case SENSOR_IOCTL_BIST_PROCESS: break; case SENSOR_IOCTL_WHO_AM_I: break; case SENSOR_IOCTL_SET_POWER: break; case SENSOR_IOCTL_GET_SENSOR_LIST: break; case SENSOR_IOCTL_DTC_CYCLE_SET: break; default: break; } return ret; } int drv_ir_akm_ak9754_init(void) { int16_t ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_IR; sensor.path = dev_ir_path; sensor.io_port = I2C_PORT; sensor.open = drv_ir_akm_ak9754_open; sensor.close = drv_ir_akm_ak9754_close; sensor.read = drv_ir_akm_ak9754_read; sensor.write = drv_ir_akm_ak9754_write; sensor.ioctl = drv_ir_akm_ak9754_ioctl; sensor.irq_handle = drv_ir_akm_ak9754_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return (int)ret; } ret = drv_ir_akm_ak9754_valid_id(&ak9754_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_ir_akm_ak9754_soft_reset(&ak9754_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_ir_akm_ak9754_set_default_config(&ak9754_dev); if (unlikely(ret)) { return (int)ret; } AKM_LOG("successfully.\n"); return (int)ret; } SENSOR_DRV_ADD(drv_ir_akm_ak9754_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_ir_akm_ak9754.c
C
apache-2.0
16,280
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include <aos/kernel.h> #include "sensor_drv_api.h" #include "sensor_hal.h" #define AK099XX_REG_WIA1 0x00 #define AK099XX_REG_WIA2 0x01 #define AK099XX_REG_INFO1 0x02 #define AK099XX_REG_INFO2 0x03 #define AK099XX_REG_ST1 0x10 #define AK099XX_REG_HXH 0x11 #define AK099XX_REG_HXL 0x12 #define AK099XX_REG_HYH 0x13 #define AK099XX_REG_HYL 0x14 #define AK099XX_REG_HZH 0x15 #define AK099XX_REG_HZL 0x16 #define AK099XX_REG_TMPS 0x17 #define AK099XX_REG_ST2 0x18 #define AK099XX_REG_CNTL1 0x30 #define AK099XX_REG_CNTL2 0x31 #define AK099XX_REG_CNTL3 0x32 #define AK099XX_BDATA_SIZE 9 #define AK099XX_MODE_NSF_DISABLE 0x00 #define AK099XX_MODE_NSF_LOW 0x20 #define AK099XX_MODE_NSF_MIDDLE 0x80 #define AK099XX_MODE_NSF_HIGH 0xA0 #define AK099XX_MODE_POWER_DOWN 0x00 #define AK099XX_MODE_SNG_MEASURE 0x01 #define AK099XX_MODE_CONT_MEASURE_MODE1 0x02 #define AK099XX_MODE_CONT_MEASURE_MODE2 0x04 #define AK099XX_MODE_CONT_MEASURE_MODE3 0x06 #define AK099XX_MODE_CONT_MEASURE_MODE4 0x08 #define AK099XX_MODE_CONT_MEASURE_MODE5 0x0A #define AK099XX_MODE_CONT_MEASURE_MODE6 0x0C #define AK099XX_MODE_SELF_TEST 0x10 #define AK099XX_MODE_FIFO_ENABLE 0x80 #define AK099XX_MODE_SDR_ENABLE 0x40 #define AK099XX_MODE_IBIP_ENABLE 0x20 #define AK099XX_SOFT_RESET 0x01 #define AK099XX_DRDY_BIT 0x01 #define AK099XX_DOR_BIT 0x02 #define AK099XX_HOFL_BIT 0x08 /** Invalid fifo data bit */ #define AK099XX_INV_FIFO_DATA 0x4 #define AK099XX_SUPPORTED_ODR_POWER_DOWN 0 #define AK099XX_SUPPORTED_ODR_1HZ 1 #define AK099XX_SUPPORTED_ODR_10HZ 10 #define AK099XX_SUPPORTED_ODR_20HZ 20 #define AK099XX_SUPPORTED_ODR_50HZ 50 #define AK099XX_SUPPORTED_ODR_100HZ 100 #define AK099XX_SUPPORTED_ODR_200HZ 200 #define AK09917D_WIA_VAL 0xD48 #define AK099XX_DEVICE_NAME "AK09917D" /***************************************************************/ /* AK09917D self test releted */ #define TLIMIT_NO_RST 0x101 #define TLIMIT_NO_RST_READ 0x102 #define TLIMIT_NO_RST_WIA1 0x103 #define TLIMIT_LO_RST_WIA1 0x48 #define TLIMIT_HI_RST_WIA1 0x48 #define TLIMIT_NO_RST_WIA2 0x104 #define TLIMIT_LO_RST_WIA2 0x0d #define TLIMIT_HI_RST_WIA2 0x0d #define TLIMIT_NO_CNT_ITRT 3 #define TLIMIT_NO_CNT_CNTL2 0x201 #define TLIMIT_NO_CNT_WAIT 0x202 #define TLIMIT_NO_CNT_READ 0x203 #define TLIMIT_NO_CNT_1ST 0x204 #define TLIMIT_LO_CNT_1ST 1 #define TLIMIT_HI_CNT_1ST 1 #define TLIMIT_NO_CNT_2ND 0x205 #define TLIMIT_LO_CNT_2ND 0 #define TLIMIT_HI_CNT_2ND 0 #define TLIMIT_NO_SNG_CNTL2 0x301 #define TLIMIT_NO_SNG_WAIT 0x302 #define TLIMIT_NO_SNG_ST1 0x303 #define TLIMIT_LO_SNG_ST1 1 #define TLIMIT_HI_SNG_ST1 1 #define TLIMIT_NO_SNG_HX 0x304 #define TLIMIT_LO_SNG_HX -32751 #define TLIMIT_HI_SNG_HX 32751 #define TLIMIT_NO_SNG_HY 0x306 #define TLIMIT_LO_SNG_HY -32751 #define TLIMIT_HI_SNG_HY 32751 #define TLIMIT_NO_SNG_HZ 0x308 #define TLIMIT_LO_SNG_HZ -32751 #define TLIMIT_HI_SNG_HZ 32751 /* Only MASKED bit of ST2 register is evaluated */ #define TLIMIT_NO_SNG_ST2 0x30A #define TLIMIT_LO_SNG_ST2 0 #define TLIMIT_HI_SNG_ST2 0 #define TLIMIT_ST2_MASK 0x08 #define TLIMIT_NO_SLF_CNTL2 0x30B #define TLIMIT_NO_SLF_WAIT 0x30C #define TLIMIT_NO_SLF_ST1 0x30D #define TLIMIT_LO_SLF_ST1 1 #define TLIMIT_HI_SLF_ST1 1 #define TLIMIT_NO_SLF_RVHX 0x30E #define TLIMIT_LO_SLF_RVHX -200 #define TLIMIT_HI_SLF_RVHX 200 #define TLIMIT_NO_SLF_RVHY 0x310 #define TLIMIT_LO_SLF_RVHY -200 #define TLIMIT_HI_SLF_RVHY 200 #define TLIMIT_NO_SLF_RVHZ 0x312 #define TLIMIT_LO_SLF_RVHZ -1000 #define TLIMIT_HI_SLF_RVHZ -200 #define TLIMIT_NO_SLF_ST2 0x314 #define TLIMIT_LO_SLF_ST2 0 #define TLIMIT_HI_SLF_ST2 0 #define AKM_FST_ERRCODE(testno, data) \ (int32_t)((((uint32_t)testno) << 16) | ((uint16_t)data)) #define AKM_FST(no, data, lo, hi, err) \ if (drv_mag_akm_ak09917_test_data((no), (data), (lo), (hi), \ (err)) != AKM_SUCCESS) \ { goto SELFTEST_FAIL; } /***************************************************************/ #define AKM_SUCCESS (0) #define AKM_ERROR (-1) #define MEASURE_WAIT_TIME (20) #define AK0991X_MAX_RANGE 49120000 /* 49120000uG = 49120mG = 4912uT */ #define AK0991X_MIN_RANGE -49120000 /* -49120000uG = -49120mG = -4912uT */ #define AK099XX_DEFAULT_MODE AK099XX_MODE_CONT_MEASURE_MODE1 /* Default 10Hz */ #define AK099XX_MAG_AXIS_ORDER_X 0 #define AK099XX_MAG_AXIS_ORDER_Y 1 #define AK099XX_MAG_AXIS_ORDER_Z 2 #define AK099XX_MAG_AXIS_SIGN_X 1 /* only 1 or -1 */ #define AK099XX_MAG_AXIS_SIGN_Y 1 /* only 1 or -1 */ #define AK099XX_MAG_AXIS_SIGN_Z 1 /* only 1 or -1 */ #define CONVERT_TO_UGAUSS 1500 /* 0.15uT = 1.5mGauss = 1500uGauss */ #define AKM_DEVICE_NAME AK099XX_DEVICE_NAME #define AKM_LOG(format, ...) LOG("%s %s %s " format, SENSOR_STR, \ AKM_DEVICE_NAME, __func__, \ ## __VA_ARGS__) i2c_dev_t ak09917_dev = { .port = 3, .config.address_width = 8, .config.dev_addr = 0x0C << 1, .config.freq = 100, }; static int16_t drv_mag_akm_ak09917_set_mode( i2c_dev_t *dev, uint8_t mode) { int16_t ret = 0; uint8_t i2c_data = mode; ret = sensor_i2c_write(dev, AK099XX_REG_CNTL2, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } /* reserve for coordinate mapping */ static void drv_mag_akm_ak09917_convert_coordinate(int16_t data[3]) { const int16_t order[3] = {AK099XX_MAG_AXIS_ORDER_X, AK099XX_MAG_AXIS_ORDER_Y, AK099XX_MAG_AXIS_ORDER_Z}; const int16_t sign[3] = {AK099XX_MAG_AXIS_SIGN_X, AK099XX_MAG_AXIS_SIGN_Y, AK099XX_MAG_AXIS_SIGN_Z}; /* only 1 or -1 */ int16_t cvt[3]; int16_t i = 0; for (i = 0; i < 3; i++) { cvt[i] = data[order[i]] * sign[i]; } for (i = 0; i < 3; i++) { data[i] = cvt[i]; } return; } static int drv_mag_akm_ak09917_soft_reset(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data = AK099XX_SOFT_RESET; ret = sensor_i2c_write(dev, AK099XX_REG_CNTL3, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_mag_akm_ak09917_valid_id(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data[2]; uint16_t id = 0; ret = sensor_i2c_read(dev, AK099XX_REG_WIA1, i2c_data, 2, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } id = (uint16_t)(((uint16_t)i2c_data[1] << 8) | i2c_data[0]); if (AK09917D_WIA_VAL != id) { AKM_LOG("invalid device.\n"); return AKM_ERROR; } return 0; } static int drv_mag_akm_ak09917_open(void) { int16_t ret = 0; i2c_dev_t *dev = &ak09917_dev; ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_DEFAULT_MODE); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_mag_akm_ak09917_close(void) { int16_t ret = 0; i2c_dev_t *dev = &ak09917_dev; ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_mag_akm_ak09917_read( void *buf, size_t len) { mag_data_t *mag_data = (mag_data_t *)buf; i2c_dev_t *dev = &ak09917_dev; size_t size; uint8_t i2c_data[AK099XX_BDATA_SIZE]; int16_t raw_lsb[3]; int16_t ret = 0; int16_t i = 0; if (NULL == buf) { return AKM_ERROR; } size = sizeof(mag_data_t); if (len < size) { return AKM_ERROR; } /* Get measurement data from AK09917 * ST1 + (HXH + HXL) + (HYH + HYL) + (HZH + HZL) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (i2c_data[8] & AK099XX_HOFL_BIT) { AKM_LOG("sensor data overflow.\n"); } for (i = 0; i < 3; i++) { raw_lsb[i] = ((int16_t)(i2c_data[i*2 + 1] << 8)) | (uint16_t)i2c_data[i*2 + 2]; } drv_mag_akm_ak09917_convert_coordinate(raw_lsb); for (i = 0; i < 3; i++) { mag_data->data[i] = (raw_lsb[i] * CONVERT_TO_UGAUSS) /1000; } mag_data->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_akm_ak09917_write( const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_mag_akm_ak09917_set_odr( i2c_dev_t *dev, uint32_t odr) { uint8_t mode = 0; int ret; if (odr == AK099XX_SUPPORTED_ODR_POWER_DOWN) { mode = AK099XX_MODE_POWER_DOWN; } else if (odr <= AK099XX_SUPPORTED_ODR_1HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE6; } else if (odr <= AK099XX_SUPPORTED_ODR_10HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE1; } else if (odr <= AK099XX_SUPPORTED_ODR_20HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE2; } else if (odr <= AK099XX_SUPPORTED_ODR_50HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE3; } else if (odr <= AK099XX_SUPPORTED_ODR_100HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE4; } else if (odr <= AK099XX_SUPPORTED_ODR_200HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE5; } else { AKM_LOG("unsupported ODR : %d, set to default mode\n", odr); mode = AK099XX_DEFAULT_MODE; } /* Before set a new mode, the device must be transition to power-down mode. * If the device is already powerdown mode, this command is ignored by * the set_operation function. */ ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } /* Transition to new mode */ ret = drv_mag_akm_ak09917_set_mode(dev, mode); if (unlikely(ret)) { return ret; } return 0; } static void drv_mag_akm_ak09917_get_info(dev_sensor_info_t *info) { info->vendor = DEV_SENSOR_VENDOR_AKM; info->model = AKM_DEVICE_NAME; info->unit = mGauss; info->range_max = AK0991X_MAX_RANGE; info->range_min = AK0991X_MIN_RANGE; return; } static int16_t drv_mag_akm_ak09917_set_default_config(i2c_dev_t *dev) { int16_t ret = 0; ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } ret = drv_mag_akm_ak09917_set_odr(dev, AK099XX_SUPPORTED_ODR_10HZ); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_mag_akm_ak09917_test_data( uint16_t testno, int16_t testdata, int16_t lolimit, int16_t hilimit, int32_t *err) { //AKM_LOG("DBG: FST 0x%08X\n", AKM_FST_ERRCODE(testno, testdata)); if ((lolimit <= testdata) && (testdata <= hilimit)) { return AKM_SUCCESS; } else { *err = AKM_FST_ERRCODE(testno, testdata); return AKM_ERROR; } } int16_t drv_mag_akm_ak09917_self_test( i2c_dev_t *dev, int32_t *result) { int16_t ret; uint8_t i2c_data[AK099XX_BDATA_SIZE]; int16_t xval_i16, yval_i16, zval_i16; int16_t wait_time = 0; uint8_t val; int8_t i = 0; /* initialize arg */ *result = 0; /********************************************************************** * Step 1 **********************************************************************/ /* Soft Reset */ ret = drv_mag_akm_ak09917_soft_reset(dev); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_RST, ret); goto SELFTEST_FAIL; } /* Wait over 1 ms */ aos_msleep(2); /* Read values. */ ret = sensor_i2c_read(dev, AK099XX_REG_WIA1, i2c_data, 2, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_RST_READ, ret); goto SELFTEST_FAIL; } AKM_FST(TLIMIT_NO_RST_WIA1, i2c_data[0], TLIMIT_LO_RST_WIA1, TLIMIT_HI_RST_WIA1, result); AKM_FST(TLIMIT_NO_RST_WIA2, i2c_data[1], TLIMIT_LO_RST_WIA2, TLIMIT_HI_RST_WIA2, result); /********************************************************************** * Step 2 **********************************************************************/ /* Set to CNT measurement 50Hz pattern. */ ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_CONT_MEASURE_MODE3); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_CNT_CNTL2, ret); goto SELFTEST_FAIL; } aos_msleep(1); /* Current test program sets to MODE3, i.e. 50Hz=20msec interval * so, wait for double length of measurement time. */ wait_time = (1000 / AK099XX_SUPPORTED_ODR_50HZ); for (i = 0; i < TLIMIT_NO_CNT_ITRT; i++) { aos_msleep(wait_time * 2); /* Get measurement data from AK09917 * ST1 + (HXH + HXL) + (HYH + HYL) + (HZH + HZL) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_CNT_READ, ret); goto SELFTEST_FAIL; } val = i2c_data[0] & AK099XX_DRDY_BIT; AKM_FST(TLIMIT_NO_CNT_1ST, val, TLIMIT_LO_CNT_1ST, TLIMIT_HI_CNT_1ST, result); /* Get measurement data from AK09917 * ST1 + (HXH + HXL) + (HYH + HYL) + (HZH + HZL) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_CNT_READ, ret); goto SELFTEST_FAIL; } val = i2c_data[0] & AK099XX_DRDY_BIT; AKM_FST(TLIMIT_NO_CNT_2ND, val, TLIMIT_LO_CNT_2ND, TLIMIT_HI_CNT_2ND, result); } /********************************************************************** * Step 3 **********************************************************************/ ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_CNTL2, ret); goto SELFTEST_FAIL; } aos_msleep(1); /* Set to SNG measurement pattern. */ ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_SNG_MEASURE); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_CNTL2, ret); goto SELFTEST_FAIL; } /* Wait for single measurement. */ aos_msleep(MEASURE_WAIT_TIME); /* Get measurement data from AK09917 * ST1 + (HXH + HXL) + (HYH + HYL) + (HZH + HZL) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_WAIT, ret); goto SELFTEST_FAIL; } /* Convert to 16-bit integer value. */ xval_i16 = (int16_t)(((uint16_t)i2c_data[1] << 8) | (uint16_t)i2c_data[2]); yval_i16 = (int16_t)(((uint16_t)i2c_data[3] << 8) | (uint16_t)i2c_data[4]); zval_i16 = (int16_t)(((uint16_t)i2c_data[5] << 8) | (uint16_t)i2c_data[6]); AKM_FST(TLIMIT_NO_SNG_ST1, i2c_data[0], TLIMIT_LO_SNG_ST1, TLIMIT_HI_SNG_ST1, result); AKM_FST(TLIMIT_NO_SNG_HX, xval_i16, TLIMIT_LO_SNG_HX, TLIMIT_HI_SNG_HX, result); AKM_FST(TLIMIT_NO_SNG_HY, yval_i16, TLIMIT_LO_SNG_HY, TLIMIT_HI_SNG_HY, result); AKM_FST(TLIMIT_NO_SNG_HZ, zval_i16, TLIMIT_LO_SNG_HZ, TLIMIT_HI_SNG_HZ, result); AKM_FST(TLIMIT_NO_SNG_ST2, (i2c_data[8] & TLIMIT_ST2_MASK), TLIMIT_LO_SNG_ST2, TLIMIT_HI_SNG_ST2, result); /* Set to self-test mode. */ ret = drv_mag_akm_ak09917_set_mode(dev, AK099XX_MODE_SELF_TEST); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SLF_CNTL2, ret); goto SELFTEST_FAIL; } /* Wait for self test measurement. */ aos_msleep(MEASURE_WAIT_TIME); /* * Get measurement data from AK09917 * ST1 + (HXH + HXL) + (HYH + HYL) + (HZH + HZL) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_WAIT, ret); goto SELFTEST_FAIL; } /* Convert to 16-bit integer value. */ xval_i16 = (int16_t)(((uint16_t)i2c_data[1] << 8) | (uint16_t)i2c_data[2]); yval_i16 = (int16_t)(((uint16_t)i2c_data[3] << 8) | (uint16_t)i2c_data[4]); zval_i16 = (int16_t)(((uint16_t)i2c_data[5] << 8) | (uint16_t)i2c_data[6]); AKM_FST(TLIMIT_NO_SLF_ST1, i2c_data[0], TLIMIT_LO_SLF_ST1, TLIMIT_HI_SLF_ST1, result); AKM_FST(TLIMIT_NO_SLF_RVHX, xval_i16, TLIMIT_LO_SLF_RVHX, TLIMIT_HI_SLF_RVHX, result); AKM_FST(TLIMIT_NO_SLF_RVHY, yval_i16, TLIMIT_LO_SLF_RVHY, TLIMIT_HI_SLF_RVHY, result); AKM_FST(TLIMIT_NO_SLF_RVHZ, zval_i16, TLIMIT_LO_SLF_RVHZ, TLIMIT_HI_SLF_RVHZ, result); AKM_FST(TLIMIT_NO_SLF_ST2, (i2c_data[8] & TLIMIT_ST2_MASK), TLIMIT_LO_SLF_ST2, TLIMIT_HI_SLF_ST2, result); AKM_LOG("self test success"); return AKM_SUCCESS; SELFTEST_FAIL: AKM_LOG("self test failed result = 0x%x", *result); return AKM_ERROR; } int drv_mag_akm_ak09917_ioctl( int cmd, unsigned long arg) { int ret = 0; //int32_t self_test_result = 0; dev_sensor_info_t *info = (dev_sensor_info_t *) arg; switch (cmd) { case SENSOR_IOCTL_ODR_SET: ret = drv_mag_akm_ak09917_set_odr(&ak09917_dev, (int)arg); if (unlikely(ret)) { return AKM_ERROR; } break; case SENSOR_IOCTL_RANGE_SET: break; case SENSOR_IOCTL_GET_INFO: drv_mag_akm_ak09917_get_info(info); break; case SENSOR_IOCTL_BIST_PROCESS: break; case SENSOR_IOCTL_WHO_AM_I: break; case SENSOR_IOCTL_SET_POWER: break; case SENSOR_IOCTL_GET_SENSOR_LIST: break; case SENSOR_IOCTL_DTC_CYCLE_SET: break; /*case SENSOR_IOCTL_SELF_TEST: ret = drv_mag_akm_ak09917_self_test(&ak09917_dev, &self_test_result); return ret;*/ default: break; } return ret; } int drv_mag_akm_ak09917_init(void) { int16_t ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.io_port = I2C_PORT; sensor.open = drv_mag_akm_ak09917_open; sensor.close = drv_mag_akm_ak09917_close; sensor.read = drv_mag_akm_ak09917_read; sensor.write = drv_mag_akm_ak09917_write; sensor.ioctl = drv_mag_akm_ak09917_ioctl; sensor.irq_handle = NULL; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09917_valid_id(&ak09917_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09917_soft_reset(&ak09917_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09917_set_default_config(&ak09917_dev); if (unlikely(ret)) { return (int)ret; } AKM_LOG("successfully.\n"); return (int)ret; } SENSOR_DRV_ADD(drv_mag_akm_ak09917_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_akm_ak09917.c
C
apache-2.0
20,469
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include <aos/kernel.h> #include "sensor_drv_api.h" #include "sensor_hal.h" #define AK099XX_REG_WIA1 0x00 #define AK099XX_REG_WIA2 0x01 #define AK099XX_REG_INFO1 0x02 #define AK099XX_REG_INFO2 0x03 #define AK099XX_REG_ST1 0x10 #define AK099XX_REG_HXL 0x11 #define AK099XX_REG_HXH 0x12 #define AK099XX_REG_HYL 0x13 #define AK099XX_REG_HYH 0x14 #define AK099XX_REG_HZL 0x15 #define AK099XX_REG_HZH 0x16 #define AK099XX_REG_TMPS 0x17 #define AK099XX_REG_ST2 0x18 #define AK099XX_REG_CNTL1 0x30 #define AK099XX_REG_CNTL2 0x31 #define AK099XX_REG_CNTL3 0x32 #define AK099XX_FUSE_ASAX 0x60 #define AK099XX_FUSE_ASAY 0x61 #define AK099XX_FUSE_ASAZ 0x62 #define AK099XX_BDATA_SIZE 9 #define AK099XX_MODE_SNG_MEASURE 0x01 #define AK099XX_MODE_CONT_MEASURE_MODE1 0x02 #define AK099XX_MODE_CONT_MEASURE_MODE2 0x04 #define AK099XX_MODE_CONT_MEASURE_MODE3 0x06 #define AK099XX_MODE_CONT_MEASURE_MODE4 0x08 #define AK099XX_MODE_CONT_MEASURE_MODE5 0x0A #define AK099XX_MODE_CONT_MEASURE_MODE6 0x0C #define AK099XX_MODE_SELF_TEST 0x10 #define AK099XX_MODE_FUSE_ACCESS 0x1F #define AK099XX_MODE_POWER_DOWN 0x00 #define AK099XX_SOFT_RESET 0x01 #define AK099XX_SUPPORTED_ODR_POWER_DOWN 0 #define AK099XX_SUPPORTED_ODR_10HZ 10 #define AK099XX_SUPPORTED_ODR_20HZ 20 #define AK099XX_SUPPORTED_ODR_50HZ 50 #define AK099XX_SUPPORTED_ODR_100HZ 100 /* AKM Magnetic sensor overflow bit mask */ #define AK099XX_HOFL_BIT 0x08 #define AK0991X_DRDY_BIT 0x01 #define AK09911_WIA_VAL 0x548 #define AK09912_WIA_VAL 0x448 #define AK09913_WIA_VAL 0x848 #define AK09915_WIA_VAL 0x1048 #define AK09916C_WIA_VAL 0x948 #define AK09916D_WIA_VAL 0xB48 #define AK09918_WIA_VAL 0xC48 #define AK09918_DEVICE_NAME "AK09918C" /***************************************************************/ /* AK09918 self test releted */ #define TLIMIT_NO_RST 0x101 #define TLIMIT_NO_RST_READ 0x102 #define TLIMIT_NO_RST_WIA1 0x103 #define TLIMIT_LO_RST_WIA1 0x48 #define TLIMIT_HI_RST_WIA1 0x48 #define TLIMIT_NO_RST_WIA2 0x104 #define TLIMIT_LO_RST_WIA2 0x0c #define TLIMIT_HI_RST_WIA2 0x0c #define TLIMIT_NO_CNT_ITRT 3 #define TLIMIT_NO_CNT_CNTL2 0x201 #define TLIMIT_NO_CNT_WAIT 0x202 #define TLIMIT_NO_CNT_READ 0x203 #define TLIMIT_NO_CNT_1ST 0x204 #define TLIMIT_LO_CNT_1ST 1 #define TLIMIT_HI_CNT_1ST 1 #define TLIMIT_NO_CNT_2ND 0x205 #define TLIMIT_LO_CNT_2ND 0 #define TLIMIT_HI_CNT_2ND 0 #define TLIMIT_NO_SNG_CNTL2 0x301 #define TLIMIT_NO_SNG_WAIT 0x302 #define TLIMIT_NO_SNG_ST1 0x303 #define TLIMIT_LO_SNG_ST1 1 #define TLIMIT_HI_SNG_ST1 1 #define TLIMIT_NO_SNG_HX 0x304 #define TLIMIT_LO_SNG_HX -32751 #define TLIMIT_HI_SNG_HX 32751 #define TLIMIT_NO_SNG_HY 0x306 #define TLIMIT_LO_SNG_HY -32751 #define TLIMIT_HI_SNG_HY 32751 #define TLIMIT_NO_SNG_HZ 0x308 #define TLIMIT_LO_SNG_HZ -32751 #define TLIMIT_HI_SNG_HZ 32751 /* Only MASKED bit of ST2 register is evaluated */ #define TLIMIT_NO_SNG_ST2 0x30A #define TLIMIT_LO_SNG_ST2 0 #define TLIMIT_HI_SNG_ST2 0 #define TLIMIT_ST2_MASK 0x08 #define TLIMIT_NO_SLF_CNTL2 0x30B #define TLIMIT_NO_SLF_WAIT 0x30C #define TLIMIT_NO_SLF_ST1 0x30D #define TLIMIT_LO_SLF_ST1 1 #define TLIMIT_HI_SLF_ST1 1 #define TLIMIT_NO_SLF_RVHX 0x30E #define TLIMIT_LO_SLF_RVHX -200 #define TLIMIT_HI_SLF_RVHX 200 #define TLIMIT_NO_SLF_RVHY 0x310 #define TLIMIT_LO_SLF_RVHY -200 #define TLIMIT_HI_SLF_RVHY 200 #define TLIMIT_NO_SLF_RVHZ 0x312 #define TLIMIT_LO_SLF_RVHZ -1000 #define TLIMIT_HI_SLF_RVHZ -200 #define TLIMIT_NO_SLF_ST2 0x314 #define TLIMIT_LO_SLF_ST2 0 #define TLIMIT_HI_SLF_ST2 0 #define AKM_FST_ERRCODE(testno, data) \ (int32_t)((((uint32_t)testno) << 16) | ((uint16_t)data)) #define AKM_FST(no, data, lo, hi, err) \ if (drv_mag_akm_ak09918_test_data((no), (data), (lo), (hi), \ (err)) != AKM_SUCCESS) \ { goto SELFTEST_FAIL; } /***************************************************************/ #define AKM_SUCCESS (0) #define AKM_ERROR (-1) #define MEASURE_WAIT_TIME (20) #define AK0991X_MAX_RANGE 49120000 /* 4912uT */ #define AK0991X_MIN_RANGE -49120000 /* -4912uT */ #define AK099XX_DEFAULT_MODE AK099XX_MODE_CONT_MEASURE_MODE1 /* Default 10Hz */ #define AK099XX_MAG_AXIS_ORDER_X 0 #define AK099XX_MAG_AXIS_ORDER_Y 1 #define AK099XX_MAG_AXIS_ORDER_Z 2 #define AK099XX_MAG_AXIS_SIGN_X 1 /* only 1 or -1 */ #define AK099XX_MAG_AXIS_SIGN_Y 1 /* only 1 or -1 */ #define AK099XX_MAG_AXIS_SIGN_Z 1 /* only 1 or -1 */ #define CONVERT_TO_UGAUSS 1500 /* 0.15uT = 1.5mGauss = 1500uGauss */ #define AKM_DEVICE_NAME AK09918_DEVICE_NAME #define AKM_LOG(format, ...) LOG("%s %s %s " format, SENSOR_STR, \ AKM_DEVICE_NAME, __func__, \ ## __VA_ARGS__) i2c_dev_t ak09918_dev = { .port = 3, .config.address_width = 8, .config.dev_addr = 0x0C << 1, .config.freq = 100, }; static int16_t drv_mag_akm_ak09918_set_mode( i2c_dev_t *dev, const uint8_t mode) { int16_t ret = 0; uint8_t i2c_data = mode; ret = sensor_i2c_write(dev, AK099XX_REG_CNTL2, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } /* reserve for coordinate mapping */ static void drv_mag_akm_ak09918_convert_coordinate(int16_t data[3]) { const int16_t order[3] = {AK099XX_MAG_AXIS_ORDER_X, AK099XX_MAG_AXIS_ORDER_Y, AK099XX_MAG_AXIS_ORDER_Z}; const int16_t sign[3] = {AK099XX_MAG_AXIS_SIGN_X, AK099XX_MAG_AXIS_SIGN_Y, AK099XX_MAG_AXIS_SIGN_Z}; /* only 1 or -1 */ int16_t cvt[3]; int16_t i = 0; for (i = 0; i < 3; i++) { cvt[i] = data[order[i]] * sign[i]; } for (i = 0; i < 3; i++) { data[i] = cvt[i]; } return; } static int drv_mag_akm_ak09918_soft_reset(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data = AK099XX_SOFT_RESET; ret = sensor_i2c_write(dev, AK099XX_REG_CNTL3, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_mag_akm_ak09918_valid_id(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data[2]; uint16_t id = 0; ret = sensor_i2c_read(dev, AK099XX_REG_WIA1, i2c_data, 2, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } id = (uint16_t)(((uint16_t)i2c_data[1] << 8) | i2c_data[0]); if (AK09918_WIA_VAL != id) { AKM_LOG("invalid device.\n"); return AKM_ERROR; } return 0; } static int drv_mag_akm_ak09918_open(void) { int16_t ret = 0; i2c_dev_t *dev = &ak09918_dev; ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_DEFAULT_MODE); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_mag_akm_ak09918_close(void) { int16_t ret = 0; i2c_dev_t *dev = &ak09918_dev; ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_mag_akm_ak09918_read( void *buf, size_t len) { mag_data_t *mag_data = (mag_data_t *)buf; i2c_dev_t *dev = &ak09918_dev; size_t size; uint8_t i2c_data[AK099XX_BDATA_SIZE]; int16_t raw_lsb[3]; int16_t ret = 0; int16_t i = 0; if (NULL == buf) { return AKM_ERROR; } size = sizeof(mag_data_t); if (len < size) { return AKM_ERROR; } /* Get measurement data from AK09918 * ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (i2c_data[8] & AK099XX_HOFL_BIT) { AKM_LOG("sensor data overflow.\n"); } for (i = 0; i < 3; i++) { raw_lsb[i] = (int16_t)(i2c_data[i*2 + 1] | (((uint16_t)i2c_data[i*2 + 2]) << 8)); } drv_mag_akm_ak09918_convert_coordinate(raw_lsb); for (i = 0; i < 3; i++) { mag_data->data[i] = (raw_lsb[i] * CONVERT_TO_UGAUSS)/1000; } mag_data->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_akm_ak09918_write( const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int16_t drv_mag_akm_ak09918_set_odr( i2c_dev_t *dev, const uint32_t odr) { uint8_t mode = 0; int16_t ret; if (odr == AK099XX_SUPPORTED_ODR_POWER_DOWN) { mode = AK099XX_MODE_POWER_DOWN; } else if (odr <= AK099XX_SUPPORTED_ODR_10HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE1; } else if (odr <= AK099XX_SUPPORTED_ODR_20HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE2; } else if (odr <= AK099XX_SUPPORTED_ODR_50HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE3; } else if (odr <= AK099XX_SUPPORTED_ODR_100HZ) { mode = AK099XX_MODE_CONT_MEASURE_MODE4; } else { AKM_LOG("unsupported ODR : %d, set to default mode\n", odr); mode = AK099XX_DEFAULT_MODE; } /* Before set a new mode, the device must be transition to power-down mode. * If the device is already powerdown mode, this command is ignored by * the set_operation function. */ ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } /* Transition to new mode */ ret = drv_mag_akm_ak09918_set_mode(dev, mode); if (unlikely(ret)) { return ret; } return 0; } static void drv_mag_akm_ak09918_get_info(dev_sensor_info_t *info) { info->vendor = DEV_SENSOR_VENDOR_AKM; info->model = AKM_DEVICE_NAME; info->unit = mGauss; info->range_max = AK0991X_MAX_RANGE; info->range_min = AK0991X_MIN_RANGE; return; } static int16_t drv_mag_akm_ak09918_set_default_config(i2c_dev_t *dev) { int16_t ret = 0; ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } ret = drv_mag_akm_ak09918_set_odr(dev, AK099XX_SUPPORTED_ODR_10HZ); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_mag_akm_ak09918_test_data( uint16_t testno, int16_t testdata, int16_t lolimit, int16_t hilimit, int32_t *err) { //AKM_LOG("DBG: FST 0x%08X\n", AKM_FST_ERRCODE(testno, testdata)); if ((lolimit <= testdata) && (testdata <= hilimit)) { return AKM_SUCCESS; } else { *err = AKM_FST_ERRCODE(testno, testdata); return AKM_ERROR; } } int16_t drv_mag_akm_ak09918_self_test( i2c_dev_t *dev, int32_t *result) { int16_t ret; uint8_t i2c_data[AK099XX_BDATA_SIZE]; int16_t xval_i16, yval_i16, zval_i16; int16_t wait_time = 0; uint8_t val; int8_t i = 0; /* initialize arg */ *result = 0; /********************************************************************** * Step 1 **********************************************************************/ /* Soft Reset */ ret = drv_mag_akm_ak09918_soft_reset(dev); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_RST, ret); goto SELFTEST_FAIL; } /* Wait over 1 ms */ aos_msleep(2); /* Read values. */ ret = sensor_i2c_read(dev, AK099XX_REG_WIA1, i2c_data, 2, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_RST_READ, ret); goto SELFTEST_FAIL; } AKM_FST(TLIMIT_NO_RST_WIA1, i2c_data[0], TLIMIT_LO_RST_WIA1, TLIMIT_HI_RST_WIA1, result); AKM_FST(TLIMIT_NO_RST_WIA2, i2c_data[1], TLIMIT_LO_RST_WIA2, TLIMIT_HI_RST_WIA2, result); /********************************************************************** * Step 2 **********************************************************************/ /* Set to CNT measurement 50Hz pattern. */ ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_CONT_MEASURE_MODE3); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_CNT_CNTL2, ret); goto SELFTEST_FAIL; } aos_msleep(1); /* Current test program sets to MODE3, i.e. 50Hz=20msec interval * so, wait for double length of measurement time. */ wait_time = (1000 / AK099XX_SUPPORTED_ODR_50HZ); for (i = 0; i < TLIMIT_NO_CNT_ITRT; i++) { aos_msleep(wait_time * 2); /* Get measurement data from AK09918 * ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_CNT_READ, ret); goto SELFTEST_FAIL; } val = i2c_data[0] & AK0991X_DRDY_BIT; AKM_FST(TLIMIT_NO_CNT_1ST, val, TLIMIT_LO_CNT_1ST, TLIMIT_HI_CNT_1ST, result); /* Get measurement data from AK09918 * ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_CNT_READ, ret); goto SELFTEST_FAIL; } val = i2c_data[0] & AK0991X_DRDY_BIT; AKM_FST(TLIMIT_NO_CNT_2ND, val, TLIMIT_LO_CNT_2ND, TLIMIT_HI_CNT_2ND, result); } /********************************************************************** * Step 3 **********************************************************************/ ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_CNTL2, ret); goto SELFTEST_FAIL; } aos_msleep(1); /* Set to SNG measurement pattern. */ ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_SNG_MEASURE); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_CNTL2, ret); goto SELFTEST_FAIL; } /* Wait for single measurement. */ aos_msleep(MEASURE_WAIT_TIME); /* Get measurement data from AK09918 * ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_WAIT, ret); goto SELFTEST_FAIL; } /* Convert to 16-bit integer value. */ xval_i16 = (int16_t)(((uint16_t)i2c_data[1]) | ((uint16_t)i2c_data[2] << 8)); yval_i16 = (int16_t)(((uint16_t)i2c_data[3]) | ((uint16_t)i2c_data[4] << 8)); zval_i16 = (int16_t)(((uint16_t)i2c_data[5]) | ((uint16_t)i2c_data[6] << 8)); AKM_FST(TLIMIT_NO_SNG_ST1, i2c_data[0], TLIMIT_LO_SNG_ST1, TLIMIT_HI_SNG_ST1, result); AKM_FST(TLIMIT_NO_SNG_HX, xval_i16, TLIMIT_LO_SNG_HX, TLIMIT_HI_SNG_HX, result); AKM_FST(TLIMIT_NO_SNG_HY, yval_i16, TLIMIT_LO_SNG_HY, TLIMIT_HI_SNG_HY, result); AKM_FST(TLIMIT_NO_SNG_HZ, zval_i16, TLIMIT_LO_SNG_HZ, TLIMIT_HI_SNG_HZ, result); AKM_FST(TLIMIT_NO_SNG_ST2, (i2c_data[8] & TLIMIT_ST2_MASK), TLIMIT_LO_SNG_ST2, TLIMIT_HI_SNG_ST2, result); /* Set to self-test mode. */ ret = drv_mag_akm_ak09918_set_mode(dev, AK099XX_MODE_SELF_TEST); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SLF_CNTL2, ret); goto SELFTEST_FAIL; } /* Wait for self test measurement. */ aos_msleep(MEASURE_WAIT_TIME); /* * Get measurement data from AK09918 * ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TMPS + ST2 = 9bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { *result = AKM_FST_ERRCODE(TLIMIT_NO_SNG_WAIT, ret); goto SELFTEST_FAIL; } /* Convert to 16-bit integer value. */ xval_i16 = (int16_t)(((uint16_t)i2c_data[1]) | ((uint16_t)i2c_data[2] << 8)); yval_i16 = (int16_t)(((uint16_t)i2c_data[3]) | ((uint16_t)i2c_data[4] << 8)); zval_i16 = (int16_t)(((uint16_t)i2c_data[5]) | ((uint16_t)i2c_data[6] << 8)); AKM_FST(TLIMIT_NO_SLF_ST1, i2c_data[0], TLIMIT_LO_SLF_ST1, TLIMIT_HI_SLF_ST1, result); AKM_FST(TLIMIT_NO_SLF_RVHX, xval_i16, TLIMIT_LO_SLF_RVHX, TLIMIT_HI_SLF_RVHX, result); AKM_FST(TLIMIT_NO_SLF_RVHY, yval_i16, TLIMIT_LO_SLF_RVHY, TLIMIT_HI_SLF_RVHY, result); AKM_FST(TLIMIT_NO_SLF_RVHZ, zval_i16, TLIMIT_LO_SLF_RVHZ, TLIMIT_HI_SLF_RVHZ, result); AKM_FST(TLIMIT_NO_SLF_ST2, (i2c_data[8] & TLIMIT_ST2_MASK), TLIMIT_LO_SLF_ST2, TLIMIT_HI_SLF_ST2, result); AKM_LOG("self test success"); return AKM_SUCCESS; SELFTEST_FAIL: AKM_LOG("self test failed result = 0x%x", *result); return AKM_ERROR; } int drv_mag_akm_ak09918_ioctl( int cmd, unsigned long arg) { int ret = 0; //int32_t self_test_result = 0; dev_sensor_info_t *info = (dev_sensor_info_t *) arg; switch (cmd) { case SENSOR_IOCTL_ODR_SET: ret = drv_mag_akm_ak09918_set_odr(&ak09918_dev, (int)arg); if (unlikely(ret)) { return AKM_ERROR; } break; case SENSOR_IOCTL_RANGE_SET: break; case SENSOR_IOCTL_GET_INFO: drv_mag_akm_ak09918_get_info(info); break; case SENSOR_IOCTL_BIST_PROCESS: break; case SENSOR_IOCTL_WHO_AM_I: break; case SENSOR_IOCTL_SET_POWER: break; case SENSOR_IOCTL_GET_SENSOR_LIST: break; case SENSOR_IOCTL_DTC_CYCLE_SET: break; /*case SENSOR_IOCTL_SELF_TEST: ret = drv_mag_akm_ak09918_self_test(&ak09918_dev, &self_test_result); return ret;*/ default: break; } return ret; } int drv_mag_akm_ak09918_init(void) { int16_t ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.io_port = I2C_PORT; sensor.open = drv_mag_akm_ak09918_open; sensor.close = drv_mag_akm_ak09918_close; sensor.read = drv_mag_akm_ak09918_read; sensor.write = drv_mag_akm_ak09918_write; sensor.ioctl = drv_mag_akm_ak09918_ioctl; sensor.irq_handle = NULL; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09918_valid_id(&ak09918_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09918_soft_reset(&ak09918_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09918_set_default_config(&ak09918_dev); if (unlikely(ret)) { return (int)ret; } AKM_LOG("successfully.\n"); return (int)ret; } SENSOR_DRV_ADD(drv_mag_akm_ak09918_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_akm_ak09918.c
C
apache-2.0
20,106
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include <aos/kernel.h> #include "sensor_drv_api.h" #include "sensor_hal.h" #define AK099XX_REG_WIA1 0x00 #define AK099XX_REG_WIA2 0x01 #define AK099XX_REG_RSV1 0x02 #define AK099XX_REG_RSV2 0x03 #define AK099XX_REG_ST1 0x10 #define AK099XX_REG_HXL 0x11 #define AK099XX_REG_HXM 0x12 #define AK099XX_REG_HXH 0x13 #define AK099XX_REG_HYL 0x14 #define AK099XX_REG_HYM 0x15 #define AK099XX_REG_HYH 0x16 #define AK099XX_REG_HZL 0x17 #define AK099XX_REG_HZM 0x18 #define AK099XX_REG_HZH 0x19 #define AK099XX_REG_TMPS 0x1A #define AK099XX_REG_ST2 0x1B #define AK099XX_REG_CNTL1 0x30 #define AK099XX_REG_CNTL2 0x31 #define AK099XX_REG_CNTL3 0x32 #define AK099XX_REG_CNTL4 0x33 #define AK099XX_REG_I2C_DIS 0x36 #define AK099XX_REG_TS 0x37 #define AK099XX_BDATA_SIZE 12 #define AK099XX_TEM_ENABLE 0x40 #define AK099XX_MODE_POWER_DOWN 0x00 #define AK099XX_MODE_SNG_MEASURE 0x01 #define AK099XX_MODE_CONT_MEASURE_MODE1 0x02 #define AK099XX_MODE_CONT_MEASURE_MODE2 0x04 #define AK099XX_MODE_CONT_MEASURE_MODE3 0x06 #define AK099XX_MODE_CONT_MEASURE_MODE4 0x08 #define AK099XX_MODE_CONT_MEASURE_MODE5 0x0A #define AK099XX_MODE_CONT_MEASURE_MODE6 0x0C #define AK099XX_MODE_SELF_TEST 0x10 #define AK099XX_MODE_FIFO_ENABLE 0x80 #define AK099XX_LOW_POWER_DRIVE_1 0x00 #define AK099XX_LOW_POWER_DRIVE_2 0x20 #define AK099XX_LOW_NOISE_DRIVE_1 0x40 #define AK099XX_LOW_NOISE_DRIVE_2 0x60 #define AK099XX_SOFT_RESET 0x01 #define AK099XX_I2C_DIS 0x1D #define AK099XX_DRDY_BIT 0x01 #define AK099XX_VAL_OVERFLOW 0x1FFFF /* * Refer to spec 11.3.4. * HXH, HYH, HZH only use 2 bits (include sign bit); * In order to set the sign bit with using 32 bits integer, * need to shift each byte 14 bits left to compose and shift back the composed value */ #define AK09940_SIGN_SHIFT 14 #define AK09940_H_SHIFT (16 + AK09940_SIGN_SHIFT) #define AK09940_M_SHIFT (8 + AK09940_SIGN_SHIFT) #define AK09940_L_SHIFT (AK09940_SIGN_SHIFT) /* DOR bit in ST2 */ #define AK099XX_DOR_BIT 0x01 /* Invalid fifo data bit in ST2 */ #define AK099XX_INV_FIFO_DATA 0x02 #define AK099XX_SUPPORTED_ODR_POWER_DOWN 0 #define AK099XX_SUPPORTED_ODR_10HZ 10 #define AK099XX_SUPPORTED_ODR_20HZ 20 #define AK099XX_SUPPORTED_ODR_50HZ 50 #define AK099XX_SUPPORTED_ODR_100HZ 100 #define AK099XX_SUPPORTED_ODR_200HZ 200 #define AK099XX_SUPPORTED_ODR_400HZ 400 #define AK09940_WIA_VAL 0xA148 #define AK099XX_DEVICE_NAME "AK09940" /***************************************************************/ /* AK09940 self test releted */ #define TLIMIT_NO_RST 0x101 #define TLIMIT_NO_RST_READ 0x102 #define TLIMIT_NO_RST_WIA1 0x103 #define TLIMIT_LO_RST_WIA1 0x48 #define TLIMIT_HI_RST_WIA1 0x48 #define TLIMIT_NO_RST_WIA2 0x104 #define TLIMIT_LO_RST_WIA2 0xA1 #define TLIMIT_HI_RST_WIA2 0xA1 #define TLIMIT_NO_CNT_ITRT 3 #define TLIMIT_NO_CNT_CNTL2 0x201 #define TLIMIT_NO_CNT_WAIT 0x202 #define TLIMIT_NO_CNT_READ 0x203 #define TLIMIT_NO_CNT_1ST 0x204 #define TLIMIT_LO_CNT_1ST 1 #define TLIMIT_HI_CNT_1ST 1 #define TLIMIT_NO_CNT_2ND 0x205 #define TLIMIT_LO_CNT_2ND 0 #define TLIMIT_HI_CNT_2ND 0 #define TLIMIT_CNT_PWD 0x206 #define TLIMIT_NO_SNG_CNTL2 0x301 #define TLIMIT_NO_SNG_WAIT 0x302 #define TLIMIT_NO_SNG_ST1 0x303 #define TLIMIT_LO_SNG_ST1 1 #define TLIMIT_HI_SNG_ST1 1 #define TLIMIT_NO_SNG_HX 0x304 #define TLIMIT_LO_SNG_HX -131072 #define TLIMIT_HI_SNG_HX 131070 #define TLIMIT_NO_SNG_HY 0x306 #define TLIMIT_LO_SNG_HY -131072 #define TLIMIT_HI_SNG_HY 131070 #define TLIMIT_NO_SNG_HZ 0x308 #define TLIMIT_LO_SNG_HZ -131072 #define TLIMIT_HI_SNG_HZ 131070 /* Only MASKED bit of ST2 register is evaluated */ #define TLIMIT_NO_SNG_ST2 0x30A #define TLIMIT_LO_SNG_ST2 0 #define TLIMIT_HI_SNG_ST2 0 #define TLIMIT_ST2_MASK 0x03 #define TLIMIT_NO_SLF_CNTL2 0x30B #define TLIMIT_NO_SLF_WAIT 0x30C #define TLIMIT_NO_SLF_ST1 0x30D #define TLIMIT_LO_SLF_ST1 1 #define TLIMIT_HI_SLF_ST1 1 #define TLIMIT_NO_SLF_RVHX 0x30E #define TLIMIT_LO_SLF_RVHX -30000 //TBD #define TLIMIT_HI_SLF_RVHX 30000 //TBD #define TLIMIT_NO_SLF_RVHY 0x310 #define TLIMIT_LO_SLF_RVHY -30000 //TBD #define TLIMIT_HI_SLF_RVHY 30000 //TBD #define TLIMIT_NO_SLF_RVHZ 0x312 #define TLIMIT_LO_SLF_RVHZ -150000 //TBD #define TLIMIT_HI_SLF_RVHZ 30000 //TBD #define TLIMIT_NO_SLF_ST2 0x314 #define TLIMIT_LO_SLF_ST2 0 #define TLIMIT_HI_SLF_ST2 0 #define AKM_FST(no, data, lo, hi, err) \ if (drv_mag_akm_ak09940_test_data((no), (data), (lo), (hi), \ (err)) != AKM_SUCCESS) \ { goto SELFTEST_FAIL; } /***************************************************************/ #define AKM_SUCCESS (0) #define AKM_ERROR (-1) #define MEASURE_WAIT_TIME (20) #define AK09940_MAX_RANGE 12000000 /* 12000000uG = 12000mG = 1200uT */ #define AK09940_MIN_RANGE -12000000 /* -12000000uG = -12000mG = -1200uT */ #define AK099XX_DEFAULT_MODE (AK099XX_MODE_CONT_MEASURE_MODE1 | AK099XX_LOW_NOISE_DRIVE_2) /* Default 10Hz and low noise drive 2 */ #define AK099XX_MAG_AXIS_ORDER_X 0 #define AK099XX_MAG_AXIS_ORDER_Y 1 #define AK099XX_MAG_AXIS_ORDER_Z 2 #define AK099XX_MAG_AXIS_SIGN_X 1 /* only 1 or -1 */ #define AK099XX_MAG_AXIS_SIGN_Y 1 /* only 1 or -1 */ #define AK099XX_MAG_AXIS_SIGN_Z 1 /* only 1 or -1 */ #define CONVERT_TO_UGAUSS 100 /* 10nT = 0.01uT = 0.1mGauss = 100uGauss */ #define AKM_DEVICE_NAME AK099XX_DEVICE_NAME #define AKM_LOG(format, ...) LOG("%s %s %s " format, SENSOR_STR, \ AKM_DEVICE_NAME, __func__, \ ## __VA_ARGS__) i2c_dev_t ak09940_dev = { .port = 3, .config.address_width = 8, .config.dev_addr = 0x0C << 1, .config.freq = 100, }; static int16_t drv_mag_akm_ak09940_set_wm( i2c_dev_t *dev, uint8_t wm) { int16_t ret; // Set water mark ret = sensor_i2c_write(dev, AK099XX_REG_CNTL2, &wm, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } static int drv_mag_akm_ak09940_set_mode( i2c_dev_t *dev, const uint8_t mode) { int ret = 0; uint8_t wm = 0x00; uint8_t temp_enable = AK099XX_TEM_ENABLE; uint8_t i2c_data = mode; // FIFO function will be supported in the future. drv_mag_akm_ak09940_set_wm(dev, wm); // Enable temperature measurement ret = sensor_i2c_write(dev, AK099XX_REG_CNTL2, &temp_enable, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_write(dev, AK099XX_REG_CNTL3, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } /* reserve for coordinate mapping */ static void drv_mag_akm_ak09940_convert_coordinate(int32_t data[3]) { const int32_t order[3] = {AK099XX_MAG_AXIS_ORDER_X, AK099XX_MAG_AXIS_ORDER_Y, AK099XX_MAG_AXIS_ORDER_Z}; const int32_t sign[3] = {AK099XX_MAG_AXIS_SIGN_X, AK099XX_MAG_AXIS_SIGN_Y, AK099XX_MAG_AXIS_SIGN_Z}; /* only 1 or -1 */ int32_t cvt[3]; int16_t i = 0; for (i = 0; i < 3; i++) { cvt[i] = data[order[i]] * sign[i]; } for (i = 0; i < 3; i++) { data[i] = cvt[i]; } return; } static int drv_mag_akm_ak09940_soft_reset(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data = AK099XX_SOFT_RESET; ret = sensor_i2c_write(dev, AK099XX_REG_CNTL4, &i2c_data, 1, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_mag_akm_ak09940_valid_id(i2c_dev_t *dev) { int ret = 0; uint8_t i2c_data[2]; uint16_t id = 0; ret = sensor_i2c_read(dev, AK099XX_REG_WIA1, i2c_data, 2, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } id = (uint16_t)(((uint16_t)i2c_data[1] << 8) | i2c_data[0]); if (AK09940_WIA_VAL != id) { AKM_LOG("invalid device.\n"); return AKM_ERROR; } return 0; } static int drv_mag_akm_ak09940_open(void) { int16_t ret = 0; i2c_dev_t *dev = &ak09940_dev; ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_DEFAULT_MODE); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_mag_akm_ak09940_close(void) { int16_t ret = 0; i2c_dev_t *dev = &ak09940_dev; ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } AKM_LOG("successfully \n"); return ret; } static int drv_mag_akm_ak09940_is_overflow(int32_t data[]) { int ret = 0; if (AK099XX_VAL_OVERFLOW == data[0] && AK099XX_VAL_OVERFLOW == data[1] && AK099XX_VAL_OVERFLOW == data[2]) { ret = 1; } return ret; } static int32_t drv_mag_akm_ak09940_byts_compose(uint8_t l, uint8_t m, uint8_t h) { int32_t val = 0; int32_t temp_l, temp_m, temp_h; temp_l = ((uint32_t)l) << AK09940_L_SHIFT; temp_m = ((uint32_t)m) << AK09940_M_SHIFT; temp_h = ((uint32_t)h) << AK09940_H_SHIFT; val = ((int32_t)(temp_l | temp_m | temp_h)) >> AK09940_SIGN_SHIFT; return val; } static int drv_mag_akm_ak09940_read( void *buf, size_t len) { mag_data_t *mag_data = (mag_data_t *)buf; i2c_dev_t *dev = &ak09940_dev; size_t size; uint8_t i2c_data[AK099XX_BDATA_SIZE]; int32_t raw_lsb[3]; int ret = 0; int16_t i = 0; if (NULL == buf) { return AKM_ERROR; } size = sizeof(mag_data_t); if (len < size) { return AKM_ERROR; } /* Get measurement data from AK09940 * ST1 + (HXL + HXM + HXH) + (HYL + HYM + HYH) + (HZL + HZM + HZH) + TMPS + ST2 = 12bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } for (i = 0; i < 3; i++) { raw_lsb[i] = drv_mag_akm_ak09940_byts_compose(i2c_data[i*3 + 1], i2c_data[i*3 + 2], i2c_data[i*3 + 3]); } if (drv_mag_akm_ak09940_is_overflow(raw_lsb)) { AKM_LOG("sensor data overflow.\n"); } drv_mag_akm_ak09940_convert_coordinate(raw_lsb); for (i = 0; i < 3; i++) { mag_data->data[i] = (raw_lsb[i] * CONVERT_TO_UGAUSS)/1000; } mag_data->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_akm_ak09940_write( const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_mag_akm_ak09940_set_odr( i2c_dev_t *dev, const uint32_t odr) { uint8_t mode = 0; int ret; if (odr == AK099XX_SUPPORTED_ODR_POWER_DOWN) { mode = AK099XX_MODE_POWER_DOWN; } else if (odr <= AK099XX_SUPPORTED_ODR_10HZ) { mode = (AK099XX_MODE_CONT_MEASURE_MODE1 | AK099XX_LOW_NOISE_DRIVE_2); } else if (odr <= AK099XX_SUPPORTED_ODR_20HZ) { mode = (AK099XX_MODE_CONT_MEASURE_MODE2 | AK099XX_LOW_NOISE_DRIVE_2); } else if (odr <= AK099XX_SUPPORTED_ODR_50HZ) { mode = (AK099XX_MODE_CONT_MEASURE_MODE3 | AK099XX_LOW_NOISE_DRIVE_2); } else if (odr <= AK099XX_SUPPORTED_ODR_100HZ) { mode = (AK099XX_MODE_CONT_MEASURE_MODE4 | AK099XX_LOW_NOISE_DRIVE_2); } else if (odr <= AK099XX_SUPPORTED_ODR_200HZ) { mode = (AK099XX_MODE_CONT_MEASURE_MODE5 | AK099XX_LOW_NOISE_DRIVE_2); } else if (odr <= AK099XX_SUPPORTED_ODR_400HZ) { mode = (AK099XX_MODE_CONT_MEASURE_MODE5 | AK099XX_LOW_POWER_DRIVE_2); } else { AKM_LOG("unsupported ODR : %d, set to default mode\n", odr); mode = AK099XX_DEFAULT_MODE; } /* Before set a new mode, the device must be transition to power-down mode. * If the device is already powerdown mode, this command is ignored by * the set_operation function. */ ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } /* Transition to new mode */ ret = drv_mag_akm_ak09940_set_mode(dev, mode); if (unlikely(ret)) { return ret; } return 0; } static void drv_mag_akm_ak09940_get_info(dev_sensor_info_t *info) { info->vendor = DEV_SENSOR_VENDOR_AKM; info->model = AKM_DEVICE_NAME; info->unit = mGauss; info->range_max = AK09940_MAX_RANGE; info->range_min = AK09940_MIN_RANGE; return; } static int16_t drv_mag_akm_ak09940_set_default_config(i2c_dev_t *dev) { int16_t ret = 0; ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (unlikely(ret)) { return ret; } ret = drv_mag_akm_ak09940_set_odr(dev, AK099XX_SUPPORTED_ODR_10HZ); if (unlikely(ret)) { return ret; } return ret; } static int16_t drv_mag_akm_ak09940_test_data( uint16_t testno, int32_t testdata, int32_t lolimit, int32_t hilimit, int32_t err[]) { //AKM_LOG("DBG: FST 0x%08X\n", AKM_FST_ERRCODE(testno, testdata)); if ((lolimit <= testdata) && (testdata <= hilimit)) { return AKM_SUCCESS; } else { err[0] = testno; err[1] = testdata; return AKM_ERROR; } } int16_t drv_mag_akm_ak09940_self_test( i2c_dev_t *dev, int32_t result[]) { int16_t ret; uint8_t i2c_data[AK099XX_BDATA_SIZE]; int32_t xval_i32, yval_i32, zval_i32; int16_t wait_time = 0; uint8_t val; int8_t i = 0; /* initialize arg */ result[0] = 0; result[1] = 0; /********************************************************************** * Step 1 **********************************************************************/ /* Soft Reset */ ret = drv_mag_akm_ak09940_soft_reset(dev); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_RST; result[1] = ret; goto SELFTEST_FAIL; } /* Wait over 1 ms */ aos_msleep(2); /* Read values. */ ret = sensor_i2c_read(dev, AK099XX_REG_WIA1, i2c_data, 2, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_RST_READ; result[1] = ret; goto SELFTEST_FAIL; } AKM_FST(TLIMIT_NO_RST_WIA1, (int32_t)i2c_data[0], TLIMIT_LO_RST_WIA1, TLIMIT_HI_RST_WIA1, result); AKM_FST(TLIMIT_NO_RST_WIA2, (int32_t)i2c_data[1], TLIMIT_LO_RST_WIA2, TLIMIT_HI_RST_WIA2, result); /********************************************************************** * Step 2 **********************************************************************/ /* Set to CNT measurement 50Hz pattern. */ ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_CONT_MEASURE_MODE3); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_CNT_CNTL2; result[1] = ret; goto SELFTEST_FAIL; } /* Wait 1ms for register setting write done. */ aos_msleep(1); /* Current test program sets to MODE3, i.e. 50Hz=20msec interval * so, wait for double length of measurement time. */ wait_time = (1000 / AK099XX_SUPPORTED_ODR_50HZ); for (i = 0; i < TLIMIT_NO_CNT_ITRT; i++) { aos_msleep(wait_time * 2); /* Get measurement data from AK09940 * ST1 + (HXL + HXM + HXH) + (HYL + HYM + HYH) + (HZL + HZM + HZH) + TMPS + ST2 = 12bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_CNT_READ; result[1] = ret; goto SELFTEST_FAIL; } val = i2c_data[0] & AK099XX_DRDY_BIT; AKM_FST(TLIMIT_NO_CNT_1ST, (int32_t)val, TLIMIT_LO_CNT_1ST, TLIMIT_HI_CNT_1ST, result); /* Get measurement data from AK09940 * ST1 + (HXL + HXM + HXH) + (HYL + HYM + HYH) + (HZL + HZM + HZH) + TMPS + ST2 = 12bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_CNT_READ; result[1] = ret; goto SELFTEST_FAIL; } val = i2c_data[0] & AK099XX_DRDY_BIT; AKM_FST(TLIMIT_NO_CNT_2ND, (int32_t)val, TLIMIT_LO_CNT_2ND, TLIMIT_HI_CNT_2ND, result); } ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_POWER_DOWN); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_CNT_PWD; result[1] = ret; goto SELFTEST_FAIL; } /* Wait 1ms for register setting write done. */ aos_msleep(1); /********************************************************************** * Step 3 **********************************************************************/ /* Set to SNG measurement pattern. */ ret = drv_mag_akm_ak09940_set_mode(dev, AK099XX_MODE_SNG_MEASURE); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_SNG_CNTL2; result[1] = ret; goto SELFTEST_FAIL; } /* Wait for single measurement. */ aos_msleep(MEASURE_WAIT_TIME); /* Get measurement data from AK09940 * ST1 + (HXL + HXM + HXH) + (HYL + HYM + HYH) + (HZL + HZM + HZH) + TMPS + ST2 = 12bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_SNG_WAIT; result[1] = ret; goto SELFTEST_FAIL; } /* Convert to 32-bit integer value. */ xval_i32 = drv_mag_akm_ak09940_byts_compose(i2c_data[1], i2c_data[2], i2c_data[3]); yval_i32 = drv_mag_akm_ak09940_byts_compose(i2c_data[4], i2c_data[5], i2c_data[6]); zval_i32 = drv_mag_akm_ak09940_byts_compose(i2c_data[7], i2c_data[8], i2c_data[9]); AKM_FST(TLIMIT_NO_SNG_ST1, (int32_t)i2c_data[0], TLIMIT_LO_SNG_ST1, TLIMIT_HI_SNG_ST1, result); AKM_FST(TLIMIT_NO_SNG_HX, xval_i32, TLIMIT_LO_SNG_HX, TLIMIT_HI_SNG_HX, result); AKM_FST(TLIMIT_NO_SNG_HY, yval_i32, TLIMIT_LO_SNG_HY, TLIMIT_HI_SNG_HY, result); AKM_FST(TLIMIT_NO_SNG_HZ, zval_i32, TLIMIT_LO_SNG_HZ, TLIMIT_HI_SNG_HZ, result); AKM_FST(TLIMIT_NO_SNG_ST2, (int32_t)(i2c_data[11] & TLIMIT_ST2_MASK), TLIMIT_LO_SNG_ST2, TLIMIT_HI_SNG_ST2, result); /* Set to self-test mode. */ ret = drv_mag_akm_ak09940_set_mode(dev, (AK099XX_LOW_NOISE_DRIVE_2 | AK099XX_MODE_SELF_TEST)); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_SLF_CNTL2; result[1] = ret; goto SELFTEST_FAIL; } /* Wait for self test measurement. */ aos_msleep(MEASURE_WAIT_TIME); /* Get measurement data from AK09940 * ST1 + (HXL + HXM + HXH) + (HYL + HYM + HYH) + (HZL + HZM + HZH) + TMPS + ST2 = 12bytes */ ret = sensor_i2c_read(dev, AK099XX_REG_ST1, i2c_data, AK099XX_BDATA_SIZE, I2C_OP_RETRIES); if (AKM_SUCCESS != ret) { result[0] = TLIMIT_NO_SNG_WAIT; result[1] = ret; goto SELFTEST_FAIL; } /* Convert to 32-bit integer value. */ xval_i32 = drv_mag_akm_ak09940_byts_compose(i2c_data[1], i2c_data[2], i2c_data[3]); yval_i32 = drv_mag_akm_ak09940_byts_compose(i2c_data[4], i2c_data[5], i2c_data[6]); zval_i32 = drv_mag_akm_ak09940_byts_compose(i2c_data[7], i2c_data[8], i2c_data[9]); AKM_FST(TLIMIT_NO_SLF_ST1, (int32_t)i2c_data[0], TLIMIT_LO_SLF_ST1, TLIMIT_HI_SLF_ST1, result); AKM_FST(TLIMIT_NO_SLF_RVHX, xval_i32, TLIMIT_LO_SLF_RVHX, TLIMIT_HI_SLF_RVHX, result); AKM_FST(TLIMIT_NO_SLF_RVHY, yval_i32, TLIMIT_LO_SLF_RVHY, TLIMIT_HI_SLF_RVHY, result); AKM_FST(TLIMIT_NO_SLF_RVHZ, zval_i32, TLIMIT_LO_SLF_RVHZ, TLIMIT_HI_SLF_RVHZ, result); AKM_FST(TLIMIT_NO_SLF_ST2, (int32_t)(i2c_data[11] & TLIMIT_ST2_MASK), TLIMIT_LO_SLF_ST2, TLIMIT_HI_SLF_ST2, result); AKM_LOG("self test success"); return AKM_SUCCESS; SELFTEST_FAIL: AKM_LOG("self test failed result step:0x%x, val:%d", result[0], result[1]); return AKM_ERROR; } int drv_mag_akm_ak09940_ioctl( int cmd, unsigned long arg) { int ret = 0; //int64_t self_test_result; dev_sensor_info_t *info = (dev_sensor_info_t *) arg; switch (cmd) { case SENSOR_IOCTL_ODR_SET: ret = drv_mag_akm_ak09940_set_odr(&ak09940_dev, (int)arg); if (unlikely(ret)) { return AKM_ERROR; } break; case SENSOR_IOCTL_RANGE_SET: break; case SENSOR_IOCTL_GET_INFO: drv_mag_akm_ak09940_get_info(info); break; case SENSOR_IOCTL_BIST_PROCESS: break; case SENSOR_IOCTL_WHO_AM_I: break; case SENSOR_IOCTL_SET_POWER: break; case SENSOR_IOCTL_GET_SENSOR_LIST: break; case SENSOR_IOCTL_DTC_CYCLE_SET: break; /*case SENSOR_IOCTL_SELF_TEST: ret = drv_mag_akm_ak09940_self_test(&ak09940_dev, &self_test_result); return ret;*/ default: break; } return ret; } int drv_mag_akm_ak09940_init(void) { int16_t ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.io_port = I2C_PORT; sensor.open = drv_mag_akm_ak09940_open; sensor.close = drv_mag_akm_ak09940_close; sensor.read = drv_mag_akm_ak09940_read; sensor.write = drv_mag_akm_ak09940_write; sensor.ioctl = drv_mag_akm_ak09940_ioctl; sensor.irq_handle = NULL; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09940_valid_id(&ak09940_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09940_soft_reset(&ak09940_dev); if (unlikely(ret)) { return (int)ret; } ret = drv_mag_akm_ak09940_set_default_config(&ak09940_dev); if (unlikely(ret)) { return (int)ret; } AKM_LOG("successfully.\n"); return (int)ret; } SENSOR_DRV_ADD(drv_mag_akm_ak09940_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_akm_ak09940.c
C
apache-2.0
23,186
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define BMM150_I2C_ADDR1 (0x10<<1) #define BMM150_I2C_ADDR2 (0x11 << 1) #define BMM150_I2C_ADDR3 (0x12 << 1) #define BMM150_I2C_ADDR4 (0x13 << 1) #define BMM150_CHIP_ID_ADDR (0X40) #define BMM150_CHIP_ID_VALUE (0X32) #define BMM150_OP_MODE_ADDR (0x4C) #define BMM150_DATA_X_LSB (0x42) #define BMM150_ODR_ADDR_POS (3) #define BMM150_ODR_ADDR_LEN (3) #define BMM150_ODR_ADDR_MSK (0x31) #define BMM150_ODR_ADDR_REG (BMM150_OP_MODE_ADDR) #define BMM150_POWER_MODE_POS (1) #define BMM150_POWER_MODE_LEN (2) #define BMM150_POWER_MODE_MSK (0xf9) #define BMM150_POWER_MODE_REG (BMM150_OP_MODE_ADDR) #define BMM150_POWER_MODE_NORMAL (0X0) #define BMM150_POWER_MODE_SLEEP (0X3) #define BMM150_POWER_MODE_OFF (0X3) #define BMM150_ODR_2 (2) #define BMM150_ODR_6 (6) #define BMM150_ODR_8 (8) #define BMM150_ODR_10 (10) #define BMM150_ODR_15 (15) #define BMM150_ODR_20 (20) #define BMM150_ODR_25 (25) #define BMM150_ODR_30 (30) #define BMM150_ODR_2_REG (0x1) #define BMM150_ODR_6_REG (0x2) #define BMM150_ODR_8_REG (0x3) #define BMM150_ODR_10_REG (0x0) #define BMM150_ODR_15_REG (0x4) #define BMM150_ODR_20_REG (0x5) #define BMM150_ODR_25_REG (0x6) #define BMM150_ODR_30_REG (0x7) #define BMM150_DIG_X1 (0x5D) #define BMM150_DIG_Y1 (0x5E) #define BMM150_DIG_Z4_LSB (0x62) #define BMM150_DIG_Z4_MSB (0x63) #define BMM150_DIG_X2 (0x64) #define BMM150_DIG_Y2 (0x65) #define BMM150_DIG_Z2_LSB (0x68) #define BMM150_DIG_Z2_MSB (0x69) #define BMM150_DIG_Z1_LSB (0x6A) #define BMM150_DIG_Z1_MSB (0x6B) #define BMM150_DIG_XYZ1_LSB (0x6C) #define BMM150_DIG_XYZ1_MSB (0x6D) #define BMM150_DIG_Z3_LSB (0x6E) #define BMM150_DIG_Z3_MSB (0x6F) #define BMM150_DIG_XY2 (0x70) #define BMM150_DIG_XY1 (0x71) #define BMM150_DATA_X_MSK (0xF8) #define BMM150_DATA_X_POS (0x03) #define BMM150_DATA_Y_MSK (0xF8) #define BMM150_DATA_Y_POS (0x03) #define BMM150_DATA_Z_MSK (0xFE) #define BMM150_DATA_Z_POS (0x01) #define BMM150_DATA_RHALL_MSK (0xFC) #define BMM150_DATA_RHALL_POS (0x02) #define BMM150_DATA_UT_2_MG (10) #define BMM150_OVERFLOW_OUTPUT (-32768) #define BMM150_NEGATIVE_SATURATION_Z (-32767) #define BMM150_POSITIVE_SATURATION_Z (32767) #define BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL (-4096) #define BMM150_ZAXIS_HALL_OVERFLOW_ADCVAL (-16384) #define BMM150_GET_BITSLICE(regvar, bitname) \ ((regvar & bitname##_MSK) >> bitname##_POS) #define BMM150_SET_BITSLICE(regvar, bitname, val) \ ((regvar & (~bitname##_MSK)) | ((val << bitname##_POS) & bitname##_MSK)) typedef struct bmm150_trim_registers { int8_t dig_x1; int8_t dig_y1; int8_t dig_x2; int8_t dig_y2; uint16_t dig_z1; int16_t dig_z2; int16_t dig_z3; int16_t dig_z4; uint8_t dig_xy1; int8_t dig_xy2; uint16_t dig_xyz1; }bmm150_trim_reg_st; bmm150_trim_reg_st g_bmm150_trim_reg = {0}; i2c_dev_t bmm150_ctx = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = BMM150_I2C_ADDR1, }; int drv_mag_bosch_bmm150_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, BMM150_CHIP_ID_ADDR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (id_value != value) { return -1; } return 0; } int drv_mag_bosch_bmm150_set_power_mode(i2c_dev_t * drv, dev_power_mode_e mode) { uint8_t value = 0x00; uint8_t value1 = 0x00; int ret = 0; ret = sensor_i2c_read(drv, BMM150_POWER_MODE_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (mode) { case DEV_POWER_ON: { ret = sensor_i2c_read(drv, 0x4b, &value1, I2C_DATA_LEN, I2C_OP_RETRIES); value1 |= 1; ret = sensor_i2c_write(drv, 0x4b, &value1, I2C_DATA_LEN, I2C_OP_RETRIES); aos_msleep(1); value = BMM150_SET_BITSLICE(value,BMM150_POWER_MODE,BMM150_POWER_MODE_NORMAL); } break; case DEV_POWER_OFF: { value = BMM150_SET_BITSLICE(value,BMM150_POWER_MODE,BMM150_POWER_MODE_OFF); } break; case DEV_SLEEP: { value = BMM150_SET_BITSLICE(value,BMM150_POWER_MODE,BMM150_POWER_MODE_OFF); } break; default: return -1; } ret = sensor_i2c_write(drv, BMM150_POWER_MODE_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } int drv_mag_bosch_bmm150_set_odr(i2c_dev_t *drv, uint32_t odr) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, BMM150_ODR_ADDR_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (odr >= BMM150_ODR_30) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_30_REG); } else if (odr >= BMM150_ODR_25) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_25_REG); } else if (odr >= BMM150_ODR_20) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_20_REG); } else if (odr >= BMM150_ODR_15) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_15_REG); } else if (odr >= BMM150_ODR_10) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_10_REG); } else if (odr >= BMM150_ODR_8) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_8_REG); } else if (odr >= BMM150_ODR_6) { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_6_REG); } else { value = BMM150_SET_BITSLICE(value,BMM150_ODR_ADDR,BMM150_ODR_2_REG); } ret = sensor_i2c_write(drv, BMM150_ODR_ADDR_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } void drv_mag_bosch_bmm150_irq_handle(void) { /* no handle so far */ } int drv_mag_bosch_bmm150_open(void) { int ret = 0; ret = drv_mag_bosch_bmm150_set_power_mode(&bmm150_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_mag_bosch_bmm150_close(void) { int ret = 0; ret = drv_mag_bosch_bmm150_set_power_mode(&bmm150_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } return 0; } static int16_t drv_mag_bosch_bmm150_compensate_x(int16_t mag_data_x, uint16_t data_rhall) { int16_t retval; uint16_t process_comp_x0 = 0; int32_t process_comp_x1; uint16_t process_comp_x2; int32_t process_comp_x3; int32_t process_comp_x4; int32_t process_comp_x5; int32_t process_comp_x6; int32_t process_comp_x7; int32_t process_comp_x8; int32_t process_comp_x9; int32_t process_comp_x10; /* Overflow condition check */ if (mag_data_x != BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL) { if (data_rhall != 0) { process_comp_x0 = data_rhall; } else if (g_bmm150_trim_reg.dig_xyz1 != 0) { process_comp_x0 = g_bmm150_trim_reg.dig_xyz1; } else { process_comp_x0 = 0; } if (process_comp_x0 != 0) { process_comp_x1 = ((int32_t)g_bmm150_trim_reg.dig_xyz1) * 16384; process_comp_x2 = ((uint16_t)(process_comp_x1 / process_comp_x0)) - ((uint16_t)0x4000); retval = ((int16_t)process_comp_x2); process_comp_x3 = (((int32_t)retval) * ((int32_t)retval)); process_comp_x4 = (((int32_t)g_bmm150_trim_reg.dig_xy2) * (process_comp_x3 / 128)); process_comp_x5 = (int32_t)(((int16_t)g_bmm150_trim_reg.dig_xy1) * 128); process_comp_x6 = ((int32_t)retval) * process_comp_x5; process_comp_x7 = (((process_comp_x4 + process_comp_x6) / 512) + ((int32_t)0x100000)); process_comp_x8 = ((int32_t)(((int16_t)g_bmm150_trim_reg.dig_x2) + ((int16_t)0xA0))); process_comp_x9 = ((process_comp_x7 * process_comp_x8) / 4096); process_comp_x10 = ((int32_t)mag_data_x) * process_comp_x9; retval = ((int16_t)(process_comp_x10 / 8192)); retval = (retval + (((int16_t)g_bmm150_trim_reg.dig_x1) * 8)) / 16; } else { retval = BMM150_OVERFLOW_OUTPUT; } } else { retval = BMM150_OVERFLOW_OUTPUT; } return retval; } static int16_t drv_mag_bosch_bmm150_compensate_y(int16_t mag_data_y, uint16_t data_rhall) { int16_t retval; uint16_t process_comp_y0 = 0; int32_t process_comp_y1; uint16_t process_comp_y2; int32_t process_comp_y3; int32_t process_comp_y4; int32_t process_comp_y5; int32_t process_comp_y6; int32_t process_comp_y7; int32_t process_comp_y8; int32_t process_comp_y9; if (mag_data_y != BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL) { if (data_rhall != 0) { process_comp_y0 = data_rhall; } else if (g_bmm150_trim_reg.dig_xyz1 != 0) { process_comp_y0 = g_bmm150_trim_reg.dig_xyz1; } else { process_comp_y0 = 0; } if (process_comp_y0 != 0) { process_comp_y1 = (((int32_t)g_bmm150_trim_reg.dig_xyz1) * 16384) / process_comp_y0; process_comp_y2 = ((uint16_t)process_comp_y1) - ((uint16_t)0x4000); retval = ((int16_t)process_comp_y2); process_comp_y3 = ((int32_t) retval) * ((int32_t)retval); process_comp_y4 = ((int32_t)g_bmm150_trim_reg.dig_xy2) * (process_comp_y3 / 128); process_comp_y5 = ((int32_t)(((int16_t)g_bmm150_trim_reg.dig_xy1) * 128)); process_comp_y6 = ((process_comp_y4 + (((int32_t)retval) * process_comp_y5)) / 512); process_comp_y7 = ((int32_t)(((int16_t)g_bmm150_trim_reg.dig_y2) + ((int16_t)0xA0))); process_comp_y8 = (((process_comp_y6 + ((int32_t)0x100000)) * process_comp_y7) / 4096); process_comp_y9 = (((int32_t)mag_data_y) * process_comp_y8); retval = (int16_t)(process_comp_y9 / 8192); retval = (retval + (((int16_t)g_bmm150_trim_reg.dig_y1) * 8)) / 16; } else { retval = BMM150_OVERFLOW_OUTPUT; } } else { retval = BMM150_OVERFLOW_OUTPUT; } return retval; } /*! * @brief This internal API is used to obtain the compensated * magnetometer Z axis data(micro-tesla) in int16_t. */ static int16_t drv_mag_bosch_bmm150_compensate_z(int16_t mag_data_z, uint16_t data_rhall) { int32_t retval; int16_t process_comp_z0; int32_t process_comp_z1; int32_t process_comp_z2; int32_t process_comp_z3; int16_t process_comp_z4; if (mag_data_z != BMM150_ZAXIS_HALL_OVERFLOW_ADCVAL) { if ((g_bmm150_trim_reg.dig_z2 != 0) && (g_bmm150_trim_reg.dig_z1 != 0) && (data_rhall != 0) && (g_bmm150_trim_reg.dig_xyz1 != 0)) { /*Processing compensation equations*/ process_comp_z0 = ((int16_t)data_rhall) - ((int16_t) g_bmm150_trim_reg.dig_xyz1); process_comp_z1 = (((int32_t)g_bmm150_trim_reg.dig_z3) * ((int32_t)(process_comp_z0))) / 4; process_comp_z2 = (((int32_t)(mag_data_z - g_bmm150_trim_reg.dig_z4)) * 32768); process_comp_z3 = ((int32_t)g_bmm150_trim_reg.dig_z1) * (((int16_t)data_rhall) * 2); process_comp_z4 = (int16_t)((process_comp_z3 + (32768)) / 65536); retval = ((process_comp_z2 - process_comp_z1) / (g_bmm150_trim_reg.dig_z2 + process_comp_z4)); /* saturate result to +/- 2 micro-tesla */ if (retval > BMM150_POSITIVE_SATURATION_Z) { retval = BMM150_POSITIVE_SATURATION_Z; } else { if (retval < BMM150_NEGATIVE_SATURATION_Z) retval = BMM150_NEGATIVE_SATURATION_Z; } /* Conversion of LSB to micro-tesla*/ retval = retval / 16; } else { retval = BMM150_OVERFLOW_OUTPUT; } } else { /* Overflow condition*/ retval = BMM150_OVERFLOW_OUTPUT; } return (int16_t)retval; } static int8_t drv_mag_bosch_bmm150_read_calib_reg(i2c_dev_t *drv) { int8_t ret; uint8_t trim_x1y1[2] = {0}; uint8_t trim_xyz_data[4] = {0}; uint8_t trim_xy1xy2[10] = {0}; uint16_t temp_msb = 0; ret = sensor_i2c_read(drv, BMM150_DIG_X1, trim_x1y1, 2, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(drv, BMM150_DIG_Z4_LSB, trim_xyz_data, 4, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(drv, BMM150_DIG_Z2_LSB, trim_xy1xy2, 10, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } g_bmm150_trim_reg.dig_x1 = (int8_t)trim_x1y1[0]; g_bmm150_trim_reg.dig_y1 = (int8_t)trim_x1y1[1]; g_bmm150_trim_reg.dig_x2 = (int8_t)trim_xyz_data[2]; g_bmm150_trim_reg.dig_y2 = (int8_t)trim_xyz_data[3]; temp_msb = ((uint16_t)trim_xy1xy2[3]) << 8; g_bmm150_trim_reg.dig_z1 = (uint16_t)(temp_msb | trim_xy1xy2[2]); temp_msb = ((uint16_t)trim_xy1xy2[1]) << 8; g_bmm150_trim_reg.dig_z2 = (int16_t)(temp_msb | trim_xy1xy2[0]); temp_msb = ((uint16_t)trim_xy1xy2[7]) << 8; g_bmm150_trim_reg.dig_z3 = (int16_t)(temp_msb | trim_xy1xy2[6]); temp_msb = ((uint16_t)trim_xyz_data[1]) << 8; g_bmm150_trim_reg.dig_z4 = (int16_t)(temp_msb | trim_xyz_data[0]); g_bmm150_trim_reg.dig_xy1 = trim_xy1xy2[9]; g_bmm150_trim_reg.dig_xy2 = (int8_t)trim_xy1xy2[8]; temp_msb = ((uint16_t)(trim_xy1xy2[5] & 0x7F)) << 8; g_bmm150_trim_reg.dig_xyz1 = (uint16_t)(temp_msb | trim_xy1xy2[4]); return ret; } int drv_mag_bosch_bmm150_read(void *buf, size_t len) { int ret = 0; size_t size = 0; uint8_t reg[8]; int16_t msb_data; int16_t raw_datax; int16_t raw_datay; int16_t raw_dataz; uint16_t raw_data_r; mag_data_t *mag = (mag_data_t *)buf; if (mag == NULL) { return -1; } size = sizeof(mag_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&bmm150_ctx, BMM150_DATA_X_LSB, &reg[0], 8, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } reg[0] = BMM150_GET_BITSLICE(reg[0], BMM150_DATA_X); msb_data = ((int16_t)((int8_t)reg[1])) * 32; raw_datax = (int16_t)(msb_data | reg[0]); reg[2] = BMM150_GET_BITSLICE(reg[2], BMM150_DATA_Y); msb_data = ((int16_t)((int8_t)reg[3])) * 32; raw_datay = (int16_t)(msb_data | reg[2]); reg[4] = BMM150_GET_BITSLICE(reg[4], BMM150_DATA_Z); msb_data = ((int16_t)((int8_t)reg[5])) * 128; raw_dataz = (int16_t)(msb_data | reg[4]); reg[6] = BMM150_GET_BITSLICE(reg[6], BMM150_DATA_RHALL); raw_data_r = (uint16_t)(((uint16_t)reg[7] << 6) | reg[6]); mag->data[0] = (int32_t)drv_mag_bosch_bmm150_compensate_x(raw_datax, raw_data_r); mag->data[1] = (int32_t)drv_mag_bosch_bmm150_compensate_y(raw_datay, raw_data_r); mag->data[2] = (int32_t)drv_mag_bosch_bmm150_compensate_z(raw_dataz, raw_data_r); mag->data[0] = mag->data[0] * BMM150_DATA_UT_2_MG; mag->data[1] = mag->data[1] * BMM150_DATA_UT_2_MG; mag->data[2] = mag->data[2] * BMM150_DATA_UT_2_MG; mag->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_bosch_bmm150_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { ret = drv_mag_bosch_bmm150_set_odr(&bmm150_ctx, arg); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_RANGE_SET: { } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_mag_bosch_bmm150_set_power_mode(&bmm150_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 = "BMM150"; info->range_max = 2500; info->range_min = 2500; info->unit = udps; } break; default: break; } return 0; } int drv_mag_bosch_bmm150_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.open = drv_mag_bosch_bmm150_open; sensor.close = drv_mag_bosch_bmm150_close; sensor.read = drv_mag_bosch_bmm150_read; sensor.write = NULL; sensor.ioctl = drv_mag_bosch_bmm150_ioctl; sensor.irq_handle = drv_mag_bosch_bmm150_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } ret = drv_mag_bosch_bmm150_set_power_mode(&bmm150_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } aos_msleep(10); ret = drv_mag_bosch_bmm150_validate_id(&bmm150_ctx, BMM150_CHIP_ID_VALUE); if (unlikely(ret)) { return -1; } ret = drv_mag_bosch_bmm150_set_odr(&bmm150_ctx, 2); if (unlikely(ret)) { return -1; } memset(&g_bmm150_trim_reg, 0, sizeof(g_bmm150_trim_reg)); ret = drv_mag_bosch_bmm150_read_calib_reg(&bmm150_ctx); if (unlikely(ret)) { return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_mag_bosch_bmm150_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_bosch_bmm150.c
C
apache-2.0
19,336
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited ***** only for 1422a ,not for 1422 *********** * Edit wanjiang-yan 2018-6-26 */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" // ********** ADDR = L ,addr=0x0E,ADDR = H,addr=0x0f ************ //#define ADDR_HIGH 1 #ifdef ADDR_HIGH #define BM1422AGMV_I2C_ADDR1 0x0F //ADDR=H #else #define BM1422AGMV_I2C_ADDR1 0x0E //ADDR=L #endif #define BM1422AGMV_I2C_ADDR_TRANS(n) ((n)<<1) #define BM1422AGMV_I2C_ADDR BM1422AGMV_I2C_ADDR_TRANS(BM1422AGMV_I2C_ADDR1) #define BM1422AGMV_BIT(x) (x) #define I_AM_BM1422AGMV 0x41 #define BM1422AGMV_MAG_INFO1_REG 0x0D #define BM1422AGMV_MAG_INFO2_REG 0x0E #define BM1422AGMV_MAG_WHO_AM_I_REG 0x0F #define BM1422AGMV_MAG_OUTX_L 0x10 #define BM1422AGMV_MAG_OUTX_H 0x11 #define BM1422AGMV_MAG_OUTY_L 0x12 #define BM1422AGMV_MAG_OUTY_H 0x13 #define BM1422AGMV_MAG_OUTZ_L 0x14 #define BM1422AGMV_MAG_OUTZ_H 0x15 #define BM1422AGMV_MAG_STATUS_REG 0x18 #define BM1422AGMV_MAG_CNTL1_REG 0x1B #define BM1422AGMV_MAG_CNTL2_REG 0x1C #define BM1422AGMV_MAG_CNTL3_REG 0x1D #define BM1422AGMV_MAG_PRET_REG 0x30 #define BM1422AGMV_MAG_AVE_A_REG 0x40 #define BM1422AGMV_MAG_CNTL4_REG 0x5C #define BM1422AGMV_MAG_CNTL4_REG2 0x5D #define BM1422AGMV_MAG_TEMP_OUT_L 0x60 #define BM1422AGMV_MAG_TEMP_OUT_H 0x61 #define BM1422AGMV_MAG_OFF_X_L 0x6C #define BM1422AGMV_MAG_OFF_X_H 0x6D #define BM1422AGMV_MAG_OFF_Y_L 0x72 #define BM1422AGMV_MAG_OFF_Y_H 0x73 #define BM1422AGMV_MAG_OFF_Z_L 0x78 #define BM1422AGMV_MAG_OFF_Z_H 0x79 #define BM1422AGMV_MAG_FINE_OUT_X_L 0x90 #define BM1422AGMV_MAG_FINE_OUT_X_H 0x91 #define BM1422AGMV_MAG_FINE_OUT_Y_L 0x92 #define BM1422AGMV_MAG_FINE_OUT_Y_H 0x93 #define BM1422AGMV_MAG_FINE_OUT_Z_L 0x94 #define BM1422AGMV_MAG_FINE_OUT_Z_H 0x95 #define BM1422AGMV_MAG_GAIN_PARA_X_L 0x9C #define BM1422AGMV_MAG_GAIN_PARA_X_H 0x9D #define BM1422AGMV_MAG_GAIN_PARA_Y_L 0x9E #define BM1422AGMV_MAG_GAIN_PARA_Y_H 0x9F #define BM1422AGMV_MAG_GAIN_PARA_Z_L 0xA0 #define BM1422AGMV_MAG_GAIN_PARA_Z_H 0xA1 #define INFORMATION_BM1422AGMV 0x0101 #define I_AM_BM1422AGMV 0x41 //0X18 STA1 BIT 6 #define BM1422AGMV_MAG_STATUS_RD_DRDY_BIT 0x40 //CNTL1 0X1B #define BM1422AGMV_MAG_CNTL1_ODR_BIT BM1422AGMV_BIT(0x18) #define BM1422AGMV_MAG_CNTL1_ODR_10_HZ 0x00 #define BM1422AGMV_MAG_CNTL1_ODR_20_HZ 0x10 #define BM1422AGMV_MAG_CNTL1_ODR_100_HZ 0x08 #define BM1422AGMV_MAG_CNTL1_ODR_1000_HZ 0x18 #define BM1422AGMV_MAG_CNTL1_FS1_BIT BM1422AGMV_BIT(0x02) #define BM1422AGMV_MAG_CNTL1_FS1_CONTINUOUS 0x00 #define BM1422AGMV_MAG_CNTL1_FS1_SINGLE 0x02 #define BM1422AGMV_MAG_CNTL1_PC1_BIT BM1422AGMV_BIT(0x80) #define BM1422AGMV_MAG_CNTL1_PC1_POWERDOWN 0x00 #define BM1422AGMV_MAG_CNTL1_PC1_ACTIVE 0x80 #define BM1422AGMV_MAG_CNTL1_OUT_BIT BM1422AGMV_BIT(0x40) #define BM1422AGMV_MAG_CNTL1_OUT12_BIT 0x40 #define BM1422AGMV_MAG_CNTL1_OUT14_BIT 0x00 #define BM1422AGMV_MAG_CNTL1_RST_LV_BIT BM1422AGMV_BIT(0x20) //CNTL2 0X1C #define BM1422AGMV_MAG_CNTL2_DRP_BIT BM1422AGMV_BIT(0x04) #define BM1422AGMV_MAG_CNTL2_DREN_BIT BM1422AGMV_BIT(0x08) //CNTL3 0X1D #define BM1422AGMV_MAG_CNTL3_FORCE_BIT BM1422AGMV_BIT(0x40) //PRET 0X30 #define BM1422AGMV_MAG_PRET_PS_BIT BM1422AGMV_BIT(0x01) //AVE 0X40 #define BM1422AGMV_MAG_AVE_A_BIT BM1422AGMV_BIT(0x1C) //CNTL4 0X5D #define BM1422AGMV_MAG_CNTL4_RSTB_LV_BIT BM1422AGMV_BIT(0x3F) #define DEV_POWER_ON 1 #define DEV_POWER_OFF 0 i2c_dev_t bm1422a_ctx = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = BM1422AGMV_I2C_ADDR, }; uint16_t offx_dat,offy_dat,offz_dat; static int drv_mag_rohm_bm1422a_soft_reset(i2c_dev_t* drv) { int ret = 0; uint8_t value = BM1422AGMV_MAG_CNTL1_PC1_ACTIVE; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } UNUSED static int drv_mag_rohm_bm1422a_selftest(i2c_dev_t* drv) { /* int ret = 0; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CTRL_REG1, LMS303C_MAG_SELFTEST_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } */ return 0; } UNUSED static int drv_mag_rohm_bm1422a_reboot(i2c_dev_t* drv) { /* int ret = 0; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL2_REG, BM1422AGMV_MAG_REBOOT_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; }*/ return 0; } static int drv_mag_rohm_bm1422a_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, BM1422AGMV_MAG_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (id_value != value){ return -1; } //ok return 0; } // static int drv_mag_rohm_bm1422a_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (mode == DEV_POWER_ON) { value &= ~BM1422AGMV_MAG_CNTL1_PC1_BIT; value |= BM1422AGMV_MAG_CNTL1_PC1_ACTIVE; } else{ value &= ~BM1422AGMV_MAG_CNTL1_PC1_BIT; value |= BM1422AGMV_MAG_CNTL1_PC1_POWERDOWN; } ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } // static int drv_mag_rohm_bm1422a_set_odr(i2c_dev_t* drv, uint8_t odr) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value &= ~BM1422AGMV_MAG_CNTL1_ODR_BIT; value |= (uint8_t)odr; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } //single mode or continuous mode UNUSED static int drv_mag_rohm_bm1422a_set_mode(i2c_dev_t* drv, uint8_t mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value &= ~BM1422AGMV_MAG_CNTL1_FS1_BIT; value |= (uint8_t)mode; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } //Output bit 12bit 14bit UNUSED static int drv_mag_rohm_bm1422a_set_outmode(i2c_dev_t* drv, uint8_t bit_wide) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value &= ~BM1422AGMV_MAG_CNTL1_OUT_BIT; value |= (uint8_t)bit_wide; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } // static int drv_mag_rohm_bm1422a_set_cntl1(i2c_dev_t* drv, uint8_t value) { int ret = 0; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_rohm_bm1422a_set_step1(i2c_dev_t* drv, uint16_t value) { //uint8_t value = 0x00; int ret = 0; //5C //5D //value = 0X00; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL4_REG, (uint8_t*)&value, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_rohm_bm1422a_set_step2(i2c_dev_t* drv, uint8_t value) { //uint8_t value = 0x00; int ret = 0; //value = BM1422AGMV_MAG_CNTL2_DRP_BIT | BM1422AGMV_MAG_CNTL2_DREN_BIT; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL2_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_rohm_bm1422a_set_step4(i2c_dev_t* drv, uint8_t value) { //uint8_t value = 0x00; int ret = 0; //value = BM1422AGMV_MAG_CNTL3_FORCE_BIT; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL3_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } // offset x,y,z step 3 static int drv_mag_rohm_bm1422a_set_x_offset(i2c_dev_t* drv, uint16_t value) { //uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_OFF_X_L, (uint8_t*)&value, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_rohm_bm1422a_set_y_offset(i2c_dev_t* drv, uint16_t value) { //uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_OFF_Y_L, (uint8_t*)&value, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_rohm_bm1422a_set_z_offset(i2c_dev_t* drv, uint16_t value) { //uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_write(drv, BM1422AGMV_MAG_OFF_Z_L, (uint8_t*)&value, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } //select x,y,z UNUSED static int drv_mag_rohm_bm1422a_offset_adjustment(i2c_dev_t* drv, uint8_t xyz_wide) { int ret = 0; // int diff_x = 9999; uint8_t wk_dat = 1,off_dat=1,drdy=0,buffer[2]; uint16_t data_temp,diff_x=9999; drv_mag_rohm_bm1422a_set_step1(drv,0x82); drv_mag_rohm_bm1422a_set_step2(drv,0x0C); switch(xyz_wide) { case 1: while(wk_dat<96) { drv_mag_rohm_bm1422a_set_x_offset(drv,wk_dat); drv_mag_rohm_bm1422a_set_step4(drv,0x40); do { ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES); }while((drdy & BM1422AGMV_MAG_STATUS_RD_DRDY_BIT) != BM1422AGMV_MAG_STATUS_RD_DRDY_BIT); // read x,y,z data ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_L , buffer, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } data_temp=((((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]); if(diff_x > abs(data_temp)) { off_dat = wk_dat; diff_x = abs(data_temp); offx_dat = off_dat; } wk_dat ++; } drv_mag_rohm_bm1422a_set_x_offset(drv,off_dat); break; case 2: while(wk_dat<96) { drv_mag_rohm_bm1422a_set_y_offset(drv,wk_dat); drv_mag_rohm_bm1422a_set_step4(drv,0x40); do { ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES); }while((drdy & BM1422AGMV_MAG_STATUS_RD_DRDY_BIT) != BM1422AGMV_MAG_STATUS_RD_DRDY_BIT); // read x,y,z data ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTY_L, buffer, 2, I2C_OP_RETRIES); data_temp=((((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]); if(diff_x > abs(data_temp)) { off_dat = wk_dat; diff_x = abs(data_temp); offy_dat = off_dat; } wk_dat ++; } drv_mag_rohm_bm1422a_set_y_offset(drv,off_dat); break; case 3: while(wk_dat<96) { drv_mag_rohm_bm1422a_set_z_offset(drv,wk_dat); drv_mag_rohm_bm1422a_set_step4(drv,0x40); do { ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES); }while((drdy & BM1422AGMV_MAG_STATUS_RD_DRDY_BIT) != BM1422AGMV_MAG_STATUS_RD_DRDY_BIT); // read x,y,z data ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTZ_L, buffer, 2, I2C_OP_RETRIES); data_temp=((((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]); if(diff_x > abs(data_temp)) { off_dat = wk_dat; diff_x = abs(data_temp); offz_dat = off_dat; } wk_dat ++; } drv_mag_rohm_bm1422a_set_z_offset(drv,off_dat); break; default: break; } return 0; } static int drv_mag_rohm_bm1422a_set_default_config(i2c_dev_t* drv) { /* uint8_t value = 0x00; ret = drv_mag_rohm_bm1422a_set_power_mode(drv, DEV_POWER_ON); if(unlikely(ret)){ return ret; } ret = drv_mag_rohm_bm1422a_set_odr(drv, BM1422AGMV_MAG_CNTL1_ODR_10_HZ); if(unlikely(ret)){ return ret; } //single or connutional ret = drv_mag_rohm_bm1422a_set_mode(drv, BM1422AGMV_MAG_CNTL1_FS1_CONTINUOUS); if(unlikely(ret)){ return ret; } //single or connutional ret = drv_mag_rohm_bm1422a_set_mode(drv, BM1422AGMV_MAG_CNTL1_FS1_CONTINUOUS); if(unlikely(ret)){ return ret; } ret = drv_mag_rohm_bm1422a_set_outmode(drv, BM1422AGMV_MAG_CNTL1_OUT12_BIT); if(unlikely(ret)){ return ret; } */ //step 1 drv_mag_rohm_bm1422a_set_cntl1(drv,0x80); drv_mag_rohm_bm1422a_set_step1(drv,0x0000); aos_msleep(10); //step 2 drv_mag_rohm_bm1422a_set_step2(drv,0x0c); aos_msleep(10); //step 3 //step 4 drv_mag_rohm_bm1422a_set_step4(drv,0x40); aos_msleep(10); return 0; } static void drv_mag_rohm_bm1422a_irq_handle(void) { /* no handle so far */ } static int drv_mag_rohm_bm1422a_open(void) { int ret = 0; ret = drv_mag_rohm_bm1422a_set_power_mode(&bm1422a_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_rohm_bm1422a_close(void) { int ret = 0; ret = drv_mag_rohm_bm1422a_set_power_mode(&bm1422a_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } return 0; } /////////////////////////////////////////// static int drv_mag_rohm_bm1422a_read(void* buf, size_t len) { int ret = 0; size_t size; int16_t data_temp[3]; uint8_t drdy= 0; uint8_t buffer[6]; uint8_t i = 0; mag_data_t* pdata = (mag_data_t*)buf; if(buf == NULL){ return -1; } size = sizeof(mag_data_t); if(len < size){ return -1; } drdy = 0; do{ ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES); }while(drdy == 0); ret = 0; ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_L, &buffer[0], 1, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_H, &buffer[1], 1, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTY_L, &buffer[2], 1, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTY_H, &buffer[3], 1, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTZ_L, &buffer[4], 1, I2C_OP_RETRIES); ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTZ_H, &buffer[5], 1, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } //ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_L, buffer, 6, I2C_OP_RETRIES); for(i=0; i<3; i++) { data_temp[i]=(((buffer[2*i+1]) << 8) | buffer[2*i]); } //check x,y,z value is ok // for(i=0; i<3; i++) { //pdata->data[i] = ((data_temp[i] * sensitivity) >> 10); pdata->data[i] = data_temp[i] /6000; } pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_rohm_bm1422a_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ ret = drv_mag_rohm_bm1422a_set_odr(&bm1422a_ctx, arg); if(unlikely(ret)){ return -1; } }break; /* case SENSOR_IOCTL_RANGE_SET:{ ret = drv_mag_rohm_bm1422a_set_range(&bm1422a_ctx, arg); if(unlikely(ret)){ return -1; } }break; */ case SENSOR_IOCTL_SET_POWER:{ ret = drv_mag_rohm_bm1422a_set_power_mode(&bm1422a_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 = "BM1422AGMV"; info->range_max = 8191; info->range_min = -8192; info->unit = mGauss; }break; default:break; } return 0; } int drv_mag_rohm_bm1422a_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.open = drv_mag_rohm_bm1422a_open; sensor.close = drv_mag_rohm_bm1422a_close; sensor.read = drv_mag_rohm_bm1422a_read; sensor.write = NULL; sensor.ioctl = drv_mag_rohm_bm1422a_ioctl; sensor.irq_handle = drv_mag_rohm_bm1422a_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_mag_rohm_bm1422a_validate_id(&bm1422a_ctx, I_AM_BM1422AGMV); if(unlikely(ret)){ return -1; } ret = drv_mag_rohm_bm1422a_soft_reset(&bm1422a_ctx); if(unlikely(ret)){ return -1; } ret = drv_mag_rohm_bm1422a_set_default_config(&bm1422a_ctx); if(unlikely(ret)){ return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_mag_rohm_bm1422a_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_rohm_bm1422a.c
C
apache-2.0
18,145
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" /*#define ST350MC_DEBUG*/ #ifdef ST350MC_DEBUG #define ST350_LOG LOG #else #define ST350_LOG #endif #define ST350MC_REGISTER_SETTING_TOTAL 5 #define ST350MC_OPERATION_TYPES_REG_TOTAL 4 #define ST350_I2C_ADDR2 0x0D #define ST350_I2C_ADDR_TRANS(n) ((n)<<1) #define ST350_I2C_ADDR ST350_I2C_ADDR_TRANS(ST350_I2C_ADDR2) #define ST350_BIT(x) (x) #define I_AM_ST350 0x53 #define ST350_MAG_WHO_AM_I_REG 0x00 #define ST350MC_REG_MINFO 0x01 #define ST350MC_REG_STAT1 0x02 #define ST350MC_REG_DATAX_L 0x03 #define ST350MC_REG_DATAX_H 0x04 #define ST350MC_REG_DATAY_L 0x05 #define ST350MC_REG_DATAY_H 0x06 #define ST350MC_REG_DATAZ_L 0x07 #define ST350MC_REG_DATAZ_H 0x08 #define ST350MC_REG_STAT2 0x09 #define ST350MC_REG_CNTRL1 0x0A #define ST350MC_REG_CNTRL2 0x0B #define ST350MC_REG_STCR 0x0C #define ST350MC_REG_CNTRL3 0x0D #define ST350MC_REG_TEMP_L 0x1C #define ST350MC_REG_TEMP_H 0x1D #define ST350MC_REG_AVGCNTL 0x41 #define ST350MC_REG_DSM1 0x6c #define ST350MC_REG_X_GAIN_CNTL 0x50 #define ST350MC_REG_Y_GAIN_CNTL 0x52 #define ST350MC_REG_Z_GAIN_CNTL 0x54 #define ST350MC_REG_MHZ_CLK_TUNING 0x56 #define ST350MC_REG_ANALOG_TEST_CTL3 0x72 #define ST350MC_REG_ANALOG_TEST_CTL7 0x76 #define ST350MC_REG_SSR 0x42 #define ST350MC_REG_CTR 0x40 #define ST350MC_REG_BTR 0x57 #define ST350_MAG_SENSITIVITY_FOR_FS_20GA 3 #define UTTOUG 10000 #define UTTOMG 10 typedef enum { ST350MC_SINGLE_MEASURE, ST350MC_STANDBY, ST350MC_SUSPEND }st350_operation_mode_e; typedef enum { ST350MC_NORMAL, ST350MC_HIGH_PRECISION, ST350MC_HIGH_SPEED, ST350MC_LOW_POWER }st350mc_operation_types_e; i2c_dev_t ST350_ctx = { .port = 2, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = ST350_I2C_ADDR, }; UNUSED static int drv_mag_sen_st350_soft_reset(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0x1; ret = sensor_i2c_write(drv, ST350MC_REG_CNTRL2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_sen_st350_validate_id(i2c_dev_t* drv, uint8_t id_value) { uint8_t value = 0x00; int ret = 0, i = 3; (void)ret; if(drv == NULL){ return -1; } do{ ret = sensor_i2c_read(drv, ST350_MAG_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); }while((value != I_AM_ST350) && (i-- > 0)); if (id_value != value){ return -1; } return 0; } static int drv_mag_sen_st350_set_operation_types(i2c_dev_t* drv, st350mc_operation_types_e types) { uint8_t ST350MCreg[ST350MC_OPERATION_TYPES_REG_TOTAL] = {0x09,0x41,0x42,0x6C}; uint8_t ST350MCSetRegData[ST350MC_OPERATION_TYPES_REG_TOTAL]; uint8_t data, reg , i; int ret = 0; ST350MCSetRegData[0] = 0x02; ST350MCSetRegData[1] = 0x03; ST350MCSetRegData[2] = 0x40; ST350MCSetRegData[3] = 0x05; switch(types){ case ST350MC_HIGH_PRECISION: ST350MCSetRegData[3] |= 0x50; break; case ST350MC_HIGH_SPEED: ST350MCSetRegData[3] |= 0x30; break; case ST350MC_LOW_POWER: ST350MCSetRegData[0] |= 0xA0; ST350MCSetRegData[3] |= 0x30; break; case ST350MC_NORMAL: default: ST350MCSetRegData[3] |= 0x40; } for( i = 0 ; i < ST350MC_OPERATION_TYPES_REG_TOTAL ; i++){ reg = ST350MCreg[i]; data = ST350MCSetRegData[i]; ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } #ifdef ST350MC_DEBUG data = 0x0; ret = sensor_i2c_read(&ST350_ctx, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } ST350_LOG("operation types >>>>>0x%x = %x", reg, data); #endif } return 0; } static int drv_mag_sen_st350_set_operation_mode(i2c_dev_t* drv, st350_operation_mode_e mode) { uint8_t data, ret = 0, reg , i; uint8_t regBuff[2],dataBuff[2]; switch(mode){ case ST350MC_SINGLE_MEASURE: regBuff[0] = 0x20; dataBuff[0] = 0; regBuff[1] = 0x0A; dataBuff[1] = 1; break; case ST350MC_SUSPEND: regBuff[0] = 0x0A; dataBuff[0] = 0; regBuff[1] = 0x20; dataBuff[1] = 1; break; case ST350MC_STANDBY: default: regBuff[0] = 0x20; dataBuff[0] = 0; regBuff[1] = 0x0A; dataBuff[1] = 0; } for(i = 0; i < 2; i++){ reg = regBuff[i]; data = dataBuff[i]; ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } #ifdef ST350MC_DEBUG data = 0x0; ret = sensor_i2c_read(&ST350_ctx, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } ST350_LOG("operation mode >>>>>0x%x = %x", reg, data); #endif } return 0; } static int drv_mag_sen_st350_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { if (mode == DEV_POWER_ON){ drv_mag_sen_st350_set_operation_mode(&ST350_ctx, ST350MC_STANDBY); } else{ drv_mag_sen_st350_set_operation_mode(&ST350_ctx, ST350MC_SUSPEND); } return 0; } UNUSED static int drv_mag_sen_st350_set_odr(i2c_dev_t* drv, uint8_t odr) { return 0; } UNUSED static int drv_mag_sen_st350_lowpower_mode(i2c_dev_t* drv, uint8_t lowpower_mode) { int ret = 0; ret = drv_mag_sen_st350_set_operation_types(&ST350_ctx, ST350MC_LOW_POWER); if(unlikely(ret)){ return -1; } return 0; } UNUSED static int drv_mag_sen_st350_set_range(i2c_dev_t* drv, uint32_t range) { return 0; } static int drv_mag_sen_st350_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t ST350MCreg[ST350MC_REGISTER_SETTING_TOTAL] = {0x0D,0x56,0x57,0x72,0x76}; uint8_t ST350MCSetRegData[ST350MC_REGISTER_SETTING_TOTAL] = {0x00,0x1F,0x00,0x2B,0x00}; uint8_t data, reg , i; reg = 0xBA; data = 0x0; ret = sensor_i2c_read(&ST350_ctx, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } else{ if((data == 0x10) || (data == 0xFF)){ ST350MCSetRegData[4] = 0x20; } } for( i = 0 ; i < ST350MC_REGISTER_SETTING_TOTAL ; i++ ) { reg = ST350MCreg[i]; data = ST350MCSetRegData[i]; ret = sensor_i2c_write(drv, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } #ifdef ST350MC_DEBUG data = 0x0; ret = sensor_i2c_read(&ST350_ctx, reg, &data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } ST350_LOG(">>>>>0x%x = %x", reg, data); #endif } return 0; } static void drv_mag_sen_st350_irq_handle(void) { /* no handle so far */ } UNUSED static int drv_mag_sen_st350_dump_reg(void) { uint8_t rw_buffer[32] = {0}; uint8_t reg_map[] = { 0x0D, 0x56, 0x57, 0x72, 0x76, 0x20, 0x0A, 0x09, 0x41, 0x42, 0x6C }; uint8_t i = 0; uint16_t n = sizeof(reg_map)/sizeof(reg_map[0]); int ret = 0; for(i=0; i<n;i++) { ret = sensor_i2c_read(&ST350_ctx, reg_map[i], &rw_buffer[i],I2C_REG_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } } return 0; } static int drv_mag_sen_st350_open(void) { int ret = 0; ret = drv_mag_sen_st350_set_power_mode(&ST350_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } ret = drv_mag_sen_st350_set_operation_mode(&ST350_ctx, ST350MC_SINGLE_MEASURE); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_sen_st350_close(void) { int ret = 0; ret = drv_mag_sen_st350_set_power_mode(&ST350_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_sen_st350_read(void* buf, size_t len) { int ret = 0, data; size_t size; int16_t pnRawData[3]; uint8_t buffer[6]; uint8_t i = 0; mag_data_t* pdata = (mag_data_t*)buf; if(buf == NULL){ return -1; } size = sizeof(mag_data_t); if(len < size){ return -1; } ret = sensor_i2c_read(&ST350_ctx, ST350MC_REG_DATAX_L, buffer, 6, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } for(i=0; i<3; i++) { pnRawData[i]=(int16_t)((((uint16_t)buffer[2*i+1]) << 8) | ((uint16_t)buffer[2*i])); } /*ST350_LOG("raw uint st350 x = %d, y = %d, z = %d", pnRawData[0], pnRawData[1], pnRawData[2]);*/ for(i=0; i<3; i++) { pdata->data[i] =(int32_t)(pnRawData[i] * ST350_MAG_SENSITIVITY_FOR_FS_20GA * UTTOMG / 10); } pdata->timestamp = aos_now_ms(); data = 1; ret = sensor_i2c_write(&ST350_ctx, 0xa, (uint8_t *)&data, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } aos_msleep(1); return (int)size; } static int drv_mag_sen_st350_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ }break; case SENSOR_IOCTL_RANGE_SET:{ }break; case SENSOR_IOCTL_SET_POWER:{ ret = drv_mag_sen_st350_set_power_mode(&ST350_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 = "ST350"; info->range_max = 25; info->range_min = 20; info->unit = mGauss; }break; default:break; } return 0; } int drv_mag_sen_st350_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.open = drv_mag_sen_st350_open; sensor.close = drv_mag_sen_st350_close; sensor.read = drv_mag_sen_st350_read; sensor.write = NULL; sensor.ioctl = drv_mag_sen_st350_ioctl; sensor.irq_handle = drv_mag_sen_st350_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_mag_sen_st350_validate_id(&ST350_ctx, I_AM_ST350); if(unlikely(ret)){ return -1; } ret = drv_mag_sen_st350_set_power_mode(&ST350_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } ret = drv_mag_sen_st350_set_default_config(&ST350_ctx); if(unlikely(ret)){ return -1; } aos_msleep(1); ret = drv_mag_sen_st350_set_operation_types(&ST350_ctx, ST350MC_NORMAL); if(unlikely(ret)){ return -1; } aos_msleep(1); /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_mag_sen_st350_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_senodia_st350.c
C
apache-2.0
10,940
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define ST480_DEBUG #ifdef ST480_DEBUG #define ST480_LOG LOG #else #define ST480_LOG #endif //#define ST480_I2C_ADDR1 0x1C #define ST480_I2C_ADDR2 0x0C #define ST480_I2C_ADDR_TRANS(n) ((n)<<1) #define ST480_I2C_ADDR ST480_I2C_ADDR_TRANS(ST480_I2C_ADDR2) #define ST480_BIT(x) (x) #define I_AM_ST480 0x7C //TODO #define ST480_MAG_WHO_AM_I_REG 0x00 #define WRITE_REGISTER_CMD 0x60 #define READ_REGISTER_CMD 0x50 #define EXIT_REGISTER_CMD 0x80 #define MEMORY_RECALL_CMD 0xD0 #define MEMORY_STORE_CMD 0xE0 #define RESET_CMD 0xF0 #define ST480_REG_DRR_SHIFT 2 #define CALIBRATION_REG (0x02 << ST480_REG_DRR_SHIFT) #define CALIBRATION_DATA_LOW 0x18 #define CALIBRATION_DATA_HIGH 0x00 #define ONE_INIT_DATA_LOW 0x7C #define ONE_INIT_DATA_HIGH 0x00 #define ONE_INIT_REG (0x00 << ST480_REG_DRR_SHIFT) #define TWO_INIT_DATA_LOW 0x00 #define TWO_INIT_DATA_HIGH 0x00 #define TWO_INIT_REG (0x02 << ST480_REG_DRR_SHIFT) #define ST480_SINGLE_MODE 1 #define SINGLE_MEASUREMENT_MODE_CMD 0x3F #define READ_MEASUREMENT_CMD 0x4F #define ST480_MAG_XY_SENSITIVITY_FOR_48GA 15 #define ST480_MAG_Z_SENSITIVITY_FOR_48GA 25 i2c_dev_t ST480_ctx = { .port = 4, .config.address_width = 8, .config.freq = 200000, .config.dev_addr = ST480_I2C_ADDR, }; static int32_t sensor_i2c_single_write(i2c_dev_t *i2c, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t ret = 0; if(i2c == NULL){ return -1; } ret = hal_i2c_master_send(i2c, i2c->config.dev_addr, data, size, AOS_WAIT_FOREVER); return ret; } static int32_t sensor_i2c_single_read(i2c_dev_t *i2c, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t ret = 0; if(i2c == NULL){ return -1; } ret = hal_i2c_master_recv(i2c, i2c->config.dev_addr, data, size, AOS_WAIT_FOREVER); return ret; } static int drv_mag_sen_st480_validate_id(i2c_dev_t* drv, uint8_t id_value) { uint8_t value = 0x00; int ret = 0, i = 1; uint8_t buf[5]; if(drv == NULL){ return -1; } do{ buf[0] = READ_REGISTER_CMD; buf[1] = 0x00; ret = sensor_i2c_single_write(drv, buf, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(drv, buf, 3, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ST480_LOG("senodia st480 id = %d.", buf[2]); value = buf[2]; }while((buf[2] != I_AM_ST480) && (i-- > 0)); if (id_value != value){ return -1; } return 0; } static int drv_mag_sen_st480_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { //no use return 0; } static int drv_mag_sen_st480_set_odr(i2c_dev_t* drv, uint8_t odr) { //no use return 0; } static int drv_mag_sen_st480_set_range(i2c_dev_t* drv, uint32_t range) { //no use return 0; } static int drv_mag_sen_st480_set_default_config(i2c_dev_t* drv) { uint8_t buf[5] = {0}; int ret = 0; //init register step 1 buf[0] = WRITE_REGISTER_CMD; buf[1] = ONE_INIT_DATA_HIGH; buf[2] = ONE_INIT_DATA_LOW; buf[3] = ONE_INIT_REG; ret = sensor_i2c_single_write(drv, buf, 4, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(drv, buf, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } //init register step 2 buf[0] = WRITE_REGISTER_CMD; buf[1] = TWO_INIT_DATA_HIGH; buf[2] = TWO_INIT_DATA_LOW; buf[3] = TWO_INIT_REG; ret = sensor_i2c_single_write(drv, buf, 4, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(drv, buf, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } //set calibration register buf[0] = WRITE_REGISTER_CMD; buf[1] = CALIBRATION_DATA_HIGH; buf[2] = CALIBRATION_DATA_LOW; buf[3] = CALIBRATION_REG; ret = sensor_i2c_single_write(drv, buf, 4, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(drv, buf, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } //set mode config buf[0] = SINGLE_MEASUREMENT_MODE_CMD; ret = sensor_i2c_single_write(&ST480_ctx, buf, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(&ST480_ctx, buf, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static void drv_mag_sen_st480_irq_handle(void) { /* no handle so far */ } static int drv_mag_sen_st480_open(void) { //no use ST480_LOG("drv_mag_sen_st480_open:"); return 0; } static int drv_mag_sen_st480_close(void) { //no use ST480_LOG("drv_mag_sen_st480_close:"); return 0; } static int drv_mag_sen_st480_read(void* buf, size_t len) { int ret = 0; size_t size; int16_t pnRawData[3] = {0}; uint8_t buffer[9]; uint8_t i = 0; mag_data_t* pdata = (mag_data_t*)buf; if(buf == NULL){ return -1; } size = sizeof(mag_data_t); if(len < size){ return -1; } buffer[0] = READ_MEASUREMENT_CMD; ret = sensor_i2c_single_write(&ST480_ctx, buffer, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(&ST480_ctx, buffer, 9, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (!((buffer[0]>>4) & 0X01)) { for(i=0; i<3; i++) { pnRawData[i]=(int16_t)((((uint16_t)buffer[2*i + 3]) << 8) | ((uint16_t)buffer[2*i + 4])); } } pdata->data[0] =(int32_t)(pnRawData[0] * ST480_MAG_XY_SENSITIVITY_FOR_48GA / 10); pdata->data[1] =(int32_t)(pnRawData[1] * ST480_MAG_XY_SENSITIVITY_FOR_48GA / 10); pdata->data[2] =(int32_t)(pnRawData[2] * ST480_MAG_Z_SENSITIVITY_FOR_48GA / 10); pdata->timestamp = aos_now_ms(); //set mode config buffer[0] = SINGLE_MEASUREMENT_MODE_CMD; ret = sensor_i2c_single_write(&ST480_ctx, buffer, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_single_read(&ST480_ctx, buffer, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return (int)size; } static int drv_mag_sen_st480_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ ret = drv_mag_sen_st480_set_odr(&ST480_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_RANGE_SET:{ ret = drv_mag_sen_st480_set_range(&ST480_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_SET_POWER:{ ret = drv_mag_sen_st480_set_power_mode(&ST480_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 = "ST480"; info->range_max = 48; info->range_min = 48; info->unit = mGauss; }break; default:break; } return 0; } int drv_mag_sen_st480_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.open = drv_mag_sen_st480_open; sensor.close = drv_mag_sen_st480_close; sensor.read = drv_mag_sen_st480_read; sensor.write = NULL; sensor.ioctl = drv_mag_sen_st480_ioctl; sensor.irq_handle = drv_mag_sen_st480_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_mag_sen_st480_validate_id(&ST480_ctx, I_AM_ST480); if(unlikely(ret)){ return -1; } ret = drv_mag_sen_st480_set_default_config(&ST480_ctx); if(unlikely(ret)){ return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_mag_sen_st480_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_senodia_st480.c
C
apache-2.0
8,317
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define LIS2MDL_I2C_ADDR1 0x1E #define LIS2MDL_I2C_ADDR_TRANS(n) ((n)<<1) #define LIS2MDL_I2C_ADDR LIS2MDL_I2C_ADDR_TRANS(LIS2MDL_I2C_ADDR1) #define LIS2MDL_BIT(x) (x) #define LIS2MDL_MAG_OFFSET_X_REG_L 0x45 #define LIS2MDL_MAG_OFFSET_X_REG_H 0x46 #define LIS2MDL_MAG_OFFSET_Y_REG_L 0x47 #define LIS2MDL_MAG_OFFSET_Y_REG_H 0x48 #define LIS2MDL_MAG_OFFSET_Z_REG_L 0x49 #define LIS2MDL_MAG_OFFSET_Z_REG_H 0x4A #define LIS2MDL_MAG_WHO_AM_I 0x4F #define LIS2MDL_MAG_CFG_REG_A 0x60 #define LIS2MDL_MAG_CFG_REG_B 0x61 #define LIS2MDL_MAG_CFG_REG_C 0x62 #define LIS2MDL_MAG_INT_CRTL_REG 0x63 #define LIS2MDL_MAG_INT_SOURCE_REG 0x64 #define LIS2MDL_MAG_INT_THS_L_REG 0x65 #define LIS2MDL_MAG_INT_THS_H_REG 0x66 #define LIS2MDL_MAG_STATUS_REG 0x67 #define LIS2MDL_MAG_OUTX_L_REG 0x68 #define LIS2MDL_MAG_OUTX_H_REG 0x69 #define LIS2MDL_MAG_OUTY_L_REG 0x6A #define LIS2MDL_MAG_OUTY_H_REG 0x6B #define LIS2MDL_MAG_OUTZ_L_REG 0x6C #define LIS2MDL_MAG_OUTZ_H_REG 0x6D #define LIS2MDL_MAG_TEMP_OUT_L_REG 0x6E #define LIS2MDL_MAG_TEMP_OUT_H_REG 0x6F #define I_AM_LIS2MDL 0x40 #define LIS2MDL_MAG_ODR_BIT LIS2MDL_BIT(0x0C) #define LIS2MDL_MAG_ODR_10_HZ 0x00 #define LIS2MDL_MAG_ODR_20_HZ 0x04 #define LIS2MDL_MAG_ODR_50_HZ 0x08 #define LIS2MDL_MAG_ODR_100_HZ 0x0C #define LIS2MDL_MAG_SELFTEST_DISABLE 0x00 #define LIS2MDL_MAG_SELFTEST_ENABLE 0x02 #define LIS2MDL_MAG_FS_50_GA 0x00 #define LIS2MDL_MAG_REBOOT_DEFAULT 0x00 #define LIS2MDL_MAG_REBOOT_ENABLE 0x40 #define LIS2MDL_MAG_SOFT_RESET_DEFAULT 0x00 #define LIS2MDL_MAG_SOFT_RESET_ENABLE 0x02 #define LIS2MDL_MAG_CONFIG_LOWPOWER_BIT LIS2MDL_BIT(0x10) #define LIS2MDL_MAG_CONFIG_NORMAL_MODE 0x00 #define LIS2MDL_MAG_CONFIG_LOWPOWER_MODE 0x10 #define LIS2MDL_MAG_POWERMODE_BIT LIS2MDL_BIT(0x03) #define LIS2MDL_MAG_CONTINUOUS_MODE 0x00 #define LIS2MDL_MAG_SINGLE_MODE 0x01 #define LIS2MDL_MAG_POWERDOWN1_MODE 0x02 #define LIS2MDL_MAG_POWERDOWN2_MODE 0x03 #define LIS2MDL_MAG_COMP_TEMP_EN 0x80 #define LIS2MDL_MAG_OFF_CANC 0x02 #define LIS2MDL_MAG_BLE_BIT LIS2MDL_BIT(0x08) #define LIS2MDL_MAG_BLE_LSB 0x00 #define LIS2MDL_MAG_BLE_MSB 0x08 #define LIS2MDL_MAG_BDU_BIT LIS2MDL_BIT(0x10) #define LIS2MDL_MAG_BDU_CONTINUOUS 0x00 #define LIS2MDL_MAG_BDU_MSBLSB 0x10 //#define LIS2MDL_MAG_SENSITIVITY_FOR_FS_50GA 15/10 #define LIS2MDL_MAG_SENSITIVITY_FOR_FS_50GA 1500 #define LIS2MDL_MAG_SELF_TEST_MIN_X (15) // 15mGuass #define LIS2MDL_MAG_SELF_TEST_MIN_Y (15) // 15mGuass #define LIS2MDL_MAG_SELF_TEST_MIN_Z (15) // 15mGuass #define LIS2MDL_MAG_SELF_TEST_MAX_X (500) // 500mGuass #define LIS2MDL_MAG_SELF_TEST_MAX_Y (500) // 500mGuass #define LIS2MDL_MAG_SELF_TEST_MAX_Z (500) // 500mGuass #define LIS2MDL_MAG_SELF_TEST_DRY_WAIT_CNT 5 #define LIS2MDL_MAG_SELF_TEST_AVG_SAMPLE_CNT 50 i2c_dev_t LIS2MDL_ctx = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = LIS2MDL_I2C_ADDR, }; UNUSED static int drv_mag_st_lis2mdl_soft_reset(i2c_dev_t* drv) { int ret = 0; uint8_t value = LIS2MDL_MAG_SOFT_RESET_ENABLE; //ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, LIS2MDL_MAG_SOFT_RESET_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES); ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } UNUSED static int drv_mag_st_lis2mdl_selftest(i2c_dev_t* drv) { int ret = 0; uint8_t value = LIS2MDL_MAG_SELFTEST_ENABLE; //ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_C, LIS2MDL_MAG_SELFTEST_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES); ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } UNUSED static int drv_mag_st_lis2mdl_reboot(i2c_dev_t* drv) { int ret = 0; uint8_t value = LIS2MDL_MAG_REBOOT_ENABLE; //ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, LIS2MDL_MAG_REBOOT_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES); ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_st_lis2mdl_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, LIS2MDL_MAG_WHO_AM_I, &value, I2C_DATA_LEN, I2C_OP_RETRIES); LOG("%s %s right id (0x%02x), read id(0x%02x)\n", SENSOR_STR, __func__, id_value, value); if(unlikely(ret)){ return ret; } if (id_value != value){ return -1; } return 0; } static int drv_mag_st_lis2mdl_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (mode == DEV_POWER_ON) { value &= ~LIS2MDL_MAG_POWERMODE_BIT; value |= LIS2MDL_MAG_CONTINUOUS_MODE; } else{ value &= ~LIS2MDL_MAG_POWERMODE_BIT; value |= LIS2MDL_MAG_POWERDOWN2_MODE; } ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_st_lis2mdl_set_odr(i2c_dev_t* drv, uint8_t odr) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value &= ~LIS2MDL_MAG_ODR_BIT; value |= (uint8_t)odr; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_st_lis2mdl_enable_off_canc(i2c_dev_t* drv) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_B, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value |= LIS2MDL_MAG_OFF_CANC; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_B, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_st_lis2mdl_enable_temp(i2c_dev_t* drv) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value |= LIS2MDL_MAG_COMP_TEMP_EN; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } UNUSED static int drv_mag_st_lis2mdl_lowpower_mode(i2c_dev_t* drv, uint8_t lowpower_mode) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (lowpower_mode == LIS2MDL_MAG_CONFIG_LOWPOWER_MODE) { value &= ~LIS2MDL_MAG_CONFIG_LOWPOWER_BIT; value |= LIS2MDL_MAG_CONFIG_LOWPOWER_MODE; } else{ value &= ~LIS2MDL_MAG_CONFIG_LOWPOWER_BIT; value |= LIS2MDL_MAG_CONFIG_NORMAL_MODE; } ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_st_lis2mdl_set_range(i2c_dev_t* drv, uint32_t range) { // default FS +/-50Gauss return 0; } static int drv_mag_st_lis2mdl_set_ble(i2c_dev_t* drv, uint8_t ble) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (ble == LIS2MDL_MAG_BLE_LSB) { value &= ~LIS2MDL_MAG_BLE_BIT; value |= LIS2MDL_MAG_BLE_LSB; } else{ value &= ~LIS2MDL_MAG_BLE_BIT; value |= LIS2MDL_MAG_BLE_MSB; } ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_st_lis2mdl_set_bdu(i2c_dev_t* drv, uint8_t bdu) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (bdu == LIS2MDL_MAG_BDU_CONTINUOUS) { value &= ~LIS2MDL_MAG_BDU_BIT; value |= LIS2MDL_MAG_BDU_CONTINUOUS; } else{ value &= ~LIS2MDL_MAG_BDU_BIT; value |= LIS2MDL_MAG_BDU_MSBLSB; } ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_mag_st_lis2mdl_set_default_config(i2c_dev_t* drv) { int ret = 0; ret = drv_mag_st_lis2mdl_set_power_mode(drv, DEV_POWER_OFF); if(unlikely(ret)){ return ret; } ret = drv_mag_st_lis2mdl_set_odr(drv, LIS2MDL_MAG_ODR_10_HZ); if(unlikely(ret)){ return ret; } ret = drv_mag_st_lis2mdl_set_range(drv, LIS2MDL_MAG_FS_50_GA); if(unlikely(ret)){ return -1; } ret = drv_mag_st_lis2mdl_set_ble(drv, LIS2MDL_MAG_BLE_LSB); if(unlikely(ret)){ return -1; } ret = drv_mag_st_lis2mdl_set_bdu(drv, LIS2MDL_MAG_BDU_MSBLSB); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_st_lis2mdl_st_discard(i2c_dev_t* drv) { uint8_t i; uint8_t value = 0x00; int ret = 0; uint8_t buffer[6]; for (i = 0; i < LIS2MDL_MAG_SELF_TEST_DRY_WAIT_CNT; i ++) { ret = sensor_i2c_read(drv, LIS2MDL_MAG_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return ret; } if (value & 0x08) break; aos_msleep(10); } if (i >= LIS2MDL_MAG_SELF_TEST_DRY_WAIT_CNT) { LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = sensor_i2c_read(drv, (LIS2MDL_MAG_OUTX_L_REG | 0x80), buffer, 6, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return ret; } return ret; } static int drv_mag_st_lis2mdl_st_data(i2c_dev_t* drv,int32_t* data) { uint8_t i, j; int16_t x_raw, y_raw, z_raw; int32_t x_mg, y_mg, z_mg; int32_t x_sum, y_sum, z_sum; uint8_t value = 0x00; int ret = 0; uint8_t buffer[6]; x_sum = 0; y_sum = 0; z_sum = 0; for (i = 0; i < LIS2MDL_MAG_SELF_TEST_AVG_SAMPLE_CNT; i ++) { for (j = 0; j < LIS2MDL_MAG_SELF_TEST_DRY_WAIT_CNT; j ++) { ret = sensor_i2c_read(drv, LIS2MDL_MAG_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return ret; } if (value & 0x08) break; aos_msleep(10); } if (j >= LIS2MDL_MAG_SELF_TEST_DRY_WAIT_CNT) { LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = sensor_i2c_read(drv, (LIS2MDL_MAG_OUTX_L_REG | 0x80), buffer, 6, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return ret; } x_raw = (buffer[1] << 8) + buffer[0]; y_raw = (buffer[3] << 8) + buffer[2]; z_raw = (buffer[5] << 8) + buffer[4]; x_mg = x_raw * LIS2MDL_MAG_SENSITIVITY_FOR_FS_50GA / 1000; y_mg = y_raw * LIS2MDL_MAG_SENSITIVITY_FOR_FS_50GA / 1000; z_mg = z_raw * LIS2MDL_MAG_SENSITIVITY_FOR_FS_50GA / 1000; x_sum += x_mg; y_sum += y_mg; z_sum += z_mg; } data[0] = x_sum / LIS2MDL_MAG_SELF_TEST_AVG_SAMPLE_CNT; data[1] = y_sum / LIS2MDL_MAG_SELF_TEST_AVG_SAMPLE_CNT; data[2] = z_sum / LIS2MDL_MAG_SELF_TEST_AVG_SAMPLE_CNT; return ret; } static int drv_mag_st_lis2mdl_self_test(i2c_dev_t* drv,int32_t* data) { uint8_t i; uint8_t value = 0x00; int ret = 0; uint8_t cfg_reg[3]; int32_t out_nost[3]; int32_t out_st[3]; int32_t out_diff[3]; // Save cfg registers which will be modified during self-test ret = sensor_i2c_read(drv, (LIS2MDL_MAG_CFG_REG_A | 0x80), cfg_reg, 3, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return ret; } // Initialize Sensor, turn on sensor, COMP_TEMP_EN, BDU, Continueous-Measurement, // Enable offset concellation, ODR = 100Hz value = 0x8c; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } value = 0x02; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_B, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } value = 0x10; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } aos_msleep(20); // Discard the first sample ret = drv_mag_st_lis2mdl_st_discard(drv); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } // Read some samples, and averate them ret = drv_mag_st_lis2mdl_st_data(drv, out_nost); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } // Enable seft-test value = 0x12; ret = sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_C, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } aos_msleep(60); // Discard the first sample ret = drv_mag_st_lis2mdl_st_discard(drv); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } // Read some samples, and average them ret = drv_mag_st_lis2mdl_st_data(drv, out_st); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); goto restore; } // Check if the differences are between min and max for (i = 0; i < 3; i ++) { out_diff[i] = abs(out_st[i] - out_nost[i]); data[i] = out_diff[i]; } if ((LIS2MDL_MAG_SELF_TEST_MIN_X > out_diff[0]) || (out_diff[0] > LIS2MDL_MAG_SELF_TEST_MAX_X)) { LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); ret = -1; goto restore; } if ((LIS2MDL_MAG_SELF_TEST_MIN_Y > out_diff[1]) || (out_diff[1] > LIS2MDL_MAG_SELF_TEST_MAX_Y)) { LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); ret = -1; goto restore; } if ((LIS2MDL_MAG_SELF_TEST_MIN_Z > out_diff[2]) || (out_diff[2] > LIS2MDL_MAG_SELF_TEST_MAX_Z)) { LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); ret = -1; goto restore; } restore: ret += sensor_i2c_write(drv, LIS2MDL_MAG_CFG_REG_A | 0x80, cfg_reg, 3, I2C_OP_RETRIES); return ret; } static void drv_mag_st_lis2mdl_irq_handle(void) { /* no handle so far */ } static int drv_mag_st_lis2mdl_open(void) { int ret = 0; ret = drv_mag_st_lis2mdl_set_power_mode(&LIS2MDL_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_st_lis2mdl_close(void) { int ret = 0; ret = drv_mag_st_lis2mdl_set_power_mode(&LIS2MDL_ctx, DEV_POWER_OFF); if(unlikely(ret)){ return -1; } return 0; } static int drv_mag_st_lis2mdl_read(void* buf, size_t len) { int ret = 0; size_t size; int16_t pnRawData[3]; uint8_t buffer[6]; uint8_t i = 0; uint16_t sensitivity = 0; mag_data_t* pdata = (mag_data_t*)buf; if(buf == NULL){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } size = sizeof(mag_data_t); if(len < size){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = sensor_i2c_read(&LIS2MDL_ctx, (LIS2MDL_MAG_OUTX_L_REG | 0x80), buffer, 6, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } for(i=0; i<3; i++) { pnRawData[i]=((((uint16_t)buffer[2*i+1]) << 8) | (uint16_t)buffer[2*i]); } //LOG("%s %s: %d, %d, %d \n", SENSOR_STR, __func__, pnRawData[0], pnRawData[1], pnRawData[2]); sensitivity = LIS2MDL_MAG_SENSITIVITY_FOR_FS_50GA; for(i=0; i<3; i++) { //pdata->data[i] = ( int16_t )(pnRawData[i] * sensitivity); pdata->data[i] = pnRawData[i] * sensitivity / 1000; } pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_st_lis2mdl_ioctl(int cmd, unsigned long arg) { int ret = 0; dev_sensor_info_t *info = (dev_sensor_info_t *)arg; switch(cmd){ case SENSOR_IOCTL_ODR_SET:{ ret = drv_mag_st_lis2mdl_set_odr(&LIS2MDL_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_RANGE_SET:{ ret = drv_mag_st_lis2mdl_set_range(&LIS2MDL_ctx, arg); if(unlikely(ret)){ return -1; } }break; case SENSOR_IOCTL_SET_POWER:{ ret = drv_mag_st_lis2mdl_set_power_mode(&LIS2MDL_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 = "LIS2MDL"; info->range_max = 50; info->range_min = 50; info->unit = mGauss; }break; case SENSOR_IOCTL_SELF_TEST:{ ret = drv_mag_st_lis2mdl_self_test(&LIS2MDL_ctx, (int32_t*)info->data); //printf("%d %d %d\n",info->data[0],info->data[1],info->data[2]); LOG("%s %s: %d, %d, %d\n", SENSOR_STR, __func__, info->data[0],info->data[1],info->data[2]); return ret; } default:break; } return 0; } int drv_mag_st_lis2mdl_init(void){ int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.open = drv_mag_st_lis2mdl_open; sensor.close = drv_mag_st_lis2mdl_close; sensor.read = drv_mag_st_lis2mdl_read; sensor.write = NULL; sensor.ioctl = drv_mag_st_lis2mdl_ioctl; sensor.irq_handle = drv_mag_st_lis2mdl_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = drv_mag_st_lis2mdl_validate_id(&LIS2MDL_ctx, I_AM_LIS2MDL); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = drv_mag_st_lis2mdl_soft_reset(&LIS2MDL_ctx); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = drv_mag_st_lis2mdl_set_default_config(&LIS2MDL_ctx); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = drv_mag_st_lis2mdl_enable_temp(&LIS2MDL_ctx); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } ret = drv_mag_st_lis2mdl_enable_off_canc(&LIS2MDL_ctx); if(unlikely(ret)){ LOG("%s %s %s %d\n", SENSOR_STR, __func__, ERROR_LINE, __LINE__); return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_mag_st_lis2mdl_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_st_lis2mdl.c
C
apache-2.0
21,336
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define LIS3MDL_I2C_ADDR1 0x1C #define LIS3MDL_I2C_ADDR2 0x1E #define LIS3MDL_I2C_ADDR_TRANS(n) ((n) << 1) #define LIS3MDL_I2C_ADDR LIS3MDL_I2C_ADDR_TRANS(LIS3MDL_I2C_ADDR2) #define LIS3MDL_BIT(x) (x) #define I_AM_LIS3MDL 0x3D #define LIS3MDL_MAG_WHO_AM_I_REG 0x0F #define LIS3MDL_MAG_CTRL_REG1 0x20 #define LIS3MDL_MAG_CTRL_REG2 0x21 #define LIS3MDL_MAG_CTRL_REG3 0x22 #define LIS3MDL_MAG_CTRL_REG4 0x23 #define LIS3MDL_MAG_CTRL_REG5 0x24 #define LIS3MDL_MAG_STATUS_REG 0x27 #define LIS3MDL_MAG_OUTX_L 0x28 #define LIS3MDL_MAG_OUTX_H 0x29 #define LIS3MDL_MAG_OUTY_L 0x2A #define LIS3MDL_MAG_OUTY_H 0x2B #define LIS3MDL_MAG_OUTZ_L 0x2C #define LIS3MDL_MAG_OUTZ_H 0x2D #define LIS3MDL_MAG_TEMP_OUT_L 0x2E #define LIS3MDL_MAG_TEMP_OUT_H 0x2F #define LIS3MDL_MAG_INT_CFG 0x30 #define LIS3MDL_MAG_INT_SRC 0x31 #define LIS3MDL_MAG_INT_THS_L 0x32 #define LIS3MDL_MAG_INT_THS_H 0x33 #define LIS3MDL_MAG_TEMPSENSOR_ENABLE 0x80 #define LIS3MDL_MAG_TEMPSENSOR_DISABLE 0x00 #define LIS3MDL_MAG_OM_XY_BIT LIS3MDL_BIT(0x60) #define LIS3MDL_MAG_OM_XY_LOWPOWER 0x00 #define LIS3MDL_MAG_OM_XY_MEDIUM 0x20 #define LIS3MDL_MAG_OM_XY_HIGH 0x40 #define LIS3MDL_MAG_OM_XY_ULTRAHIGH 0x60 #define LIS3MDL_MAG_ODR_BIT LIS3MDL_BIT(0x1C) #define LIS3MDL_MAG_ODR_0_625_HZ 0x00 #define LIS3MDL_MAG_ODR_1_25_HZ 0x04 #define LIS3MDL_MAG_ODR_2_5_HZ 0x08 #define LIS3MDL_MAG_ODR_5_0_HZ 0x0C #define LIS3MDL_MAG_ODR_10_HZ 0x10 #define LIS3MDL_MAG_ODR_20_HZ 0x14 #define LIS3MDL_MAG_ODR_40_HZ 0x18 #define LIS3MDL_MAG_ODR_80_HZ 0x1C #define LMS303C_MAG_SELFTEST_DISABLE 0x00 #define LMS303C_MAG_SELFTEST_ENABLE 0x01 #define LIS3MDL_MAG_FS_BIT LIS3MDL_BIT(0x60) #define LIS3MDL_MAG_FS_DEFAULT 0x00 #define LIS3MDL_MAG_FS_4_GA 0x00 #define LIS3MDL_MAG_FS_8_GA 0x20 #define LIS3MDL_MAG_FS_12_GA 0x40 #define LIS3MDL_MAG_FS_16_GA 0x60 #define LIS3MDL_MAG_REBOOT_DEFAULT 0x00 #define LIS3MDL_MAG_REBOOT_ENABLE 0x08 #define LIS3MDL_MAG_SOFT_RESET_DEFAULT 0x00 #define LIS3MDL_MAG_SOFT_RESET_ENABLE 0x04 #define LIS3MDL_MAG_SIM_4_WIRE 0x00 #define LIS3MDL_MAG_SIM_3_WIRE 0x04 #define LIS3MDL_MAG_CONFIG_LOWPOWER_BIT LIS3MDL_BIT(0x20) #define LIS3MDL_MAG_CONFIG_NORMAL_MODE 0x00 #define LIS3MDL_MAG_CONFIG_LOWPOWER_MODE 0x20 #define LIS3MDL_MAG_POWERMODE_BIT LIS3MDL_BIT(0x03) #define LIS3MDL_MAG_CONTINUOUS_MODE 0x00 #define LIS3MDL_MAG_SINGLE_MODE 0x01 #define LIS3MDL_MAG_POWERDOWN1_MODE 0x02 #define LIS3MDL_MAG_POWERDOWN2_MODE 0x03 #define LIS3MDL_MAG_OM_Z_BIT LIS3MDL_BIT(0x0C) #define LIS3MDL_MAG_OM_Z_LOWPOWER 0x00 #define LIS3MDL_MAG_OM_Z_MEDIUM 0x04 #define LIS3MDL_MAG_OM_Z_HIGH 0x08 #define LIS3MDL_MAG_OM_Z_ULTRAHIGH 0x0C #define LIS3MDL_MAG_BLE_BIT LIS3MDL_BIT(0x02) #define LIS3MDL_MAG_BLE_LSB 0x00 #define LIS3MDL_MAG_BLE_MSB 0x02 #define LIS3MDL_MAG_BDU_BIT LIS3MDL_BIT(0x40) #define LIS3MDL_MAG_BDU_CONTINUOUS 0x00 #define LIS3MDL_MAG_BDU_MSBLSB 0x40 #define LIS3MDL_MAG_SENSITIVITY_FOR_FS_4GA (140) #define LIS3MDL_MAG_SENSITIVITY_FOR_FS_8GA (290) #define LIS3MDL_MAG_SENSITIVITY_FOR_FS_12GA (430) #define LIS3MDL_MAG_SENSITIVITY_FOR_FS_16GA (580) i2c_dev_t LIS3MDL_ctx = { .config.dev_addr = LIS3MDL_I2C_ADDR, }; static int drv_mag_st_lis3mdl_soft_reset(i2c_dev_t *drv) { int ret = 0; uint8_t value = LIS3MDL_MAG_SOFT_RESET_ENABLE; ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } return 0; } UNUSED static int drv_mag_st_lis3mdl_selftest(i2c_dev_t *drv) { int ret = 0; uint8_t value = LMS303C_MAG_SELFTEST_ENABLE; ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } return 0; } UNUSED static int drv_mag_st_lis3mdl_reboot(i2c_dev_t *drv) { int ret = 0; uint8_t value = LIS3MDL_MAG_REBOOT_ENABLE; ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } return 0; } static int drv_mag_st_lis3mdl_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, LIS3MDL_MAG_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_mag_st_lis3mdl_set_power_mode(i2c_dev_t * drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (mode == DEV_POWER_ON) { value &= ~LIS3MDL_MAG_POWERMODE_BIT; value |= LIS3MDL_MAG_CONTINUOUS_MODE; } else { value &= ~LIS3MDL_MAG_POWERMODE_BIT; value |= LIS3MDL_MAG_POWERDOWN2_MODE; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_odr(i2c_dev_t *drv, uint8_t odr) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value &= ~LIS3MDL_MAG_ODR_BIT; value |= (uint8_t)odr; ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_xyaxes(i2c_dev_t *drv, uint8_t data_rate) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (data_rate) { case LIS3MDL_MAG_OM_XY_LOWPOWER: { value &= ~LIS3MDL_MAG_OM_XY_BIT; value |= LIS3MDL_MAG_OM_XY_LOWPOWER; } break; case LIS3MDL_MAG_OM_XY_MEDIUM: { value &= ~LIS3MDL_MAG_OM_XY_BIT; value |= LIS3MDL_MAG_OM_XY_MEDIUM; } break; case LIS3MDL_MAG_OM_XY_HIGH: { value &= ~LIS3MDL_MAG_OM_XY_BIT; value |= LIS3MDL_MAG_OM_XY_HIGH; } break; case LIS3MDL_MAG_OM_XY_ULTRAHIGH: { value &= ~LIS3MDL_MAG_OM_XY_BIT; value |= LIS3MDL_MAG_OM_XY_ULTRAHIGH; } break; default: break; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_zaxes(i2c_dev_t *drv, uint8_t data_rate) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (data_rate) { case LIS3MDL_MAG_OM_Z_LOWPOWER: { value &= ~LIS3MDL_MAG_OM_Z_BIT; value |= LIS3MDL_MAG_OM_Z_LOWPOWER; } break; case LIS3MDL_MAG_OM_Z_MEDIUM: { value &= ~LIS3MDL_MAG_OM_Z_BIT; value |= LIS3MDL_MAG_OM_Z_MEDIUM; } break; case LIS3MDL_MAG_OM_Z_HIGH: { value &= ~LIS3MDL_MAG_OM_Z_BIT; value |= LIS3MDL_MAG_OM_Z_HIGH; } break; case LIS3MDL_MAG_OM_Z_ULTRAHIGH: { value &= ~LIS3MDL_MAG_OM_Z_BIT; value |= LIS3MDL_MAG_OM_Z_ULTRAHIGH; } break; default: break; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } UNUSED static int drv_mag_st_lis3mdl_lowpower_mode(i2c_dev_t *drv, uint8_t lowpower_mode) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (lowpower_mode == LIS3MDL_MAG_CONFIG_LOWPOWER_MODE) { value &= ~LIS3MDL_MAG_CONFIG_LOWPOWER_BIT; value |= LIS3MDL_MAG_CONFIG_LOWPOWER_MODE; } else { value &= ~LIS3MDL_MAG_CONFIG_LOWPOWER_BIT; value |= LIS3MDL_MAG_CONFIG_NORMAL_MODE; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG3, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_range(i2c_dev_t *drv, uint32_t range) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (range) { case MAG_RANGE_4GAUSS: { value &= ~LIS3MDL_MAG_FS_BIT; value |= LIS3MDL_MAG_FS_4_GA; } break; case MAG_RANGE_8GAUSS: { value &= ~LIS3MDL_MAG_FS_BIT; value |= LIS3MDL_MAG_FS_8_GA; } break; case MAG_RANGE_12GAUSS: { value &= ~LIS3MDL_MAG_FS_BIT; value |= LIS3MDL_MAG_FS_12_GA; } break; case MAG_RANGE_16GAUSS: { value &= ~LIS3MDL_MAG_FS_BIT; value |= LIS3MDL_MAG_FS_16_GA; } break; default: break; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_ble(i2c_dev_t *drv, uint8_t ble) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (ble == LIS3MDL_MAG_BLE_LSB) { value &= ~LIS3MDL_MAG_BLE_BIT; value |= LIS3MDL_MAG_BLE_LSB; } else { value &= ~LIS3MDL_MAG_BLE_BIT; value |= LIS3MDL_MAG_BLE_MSB; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG4, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_bdu(i2c_dev_t *drv, uint8_t bdu) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, LIS3MDL_MAG_CTRL_REG5, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (bdu == LIS3MDL_MAG_BDU_CONTINUOUS) { value &= ~LIS3MDL_MAG_BDU_BIT; value |= LIS3MDL_MAG_BDU_CONTINUOUS; } else { value &= ~LIS3MDL_MAG_BDU_BIT; value |= LIS3MDL_MAG_BDU_MSBLSB; } ret = sensor_i2c_write(drv, LIS3MDL_MAG_CTRL_REG5, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_mag_st_lis3mdl_set_default_config(i2c_dev_t *drv) { int ret = 0; ret = drv_mag_st_lis3mdl_set_power_mode(drv, DEV_POWER_OFF); if (unlikely(ret)) { return ret; } ret = drv_mag_st_lis3mdl_set_odr(drv, LIS3MDL_MAG_ODR_2_5_HZ); if (unlikely(ret)) { return ret; } ret = drv_mag_st_lis3mdl_set_xyaxes(drv, LIS3MDL_MAG_OM_XY_MEDIUM); if (unlikely(ret)) { return ret; } ret = drv_mag_st_lis3mdl_set_zaxes(drv, LIS3MDL_MAG_OM_Z_MEDIUM); if (unlikely(ret)) { return ret; } ret = drv_mag_st_lis3mdl_set_range(drv, MAG_RANGE_8GAUSS); if (unlikely(ret)) { return -1; } ret = drv_mag_st_lis3mdl_set_ble(drv, LIS3MDL_MAG_BLE_LSB); if (unlikely(ret)) { return -1; } ret = drv_mag_st_lis3mdl_set_bdu(drv, LIS3MDL_MAG_BDU_MSBLSB); if (unlikely(ret)) { return -1; } return 0; } static void drv_mag_st_lis3mdl_irq_handle(void) { /* no handle so far */ } static int drv_mag_st_lis3mdl_open(void) { int ret = 0; ret = drv_mag_st_lis3mdl_set_power_mode(&LIS3MDL_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } return 0; } static int drv_mag_st_lis3mdl_close(void) { int ret = 0; ret = drv_mag_st_lis3mdl_set_power_mode(&LIS3MDL_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } return 0; } static int drv_mag_st_lis3mdl_read(void *buf, size_t len) { int ret = 0; size_t size; int16_t pnRawData[3]; uint8_t ctrlm = 0; uint8_t buffer[6]; uint8_t i = 0; uint16_t sensitivity = 0; mag_data_t *pdata = (mag_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(mag_data_t); if (len < size) { return -1; } ret |= sensor_i2c_read(&LIS3MDL_ctx, LIS3MDL_MAG_CTRL_REG2, &ctrlm, I2C_DATA_LEN, I2C_OP_RETRIES); ret |= sensor_i2c_read(&LIS3MDL_ctx, (LIS3MDL_MAG_OUTX_L | 0x80), buffer, 6, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } for (i = 0; i < 3; i++) { pnRawData[i] = ((((uint16_t)buffer[2 * i + 1]) << 8) | (uint16_t)buffer[2 * i]); } switch (ctrlm & LIS3MDL_MAG_FS_BIT) { case LIS3MDL_MAG_FS_4_GA: sensitivity = LIS3MDL_MAG_SENSITIVITY_FOR_FS_4GA; break; case LIS3MDL_MAG_FS_8_GA: sensitivity = LIS3MDL_MAG_SENSITIVITY_FOR_FS_8GA; break; case LIS3MDL_MAG_FS_12_GA: sensitivity = LIS3MDL_MAG_SENSITIVITY_FOR_FS_12GA; break; case LIS3MDL_MAG_FS_16_GA: sensitivity = LIS3MDL_MAG_SENSITIVITY_FOR_FS_16GA; break; } for (i = 0; i < 3; i++) { pdata->data[i] = (int16_t)((pnRawData[i] * sensitivity) >> 10); } pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_st_lis3mdl_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { ret = drv_mag_st_lis3mdl_set_odr(&LIS3MDL_ctx, arg); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_RANGE_SET: { ret = drv_mag_st_lis3mdl_set_range(&LIS3MDL_ctx, arg); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_mag_st_lis3mdl_set_power_mode(&LIS3MDL_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 = "LIS3MDL"; info->range_max = 16; info->range_min = 4; info->unit = mGauss; } break; default: break; } return 0; } int drv_mag_st_lis3mdl_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_MAG; sensor.path = dev_mag_path; sensor.open = drv_mag_st_lis3mdl_open; sensor.close = drv_mag_st_lis3mdl_close; sensor.read = drv_mag_st_lis3mdl_read; sensor.write = NULL; sensor.ioctl = drv_mag_st_lis3mdl_ioctl; sensor.irq_handle = drv_mag_st_lis3mdl_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } ret = drv_mag_st_lis3mdl_validate_id(&LIS3MDL_ctx, I_AM_LIS3MDL); if (unlikely(ret)) { return -1; } ret = drv_mag_st_lis3mdl_soft_reset(&LIS3MDL_ctx); if (unlikely(ret)) { return -1; } ret = drv_mag_st_lis3mdl_set_default_config(&LIS3MDL_ctx); if (unlikely(ret)) { return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_mag_st_lis3mdl_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_st_lis3mdl.c
C
apache-2.0
16,894
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "ulog/ulog.h" #include <k_api.h> #include "sensor_drv_api.h" #include "sensor_hal.h" #define MMC3680KJ_REG_DATA 0x00 #define MMC3680KJ_REG_XL 0x00 #define MMC3680KJ_REG_XH 0x01 #define MMC3680KJ_REG_YL 0x02 #define MMC3680KJ_REG_YH 0x03 #define MMC3680KJ_REG_ZL 0x04 #define MMC3680KJ_REG_ZH 0x05 #define MMC3680KJ_REG_TEMP 0x06 #define MMC3680KJ_REG_STATUS 0x07 #define MMC3680KJ_REG_CTRL0 0x08 #define MMC3680KJ_REG_CTRL1 0x09 #define MMC3680KJ_REG_CTRL2 0x0a #define MMC3680KJ_REG_X_THD 0x0b #define MMC3680KJ_REG_Y_THD 0x0c #define MMC3680KJ_REG_Z_THD 0x0d #define MMC3680KJ_REG_SELFTEST 0x0e #define MMC3680KJ_REG_PASSWORD 0x0f #define MMC3680KJ_REG_OTPMODE 0x12 #define MMC3680KJ_REG_TESTMODE 0x13 #define MMC3680KJ_REG_SR_PWIDTH 0x20 #define MMC3680KJ_REG_OTP 0x2a #define MMC3680KJ_REG_PRODUCTID 0x2f #define MMC3680KJ_CMD_REFILL 0x20 #define MMC3680KJ_CMD_RESET 0x10 #define MMC3680KJ_CMD_SET 0x08 #define MMC3680KJ_CMD_TM_M 0x01 #define MMC3680KJ_CMD_TM_T 0x02 #define MMC3680KJ_CMD_START_MDT 0x04 #define MMC3680KJ_CMD_100HZ 0x00 #define MMC3680KJ_CMD_200HZ 0x01 #define MMC3680KJ_CMD_400HZ 0x02 #define MMC3680KJ_CMD_600HZ 0x03 #define MMC3680KJ_CMD_CM_14HZ 0x01 #define MMC3680KJ_CMD_CM_5HZ 0x02 #define MMC3680KJ_CMD_CM_1HZ 0x04 #define MMC3680KJ_CMD_SW_RST 0x80 #define MMC3680KJ_CMD_PASSWORD 0xe1 #define MMC3680KJ_CMD_OTP_OPER 0x11 #define MMC3680KJ_CMD_OTP_MR 0x80 #define MMC3680KJ_CMD_OTP_ACT 0x80 #define MMC3680KJ_CMD_OTP_NACT 0x00 #define MMC3680KJ_CMD_STSET_OPEN 0x02 #define MMC3680KJ_CMD_STRST_OPEN 0x04 #define MMC3680KJ_CMD_ST_CLOSE 0x00 #define MMC3680KJ_CMD_INT_MD_EN 0x40 #define MMC3680KJ_CMD_INT_MDT_EN 0x20 #define MMC3680KJ_PRODUCT_ID 0x0a #define MMC3680KJ_OTP_READ_DONE_BIT 0x10 #define MMC3680KJ_PUMP_ON_BIT 0x08 #define MMC3680KJ_MDT_BIT 0x04 #define MMC3680KJ_MEAS_T_DONE_BIT 0x02 #define MMC3680KJ_MEAS_M_DONE_BIT 0x01 #define MMC3680KJ_I2C_SLAVE_ADDR 0x30 #define MMC3680KJ_ADDR_TRANS(n) ((n) << 1) #define MMC3680KJ_I2C_ADDR MMC3680KJ_ADDR_TRANS(MMC3680KJ_I2C_SLAVE_ADDR) #define MMC3680KJ_OFFSET 32768 #define MMC3680KJ_SENSITIVITY 1024000 #define MMC3680KJ_T_ZERO -75 #define MMC3680KJ_T_SENSITIVITY 80 #define MMC3680KJ_MAG_DATA_SIZE 6 #define OTP_CONVERT(REG) (((REG) >= 32 ? (32 - (REG)) : (REG)) * 6) typedef enum { FLAG_INIT_MAG = 0, FLAG_INIT_TEMP, } FLAG_INIT_BIT; i2c_dev_t mmc3680kj_ctx = { .port = 4, .config.address_width = 7, .config.freq = 100000, .config.dev_addr = MMC3680KJ_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; static int32_t g_otp_matrix[3] = { 1000000, 1000000, 1350000 }; static int mmc3680kj_validate_id(i2c_dev_t *drv, uint8_t product_id) { uint8_t value = 0; int ret = 0; if (drv == NULL) { return -1; } ret = sensor_i2c_read(drv, MMC3680KJ_REG_PRODUCTID, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (value != product_id) { return -1; } return 0; } static int mmc3680kj_check_otp(i2c_dev_t *drv) { uint8_t value = 0; int ret = 0; if (drv == NULL) { return -1; } ret = sensor_i2c_read(drv, MMC3680KJ_REG_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if ((value & MMC3680KJ_OTP_READ_DONE_BIT) != MMC3680KJ_OTP_READ_DONE_BIT) { return -1; } return 0; } static int mmc3680kj_get_comp_matrix(i2c_dev_t *drv) { uint8_t value = 0; uint8_t reg_data[2] = { 0 }; int ret = 0; if (drv == NULL) { return -1; } value = MMC3680KJ_CMD_PASSWORD; ret = sensor_i2c_write(drv, MMC3680KJ_REG_PASSWORD, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = MMC3680KJ_CMD_OTP_OPER; ret = sensor_i2c_write(drv, MMC3680KJ_REG_OTPMODE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = MMC3680KJ_CMD_OTP_MR; ret = sensor_i2c_write(drv, MMC3680KJ_REG_TESTMODE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = MMC3680KJ_CMD_OTP_ACT; ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, MMC3680KJ_REG_OTP, reg_data, 2, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = MMC3680KJ_CMD_OTP_NACT; ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } g_otp_matrix[0] = 1000000; g_otp_matrix[1] = OTP_CONVERT(reg_data[0] & 0x3f) * 1000 + 1000000; g_otp_matrix[2] = (OTP_CONVERT((reg_data[1] & 0x0f) << 2 | (reg_data[0] & 0xc0) >> 6) + 1000) * 1350; return 0; } static int mmc3680kj_set_pulse_width(i2c_dev_t *drv) { uint8_t value = 0; int ret = 0; if (drv == NULL) { return -1; } value = MMC3680KJ_CMD_OTP_NACT; ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL2, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = MMC3680KJ_CMD_PASSWORD; ret = sensor_i2c_write(drv, MMC3680KJ_REG_PASSWORD, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, MMC3680KJ_REG_SR_PWIDTH, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value &= 0xe7; ret = sensor_i2c_write(drv, MMC3680KJ_REG_SR_PWIDTH, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int mmc3680kj_set(i2c_dev_t *drv) { uint8_t value = 0; int ret = 0; if (drv == NULL) { return -1; } value = MMC3680KJ_CMD_SET; ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL0, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } krhino_task_sleep(krhino_ms_to_ticks(1)); return 0; } static int mmc3680kj_set_output_resolution(i2c_dev_t *drv, uint8_t res) { int ret = 0; if (drv == NULL) { return -1; } ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL1, &res, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int mmc3680kj_enable(i2c_dev_t *drv, FLAG_INIT_BIT flag) { uint8_t value = 0; int ret = 0; if (drv == NULL) { return -1; } if (flag == FLAG_INIT_MAG) { value = MMC3680KJ_CMD_TM_M; ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL0, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } do { krhino_task_sleep(krhino_ms_to_ticks(10)); ret = sensor_i2c_read(drv, MMC3680KJ_REG_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } while ((value & 0x01) != 0x01); } else if (flag == FLAG_INIT_TEMP) { value = MMC3680KJ_CMD_TM_T; ret = sensor_i2c_write(drv, MMC3680KJ_REG_CTRL0, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } do { krhino_task_sleep(krhino_ms_to_ticks(10)); ret = sensor_i2c_read(drv, MMC3680KJ_REG_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } while ((value & 0x02) != 0x02); } else { return -1; } return 0; } static int mmc3680kj_need_set() { static sys_time_t last_time = 0; sys_time_t now_time = 0; now_time = krhino_sys_time_get(); if (now_time - last_time > 5000) { last_time = now_time; return 1; } return 0; } static void drv_mag_memsic_mmc3680kj_irq_handle(void) { /* no handle so far */ } static int drv_mag_memsic_mmc3680kj_open(void) { int ret = 0; ret = mmc3680kj_set(&mmc3680kj_ctx); if (unlikely(ret)) { return ret; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_mag_memsic_mmc3680kj_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_mag_memsic_mmc3680kj_read(void *buf, size_t len) { int ret = 0; size_t size; mag_data_t *pdata = (mag_data_t *)buf; uint8_t reg_raw[MMC3680KJ_MAG_DATA_SIZE] = { 0 }; uint16_t data_raw[3] = { 0 }; uint32_t mag_raw[3] = { 0 }; if (buf == NULL) { return -1; } size = sizeof(mag_data_t); if (len < size) { return -1; } if (mmc3680kj_need_set()) { ret = mmc3680kj_set(&mmc3680kj_ctx); if (unlikely(ret)) { return ret; } } ret = mmc3680kj_enable(&mmc3680kj_ctx, FLAG_INIT_MAG); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(&mmc3680kj_ctx, MMC3680KJ_REG_DATA, reg_raw, MMC3680KJ_MAG_DATA_SIZE, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } data_raw[0] = (uint16_t)(reg_raw[1] << 8 | reg_raw[0]); data_raw[1] = (uint16_t)(reg_raw[3] << 8 | reg_raw[2]); data_raw[2] = (uint16_t)(reg_raw[5] << 8 | reg_raw[4]); mag_raw[0] = (uint32_t)(data_raw[0]); mag_raw[1] = (uint32_t)(data_raw[1] - data_raw[2] + MMC3680KJ_OFFSET); mag_raw[2] = (uint32_t)(data_raw[1] + data_raw[2] - MMC3680KJ_OFFSET); pdata->data[0] = (int32_t)(mag_raw[0] - MMC3680KJ_OFFSET) * g_otp_matrix[0] / MMC3680KJ_SENSITIVITY; pdata->data[1] = (int32_t)(mag_raw[1] - MMC3680KJ_OFFSET) * g_otp_matrix[1] / MMC3680KJ_SENSITIVITY; pdata->data[2] = (int32_t)(mag_raw[2] - MMC3680KJ_OFFSET) * g_otp_matrix[2] / MMC3680KJ_SENSITIVITY; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_mag_memsic_mmc3680kj_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_mag_memsic_mmc3680kj_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 = "MMC3680KJ"; info->unit = mGauss; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_mag_memsic_mmc3680kj_init(void) { int ret = 0; sensor_obj_t sensor_mag; memset(&sensor_mag, 0, sizeof(sensor_mag)); if (!g_init_bitwise) { ret = mmc3680kj_check_otp(&mmc3680kj_ctx); if (unlikely(ret)) { return -1; } ret = mmc3680kj_validate_id(&mmc3680kj_ctx, MMC3680KJ_PRODUCT_ID); if (unlikely(ret)) { return -1; } } if (!(g_init_bitwise & (1 << FLAG_INIT_MAG))) { /* fill the sensor_mag obj parameters here */ sensor_mag.tag = TAG_DEV_MAG; sensor_mag.path = dev_mag_path; sensor_mag.io_port = I2C_PORT; sensor_mag.open = drv_mag_memsic_mmc3680kj_open; sensor_mag.close = drv_mag_memsic_mmc3680kj_close; sensor_mag.read = drv_mag_memsic_mmc3680kj_read; sensor_mag.write = drv_mag_memsic_mmc3680kj_write; sensor_mag.ioctl = drv_mag_memsic_mmc3680kj_ioctl; sensor_mag.irq_handle = drv_mag_memsic_mmc3680kj_irq_handle; ret = sensor_create_obj(&sensor_mag); if (unlikely(ret)) { return -1; } ret = mmc3680kj_get_comp_matrix(&mmc3680kj_ctx); if (unlikely(ret)) { return -1; } ret = mmc3680kj_set_pulse_width(&mmc3680kj_ctx); if (unlikely(ret)) { return -1; } ret = mmc3680kj_set_output_resolution(&mmc3680kj_ctx, MMC3680KJ_CMD_100HZ); if (unlikely(ret)) { return -1; } g_init_bitwise |= 1 << FLAG_INIT_MAG; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_temp_memsic_mmc3680kj_irq_handle(void) { /* no handle so far */ } static int drv_temp_memsic_mmc3680kj_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_memsic_mmc3680kj_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_memsic_mmc3680kj_read(void *buf, size_t len) { int ret = 0; size_t size; temperature_data_t *pdata = (temperature_data_t *)buf; uint8_t reg_raw = 0; if (buf == NULL) { return -1; } size = sizeof(temperature_data_t); if (len < size) { return -1; } ret = mmc3680kj_enable(&mmc3680kj_ctx, FLAG_INIT_TEMP); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(&mmc3680kj_ctx, MMC3680KJ_REG_TEMP, &reg_raw, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } pdata->t = reg_raw * MMC3680KJ_T_SENSITIVITY / 100 + MMC3680KJ_T_ZERO; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_memsic_mmc3680kj_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_temp_memsic_mmc3680kj_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 = "MMC3680KJ"; info->unit = dCelsius; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_memsic_mmc3680kj_init(void) { int ret = 0; sensor_obj_t sensor_temp; memset(&sensor_temp, 0, sizeof(sensor_temp)); if (!g_init_bitwise) { ret = mmc3680kj_check_otp(&mmc3680kj_ctx); if (unlikely(ret)) { return -1; } ret = mmc3680kj_validate_id(&mmc3680kj_ctx, MMC3680KJ_PRODUCT_ID); 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_memsic_mmc3680kj_open; sensor_temp.close = drv_temp_memsic_mmc3680kj_close; sensor_temp.read = drv_temp_memsic_mmc3680kj_read; sensor_temp.write = drv_temp_memsic_mmc3680kj_write; sensor_temp.ioctl = drv_temp_memsic_mmc3680kj_ioctl; sensor_temp.irq_handle = drv_temp_memsic_mmc3680kj_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; } SENSOR_DRV_ADD(drv_mag_memsic_mmc3680kj_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_mag_temp_memsic_mmc3680kj.c
C
apache-2.0
16,156
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define LTR659_I2C_SLAVE_ADDR 0x23 #define LTR659_SW_RESET 0x80 #define LTR659_PS_CONTR 0x81 /* PS operation mode */ #define LTR659_PS_LED 0x82 /* LED pulse freq, current duty, peak current */ #define LTR659_PS_N_PULSES 0x83 /* PS number of pulses */ #define LTR659_PS_MEAS_RATE 0x84 /* measurement rate*/ #define LTR659_PART_ID 0x86 #define LTR659_MANUFAC_ID 0x87 #define LTR659_PS_STATUS 0x8C #define LTR659_PS_DATA_0 0x8D #define LTR659_PS_DATA_1 0x8E #define LTR659_INTERRUPT 0x8F #define LTR659_PS_THRES_UP_0 0x90 /* PS interrupt upper threshold, lower byte */ #define LTR659_PS_THRES_UP_1 0x91 /* PS interrupt upper threshold, upper byte */ #define LTR659_PS_THRES_LOW_0 0x92 /* PS interrupt lower threshold, lower byte */ #define LTR659_PS_THRES_LOW_1 0x93 /* PS interrupt lower threshold, upper byte */ #define LTR659_PS_OFFSET_1 0x94 /* PS offset, upper byte */ #define LTR659_PS_OFFSET_0 0x95 /* PS offset, lower byte */ #define LTR659_INTR_PRST 0x9E /* PS interrupt persist setting */ #define LTR659_ADDR_TRANS(n) ((n) << 1) #define LTR659_I2C_ADDR LTR659_ADDR_TRANS(LTR659_I2C_SLAVE_ADDR) #define LTR659_PART_ID_VAL 0x92 #define LTR659_MANUFAC_ID_VAL 0x05 #define LTR659_SW_RESET_REG_SW_RESET__POS (1) #define LTR659_SW_RESET_REG_SW_RESET__MSK (0x02) #define LTR659_SW_RESET_REG_SW_RESET__REG (LTR659_SW_RESET) #define LTR659_PS_CONTR_REG_PS_MODE__POS (0) #define LTR659_PS_CONTR_REG_PS_MODE__MSK (0x03) #define LTR659_PS_CONTR_REG_PS_MODE__REG (LTR659_PS_CONTR) #define LTR659_PS_CONTR_REG_PS_GAIN__POS (2) #define LTR659_PS_CONTR_REG_PS_GAIN__MSK (0x0C) #define LTR659_PS_CONTR_REG_PS_GAIN__REG (LTR659_PS_CONTR) #define LTR659_PS_CONTR_REG_PS_SAT_IND_EN__POS (5) #define LTR659_PS_CONTR_REG_PS_SAT_IND_EN__MSK (0x20) #define LTR659_PS_CONTR_REG_PS_SAT_IND_EN__REG (LTR659_PS_CONTR) #define LTR659_PS_LED_REG_LED_CURR__POS (0) #define LTR659_PS_LED_REG_LED_CURR__MSK (0x07) #define LTR659_PS_LED_REG_LED_CURR__REG (LTR659_PS_LED) #define LTR659_PS_LED_REG_LED_DUTY__POS (3) #define LTR659_PS_LED_REG_LED_DUTY__MSK (0x18) #define LTR659_PS_LED_REG_LED_DUTY__REG (LTR659_PS_LED) #define LTR659_PS_LED_REG_LED_PULSE__POS (5) #define LTR659_PS_LED_REG_LED_PULSE__MSK (0xE0) #define LTR659_PS_LED_REG_LED_PULSE__REG (LTR659_PS_LED) #define LTR659_PS_N_PULSES_REG_PULSES__POS (0) #define LTR659_PS_N_PULSES_REG_PULSES__MSK (0x0F) #define LTR659_PS_N_PULSES_REG_PULSES__REG (LTR659_PS_N_PULSES) #define LTR659_PS_MEAS_RATE_REG_MEAS_RPT_RATE__POS (0) #define LTR659_PS_MEAS_RATE_REG_MEAS_RPT_RATE__MSK (0x0F) #define LTR659_PS_MEAS_RATE_REG_MEAS_RPT_RATE__REG (LTR659_PS_MEAS_RATE) #define LTR659_PS_STATUS_REG_PS_DATA_STATUS__POS (0) #define LTR659_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01) #define LTR659_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR659_PS_STATUS) #define LTR659_PS_STATUS_REG_PS_INT_STATUS__POS (1) #define LTR659_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02) #define LTR659_PS_STATUS_REG_PS_INT_STATUS__REG (LTR659_PS_STATUS) #define LTR659_INTERRUPT_REG_INT_MODE__POS (0) #define LTR659_INTERRUPT_REG_INT_MODE__MSK (0x01) #define LTR659_INTERRUPT_REG_INT_MODE__REG (LTR659_INTERRUPT) #define LTR659_INTERRUPT_REG_INT_POLARITY__POS (2) #define LTR659_INTERRUPT_REG_INT_POLARITY__MSK (0x04) #define LTR659_INTERRUPT_REG_INT_POLARITY__REG (LTR659_INTERRUPT) #define LTR659_INTR_PRST_REG_PS_PERSIST__POS (4) #define LTR659_INTR_PRST_REG_PS_PERSIST__MSK (0xF0) #define LTR659_INTR_PRST_REG_PS_PERSIST__REG (LTR659_INTR_PRST) #define LTR659_GET_BITSLICE(regvar, bitname) ((regvar & LTR659_##bitname##__MSK) >> LTR659_##bitname##__POS) #define LTR659_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR659_##bitname##__MSK) | ((val<<LTR659_##bitname##__POS)&LTR659_##bitname##__MSK)) #define LTR659_WAIT_TIME_PER_CHECK (10) #define LTR659_WAIT_TIME_TOTAL (100) typedef enum { LTR659_SW_RESET_FALSE = 0x00, LTR659_SW_RESET_TRUE = 0x01, } LTR659_CFG_SW_RESET; typedef enum { LTR659_PS_STANDBY = 0x00, LTR659_PS_ACTIVE = 0x02, } LTR659_CFG_PS_MODE; typedef enum { LTR659_PS_GAIN_16X = 0x00, LTR659_PS_GAIN_32X = 0x02, LTR659_PS_GAIN_64X = 0x03, } LTR659_CFG_PS_GAIN; typedef enum { LTR659_PS_SAT_IND_FALSE = 0x00, LTR659_PS_SAT_IND_TRUE = 0x01, } LTR659_CFG_PS_SAT_IND_EN; typedef enum { LTR659_LED_PEAK_CURRENT_5 = 0x00, /* LED pulse current level = 5mA */ LTR659_LED_PEAK_CURRENT_10 = 0x01, /* LED pulse current level = 10mA */ LTR659_LED_PEAK_CURRENT_20 = 0x02, /* LED pulse current level = 20mA */ LTR659_LED_PEAK_CURRENT_50 = 0x03, /* LED pulse current level = 50mA */ LTR659_LED_PEAK_CURRENT_100 = 0x04, /* LED pulse current level = 100mA (default) */ } LTR659_CFG_LED_PEAK_CURRENT; typedef enum { LTR659_LED_DUTY_CYCLE_25PCT = 0x00, /* Duty = 25% */ LTR659_LED_DUTY_CYCLE_50PCT = 0x01, /* Duty = 50% */ LTR659_LED_DUTY_CYCLE_75PCT = 0x02, /* Duty = 75% */ LTR659_LED_DUTY_CYCLE_100PCT = 0x03, /* Duty = 100% (default) */ } LTR659_CFG_LED_DUTY_CYCLE; typedef enum { LTR659_LED_PULSE_30kHZ = 0x00, /* LED pulse period = 30kHz */ LTR659_LED_PULSE_40kHZ = 0x01, /* LED pulse period = 40kHz */ LTR659_LED_PULSE_50kHZ = 0x02, /* LED pulse period = 50kHz */ LTR659_LED_PULSE_60kHZ = 0x03, /* LED pulse period = 60kHz */ LTR659_LED_PULSE_70kHZ = 0x04, /* LED pulse period = 70kHz */ LTR659_LED_PULSE_80kHZ = 0x05, /* LED pulse period = 80kHz */ LTR659_LED_PULSE_90kHZ = 0x06, /* LED pulse period = 90kHz */ LTR659_LED_PULSE_100kHZ = 0x07, /* LED pulse period = 100kHz */ } LTR659_CFG_LED_PULSE_FREQUENCY; typedef enum { LTR659_PS_MEAS_RATE_50 = 0x00, /* PS Measurement Repeat Rate = 50ms */ LTR659_PS_MEAS_RATE_70 = 0x01, /* PS Measurement Repeat Rate = 70ms */ LTR659_PS_MEAS_RATE_100 = 0x02, /* PS Measurement Repeat Rate = 100ms (default) */ LTR659_PS_MEAS_RATE_200 = 0x03, /* PS Measurement Repeat Rate = 20ms */ LTR659_PS_MEAS_RATE_500 = 0x04, /* PS Measurement Repeat Rate = 500ms */ LTR659_PS_MEAS_RATE_1000 = 0x05, /* PS Measurement Repeat Rate = 1000ms */ LTR659_PS_MEAS_RATE_2000 = 0x06, /* PS Measurement Repeat Rate = 2000ms */ LTR659_PS_MEAS_RATE_10 = 0x08, /* PS Measurement Repeat Rate = 10ms */ } LTR659_CFG_PS_MEAS_RPT_RATE; typedef enum { LTR659_PS_DATA_STATUS_OLD = 0x00, LTR659_PS_DATA_STATUS_NEW = 0x01, } LTR659_CFG_PS_DATA_STATUS; typedef enum { LTR659_PS_INT_STATUS_INACTIVE = 0x00, LTR659_PS_INT_STATUS_ACTIVE = 0x01, } LTR659_CFG_PS_INT_STATUS; typedef enum { LTR659_PS_INT_MODE_DISABLE = 0x00, LTR659_PS_INT_MODE_ENABLE = 0x01, } LTR659_CFG_PS_INT_MODE; typedef enum { LTR659_PS_INT_POLARITY_ACTIVE_LO = 0x00, LTR659_PS_INT_POLARITY_ACTIVE_HI = 0x01, } LTR659_CFG_PS_INT_POLARITY; i2c_dev_t ltr659_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = LTR659_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; static int drv_ps_liteon_ltr659_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, LTR659_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, LTR659_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_ps_liteon_ltr659_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, LTR659_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 = LTR659_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR659_PS_STANDBY); break; case DEV_POWER_ON: dev_mode = LTR659_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR659_PS_ACTIVE); break; default: return -1; } ret = sensor_i2c_write(drv, LTR659_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } UNUSED static int drv_ps_liteon_ltr659_is_ready(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR659_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return 0; } ret = (LTR659_GET_BITSLICE(value, PS_STATUS_REG_PS_DATA_STATUS) == LTR659_PS_DATA_STATUS_NEW) ? 1 : 0; return ret; } static int drv_ps_liteon_ltr659_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR659_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = LTR659_SET_BITSLICE(value, PS_CONTR_REG_PS_GAIN, LTR659_PS_GAIN_16X); value = LTR659_SET_BITSLICE(value, PS_CONTR_REG_PS_SAT_IND_EN, LTR659_PS_SAT_IND_FALSE); ret = sensor_i2c_write(drv, LTR659_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR659_SET_BITSLICE(value, PS_LED_REG_LED_CURR, LTR659_LED_PEAK_CURRENT_100); value = LTR659_SET_BITSLICE(value, PS_LED_REG_LED_DUTY, LTR659_LED_DUTY_CYCLE_100PCT); value = LTR659_SET_BITSLICE(value, PS_LED_REG_LED_PULSE, LTR659_LED_PULSE_60kHZ); ret = sensor_i2c_write(drv, LTR659_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR659_SET_BITSLICE(value, PS_N_PULSES_REG_PULSES, 4); ret = sensor_i2c_write(drv, LTR659_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR659_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RPT_RATE, LTR659_PS_MEAS_RATE_100); ret = sensor_i2c_write(drv, LTR659_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static void drv_ps_liteon_ltr659_irq_handle(void) { /* no handle so far */ } static int drv_ps_liteon_ltr659_open(void) { int ret = 0; ret = drv_ps_liteon_ltr659_set_power_mode(&ltr659_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_liteon_ltr659_close(void) { int ret = 0; ret = drv_ps_liteon_ltr659_set_power_mode(&ltr659_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_liteon_ltr659_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; if (buf == NULL) { return -1; } size = sizeof(proximity_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&ltr659_ctx, LTR659_PS_DATA_0, &reg_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr659_ctx, LTR659_PS_DATA_1, &reg_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } pdata->present = (((uint32_t) (reg_data[1] & 0x07) << 8) | reg_data[0]); pdata->timestamp = aos_now_ms(); return (int) size; } static int drv_ps_liteon_ltr659_write(const void *buf, size_t len) { (void) buf; (void) len; return 0; } static int drv_ps_liteon_ltr659_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_SET_POWER: { ret = drv_ps_liteon_ltr659_set_power_mode(&ltr659_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->vendor = DEV_SENSOR_VENDOR_LITEON; info->model = "LTR659"; info->unit = cm; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_ps_liteon_ltr659_init(void) { int ret = 0; sensor_obj_t sensor_ps; memset(&sensor_ps, 0, sizeof(sensor_ps)); if (!g_init_bitwise) { ret = drv_ps_liteon_ltr659_validate_id(&ltr659_ctx, LTR659_PART_ID_VAL, LTR659_MANUFAC_ID_VAL); if (unlikely(ret)) { return -1; } } if (!g_init_bitwise) { /* 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.mode = DEV_POLLING; sensor_ps.power = DEV_POWER_OFF; sensor_ps.open = drv_ps_liteon_ltr659_open; sensor_ps.close = drv_ps_liteon_ltr659_close; sensor_ps.read = drv_ps_liteon_ltr659_read; sensor_ps.write = drv_ps_liteon_ltr659_write; sensor_ps.ioctl = drv_ps_liteon_ltr659_ioctl; sensor_ps.irq_handle = drv_ps_liteon_ltr659_irq_handle; ret = sensor_create_obj(&sensor_ps); if (unlikely(ret)) { return -1; } ret = drv_ps_liteon_ltr659_set_default_config(&ltr659_ctx); if (unlikely(ret)) { return -1; } g_init_bitwise = 1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_ps_liteon_ltr659_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_liteon_ltr659.c
C
apache-2.0
15,592
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define LTR690_I2C_SLAVE_ADDR 0x23 #define LTR690_PS_CONTR 0x81 /* PS operation mode */ #define LTR690_PS_LED 0x82 /* LED pulse freq, current duty, peak current */ #define LTR690_PS_N_PULSES 0x83 /* PS number of pulses */ #define LTR690_PS_MEAS_RATE 0x84 /* measurement rate*/ #define LTR690_PART_ID 0x86 #define LTR690_MANUFAC_ID 0x87 #define LTR690_PS_STATUS 0x91 #define LTR690_PS_DATA_0 0x92 #define LTR690_PS_DATA_1 0x93 #define LTR690_INTERRUPT 0xA6 #define LTR690_INTR_PRST 0xA7 /* PS interrupt persist setting */ #define LTR690_PS_THRES_UP_0 0xA8 /* PS interrupt upper threshold, lower byte */ #define LTR690_PS_THRES_UP_1 0xA9 /* PS interrupt upper threshold, upper byte */ #define LTR690_PS_THRES_LOW_0 0xAA /* PS interrupt lower threshold, lower byte */ #define LTR690_PS_THRES_LOW_1 0xAB /* PS interrupt lower threshold, upper byte */ #define LTR690_PS_CROSSTALK_DATA_LSB 0xB0 /* PS crosstalk data, lower byte */ #define LTR690_PS_CROSSTALK_DATA_MSB 0xB1 /* PS crosstalk data, upper byte */ #define LTR690_ADDR_TRANS(n) ((n) << 1) #define LTR690_I2C_ADDR LTR690_ADDR_TRANS(LTR690_I2C_SLAVE_ADDR) #define LTR690_PART_ID_VAL 0x1E #define LTR690_MANUFAC_ID_VAL 0x05 #define LTR690_PS_CONTR_REG_SW_RESET__POS (0) #define LTR690_PS_CONTR_REG_SW_RESET__MSK (0x01) #define LTR690_PS_CONTR_REG_SW_RESET__REG (LTR690_PS_CONTR) #define LTR690_PS_CONTR_REG_PS_MODE__POS (1) #define LTR690_PS_CONTR_REG_PS_MODE__MSK (0x02) #define LTR690_PS_CONTR_REG_PS_MODE__REG (LTR690_PS_CONTR) #define LTR690_PS_CONTR_REG_FTN_NTF_EN__POS (2) #define LTR690_PS_CONTR_REG_FTN_NTF_EN__MSK (0x04) #define LTR690_PS_CONTR_REG_FTN_NTF_EN__REG (LTR690_PS_CONTR) #define LTR690_PS_CONTR_REG_PS_OS__POS (3) #define LTR690_PS_CONTR_REG_PS_OS__MSK (0x08) #define LTR690_PS_CONTR_REG_PS_OS__REG (LTR690_PS_CONTR) #define LTR690_PS_LED_REG_LED_CURR__POS (0) #define LTR690_PS_LED_REG_LED_CURR__MSK (0x07) #define LTR690_PS_LED_REG_LED_CURR__REG (LTR690_PS_LED) #define LTR690_PS_LED_REG_PULSE_WIDTH__POS (4) #define LTR690_PS_LED_REG_PULSE_WIDTH__MSK (0x10) #define LTR690_PS_LED_REG_PULSE_WIDTH__REG (LTR690_PS_LED) #define LTR690_PS_N_PULSES_REG_PULSES__POS (0) #define LTR690_PS_N_PULSES_REG_PULSES__MSK (0x0F) #define LTR690_PS_N_PULSES_REG_PULSES__REG (LTR690_PS_N_PULSES) #define LTR690_PS_N_PULSES_REG_SEQUENCE__POS (4) #define LTR690_PS_N_PULSES_REG_SEQUENCE__MSK (0xF0) #define LTR690_PS_N_PULSES_REG_SEQUENCE__REG (LTR690_PS_N_PULSES) #define LTR690_PS_MEAS_RATE_REG_MEAS_RATE__POS (0) #define LTR690_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07) #define LTR690_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR690_PS_MEAS_RATE) #define LTR690_PS_STATUS_REG_PS_DATA_STATUS__POS (0) #define LTR690_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01) #define LTR690_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR690_PS_STATUS) #define LTR690_PS_STATUS_REG_PS_INT_STATUS__POS (1) #define LTR690_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02) #define LTR690_PS_STATUS_REG_PS_INT_STATUS__REG (LTR690_PS_STATUS) #define LTR690_PS_STATUS_REG_NTF__POS (6) #define LTR690_PS_STATUS_REG_NTF__MSK (0x40) #define LTR690_PS_STATUS_REG_NTF__REG (LTR690_PS_STATUS) #define LTR690_PS_STATUS_REG_FTN__POS (7) #define LTR690_PS_STATUS_REG_FTN__MSK (0x80) #define LTR690_PS_STATUS_REG_FTN__REG (LTR690_PS_STATUS) #define LTR690_GET_BITSLICE(regvar, bitname) ((regvar & LTR690_##bitname##__MSK) >> LTR690_##bitname##__POS) #define LTR690_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR690_##bitname##__MSK) | ((val<<LTR690_##bitname##__POS)&LTR690_##bitname##__MSK)) #define LTR690_WAIT_TIME_PER_CHECK (10) #define LTR690_WAIT_TIME_TOTAL (50) typedef enum { LTR690_SW_RESET_NEG = 0x00, LTR690_SW_RESET = 0x01, } LTR690_CFG_SW_RESET; typedef enum { LTR690_PS_STANDBY = 0x00, LTR690_PS_ACTIVE = 0x01, } LTR690_CFG_PS_MODE; typedef enum { LTR690_FTN_NTF_EN_FALSE = 0x00, LTR690_FTN_NTF_EN_TRUE = 0x01, } LTR690_CFG_FTN_NTF_EN; typedef enum { LTR690_PS_OS_FALSE = 0x00, LTR690_PS_OS_TRUE = 0x01, } LTR690_CFG_PS_OS; typedef enum { LTR690_PS_LED_CURRENT_0 = 0x00, /* LED pulse current level = 0mA */ LTR690_PS_LED_CURRENT_20 = 0x01, /* LED pulse current level = 20mA */ LTR690_PS_LED_CURRENT_50 = 0x02, /* LED pulse current level = 50mA */ LTR690_PS_LED_CURRENT_100 = 0x03, /* LED pulse current level = 100mA (default) */ LTR690_PS_LED_CURRENT_150 = 0x04, /* LED pulse current level = 150mA */ LTR690_PS_LED_CURRENT_200 = 0x05, /* LED pulse current level = 200mA */ LTR690_PS_LED_CURRENT_250 = 0x06, /* LED pulse current level = 250mA */ LTR690_PS_LED_CURRENT_300 = 0x07, /* LED pulse current level = 300mA */ } LTR690_CFG_PS_LED_LED_CURRENT; typedef enum { LTR690_PS_PULSE_WIDTH_64 = 0x00, /* LED pulse width = 64us */ LTR690_PS_PULSE_WIDTH_16 = 0x02, /* LED pulse width = 16us */ LTR690_PS_PULSE_WIDTH_32 = 0x03, /* LED pulse width = 32us (default) */ } LTR690_CFG_PS_LED_PULSE_WIDTH; typedef enum { LTR690_PS_MEAS_RATE_6_125 = 0x00, /* PS Measurement Repeat Rate = 6.125ms */ LTR690_PS_MEAS_RATE_12_5 = 0x01, /* PS Measurement Repeat Rate = 12.5ms */ LTR690_PS_MEAS_RATE_25 = 0x02, /* PS Measurement Repeat Rate = 25ms */ LTR690_PS_MEAS_RATE_50 = 0x03, /* PS Measurement Repeat Rate = 50ms (default) */ LTR690_PS_MEAS_RATE_100 = 0x04, /* PS Measurement Repeat Rate = 100ms */ LTR690_PS_MEAS_RATE_200 = 0x05, /* PS Measurement Repeat Rate = 200ms */ LTR690_PS_MEAS_RATE_400 = 0x06, /* PS Measurement Repeat Rate = 400ms */ LTR690_PS_MEAS_RATE_800 = 0x07, /* PS Measurement Repeat Rate = 800ms */ } LTR690_CFG_PS_MEAS_RATE; typedef enum { LTR690_PS_DATA_STATUS_OLD = 0x00, LTR690_PS_DATA_STATUS_NEW = 0x01, } LTR690_CFG_PS_DATA_STATUS; i2c_dev_t ltr690_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = LTR690_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; static int drv_ps_liteon_ltr690_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, LTR690_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, LTR690_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_ps_liteon_ltr690_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, LTR690_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 = LTR690_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR690_PS_STANDBY); break; case DEV_POWER_ON: dev_mode = LTR690_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR690_PS_ACTIVE); break; default: return -1; } ret = sensor_i2c_write(drv, LTR690_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } UNUSED static int drv_ps_liteon_ltr690_is_ready(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR690_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return 0; } ret = (LTR690_GET_BITSLICE(value, PS_STATUS_REG_PS_DATA_STATUS) == LTR690_PS_DATA_STATUS_NEW) ? 1 : 0; return ret; } static int drv_ps_liteon_ltr690_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR690_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = LTR690_SET_BITSLICE(value, PS_CONTR_REG_FTN_NTF_EN, LTR690_FTN_NTF_EN_FALSE); value = LTR690_SET_BITSLICE(value, PS_CONTR_REG_PS_OS, LTR690_PS_OS_FALSE); ret = sensor_i2c_write(drv, LTR690_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0xC0; value = LTR690_SET_BITSLICE(value, PS_LED_REG_LED_CURR, LTR690_PS_LED_CURRENT_100); value = LTR690_SET_BITSLICE(value, PS_LED_REG_PULSE_WIDTH, LTR690_PS_PULSE_WIDTH_32); ret = sensor_i2c_write(drv, LTR690_PS_LED, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0x88; ret = sensor_i2c_write(drv, LTR690_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0x20; value = LTR690_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RATE, LTR690_PS_MEAS_RATE_100); ret = sensor_i2c_write(drv, LTR690_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static void drv_ps_liteon_ltr690_irq_handle(void) { /* no handle so far */ } static int drv_ps_liteon_ltr690_open(void) { int ret = 0; ret = drv_ps_liteon_ltr690_set_power_mode(&ltr690_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_liteon_ltr690_close(void) { int ret = 0; ret = drv_ps_liteon_ltr690_set_power_mode(&ltr690_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_liteon_ltr690_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; if (buf == NULL) { return -1; } size = sizeof(proximity_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&ltr690_ctx, LTR690_PS_DATA_0, &reg_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr690_ctx, LTR690_PS_DATA_1, &reg_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } pdata->present = (((uint32_t) (reg_data[1] & 0xFF) << 8) | reg_data[0]); pdata->timestamp = aos_now_ms(); return (int) size; } static int drv_ps_liteon_ltr690_write(const void *buf, size_t len) { (void) buf; (void) len; return 0; } static int drv_ps_liteon_ltr690_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_SET_POWER: { ret = drv_ps_liteon_ltr690_set_power_mode(&ltr690_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->vendor = DEV_SENSOR_VENDOR_LITEON; info->model = "LTR690"; info->unit = cm; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_ps_liteon_ltr690_init(void) { int ret = 0; sensor_obj_t sensor_ps; memset(&sensor_ps, 0, sizeof(sensor_ps)); if (!g_init_bitwise) { ret = drv_ps_liteon_ltr690_validate_id(&ltr690_ctx, LTR690_PART_ID_VAL, LTR690_MANUFAC_ID_VAL); if (unlikely(ret)) { return -1; } } if (!g_init_bitwise) { /* 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.mode = DEV_POLLING; sensor_ps.power = DEV_POWER_OFF; sensor_ps.open = drv_ps_liteon_ltr690_open; sensor_ps.close = drv_ps_liteon_ltr690_close; sensor_ps.read = drv_ps_liteon_ltr690_read; sensor_ps.write = drv_ps_liteon_ltr690_write; sensor_ps.ioctl = drv_ps_liteon_ltr690_ioctl; sensor_ps.irq_handle = drv_ps_liteon_ltr690_irq_handle; ret = sensor_create_obj(&sensor_ps); if (unlikely(ret)) { return -1; } ret = drv_ps_liteon_ltr690_set_default_config(&ltr690_ctx); if (unlikely(ret)) { return -1; } g_init_bitwise = 1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_ps_liteon_ltr690_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_liteon_ltr690.c
C
apache-2.0
14,274
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define LTR706_I2C_SLAVE_ADDR 0x23 #define LTR706_CLK_ON 0x80 #define LTR706_PS_CONTR 0x81 /* PS operation mode */ #define LTR706_PS_VCSEL 0x82 /* LED pulse freq, current duty, peak current */ #define LTR706_PS_N_PULSES 0x83 /* PS number of pulses */ #define LTR706_PS_MEAS_RATE 0x84 /* measurement rate*/ #define LTR706_PART_ID 0x86 #define LTR706_MANUFAC_ID 0x87 #define LTR706_PS_STATUS 0x90 #define LTR706_PS_DATA_0 0x91 #define LTR706_PS_DATA_1 0x92 #define LTR706_INTERRUPT 0x93 #define LTR706_INTR_PRST 0x94 /* PS interrupt persist setting */ #define LTR706_PS_THRES_UP_0 0x95 /* PS interrupt upper threshold, lower byte */ #define LTR706_PS_THRES_UP_1 0x96 /* PS interrupt upper threshold, upper byte */ #define LTR706_PS_THRES_LOW_0 0x97 /* PS interrupt lower threshold, lower byte */ #define LTR706_PS_THRES_LOW_1 0x98 /* PS interrupt lower threshold, upper byte */ #define LTR706_FAULT_DETECTION 0x9F /* Fault detectino control and status register */ #define LTR706_FD_STATUS 0xA0 /* Fault detection status */ #define LTR706_ADDR_TRANS(n) ((n) << 1) #define LTR706_I2C_ADDR LTR706_ADDR_TRANS(LTR706_I2C_SLAVE_ADDR) #define LTR706_PART_ID_VAL 0x05 #define LTR706_MANUFAC_ID_VAL 0x05 #define LTR706_CLK_ON_REG_SW_RESET__POS (1) #define LTR706_CLK_ON_REG_SW_RESET__MSK (0x02) #define LTR706_CLK_ON_REG_SW_RESET__REG (LTR706_CLK_ON) #define LTR706_CLK_ON_REG_ON_CLOCK__POS (5) #define LTR706_CLK_ON_REG_ON_CLOCK__MSK (0x20) #define LTR706_CLK_ON_REG_ON_CLOCK__REG (LTR706_CLK_ON) #define LTR706_PS_CONTR_REG_PS_MODE__POS (1) #define LTR706_PS_CONTR_REG_PS_MODE__MSK (0x02) #define LTR706_PS_CONTR_REG_PS_MODE__REG (LTR706_PS_CONTR) #define LTR706_PS_CONTR_REG_FTN_NTF_EN__POS (5) #define LTR706_PS_CONTR_REG_FTN_NTF_EN__MSK (0x20) #define LTR706_PS_CONTR_REG_FTN_NTF_EN__REG (LTR706_PS_CONTR) #define LTR706_PS_CONTR_REG_PS_OFFSET_EN__POS (7) #define LTR706_PS_CONTR_REG_PS_OFFSET_EN__MSK (0x80) #define LTR706_PS_CONTR_REG_PS_OFFSET_EN__REG (LTR706_PS_CONTR) #define LTR706_PS_VCSEL_REG_VCSEL_PEAK_CURR__POS (0) #define LTR706_PS_VCSEL_REG_VCSEL_PEAK_CURR__MSK (0x0F) #define LTR706_PS_VCSEL_REG_VCSEL_PEAK_CURR__REG (LTR706_PS_VCSEL) #define LTR706_PS_N_PULSES_REG_PULSES__POS (0) #define LTR706_PS_N_PULSES_REG_PULSES__MSK (0x3F) #define LTR706_PS_N_PULSES_REG_PULSES__REG (LTR706_PS_N_PULSES) #define LTR706_PS_MEAS_RATE_REG_MEAS_RATE__POS (0) #define LTR706_PS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07) #define LTR706_PS_MEAS_RATE_REG_MEAS_RATE__REG (LTR706_PS_MEAS_RATE) #define LTR706_PS_STATUS_REG_PS_DATA_STATUS__POS (0) #define LTR706_PS_STATUS_REG_PS_DATA_STATUS__MSK (0x01) #define LTR706_PS_STATUS_REG_PS_DATA_STATUS__REG (LTR706_PS_STATUS) #define LTR706_PS_STATUS_REG_PS_INT_STATUS__POS (1) #define LTR706_PS_STATUS_REG_PS_INT_STATUS__MSK (0x02) #define LTR706_PS_STATUS_REG_PS_INT_STATUS__REG (LTR706_PS_STATUS) #define LTR706_INTERRUPT_REG_INT_MODE__POS (0) #define LTR706_INTERRUPT_REG_INT_MODE__MSK (0x03) #define LTR706_INTERRUPT_REG_INT_MODE__REG (LTR706_INTERRUPT) #define LTR706_INTERRUPT_REG_INT_POLARITY__POS (2) #define LTR706_INTERRUPT_REG_INT_POLARITY__MSK (0x04) #define LTR706_INTERRUPT_REG_INT_POLARITY__REG (LTR706_INTERRUPT) #define LTR706_INTERRUPT_REG_NTF__POS (6) #define LTR706_INTERRUPT_REG_NTF__MSK (0x40) #define LTR706_INTERRUPT_REG_NTF__REG (LTR706_INTERRUPT) #define LTR706_INTERRUPT_REG_FTN__POS (7) #define LTR706_INTERRUPT_REG_FTN__MSK (0x80) #define LTR706_INTERRUPT_REG_FTN__REG (LTR706_INTERRUPT) #define LTR706_INTR_PRST_REG_PS_PERSIST__POS (4) #define LTR706_INTR_PRST_REG_PS_PERSIST__MSK (0xF0) #define LTR706_INTR_PRST_REG_PS_PERSIST__REG (LTR706_INTR_PRST) #define LTR706_FAULT_DETECTION_REG_FD_LEVEL__POS (0) #define LTR706_FAULT_DETECTION_REG_FD_LEVEL__MSK (0x01) #define LTR706_FAULT_DETECTION_REG_FD_LEVEL__REG (LTR706_FAULT_DETECTION) #define LTR706_FAULT_DETECTION_REG_FD_SELF_CHECK__POS (4) #define LTR706_FAULT_DETECTION_REG_FD_SELF_CHECK__MSK (0x10) #define LTR706_FAULT_DETECTION_REG_FD_SELF_CHECK__REG (LTR706_FAULT_DETECTION) #define LTR706_FD_STATUS_REG_VCSEL_FAULT__POS (0) #define LTR706_FD_STATUS_REG_VCSEL_FAULT__MSK (0x01) #define LTR706_FD_STATUS_REG_VCSEL_FAULT__REG (LTR706_FD_STATUS) #define LTR706_FD_STATUS_REG_ENB_FAULT__POS (1) #define LTR706_FD_STATUS_REG_ENB_FAULT__MSK (0x02) #define LTR706_FD_STATUS_REG_ENB_FAULT__REG (LTR706_FD_STATUS) #define LTR706_FD_STATUS_REG_ENB_GATE_STUCK_HIGH__POS (2) #define LTR706_FD_STATUS_REG_ENB_GATE_STUCK_HIGH__MSK (0x04) #define LTR706_FD_STATUS_REG_ENB_GATE_STUCK_HIGH__REG (LTR706_FD_STATUS) #define LTR706_FD_STATUS_REG_ENB_GATE_STUCK_LOW__POS (3) #define LTR706_FD_STATUS_REG_ENB_GATE_STUCK_LOW__MSK (0x08) #define LTR706_FD_STATUS_REG_ENB_GATE_STUCK_LOW__REG (LTR706_FD_STATUS) #define LTR706_FD_STATUS_REG_VCSEL_LEAKAGE__POS (4) #define LTR706_FD_STATUS_REG_VCSEL_LEAKAGE__MSK (0x10) #define LTR706_FD_STATUS_REG_VCSEL_LEAKAGE__REG (LTR706_FD_STATUS) #define LTR706_GET_BITSLICE(regvar, bitname) ((regvar & LTR706_##bitname##__MSK) >> LTR706_##bitname##__POS) #define LTR706_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR706_##bitname##__MSK) | ((val<<LTR706_##bitname##__POS)&LTR706_##bitname##__MSK)) #define LTR706_WAIT_TIME_PER_CHECK (10) #define LTR706_WAIT_TIME_TOTAL (50) typedef enum { LTR706_SW_RESET_FALSE = 0x00, LTR706_SW_RESET_TRUE = 0x01, } LTR706_CFG_SW_RESET; typedef enum { LTR706_CLOCK_OFF = 0x00, LTR706_CLOCK_ON = 0x01, } LTR706_CFG_ON_CLOCK; typedef enum { LTR706_PS_STANDBY = 0x00, LTR706_PS_ACTIVE = 0x01, } LTR706_CFG_PS_MODE; typedef enum { LTR706_FTN_NTF_DISABLE = 0x00, LTR706_FTN_NTF_ENABLE = 0x01, } LTR706_CFG_FTN_NTF_EN; typedef enum { LTR706_PS_OFFSET_DISABLE = 0x00, LTR706_PS_OFFSET_ENABLE = 0x01, } LTR706_CFG_PS_OFFSET_EN; typedef enum { LTR706_VCSEL_CURRENT_3mA = 0x00, LTR706_VCSEL_CURRENT_4mA = 0x01, LTR706_VCSEL_CURRENT_5mA = 0x02, LTR706_VCSEL_CURRENT_6mA = 0x03, LTR706_VCSEL_CURRENT_7mA = 0x04, LTR706_VCSEL_CURRENT_8mA = 0x05, LTR706_VCSEL_CURRENT_9mA = 0x06, LTR706_VCSEL_CURRENT_10mA = 0x07, LTR706_VCSEL_CURRENT_11mA = 0x08, LTR706_VCSEL_CURRENT_12mA = 0x09, LTR706_VCSEL_CURRENT_13mA = 0x0A, LTR706_VCSEL_CURRENT_14mA = 0x0B, LTR706_VCSEL_CURRENT_15mA = 0x0C, } LTR706_CFG_VCSEL_PEAK_CURRENT; typedef enum { LTR706_PS_MEAS_RATE_6_125 = 0x00, /* PS Measurement Repeat Rate = 6.125ms */ LTR706_PS_MEAS_RATE_12_5 = 0x01, /* PS Measurement Repeat Rate = 12.5ms */ LTR706_PS_MEAS_RATE_25 = 0x02, /* PS Measurement Repeat Rate = 25ms */ LTR706_PS_MEAS_RATE_50 = 0x03, /* PS Measurement Repeat Rate = 50ms */ LTR706_PS_MEAS_RATE_100 = 0x04, /* PS Measurement Repeat Rate = 100ms (default) */ LTR706_PS_MEAS_RATE_200 = 0x05, /* PS Measurement Repeat Rate = 200ms */ LTR706_PS_MEAS_RATE_400 = 0x06, /* PS Measurement Repeat Rate = 400ms */ LTR706_PS_MEAS_RATE_800 = 0x07, /* PS Measurement Repeat Rate = 800ms */ } LTR706_CFG_PS_MEAS_RATE; typedef enum { LTR706_PS_DATA_STATUS_OLD = 0x00, LTR706_PS_DATA_STATUS_NEW = 0x01, } LTR706_CFG_PS_DATA_STATUS; typedef enum { LTR706_PS_INT_STATUS_INACTIVE = 0x00, LTR706_PS_INT_STATUS_ACTIVE = 0x01, } LTR706_CFG_PS_INT_STATUS; typedef enum { LTR706_PS_INT_MODE_DISABLE = 0x00, LTR706_PS_INT_MODE_ENABLE = 0x01, } LTR706_CFG_PS_INT_MODE; typedef enum { LTR706_PS_INT_POLARITY_ACTIVE_LO = 0x00, LTR706_PS_INT_POLARITY_ACTIVE_HI = 0x01, } LTR706_CFG_PS_INT_POLARITY; typedef enum { LTR706_NTF_FALSE = 0x00, LTR706_NTF_TRUE = 0x01, } LTR706_CFG_NTF; typedef enum { LTR706_FTN_FALSE = 0x00, LTR706_FTN_TRUE = 0x01, } LTR706_CFG_FTN; typedef enum { LTR706_FD_LEVEL_2 = 0x00, LTR706_FD_LEVEL_1 = 0x01, } LTR706_CFG_FD_LEVEL; typedef enum { LTR706_FD_SELF_CHECK_DISABLE = 0x00, LTR706_FD_SELF_CHECK_ENABLE = 0x01, } LTR706_CFG_FD_SELF_CHECK; typedef enum { LTR706_VCSEL_FAULT_FALSE = 0x00, LTR706_VCSEL_FAULT_TRUE = 0x01, } LTR706_CFG_VCSEL_FAULT; typedef enum { LTR706_ENB_FAULT_FALSE = 0x00, LTR706_ENB_FAULT_TRUE = 0x01, } LTR706_CFG_ENB_FAULT; typedef enum { LTR706_ENB_GATE_STUCK_HIGH_FALSE = 0x00, LTR706_ENB_GATE_STUCK_HIGH_TRUE = 0x01, } LTR706_CFG_ENB_GATE_STUCK_HIGH; typedef enum { LTR706_ENB_GATE_STUCK_LOW_FALSE = 0x00, LTR706_ENB_GATE_STUCK_LOW_TRUE = 0x01, } LTR706_CFG_ENB_GATE_STUCK_LOW; typedef enum { LTR706_VCSEL_LEAKAGE_FALSE = 0x00, LTR706_VCSEL_LEAKAGE_TRUE = 0x01, } LTR706_CFG_VCSEL_LEAKAGE; i2c_dev_t ltr706_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = LTR706_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; static int drv_ps_liteon_ltr706_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, LTR706_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, LTR706_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_ps_liteon_ltr706_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, LTR706_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 = LTR706_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR706_PS_STANDBY); break; case DEV_POWER_ON: dev_mode = LTR706_SET_BITSLICE(value, PS_CONTR_REG_PS_MODE, LTR706_PS_ACTIVE); break; default: return -1; } ret = sensor_i2c_write(drv, LTR706_PS_CONTR, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } UNUSED static int drv_ps_liteon_ltr706_is_ready(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR706_PS_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return 0; } ret = (LTR706_GET_BITSLICE(value, PS_STATUS_REG_PS_DATA_STATUS) == LTR706_PS_DATA_STATUS_NEW) ? 1 : 0; return ret; } static int drv_ps_liteon_ltr706_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR706_CLK_ON, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = LTR706_SET_BITSLICE(value, CLK_ON_REG_ON_CLOCK, LTR706_CLOCK_OFF); ret = sensor_i2c_write(drv, LTR706_CLK_ON, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, LTR706_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = LTR706_SET_BITSLICE(value, PS_CONTR_REG_FTN_NTF_EN, LTR706_FTN_NTF_DISABLE); value = LTR706_SET_BITSLICE(value, PS_CONTR_REG_PS_OFFSET_EN, LTR706_PS_OFFSET_DISABLE); ret = sensor_i2c_write(drv, LTR706_PS_CONTR, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } ret = sensor_i2c_read(drv, LTR706_PS_VCSEL, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = LTR706_SET_BITSLICE(value, PS_VCSEL_REG_VCSEL_PEAK_CURR, LTR706_VCSEL_CURRENT_5mA); ret = sensor_i2c_write(drv, LTR706_PS_VCSEL, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR706_SET_BITSLICE(value, PS_N_PULSES_REG_PULSES, 0x20); ret = sensor_i2c_write(drv, LTR706_PS_N_PULSES, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR706_SET_BITSLICE(value, PS_MEAS_RATE_REG_MEAS_RATE, LTR706_PS_MEAS_RATE_100); ret = sensor_i2c_write(drv, LTR706_PS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR706_SET_BITSLICE(value, INTERRUPT_REG_INT_MODE, LTR706_PS_INT_MODE_DISABLE); value = LTR706_SET_BITSLICE(value, INTERRUPT_REG_INT_POLARITY, LTR706_PS_INT_POLARITY_ACTIVE_LO); value = LTR706_SET_BITSLICE(value, INTERRUPT_REG_NTF, LTR706_NTF_FALSE); value = LTR706_SET_BITSLICE(value, INTERRUPT_REG_FTN, LTR706_FTN_FALSE); ret = sensor_i2c_write(drv, LTR706_INTERRUPT, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR706_SET_BITSLICE(value, FAULT_DETECTION_REG_FD_LEVEL, LTR706_FD_LEVEL_1); value = LTR706_SET_BITSLICE(value, FAULT_DETECTION_REG_FD_SELF_CHECK, LTR706_FD_SELF_CHECK_DISABLE); ret = sensor_i2c_write(drv, LTR706_FAULT_DETECTION, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static void drv_ps_liteon_ltr706_irq_handle(void) { /* no handle so far */ } static int drv_ps_liteon_ltr706_open(void) { int ret = 0; ret = drv_ps_liteon_ltr706_set_power_mode(&ltr706_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_liteon_ltr706_close(void) { int ret = 0; ret = drv_ps_liteon_ltr706_set_power_mode(&ltr706_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_liteon_ltr706_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; if (buf == NULL) { return -1; } size = sizeof(proximity_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&ltr706_ctx, LTR706_PS_DATA_0, &reg_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr706_ctx, LTR706_PS_DATA_1, &reg_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } pdata->present = ((((uint32_t) (reg_data[1] & 0x07)) << 8) | reg_data[0]); pdata->timestamp = aos_now_ms(); return (int) size; } static int drv_ps_liteon_ltr706_write(const void *buf, size_t len) { (void) buf; (void) len; return 0; } static int drv_ps_liteon_ltr706_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_SET_POWER: { ret = drv_ps_liteon_ltr706_set_power_mode(&ltr706_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->vendor = DEV_SENSOR_VENDOR_LITEON; info->model = "LTR706"; info->unit = cm; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_ps_liteon_ltr706_init(void) { int ret = 0; sensor_obj_t sensor_ps; memset(&sensor_ps, 0, sizeof(sensor_ps)); if (!g_init_bitwise) { ret = drv_ps_liteon_ltr706_validate_id(&ltr706_ctx, LTR706_PART_ID_VAL, LTR706_MANUFAC_ID_VAL); if (unlikely(ret)) { return -1; } } if (!g_init_bitwise) { /* 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.mode = DEV_POLLING; sensor_ps.power = DEV_POWER_OFF; sensor_ps.open = drv_ps_liteon_ltr706_open; sensor_ps.close = drv_ps_liteon_ltr706_close; sensor_ps.read = drv_ps_liteon_ltr706_read; sensor_ps.write = drv_ps_liteon_ltr706_write; sensor_ps.ioctl = drv_ps_liteon_ltr706_ioctl; sensor_ps.irq_handle = drv_ps_liteon_ltr706_irq_handle; ret = sensor_create_obj(&sensor_ps); if (unlikely(ret)) { return -1; } ret = drv_ps_liteon_ltr706_set_default_config(&ltr706_ctx); if (unlikely(ret)) { return -1; } g_init_bitwise = 1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_ps_liteon_ltr706_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_liteon_ltr706.c
C
apache-2.0
18,416
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" //#include "vl53l0x_proximity.h" #include "vl53l0x/vl53l0x_def.h" #include "vl53l0x/vl53l0x_api.h" #include "vl53l0x_platform.h" /* Private typedef -----------------------------------------------------------*/ /* Private defines -----------------------------------------------------------*/ #define PROXIMITY_I2C_ADDRESS ((uint16_t)0x0052) #define VL53L0X_ID ((uint16_t)0xEEAA) #define VL53L0X_XSHUT_Pin GPIO_PIN_6 #define VL53L0X_XSHUT_GPIO_Port GPIOC #define VL53L0X_IRQ_PIN (62) static gpio_irq_trigger_t vl53l0x_irq_mode_rising = IRQ_TRIGGER_RISING_EDGE; bool g_interrupt_received = false; /* Private macros ------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ VL53L0X_Dev_t Dev = { .I2cDevAddr = PROXIMITY_I2C_ADDRESS }; i2c_dev_t vl53l0x_ctx_i2c = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = PROXIMITY_I2C_ADDRESS, }; static sensor_obj_t sensor; /* Private function prototypes -----------------------------------------------*/ void SENSOR_IO_Init(void); void SetupSingleShot(VL53L0X_Dev_t Dev); void VL53L0X_INTERRRUPT_INIT() { int status; (void)status; if (sensor.mode == DEV_INT) { status = VL53L0X_SetGpioConfig( &Dev, 0, 0, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH, VL53L0X_INTERRUPTPOLARITY_HIGH); status = VL53L0X_SetInterruptThresholds( &Dev, 0, (FixPoint1616_t)100 * 65536, (FixPoint1616_t)200 * 65536); status = VL53L0X_SetDeviceMode(&Dev, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); VL53L0X_ClearInterruptMask(&Dev, 0); } else if (sensor.mode == DEV_DATA_READY) { status = VL53L0X_SetGpioConfig( &Dev, 0, 0, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY, VL53L0X_INTERRUPTPOLARITY_HIGH); status = VL53L0X_SetDeviceMode(&Dev, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); VL53L0X_ClearInterruptMask(&Dev, 0); } else { } } /** * @brief VL53L0X proximity sensor Initialization. */ void VL53L0X_PROXIMITY_Init(void) { uint16_t vl53l0x_id = 0; VL53L0X_DeviceInfo_t VL53L0X_DeviceInfo; memset(&VL53L0X_DeviceInfo, 0, sizeof(VL53L0X_DeviceInfo_t)); if (VL53L0X_ERROR_NONE == VL53L0X_GetDeviceInfo(&Dev, &VL53L0X_DeviceInfo)) { if (VL53L0X_ERROR_NONE == VL53L0X_RdWord(&Dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID, (uint16_t *)&vl53l0x_id)) { if (vl53l0x_id == VL53L0X_ID) { if (VL53L0X_ERROR_NONE == VL53L0X_DataInit(&Dev)) { SetupSingleShot(Dev); } } } else { LOG("VL53L0X Time of Flight Failed to Initialize!\n"); } } else { LOG("VL53L0X Time of Flight Failed to get infos!\n"); } VL53L0X_SetInterMeasurementPeriodMilliSeconds(&Dev, 30); VL53L0X_INTERRRUPT_INIT(); } /** * @brief Get distance from VL53L0X proximity sensor. * @retval Distance in mm */ uint16_t VL53L0X_PROXIMITY_GetDistance(void) { VL53L0X_RangingMeasurementData_t RangingMeasurementData; VL53L0X_PerformSingleRangingMeasurement(&Dev, &RangingMeasurementData); return RangingMeasurementData.RangeMilliMeter; } /** * @brief VL53L0X proximity sensor Msp Initialization. */ void VL53L0X_PROXIMITY_MspInit(void) {} /** * Setup all detected sensors for single shot mode and setup ranging * configuration */ void SetupSingleShot(VL53L0X_Dev_t Dev) { int status; uint8_t VhvSettings; uint8_t PhaseCal; uint32_t refSpadCount; uint8_t isApertureSpads; FixPoint1616_t signalLimit = (FixPoint1616_t)(0.25 * 65536); FixPoint1616_t sigmaLimit = (FixPoint1616_t)(18 * 65536); uint32_t timingBudget = 33000; uint8_t preRangeVcselPeriod = 14; uint8_t finalRangeVcselPeriod = 10; if (Dev.Present) { status = VL53L0X_StaticInit(&Dev); if (status) { LOG("VL53L0X_StaticInit failed\n"); } status = VL53L0X_PerformRefCalibration(&Dev, &VhvSettings, &PhaseCal); if (status) { LOG("VL53L0X_PerformRefCalibration failed\n"); } status = VL53L0X_PerformRefSpadManagement(&Dev, &refSpadCount, &isApertureSpads); if (status) { LOG("VL53L0X_PerformRefSpadManagement failed\n"); } status = VL53L0X_SetDeviceMode( &Dev, VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode if (status) { LOG("VL53L0X_SetDeviceMode failed\n"); } status = VL53L0X_SetLimitCheckEnable( &Dev, VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1); // Enable Sigma limit if (status) { LOG("VL53L0X_SetLimitCheckEnable failed\n"); } status = VL53L0X_SetLimitCheckEnable( &Dev, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1); // Enable Signa limit if (status) { LOG("VL53L0X_SetLimitCheckEnable failed\n"); } /* Ranging configuration */ signalLimit = (FixPoint1616_t)(0.1 * 65536); sigmaLimit = (FixPoint1616_t)(60 * 65536); // signalLimit = (FixPoint1616_t)(0.25*65536); // sigmaLimit = (FixPoint1616_t)(18*65536); timingBudget = 33000; // timingBudget = 200000; preRangeVcselPeriod = 18; finalRangeVcselPeriod = 14; status = VL53L0X_SetLimitCheckValue( &Dev, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit); if (status) { LOG("VL53L0X_SetLimitCheckValue failed\n"); } status = VL53L0X_SetLimitCheckValue( &Dev, VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit); if (status) { LOG("VL53L0X_SetLimitCheckValue failed\n"); } status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&Dev, timingBudget); if (status) { LOG("VL53L0X_SetMeasurementTimingBudgetMicroSeconds failed\n"); } status = VL53L0X_SetVcselPulsePeriod( &Dev, VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod); if (status) { LOG("VL53L0X_SetVcselPulsePeriod failed\n"); } status = VL53L0X_SetVcselPulsePeriod( &Dev, VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod); if (status) { LOG("VL53L0X_SetVcselPulsePeriod failed\n"); } Dev.LeakyFirst = 1; } } static void drv_ps_st_vl53l0x_irq_handle(void) { VL53L0X_ClearInterruptMask(&Dev, 0); g_interrupt_received = true; } static int drv_ps_st_vl53l0x_open(void) { VL53L0X_StartMeasurement(&Dev); LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_st_vl53l0x_close(void) { VL53L0X_StopMeasurement(&Dev); LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_ps_st_vl53l0x_read(void *buf, size_t len) { size_t size; VL53L0X_RangingMeasurementData_t RangingMeasurementData; VL53L0X_Error Status = VL53L0X_ERROR_NONE; proximity_data_t * pdata = (proximity_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(proximity_data_t); if (len < size) { return -1; } if (g_interrupt_received == false) { pdata->present = VL53L0X_PROXIMITY_GetDistance(); } else { g_interrupt_received = false; VL53L0X_ClearInterruptMask(&Dev, 0); Status = VL53L0X_GetRangingMeasurementData(&Dev, &RangingMeasurementData); if (Status != VL53L0X_ERROR_NONE) return -1; pdata->present = RangingMeasurementData.RangeMilliMeter; } LOG("drv_ps_st_vl53l0x_read DATA=%d\n ", pdata->present); return (int)size; } static int drv_ps_st_vl53l0x_write(const void *buf, size_t len) { return 0; } static int drv_ps_st_vl53l0x_ioctl(int cmd, unsigned long arg) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { } break; case SENSOR_IOCTL_SET_POWER: { Status = VL53L0X_SetPowerMode(&Dev, arg); if (Status != VL53L0X_ERROR_NONE) return -1; } break; case SENSOR_IOCTL_GET_INFO: { } break; default: break; } return 0; } int drv_ps_st_vl53l0x_init(void) { int ret = 0; /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_PS; sensor.path = dev_ps_path; sensor.io_port = I2C_PORT; sensor.open = drv_ps_st_vl53l0x_open; sensor.close = drv_ps_st_vl53l0x_close; sensor.read = drv_ps_st_vl53l0x_read; sensor.write = drv_ps_st_vl53l0x_write; sensor.ioctl = drv_ps_st_vl53l0x_ioctl; sensor.irq_handle = drv_ps_st_vl53l0x_irq_handle; sensor.mode = DEV_POLLING; sensor.gpio.port = VL53L0X_IRQ_PIN; sensor.gpio.config = IRQ_MODE; sensor.gpio.priv = &vl53l0x_irq_mode_rising; sensor.data_len = sizeof(proximity_data_t); ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } VL53L0X_PROXIMITY_Init(); LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_ps_st_vl53l0x_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_st_vl53l0x/drv_ps_st_vl53l0x.c
C
apache-2.0
9,862
/* * COPYRIGHT (C) STMicroelectronics 2015. All rights reserved. * * This software is the confidential and proprietary information of * STMicroelectronics ("Confidential Information"). You shall not * disclose such Confidential Information and shall use it only in * accordance with the terms of the license agreement you entered into * with STMicroelectronics * * Programming Golden Rule: Keep it Simple! * */ /*! * \file VL53L0X_platform_log.c * \brief Code function defintions for Ewok Platform Layer * */ #include <stdio.h> // sprintf(), vsnprintf(), printf() #include <stdarg.h> // sprintf(), vsnprintf(), printf() #ifdef _MSC_VER #define snprintf _snprintf #endif #include "vl53l0x_def.h" #include "vl53l0x_platform_log.h" uint32_t _trace_level = TRACE_LEVEL_WARNING; uint32_t _trace_modules = TRACE_MODULE_NONE; uint32_t _trace_functions = TRACE_FUNCTION_NONE; #if defined(VL53L0X_LOG_ENABLE) && (TRACE_UART == 1) int32_t VL53L0X_trace_config(char *filename, uint32_t modules, uint32_t level, uint32_t functions) { int STATUS = 0; _trace_functions = functions; _trace_level = level; _trace_modules = modules; return STATUS; } void trace_print_module_function(uint32_t module, uint32_t level, uint32_t function, const char *format, ...) { if (((level <= _trace_level) && ((module & _trace_modules) > 0)) || ((function & _trace_functions) > 0)) { va_list arg_list; va_start(arg_list, format); trace_vprintf(format, arg_list); va_end(arg_list); } } #endif
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_st_vl53l0x/vl53l0x/vl53l0x_platform_log.c
C
apache-2.0
1,633
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ /* Includes ------------------------------------------------------------------*/ #include <string.h> #include "vl53l0x/vl53l0x_def.h" #include "vl53l0x/vl53l0x_api.h" #include "vl53l0x_platform.h" #include "sensor_drv_api.h" /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ #define I2C_TIME_OUT_BASE 30 #define I2C_TIME_OUT_BYTE 5 #define AOS_WAIT_TIMEOUT 100 //#define VL53L0X_OsDelay(...) HAL_Delay(2) #define VL53L0X_OsDelay(...) aos_msleep(2) /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/ /* Exported functions --------------------------------------------------------*/ extern i2c_dev_t vl53l0x_ctx_i2c; VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; int i2c_time_out = I2C_TIME_OUT_BASE + I2C_TIME_OUT_BYTE; status_int = sensor_i2c_read(&vl53l0x_ctx_i2c, index, data, 1, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; goto done; } done: return Status; } // the ranging_sensor_comms.dll will take care of the page selection VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count) { int status_int; VL53L0X_Error Status = VL53L0X_ERROR_NONE; int i2c_time_out = I2C_TIME_OUT_BASE + count * I2C_TIME_OUT_BYTE; status_int = sensor_i2c_write(&vl53l0x_ctx_i2c, index, pdata, count, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; } return Status; } // the ranging_sensor_comms.dll will take care of the page selection VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; int i2c_time_out = I2C_TIME_OUT_BASE + count * I2C_TIME_OUT_BYTE; status_int = sensor_i2c_read(&vl53l0x_ctx_i2c, index, pdata, count, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; goto done; } done: return Status; } VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; uint8_t mdata[2] = { 0 }; int i2c_time_out = I2C_TIME_OUT_BASE + 2 * I2C_TIME_OUT_BYTE; status_int = sensor_i2c_read(&vl53l0x_ctx_i2c, index, &mdata[0], 2, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; goto done; } *data = ((uint16_t)mdata[0] << 8) + (uint16_t)mdata[1]; done: return Status; } VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; uint8_t mdata[4] = { 0 }; int i2c_time_out = I2C_TIME_OUT_BASE + 4 * I2C_TIME_OUT_BYTE; status_int = sensor_i2c_read(&vl53l0x_ctx_i2c, index, &mdata[0], 4, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; goto done; } *data = ((uint32_t)mdata[0] << 24) + ((uint32_t)mdata[1] << 16) + ((uint32_t)mdata[2] << 8) + (uint32_t)mdata[3]; done: return Status; } VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; uint8_t mdata = data; int i2c_time_out = I2C_TIME_OUT_BASE + I2C_TIME_OUT_BYTE; status_int = sensor_i2c_write(&vl53l0x_ctx_i2c, index, &mdata, 1, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; } return Status; } VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; int i2c_time_out = I2C_TIME_OUT_BASE + 2 * I2C_TIME_OUT_BYTE; uint8_t mdata[2] = { 0 }; mdata[0] = data >> 8; mdata[1] = data & 0x00FF; status_int = sensor_i2c_write(&vl53l0x_ctx_i2c, index, &mdata[0], 2, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; } return Status; } VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; int32_t status_int; int i2c_time_out = I2C_TIME_OUT_BASE + 4 * I2C_TIME_OUT_BYTE; uint8_t mdata[4] = { 0 }; mdata[0] = (data >> 24) & 0xFF; mdata[1] = (data >> 16) & 0xFF; mdata[2] = (data >> 8) & 0xFF; mdata[3] = (data >> 0) & 0xFF; status_int = sensor_i2c_write(&vl53l0x_ctx_i2c, index, &mdata[0], 4, i2c_time_out); if (status_int < 0) { Status = VL53L0X_ERROR_CONTROL_INTERFACE; } return Status; } VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index, uint8_t AndData, uint8_t OrData) { VL53L0X_Error Status = VL53L0X_ERROR_NONE; uint8_t data; Status = VL53L0X_RdByte(Dev, index, &data); if (Status) { goto done; } data = (data & AndData) | OrData; Status = VL53L0X_WrByte(Dev, index, data); done: return Status; } VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev) { VL53L0X_Error status = VL53L0X_ERROR_NONE; // do nothing VL53L0X_OsDelay(); return status; } /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_st_vl53l0x/vl53l0x_platform.c
C
apache-2.0
6,130
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ /* Define to prevent recursive inclusion -------------------------------------*/ #ifndef __VL53L0X_PLATFORM_H #define __VL53L0X_PLATFORM_H #ifdef __cplusplus extern "C" { #endif /* Includes * ------------------------------------------------------------------*/ #include "vl53l0x/vl53l0x_def.h" #include "vl53l0x/vl53l0x_platform_log.h" #define VL53L0X_OsDelay(...) aos_msleep(2) /* Exported types * ------------------------------------------------------------*/ /** * @struct VL53L0X_Dev_t * @brief Generic PAL device type that does link between API and platform * abstraction layer * */ typedef struct { VL53L0X_DevData_t Data; /*!< embed ST Ewok Dev data as "Data"*/ /*!< user specific field */ uint8_t I2cDevAddr; char DevLetter; int Id; int Present; int Enabled; int Ready; uint8_t comms_type; uint16_t comms_speed_khz; int LeakyRange; int LeakyFirst; uint8_t RangeStatus; uint8_t PreviousRangeStatus; FixPoint1616_t SignalRateRtnMegaCps; uint16_t EffectiveSpadRtnCount; } VL53L0X_Dev_t; /** * @brief Declare the device Handle as a pointer of the structure @a * VL53L0X_Dev_t. * */ typedef VL53L0X_Dev_t *VL53L0X_DEV; /* Exported constants --------------------------------------------------------*/ /* Exported macros -----------------------------------------------------------*/ /** * @def PALDevDataGet * @brief Get ST private structure @a VL53L0X_DevData_t data access * * @param Dev Device Handle * @param field ST structure field name * It maybe used and as real data "ref" not just as "get" for sub-structure item * like PALDevDataGet(FilterData.field)[i] or * PALDevDataGet(FilterData.MeasurementIndex)++ */ #define PALDevDataGet(Dev, field) (Dev->Data.field) /** * @def PALDevDataSet(Dev, field, data) * @brief Set ST private structure @a VL53L0X_DevData_t data field * @param Dev Device Handle * @param field ST structure field name * @param data Data to be set */ #define PALDevDataSet(Dev, field, data) (Dev->Data.field) = (data) #define VL53L0X_COPYSTRING(str, ...) strcpy(str, ##__VA_ARGS__) /* Private macros * ------------------------------------------------------------*/ /* Exported functions * --------------------------------------------------------*/ /** * Lock comms interface to serialize all commands to a shared I2C interface * for a specific device * @param Dev Device Handle * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_LockSequenceAccess(VL53L0X_DEV Dev); /** * Unlock comms interface to serialize all commands to a shared I2C * interface for a specific device * @param Dev Device Handle * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_UnlockSequenceAccess(VL53L0X_DEV Dev); /** * Writes the supplied byte buffer to the device * @param Dev Device Handle * @param index The register index * @param pdata Pointer to uint8_t buffer containing the data to be * written * @param count Number of bytes in the supplied byte buffer * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count); /** * Reads the requested number of bytes from the device * @param Dev Device Handle * @param index The register index * @param pdata Pointer to the uint8_t buffer to store read data * @param count Number of uint8_t's to read * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count); /** * Write single byte register * @param Dev Device Handle * @param index The register index * @param data 8 bit register data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data); /** * Write word register * @param Dev Device Handle * @param index The register index * @param data 16 bit register data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data); /** * Write double word (4 byte) register * @param Dev Device Handle * @param index The register index * @param data 32 bit register data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data); /** * Read single byte register * @param Dev Device Handle * @param index The register index * @param data pointer to 8 bit data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data); /** * Read word (2byte) register * @param Dev Device Handle * @param index The register index * @param data pointer to 16 bit data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data); /** * Read dword (4byte) register * @param Dev Device Handle * @param index The register index * @param data pointer to 32 bit data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data); /** * Threat safe Update (read/modify/write) single byte register * * Final_reg = (Initial_reg & and_data) |or_data * * @param Dev Device Handle * @param index The register index * @param AndData 8 bit and data * @param OrData 8 bit or data * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index, uint8_t AndData, uint8_t OrData); /** @} end of VL53L0X_registerAccess_group */ /** * @brief execute delay in all polling API call * * A typical multi-thread or RTOs implementation is to sleep the task for * some 5ms (with 100Hz max rate faster polling is not needed) if nothing * specific is need you can define it as an empty/void macro * @code * #define VL53L0X_PollingDelay(...) (void)0 * @endcode * @param Dev Device Handle * @return VL53L0X_ERROR_NONE Success * @return "Other error code" See ::VL53L0X_Error */ VL53L0X_Error VL53L0X_PollingDelay( VL53L0X_DEV Dev); /* usually best implemented as a real function */ #ifdef __cplusplus } #endif #endif /* __VL53L0X_PLATFORM_H */ /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
YifuLiu/AliOS-Things
components/sensor/drv/drv_ps_st_vl53l0x/vl53l0x_platform.h
C
apache-2.0
8,110
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" /******************************************************************************* ********************************* MACROS ********************************** ******************************************************************************/ #define LTR381_ADDR_TRANS(n) ((n) << 1) #define LTR381_GET_BITSLICE(uint8Val, bitName) (((uint8Val) & (LTR381_##bitName##__MSK)) >> (LTR381_##bitName##__POS)) #define LTR381_SET_BITSLICE(uint8Val, bitName, bitVal) (((uint8Val) & ~(LTR381_##bitName##__MSK)) | ((bitVal << (LTR381_##bitName##__POS)) & (LTR381_##bitName##__MSK))) /******************************************************************************* ************************** SENSOR SPECIFICATIONS ************************** ******************************************************************************/ /* I2C device address */ #define LTR381_SLAVE_ADDR (0x53) #define LTR381_I2C_ADDR LTR381_ADDR_TRANS(LTR381_SLAVE_ADDR) /* Device info */ #define LTR381_PART_ID_VAL 0xC2 #define LTR381_MANUFAC_ID_VAL 0x05 #define LTR381_WAIT_TIME_PER_CHECK (10) #define LTR381_WAIT_TIME_TOTAL (100) /******************************************************************************* ************* Non-Configurable (Unless data sheet is updated) ************* ******************************************************************************/ /* Device register set address */ #define LTR381_MAIN_CTRL_REG (0x00) #define LTR381_ALS_CS_MEAS_RATE_REG (0x04) #define LTR381_ALS_CS_GAIN_REG (0x05) #define LTR381_PART_ID_REG (0x06) #define LTR381_MAIN_STATUS_REG (0x07) #define LTR381_CS_DATA_IR_0_REG (0x0A) #define LTR381_CS_DATA_IR_1_REG (0x0B) #define LTR381_CS_DATA_IR_2_REG (0x0C) #define LTR381_CS_DATA_GREEN_0_REG (0x0D) #define LTR381_CS_DATA_GREEN_1_REG (0x0E) #define LTR381_CS_DATA_GREEN_2_REG (0x0F) #define LTR381_CS_DATA_RED_0_REG (0x10) #define LTR381_CS_DATA_RED_1_REG (0x11) #define LTR381_CS_DATA_RED_2_REG (0x12) #define LTR381_CS_DATA_BLUE_0_REG (0x13) #define LTR381_CS_DATA_BLUE_1_REG (0x14) #define LTR381_CS_DATA_BLUE_2_REG (0x15) #define LTR381_INT_CFG_REG (0x19) #define LTR381_INT_PST_REG (0x1A) #define LTR381_ALS_THRES_UP_0_REG (0x21) #define LTR381_ALS_THRES_UP_1_REG (0x22) #define LTR381_ALS_THRES_UP_2_REG (0x23) #define LTR381_ALS_THRES_LOW_0_REG (0x24) #define LTR381_ALS_THRES_LOW_1_REG (0x25) #define LTR381_ALS_THRES_LOW_2_REG (0x26) /* Register MAIN_CTRL field */ #define LTR381_ALS_CS_ENABLE__REG (LTR381_MAIN_CTRL_REG) #define LTR381_ALS_CS_ENABLE__POS (1) #define LTR381_ALS_CS_ENABLE__MSK (0x02) #define LTR381_CS_MODE__REG (LTR381_MAIN_CTRL_REG) #define LTR381_CS_MODE__POS (2) #define LTR381_CS_MODE__MSK (4) #define LTR381_SW_RESET__REG (LTR381_MAIN_CTRL_REG) #define LTR381_SW_RESET__POS (4) #define LTR381_SW_RESET__MSK (0x10) /* Register ALS_CS_MEAS_RATE field */ #define LTR381_ALS_CS_MEAS_RATE__REG (LTR381_ALS_CS_MEAS_RATE_REG) #define LTR381_ALS_CS_MEAS_RATE__POS (0) #define LTR381_ALS_CS_MEAS_RATE__MSK (0x07) #define LTR381_ALS_CS_RESOLUTION__REG (LTR381_ALS_CS_MEAS_RATE_REG) #define LTR381_ALS_CS_RESOLUTION__POS (4) #define LTR381_ALS_CS_RESOLUTION__MSK (0x70) /* Register ALS_CS_GAIN field */ #define LTR381_ALS_CS_GAIN_RANGE__REG (LTR381_ALS_CS_GAIN_REG) #define LTR381_ALS_CS_GAIN_RANGE__POS (0) #define LTR381_ALS_CS_GAIN_RANGE__MSK (0x07) /* Register PART_ID field */ #define LTR381_PART_NUMBER_ID__REG (LTR381_PART_ID_REG) #define LTR381_PART_NUMBER_ID__POS (4) #define LTR381_PART_NUMBER_ID__MSK (0xF0) /* Register MAIN_STATUS field */ #define LTR381_ALS_CS_DATA_STATUS__REG (LTR381_MAIN_STATUS_REG) #define LTR381_ALS_CS_DATA_STATUS__POS (3) #define LTR381_ALS_CS_DATA_STATUS__MSK (0x08) #define LTR381_ALS_CS_INT_STATUS__REG (LTR381_MAIN_STATUS_REG) #define LTR381_ALS_CS_INT_STATUS__POS (4) #define LTR381_ALS_CS_INT_STATUS__MSK (0x10) #define LTR381_POWER_ON_STATUS__REG (LTR381_MAIN_STATUS_REG) #define LTR381_POWER_ON_STATUS__POS (5) #define LTR381_POWER_ON_STATUS__MSK (0x20) /* Register INT_CFG field */ #define LTR381_ALS_INT_PIN_EN__REG (LTR381_INT_CFG_REG) #define LTR381_ALS_INT_PIN_EN__POS (2) #define LTR381_ALS_INT_PIN_EN__MSK (0x04) #define LTR381_ALS_INT_SEL__REG (LTR381_INT_CFG_REG) #define LTR381_ALS_INT_SEL__POS (4) #define LTR381_ALS_INT_SEL__MSK (0x30) /* Register INT_PST field */ #define LTR381_ALS_CS_PERSIST__REG (LTR381_INT_PST_REG) #define LTR381_ALS_CS_PERSIST__POS (4) #define LTR381_ALS_CS_PERSIST__MSK (0xF0) /* Field value enumeration */ typedef enum { LTR381_ALS_STANDBY_MODE = 0x00, LTR381_ALS_ACTIVE_MODE = 0x01, } LTR381_ALS_CS_ENABLE_VAL; typedef enum { LTR381_ALS_MODE = 0x00, LTR381_CS_MODE = 0x01, } LTR381_ALS_CS_MODE_VAL; typedef enum { LTR381_ALS_NO_RESET = 0x00, LTR381_ALS_RESET = 0x01, } LTR381_SW_RESET_VAL; typedef enum { LTR381_ALS_CS_MEAS_RATE_25MS = 0x00, LTR381_ALS_CS_MEAS_RATE_50MS = 0x01, LTR381_ALS_CS_MEAS_RATE_100MS = 0x02, LTR381_ALS_CS_MEAS_RATE_200MS = 0x03, LTR381_ALS_CS_MEAS_RATE_500MS = 0x04, LTR381_ALS_CS_MEAS_RATE_1000MS = 0x05, LTR381_ALS_CS_MEAS_RATE_2000MS = 0x06, } LTR381_ALS_CS_MEAS_RATE_VAL; typedef enum { LTR381_ALS_CS_RESOLUTION_20BIT = 0x00, LTR381_ALS_CS_RESOLUTION_19BIT = 0x01, LTR381_ALS_CS_RESOLUTION_18BIT = 0x02, LTR381_ALS_CS_RESOLUTION_17BIT = 0x03, LTR381_ALS_CS_RESOLUTION_16BIT = 0x04, } LTR381_ALS_CS_RESOLUTION_VAL; typedef enum { LTR381_ALS_CS_GAIN_RANGE_1 = 0x00, LTR381_ALS_CS_GAIN_RANGE_3 = 0x01, LTR381_ALS_CS_GAIN_RANGE_6 = 0x02, LTR381_ALS_CS_GAIN_RANGE_9 = 0x03, LTR381_ALS_CS_GAIN_RANGE_18 = 0x04, } LTR381_ALS_CS_GAIN_RANGE_VAL; typedef enum { LTR381_CS_ALS_DATA_OLD = 0x00, LTR381_CS_ALS_DATA_NEW = 0x01, } LTR381_CS_ALS_DATA_STATUS_VAL; typedef enum { LTR381_CS_ALS_INT_FALSE = 0x00, LTR381_CS_ALS_INT_TRUE = 0x01, } LTR381_CS_ALS_INT_STATUS_VAL; typedef enum { LTR381_POWER_ON_NORMAL = 0x00, LTR381_POWER_ON_GOING = 0x01, } LTR381_POWER_ON_STATUS_VAL; typedef enum { LTR381_ALS_INT_INACTIVE = 0x00, LTR381_ALS_INT_ACTIVE = 0x01, } LTR381_ALS_INT_PIN_EN_VAL; typedef enum { LTR381_ALS_INT_IR_CHANNEL = 0x00, LTR381_ALS_INT_GREEN_CHANNEL = 0x01, LTR381_ALS_INT_BLUE_CHANNEL = 0x02, LTR381_ALS_INT_RED_CHANNEL = 0x03, } LTR381_ALS_INT_SELECT_VAL; i2c_dev_t ltr381_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = LTR381_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; static int drv_rgb_liteon_ltr381_validate_id(i2c_dev_t* drv, uint8_t part_id) { int ret = 0; uint8_t part_id_value = 0; if (drv == NULL) { return -1; } ret = sensor_i2c_read(drv, LTR381_PART_ID_REG, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (part_id_value != part_id) { return -1; } return 0; } static int drv_rgb_liteon_ltr381_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, LTR381_MAIN_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (mode) { case DEV_POWER_OFF: case DEV_SLEEP: dev_mode = LTR381_SET_BITSLICE(value, ALS_CS_ENABLE, LTR381_ALS_STANDBY_MODE); break; case DEV_POWER_ON: dev_mode = LTR381_SET_BITSLICE(value, ALS_CS_ENABLE, LTR381_ALS_ACTIVE_MODE); break; default: return -1; } ret = sensor_i2c_write(drv, LTR381_MAIN_CTRL_REG, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } UNUSED static int drv_rgb_liteon_ltr381_is_ready(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR381_MAIN_STATUS_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return 0; } ret = (LTR381_GET_BITSLICE(value, ALS_CS_DATA_STATUS) == LTR381_CS_ALS_DATA_NEW) ? 1 : 0; return ret; } static int drv_rgb_liteon_ltr381_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; value = LTR381_SET_BITSLICE(value, ALS_CS_ENABLE, LTR381_ALS_STANDBY_MODE); value = LTR381_SET_BITSLICE(value, CS_MODE, LTR381_CS_MODE); value = LTR381_SET_BITSLICE(value, SW_RESET, LTR381_ALS_NO_RESET); ret = sensor_i2c_write(drv, LTR381_MAIN_CTRL_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR381_SET_BITSLICE(value, ALS_CS_MEAS_RATE, LTR381_ALS_CS_MEAS_RATE_100MS); value = LTR381_SET_BITSLICE(value, ALS_CS_RESOLUTION, LTR381_ALS_CS_RESOLUTION_18BIT); ret = sensor_i2c_write(drv, LTR381_ALS_CS_MEAS_RATE_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR381_SET_BITSLICE(value, ALS_CS_GAIN_RANGE, LTR381_ALS_CS_GAIN_RANGE_3); ret = sensor_i2c_write(drv, LTR381_ALS_CS_GAIN_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR381_SET_BITSLICE(value, ALS_INT_PIN_EN, LTR381_ALS_INT_INACTIVE); value = LTR381_SET_BITSLICE(value, ALS_INT_SEL, LTR381_ALS_INT_GREEN_CHANNEL); ret = sensor_i2c_write(drv, LTR381_INT_CFG_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; ret = sensor_i2c_write(drv, LTR381_INT_PST_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static void drv_rgb_liteon_ltr381_irq_handle(void) { /* no handle so far */ } static int drv_rgb_liteon_ltr381_open(void) { int ret = 0; ret = drv_rgb_liteon_ltr381_set_power_mode(&ltr381_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_rgb_liteon_ltr381_close(void) { int ret = 0; ret = drv_rgb_liteon_ltr381_set_power_mode(&ltr381_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_rgb_liteon_ltr381_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t reg_ch_red_data[3] = { 0 }; uint8_t reg_ch_green_data[3] = { 0 }; uint8_t reg_ch_blue_data[3] = { 0 }; uint32_t ch_red_data = 0; uint32_t ch_green_data = 0; uint32_t ch_blue_data = 0; rgb_data_t * pdata = (rgb_data_t *) buf; if (buf == NULL){ return -1; } size = sizeof(rgb_data_t); if (len < size){ return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_GREEN_0_REG, &reg_ch_green_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_GREEN_1_REG, &reg_ch_green_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_GREEN_2_REG, &reg_ch_green_data[2], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_RED_0_REG, &reg_ch_red_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_RED_1_REG, &reg_ch_red_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_RED_2_REG, &reg_ch_red_data[2], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_BLUE_0_REG, &reg_ch_blue_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_BLUE_1_REG, &reg_ch_blue_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr381_ctx, LTR381_CS_DATA_BLUE_2_REG, &reg_ch_blue_data[2], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ch_red_data = (((uint32_t) reg_ch_red_data[2] << 16) | ((uint32_t) reg_ch_red_data[1] << 8) | reg_ch_red_data[0]); ch_green_data = (((uint32_t) reg_ch_green_data[2] << 16) | ((uint32_t) reg_ch_green_data[1] << 8) | reg_ch_green_data[0]); ch_blue_data = (((uint32_t) reg_ch_blue_data[2] << 16) | ((uint32_t) reg_ch_blue_data[1] << 8) | reg_ch_blue_data[0]); pdata->data[0] = ch_red_data; pdata->data[1] = ch_green_data; pdata->data[2] = ch_blue_data; pdata->timestamp = aos_now_ms(); return (int) size; } static int drv_rgb_liteon_ltr381_write(const void *buf, size_t len) { (void) buf; (void) len; return 0; } static int drv_rgb_liteon_ltr381_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_SET_POWER: { ret = drv_rgb_liteon_ltr381_set_power_mode(&ltr381_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->vendor = DEV_SENSOR_VENDOR_LITEON; info->model = "LTR381"; info->unit = lux; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_rgb_liteon_ltr381_init(void) { int ret = 0; sensor_obj_t sensor_rgb; memset(&sensor_rgb, 0, sizeof(sensor_rgb)); if (!g_init_bitwise) { ret = drv_rgb_liteon_ltr381_validate_id(&ltr381_ctx, LTR381_PART_ID_VAL); if (unlikely(ret)) { return -1; } } if (!g_init_bitwise) { /* fill the sensor_rgb obj parameters here */ sensor_rgb.path = dev_rgb_path; sensor_rgb.tag = TAG_DEV_RGB; sensor_rgb.io_port = I2C_PORT; sensor_rgb.mode = DEV_POLLING; sensor_rgb.power = DEV_POWER_OFF; sensor_rgb.open = drv_rgb_liteon_ltr381_open; sensor_rgb.close = drv_rgb_liteon_ltr381_close; sensor_rgb.read = drv_rgb_liteon_ltr381_read; sensor_rgb.write = drv_rgb_liteon_ltr381_write; sensor_rgb.ioctl = drv_rgb_liteon_ltr381_ioctl; sensor_rgb.irq_handle = drv_rgb_liteon_ltr381_irq_handle; ret = sensor_create_obj(&sensor_rgb); if (unlikely(ret)) { return -1; } ret = drv_rgb_liteon_ltr381_set_default_config(&ltr381_ctx); if (unlikely(ret)) { return -1; } g_init_bitwise |= 1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_rgb_liteon_ltr381_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_rgb_liteon_ltr381.c
C
apache-2.0
16,155
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" /* I2C settings for I2C library */ #ifndef DS1307_I2C #define DS1307_I2C 1 //#define DS1307_I2C_PINSPACK TM_I2C_PinsPack_2 #endif /* DS1307 I2C clock */ #ifndef DS1307_I2C_CLOCK #define DS1307_I2C_CLOCK 100000 #endif /* I2C slave address for DS1307 */ #define DS1307_I2C_ADDR 0xD0 /* Registers location */ #define DS1307_SECONDS 0x00 #define DS1307_MINUTES 0x01 #define DS1307_HOURS 0x02 #define DS1307_DAY 0x03 #define DS1307_DATE 0x04 #define DS1307_MONTH 0x05 #define DS1307_YEAR 0x06 #define DS1307_CONTROL 0x07 /* Bits in control register */ #define DS1307_CONTROL_OUT 7 #define DS1307_CONTROL_SQWE 4 #define DS1307_CONTROL_RS1 1 #define DS1307_CONTROL_RS0 0 /** * @brief Result enumeration */ typedef enum { TM_DS1307_Result_Ok = 0x00, /*!< Everything OK */ TM_DS1307_Result_Error, /*!< An error occurred */ TM_DS1307_Result_DeviceNotConnected /*!< Device is not connected */ } TM_DS1307_Result_t; /** * @brief Structure for date/time */ typedef struct { uint8_t seconds; /*!< Seconds parameter, from 00 to 59 */ uint8_t minutes; /*!< Minutes parameter, from 00 to 59 */ uint8_t hours; /*!< Hours parameter, 24Hour mode, 00 to 23 */ uint8_t day; /*!< Day in a week, from 1 to 7 */ uint8_t date; /*!< Date in a month, 1 to 31 */ uint8_t month; /*!< Month in a year, 1 to 12 */ uint8_t year; /*!< Year parameter, 00 to 99, 00 is 2000 and 99 is 2099 */ } TM_DS1307_Time_t; /** * @brief Enumeration for SQW/OUT pin */ typedef enum { TM_DS1307_OutputFrequency_1Hz = 0x00, /*!< Set SQW/OUT pin to 1Hz output frequency */ TM_DS1307_OutputFrequency_4096Hz, /*!< Set SQW/OUT pin to 4096Hz output frequency */ TM_DS1307_OutputFrequency_8192Hz, /*!< Set SQW/OUT pin to 8192Hz output frequency */ TM_DS1307_OutputFrequency_32768Hz, /*!< Set SQW/OUT pin to 32768Hz output frequency */ TM_DS1307_OutputFrequency_High, /*!< Set SQW/OUT pin high. Because this pin is open-drain, you will need external pull up resistor */ TM_DS1307_OutputFrequency_Low /*!< Set SQW/OUT pin low */ } TM_DS1307_OutputFrequency_t; /** * @} */ i2c_dev_t ds1307_i2c = { .port = DS1307_I2C, .config.address_width = 8, .config.freq = DS1307_I2C_CLOCK, .config.dev_addr = DS1307_I2C_ADDR, }; uint8_t TM_DS1307_Bcd2Bin(uint8_t bcd) { uint8_t dec = 10 * (bcd >> 4); dec += bcd & 0x0F; return dec; } uint8_t TM_DS1307_Bin2Bcd(uint8_t bin) { uint8_t low = 0; uint8_t high = 0; /* High nibble */ high = bin / 10; /* Low nibble */ low = bin - (high * 10); /* Return */ return high << 4 | low; } uint8_t TM_DS1307_CheckMinMax(uint8_t val, uint8_t min, uint8_t max) { if (val < min) { return min; } else if (val > max) { return max; } return val; } static void drv_rtc_maxim_ds1307_irq_handle(void) { /* no handle so far */ } static int drv_rtc_maxim_ds1307_open(void) { return 0; /* no handle so far */ } static int drv_rtc_maxim_ds1307_close(void) { /* no handle so far */ return 0; } static int drv_rtc_maxim_ds1307_ioctl(int cmd, unsigned long arg) { /* no handle so far */ return 0; } static int drv_rtc_maxim_ds1307_write(const void *buf, size_t len) { int ret = 0; size_t size; uint8_t data[7]; const rtc_data_t *time = (rtc_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(rtc_data_t); if (len < size) { return -1; } /* Format data */ data[DS1307_SECONDS] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->seconds, 0, 59)); data[DS1307_MINUTES] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->minutes, 0, 59)); data[DS1307_HOURS] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->hours, 0, 23)); data[DS1307_DAY] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->day, 1, 7)); data[DS1307_DATE] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->date, 1, 31)); data[DS1307_MONTH] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->month, 1, 12)); data[DS1307_YEAR] = TM_DS1307_Bin2Bcd(TM_DS1307_CheckMinMax(time->year, 0, 99)); ret = sensor_i2c_write(&ds1307_i2c, DS1307_I2C_ADDR, data, 7, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } return (int)size; } static int drv_rtc_maxim_ds1307_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t data[7]; rtc_data_t *time = (rtc_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(rtc_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&ds1307_i2c, DS1307_SECONDS, data, 7, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } /* Fill data */ time->seconds = TM_DS1307_Bcd2Bin(data[DS1307_SECONDS]); time->minutes = TM_DS1307_Bcd2Bin(data[DS1307_MINUTES]); time->hours = TM_DS1307_Bcd2Bin(data[DS1307_HOURS]); time->day = TM_DS1307_Bcd2Bin(data[DS1307_DAY]); time->date = TM_DS1307_Bcd2Bin(data[DS1307_DATE]); time->month = TM_DS1307_Bcd2Bin(data[DS1307_MONTH]); time->year = TM_DS1307_Bcd2Bin(data[DS1307_YEAR]); time->timestamp = aos_now_ms(); return (int)size; } int drv_rtc_maxim_ds1307_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = I2C_PORT; sensor.tag = TAG_DEV_RTC; sensor.path = dev_rtc_path; sensor.open = drv_rtc_maxim_ds1307_open; sensor.close = drv_rtc_maxim_ds1307_close; sensor.read = drv_rtc_maxim_ds1307_read; sensor.write = drv_rtc_maxim_ds1307_write; sensor.ioctl = drv_rtc_maxim_ds1307_ioctl; sensor.irq_handle = drv_rtc_maxim_ds1307_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = hal_i2c_init(&ds1307_i2c); if(unlikely(ret)){ printf("i2c init failed!\n"); } if(unlikely(ret)){ return -1; } //set odr is 100hz, and will update if(unlikely(ret)){ return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", RTC_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_rtc_maxim_ds1307_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_rtc_maxim_ds1307.c
C
apache-2.0
6,487
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" /* ADI Temperature SENSOR REGISTER MAP */ #define ADT7410_BIT(x) ((uint8_t)x) #define ADT7410_I2C_ADDR (0x48) //#define ADT7410_I2C_ADDR_TRANS(n) ((n)<<1) //#define ADT7410_I2C_ADDR ADT7410_I2C_ADDR_TRANS(ADT7410_I2C_ADDR1) // Who Am I #define ADT7410_WHO_AM_I_REG (uint8_t)0x0B #define ADT7410_WHO_AM_I_VAL (uint8_t)0xCB // ADI Temperature REGISTER #define ADT7410_TEMPREG_MSB (uint8_t)0x00 #define ADT7410_TEMPREG_LSB (uint8_t)0x01 #define ADT7410_STATUS (uint8_t)0x02 #define ADT7410_CONFIG (uint8_t)0x03 #define ADT7410_THIGH_MSB (uint8_t)0x04 #define ADT7410_THIGH_LSB (uint8_t)0x05 #define ADT7410_TLOW_MSB (uint8_t)0x06 #define ADT7410_TLOW_LSB (uint8_t)0x07 #define ADT7410_TCRIT_MSB (uint8_t)0x08 #define ADT7410_TCRIT_LSB (uint8_t)0x09 #define ADT7410_THYST (uint8_t)0x0A #define ADT7410_SOFT_RESET (uint8_t)0x2F typedef enum { ADT7410_OD_13bits = (uint8_t)0x00, /*!< Output Data : 13bits */ ADT7410_OD_16bits = (uint8_t)0x01, /*!< Output Data : 16bits */ } adt7410_od_resolution; typedef enum { ADT7410_OPMODE_CONTINUOUS = (uint8_t)0x00, /*!< Operation Mode continuously */ ADT7410_OPMODE_ONESHOT = (uint8_t)0x01, /*!< Operation Mode one shot */ ADT7410_OPMODE_FASTONESHOT = (uint8_t)0x02, /*!< Operation Mode fast one shot */ ADT7410_OPMODE_SHUTDOWN = (uint8_t)0x03 /*!< Operation Mode shut down */ } adt7410_opmode_s; i2c_dev_t adt7410_ctx = { .port = 3, .config.address_width = 8, .config.dev_addr = ADT7410_I2C_ADDR << 1, }; static int drv_temp_adi_adt7410_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, ADT7410_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_temp_adi_adt7410_set_power_mode(i2c_dev_t * drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, ADT7410_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (mode) { case DEV_POWER_ON: { value &= ~(0x03 << 5); value |= (ADT7410_OPMODE_CONTINUOUS << 5); ret = sensor_i2c_write(drv, ADT7410_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; case DEV_POWER_OFF: { value &= ~(0x03 << 5); value |= (ADT7410_OPMODE_SHUTDOWN << 5); ret = sensor_i2c_write(drv, ADT7410_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; default: break; } return 0; } static int drv_temp_adi_adt7410_set_od_res(i2c_dev_t * drv, adt7410_od_resolution odr) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, ADT7410_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value &= ~0x80; value |= (uint8_t)(odr << 7); ret = sensor_i2c_write(drv, ADT7410_CONFIG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_temp_adi_adt7410_set_default_config(i2c_dev_t *drv) { int ret = 0; ret = drv_temp_adi_adt7410_set_power_mode(drv, DEV_POWER_OFF); if (unlikely(ret)) { return ret; } ret = drv_temp_adi_adt7410_set_od_res(drv, ADT7410_OD_16bits); if (unlikely(ret)) { return ret; } /* you also can set the low-pass filter and cut off config here */ return 0; } static void drv_temp_adi_adt7410_irq_handle(void) { /* no handle so far */ } static int drv_temp_adi_adt7410_open(void) { int ret = 0; ret = drv_temp_adi_adt7410_set_power_mode(&adt7410_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_adi_adt7410_close(void) { int ret = 0; ret = drv_temp_adi_adt7410_set_power_mode(&adt7410_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_adi_adt7410_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t data[2], buffer[2]; int16_t tmp; int16_t temp; temperature_data_t *pdata = (temperature_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(temperature_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&adt7410_ctx, ADT7410_TEMPREG_MSB, buffer, 2, I2C_OP_RETRIES); tmp = (((uint16_t)buffer[0]) << 8) | buffer[1]; if (tmp > 0) temp = (tmp * 10) / 128; else temp = ((tmp - 65536) * 10) / 128; data[0] = temp & 0x0FF; data[1] = temp >> 8; if (unlikely(ret)) { return -1; } /* hatch the temp data here*/ for (int i = 0; i < 2; i++) { pdata->t |= (((uint32_t)data[i]) << (8 * i)); } pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_adi_adt7410_write(const void *buf, size_t len) { return 0; } static int drv_temp_adi_adt7410_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { ret = drv_temp_adi_adt7410_set_od_res(&adt7410_ctx, arg); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_temp_adi_adt7410_set_power_mode(&adt7410_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 = "adt7410"; info->range_max = 105; info->range_min = -40; info->unit = dCelsius; } break; default: break; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_adi_adt7410_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_TEMP; sensor.path = dev_temp_path; sensor.io_port = I2C_PORT; sensor.open = drv_temp_adi_adt7410_open; sensor.close = drv_temp_adi_adt7410_close; sensor.read = drv_temp_adi_adt7410_read; sensor.write = drv_temp_adi_adt7410_write; sensor.ioctl = drv_temp_adi_adt7410_ioctl; sensor.irq_handle = drv_temp_adi_adt7410_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } ret = drv_temp_adi_adt7410_validate_id(&adt7410_ctx, ADT7410_WHO_AM_I_VAL); if (unlikely(ret)) { return -1; } /* set the default config for the sensor here */ ret = drv_temp_adi_adt7410_set_default_config(&adt7410_ctx); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_temp_adi_adt7410_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_adi_adt7410.c
C
apache-2.0
8,087
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define ENS210_I2C_ADDR1 (0x43) #define ENS210_I2C_ADDR_TRANS(n) ((n)<<1) #define ENS210_I2C_ADDR ENS210_I2C_ADDR_TRANS(ENS210_I2C_ADDR1) /** * @brief ENS210 API Constants */ /* Register address */ #define ENS210_REG_PART_ID 0x00 #define ENS210_REG_UID 0x04 #define ENS210_REG_SYS_CTRL 0x10 #define ENS210_REG_SYS_STAT 0x11 #define ENS210_REG_SENS_RUN 0x21 #define ENS210_REG_SENS_START 0x22 #define ENS210_REG_SENS_STOP 0x23 #define ENS210_REG_SENS_STAT 0x24 #define ENS210_REG_T_VAL 0x30 #define ENS210_REG_H_VAL 0x33 /** Mask to extract 16-bit data from raw T and H values */ #define ENS210_T_H_MASK 0xFFFFU /** Simplification macro, implementing integer division with simple rounding to closest number * It supports both positive and negative numbers, but ONLY positive divisors */ #define IDIV(n,d) ((n)>0 ? ((n)+(d)/2)/(d) : ((n)-(d)/2)/(d)) #define CRC7WIDTH 7 //7 bits CRC has polynomial of 7th order (has 8 terms) #define CRC7POLY 0x89 //The 8 coefficients of the polynomial #define CRC7IVEC 0x7F //Initial vector has all 7 bits high #define DATA7WIDTH 17 #define DATA7MASK ((1UL << DATA7WIDTH) - 1) //0b 1 1111 1111 1111 1111 #define DATA7MSB (1UL << (DATA7WIDTH - 1)) //0b 1 0000 0000 0000 0000 #define I2C_RESULT_OK 0 #define ENS210_RESET_WAIT_TIME_MS 2 #define ENS210_ADDRESS 67 //Address of the ENS210 #define WaitMsec delay /***************************************************************************** * Types/enumerations/variables ****************************************************************************/ /** ENS210 T and H conversion time in milliseconds. Refer to ENS210 data sheet for timing information. */ #define ENS210_T_H_CONVERSION_TIME_MS 130 /** ENS210 T conversion time in milliseconds */ #define ENS210_T_CONVERSION_TIME_MS 105 /** ENS210 Booting time in milliseconds. */ #define ENS210_BOOTING_TIME_MS 1 /** ENS210 SysCtrl register: Low power enable */ #define ENS210_SYSCTRL_LOWPOWER_ENABLE (1 << 0) /** ENS210 SysCtrl register: Low power disable */ #define ENS210_SYSCTRL_LOWPOWER_DISABLE (0 << 0) /** ENS210 SysCtrl register: Reset enable */ #define ENS210_SYSCTRL_RESET_ENABLE (1 << 7) /** ENS210 SysCtrl register: Reset disable */ #define ENS210_SYSCTRL_RESET_DISABLE (0 << 7) /** ENS210 SysStat register: Standby or Booting mode */ #define ENS210_SYSSTAT_MODE_STANDBY (0 << 0) /** ENS210 SysStat register: Active mode */ #define ENS210_SYSSTAT_MODE_ACTIVE (1 << 0) /** ENS210 SensRun register: temperature single shot mode */ #define ENS210_SENSRUN_T_MODE_SINGLE_SHOT (0 << 0) /** ENS210 SensRun register: temperature continuous mode */ #define ENS210_SENSRUN_T_MODE_CONTINUOUS (1 << 0) /** ENS210 SensRun register: relative humidity single shot mode */ #define ENS210_SENSRUN_H_MODE_SINGLE_SHOT (0 << 1) /** ENS210 SensRun register: relative humidity continuous mode */ #define ENS210_SENSRUN_H_MODE_CONTINUOUS (1 << 1) /** ENS210 SensStart register: T sensor start */ #define ENS210_SENSSTART_T_START (1 << 0) /** ENS210 SensStart register: H sensor start */ #define ENS210_SENSSTART_H_START (1 << 1) /** ENS210 SensStop register: T sensor stop */ #define ENS210_SENSSTOP_T_STOP (1 << 0) /** ENS210 SensStop register: H sensor stop */ #define ENS210_SENSSTOP_H_STOP (1 << 1) /** ENS210 SensStat register: T sensor idle */ #define ENS210_SENSSTAT_T_STAT_IDLE (0 << 0) /** ENS210 SensStat register: T sensor active */ #define ENS210_SENSSTAT_T_STAT_ACTIVE (1 << 0) /** ENS210 SensStat register: H sensor idle */ #define ENS210_SENSSTAT_H_STAT_IDLE (0 << 1) /** ENS210 SensStat register: H sensor active */ #define ENS210_SENSSTAT_H_STAT_ACTIVE (1 << 1) #define ENS210_CMD_LENGTH 2 #define ENS210_RESPONSE_LENGTH 6 #define ENS210_DATA_READ_MIN_INTERVAL 1000 /** * @brief ENS210 ID block structure */ typedef struct ENS210_Ids_s { uint16_t partId; /*!< Part ID */ uint8_t uId[8]; /*!< Unique Identifier 8 bytes */ } ENS210_Ids_t; typedef struct { int32_t temperature; uint32_t humidity; } ens210_sensor_data; ens210_sensor_data g_ens210_data = {0}; typedef enum { FLAG_INIT_TEMP = 0, FLAG_INIT_HUMI, } FLAG_INIT_BIT; static uint8_t g_init_bitwise = 0; i2c_dev_t ens210_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = ENS210_I2C_ADDR, }; extern long long aos_now_ms(void); // Compute the CRC-7 of 'val' (should only have 17 bits) uint32_t crc7(uint32_t val) { // Setup polynomial uint32_t pol= CRC7POLY; // Align polynomial with data pol = pol << (DATA7WIDTH-CRC7WIDTH-1); // Loop variable (indicates which bit to test, start with highest) uint32_t bit = DATA7MSB; // Make room for CRC value val = val << CRC7WIDTH; bit = bit << CRC7WIDTH; pol = pol << CRC7WIDTH; // Insert initial vector val |= CRC7IVEC; // Apply division until all bits done while( bit & (DATA7MASK<<CRC7WIDTH) ) { if( bit & val ) val ^= pol; bit >>= 1; pol >>= 1; } return val; } static int drv_ens210_read_temp_and_humi(i2c_dev_t* drv, int32_t *temperature, uint32_t *humidity) { int ret = 0; uint8_t temp_data[3] = {0}; uint8_t humi_data[3] = {0}; uint8_t cmd; cmd = ENS210_SYSCTRL_LOWPOWER_DISABLE; ret = sensor_i2c_write(&ens210_ctx, ENS210_REG_SYS_CTRL, &cmd, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } cmd = (ENS210_SENSRUN_T_MODE_SINGLE_SHOT | ENS210_SENSRUN_H_MODE_SINGLE_SHOT); ret = sensor_i2c_write(&ens210_ctx, ENS210_REG_SENS_RUN, &cmd, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } cmd = (ENS210_SENSSTART_T_START | ENS210_SENSSTART_H_START); ret = sensor_i2c_write(&ens210_ctx, ENS210_REG_SENS_START, &cmd, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (temperature == NULL && humidity == NULL) return -1; ret = sensor_i2c_read(&ens210_ctx, ENS210_REG_T_VAL, temp_data, 3, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } uint32_t t_val = (temp_data[2]<<16) + (temp_data[1]<<8) + (temp_data[0]<<0); // Extract (and print) the fields uint32_t t_data = (t_val>>0 ) & 0xffff; uint32_t t_valid= (t_val>>16) & 0x1; uint32_t t_crc = (t_val>>17) & 0x7f; // Check the CRC uint32_t t_payl = (t_val>>0 ) & 0x1ffff; bool t_crc_ok= crc7(t_payl)==t_crc; // Convert to float (and print) float TinK = (float)t_data / 64; // Temperature in Kelvin float TinC = TinK - 273.15; // Temperature in Celsius float TinF = TinC * 1.8 + 32.0; // Temperature in Fahrenheit ret = sensor_i2c_read(&ens210_ctx, ENS210_REG_H_VAL, humi_data, 3, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } uint32_t h_val = (humi_data[2]<<16) + (humi_data[1]<<8) + (humi_data[0]<<0); // Extract (and print) the fields uint32_t h_data = (h_val>>0 ) & 0xffff; uint32_t h_valid= (h_val>>16) & 0x1; uint32_t h_crc = (h_val>>17) & 0x7f; // Check the CRC uint32_t h_payl = (h_val>>0 ) & 0x1ffff; bool h_crc_ok= (crc7(h_payl)==h_crc); // Convert to float (and print) float H = (float)h_data/512; // relative humidity (in %) *temperature = (int32_t)(TinC*10); // Temperature in Celsius *humidity = (uint32_t)(H*10); // relative humidity (in ‰) (void)h_crc_ok; (void)h_valid; (void)TinF; (void)t_crc_ok; (void)t_valid; return 0; } UNUSED static int drv_ens210_update_data(i2c_dev_t* drv) { static uint32_t prev_update_tick = 0; uint32_t now_tick = 0; int ret = 0; now_tick = aos_now_ms(); if (now_tick - prev_update_tick > ENS210_DATA_READ_MIN_INTERVAL) { ret = drv_ens210_read_temp_and_humi(drv, &g_ens210_data.temperature, &g_ens210_data.humidity); if (ret != 0) { return ret; } prev_update_tick = now_tick; } return 0; } static int drv_temp_humi_ams_ens210_validate_id(i2c_dev_t* drv, uint8_t id_value) { int ret = 0; uint8_t value, value2; ENS210_Ids_t ids; if(drv == NULL){ return -1; } value = 0x00; ret = sensor_i2c_write(drv, ENS210_REG_SYS_CTRL, &value, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_read(drv, ENS210_REG_SYS_STAT, &value2, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_read(drv, ENS210_REG_PART_ID, (uint8_t*)&ids.partId, 2, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (id_value != value){ return -1; } return 0; } UNUSED static int drv_temp_humi_ams_ens210_soft_reset(i2c_dev_t* drv) { int ret = 0; uint8_t value, value2; if(drv == NULL){ return -1; } value = ENS210_SYSCTRL_RESET_ENABLE; ret = sensor_i2c_write(drv, ENS210_REG_SYS_CTRL, &value, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = sensor_i2c_read(drv, ENS210_REG_SYS_STAT, &value2, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static int drv_temp_humi_ams_ens210_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { return 0; } UNUSED static int drv_temp_humi_ams_ens210_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(&ens210_ctx, ENS210_REG_SYS_STAT, &value, 1, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = drv_temp_humi_ams_ens210_set_power_mode(&ens210_ctx, DEV_SLEEP); if(unlikely(ret)){ return ret; } return 0; } UNUSED static int drv_temp_humi_ams_ens210_get_calib_param(i2c_dev_t* drv) { return 0; } UNUSED static int drv_temp_humi_ams_ens210_set_work_mode(i2c_dev_t* drv,uint8_t mode) { return 0; } static void drv_temp_ams_ens210_irq_handle(void) { /* no handle so far */ } static int drv_temp_ams_ens210_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_ams_ens210_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_ams_ens210_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_ens210_update_data(&ens210_ctx); ret = drv_ens210_read_temp_and_humi(&ens210_ctx, &g_ens210_data.temperature, &g_ens210_data.humidity); if (ret != 0) return -1; pdata->t = g_ens210_data.temperature; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_ams_ens210_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_temp_ams_ens210_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 = "ENS210"; info->unit = dCelsius; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_humi_ams_ens210_irq_handle(void) { /* no handle so far */ } static int drv_humi_ams_ens210_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_ams_ens210_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_ams_ens210_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_ens210_read_temp_and_humi(&ens210_ctx, &g_ens210_data.temperature, &g_ens210_data.humidity); if (ret != 0) return -1; pdata->h = g_ens210_data.humidity; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_humi_ams_ens210_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_humi_ams_ens210_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 = "ENS210"; info->unit = permillage; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_ams_ens210_init(void) { int ret = 0; sensor_obj_t sensor_temp; memset(&sensor_temp, 0, sizeof(sensor_temp)); if (!g_init_bitwise) { ret = drv_temp_humi_ams_ens210_validate_id(&ens210_ctx, ENS210_REG_PART_ID); 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_ams_ens210_open; sensor_temp.close = drv_temp_ams_ens210_close; sensor_temp.read = drv_temp_ams_ens210_read; sensor_temp.write = drv_temp_ams_ens210_write; sensor_temp.ioctl = drv_temp_ams_ens210_ioctl; sensor_temp.irq_handle = drv_temp_ams_ens210_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_ams_ens210_init(void) { int ret = 0; sensor_obj_t sensor_humi; memset(&sensor_humi, 0, sizeof(sensor_humi)); if (!g_init_bitwise) { ret = drv_temp_humi_ams_ens210_validate_id(&ens210_ctx, ENS210_REG_PART_ID); 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_ams_ens210_open; sensor_humi.close = drv_humi_ams_ens210_close; sensor_humi.read = drv_humi_ams_ens210_read; sensor_humi.write = drv_humi_ams_ens210_write; sensor_humi.ioctl = drv_humi_ams_ens210_ioctl; sensor_humi.irq_handle = drv_humi_ams_ens210_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; } SENSOR_DRV_ADD(drv_temp_ams_ens210_init); SENSOR_DRV_ADD(drv_humi_ams_ens210_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_ams_ens210.c
C
apache-2.0
16,022
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.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_BARO_DATA_ADDR (0xF7) #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_BARO_DATA_LEN (3) #define BME280_HUMI_DATA_LEN (2) #define BME280_TEMP_DATA_LEN (3) #define BME280_MAX_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 (10) #define BME280_HUMI_UNIT_RATIO_1024 (1024) #define BME280_TEMP_UNIT_RATIO_10 (10) #define BME280_BARO_UNIT_RATIO_256 (256) #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)) #if AOS_SENSOR_BARO_BME280_SPI || AOS_SENSOR_TEMP_BME280_SPI || AOS_SENSOR_HUMI_BME280_SPI #define BME280_IO_PORT SPI_PORT #else #define BME280_IO_PORT I2C_PORT #endif #define BMA280_REG_ADDR(n) ((n) << 8) #define BMA280_SPI_REG_INDX (1) #define BMA280_SPI_DATA_INDX (0) #define BMA280_SPI_DATA_REG_SIZE (2) #define BMA280_SPI_WRITE_FLAG (0X7F) #define BMA280_SPI_READ_FLAG (0X80) 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; typedef enum{ bme_280_temp, bme_280_humi, bme_280_baro, bme_280_max } bme280_type_e; typedef struct _bme280_raw_data_t { uint32_t raw_t; uint32_t raw_h; uint32_t raw_p; } bme280_raw_data_t; typedef struct _bme280_comp_data_t { int32_t comp_t; uint32_t comp_h; uint32_t comp_p; } bme280_comp_data_t; static bme280_cali_table_t g_cali_table; i2c_dev_t bme280_ctx_i2c = { .port = 3, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = BME280_I2C_ADDR, }; spi_dev_t bme280_ctx_spi = { .port = 2, }; sensor_io_dev_t bme280_ctx; sensor_io_func_st bme280_api = { NULL, NULL }; uint32_t g_bme280_init_flag = 0; uint32_t g_bme280_open_flag = 0; static int bme280_io_read(uint16_t reg, uint8_t *data, uint16_t size) { if (unlikely(NULL == bme280_api.read)) { return -1; } return bme280_api.read(reg, data, size); } static int bme280_io_write(uint16_t reg, uint8_t *data, uint16_t size) { if (NULL == bme280_api.write) { return -1; } return bme280_api.write(reg, data, size); } static int drv_humi_bosch_bme280_spi_read(uint16_t reg, uint8_t *data, uint16_t size) { int i; int ret; uint8_t *tx_data = malloc(BMA280_SPI_DATA_REG_SIZE * size); if (NULL == tx_data) { return -1; } for (i = 0; i < size; i++) { tx_data[BMA280_SPI_DATA_REG_SIZE * i + BMA280_SPI_REG_INDX] = (uint8_t)(reg + i) | BMA280_SPI_READ_FLAG; } ret = sensor_io_read(&bme280_ctx, tx_data, tx_data, size, I2C_OP_RETRIES); if (unlikely(ret)) { free(tx_data); return -1; } for (i = 0; i < size; i++) { data[i] = tx_data[BMA280_SPI_DATA_REG_SIZE * i + BMA280_SPI_DATA_INDX]; } free(tx_data); return ret; } static int drv_humi_bosch_bme280_spi_write(uint16_t reg, uint8_t *data, uint16_t size) { uint16_t i; int ret; uint8_t *tx_data = malloc(BMA280_SPI_DATA_REG_SIZE * size); if (NULL == tx_data) { return -1; } for (i = 0; i < size; i++) { tx_data[BMA280_SPI_DATA_REG_SIZE * i + BMA280_SPI_DATA_INDX] = data[i]; tx_data[BMA280_SPI_DATA_REG_SIZE * i + BMA280_SPI_REG_INDX] = (uint8_t)(reg + i) & BMA280_SPI_WRITE_FLAG; } ret = sensor_io_write(&bme280_ctx, NULL, tx_data, size, I2C_OP_RETRIES); free(tx_data); return ret; } static int drv_humi_bosch_bme280_i2c_read(uint16_t reg, uint8_t *data, uint16_t size) { uint16_t addr = reg; if(bme280_ctx.io_port != I2C_PORT){ return -1; } return sensor_io_read(&bme280_ctx, (uint8_t*)&addr, data, size, I2C_OP_RETRIES); } static int drv_humi_bosch_bme280_i2c_write(uint16_t reg, uint8_t *data, uint16_t size) { uint16_t addr = reg; if(bme280_ctx.io_port != I2C_PORT){ return -1; } return sensor_io_write(&bme280_ctx, (uint8_t*)&addr, data, size, I2C_OP_RETRIES); } static int drv_bosch_bme280_io_init(int io_port) { memset(&bme280_api, 0, sizeof(bme280_api)); memset(&bme280_ctx, 0, sizeof(bme280_ctx)); if (io_port == I2C_PORT) { bme280_ctx.io_port = I2C_PORT; memcpy(&bme280_ctx.dev_i2c,&bme280_ctx_i2c,sizeof(bme280_ctx.dev_i2c)); bme280_api.read = drv_humi_bosch_bme280_i2c_read; bme280_api.write = drv_humi_bosch_bme280_i2c_write; return 0; } else if (io_port == SPI_PORT) { bme280_ctx.io_port = SPI_PORT; memcpy(&bme280_ctx.dev_spi,&bme280_ctx_spi,sizeof(bme280_ctx.dev_spi)); bme280_api.read = drv_humi_bosch_bme280_spi_read; bme280_api.write = drv_humi_bosch_bme280_spi_write; return 0; } return -1; } static int drv_bosch_bme280_get_cali_temp_baro(void) { int ret; uint8_t calib_data[BME280_TEMP_PRESS_CALIB_DATA_LEN] = { 0 }; ret = bme280_io_read(BME280_TEMP_PRESS_CALIB_DATA_ADDR, calib_data, BME280_TEMP_PRESS_CALIB_DATA_LEN); 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_bosch_bme280_get_cali_humi(void) { 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 = bme280_io_read(BME280_HUMIDITY_CALIB_DATA_ADDR, table, BME280_HUMIDITY_CALIB_DATA_LEN); 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_bosch_bme280_get_cali_parm(void) { int ret = 0; ret = drv_bosch_bme280_get_cali_temp_baro(); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_get_cali_humi(); if (unlikely(ret)) { return -1; } return 0; } static int drv_bosch_bme280_soft_reset(void) { int ret = 0; uint8_t value = BME280_SOFT_RESET; ret = bme280_io_write(BME280_RESET_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return -1; } return 0; } static int drv_bosch_bme280_validate_id(uint8_t id_value) { uint8_t value = 0x00; int ret = 0; ret = bme280_io_read(BME280_CHIP_ID_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } if (id_value != value) { return -1; } return 0; } static int drv_bosch_bme280_set_work_mode(bme280_type_e type, uint8_t mode) { uint8_t ret = 0; uint8_t value = 0; uint8_t data = 0; if(type >= bme_280_max){ return -1; } switch (mode) { case BME280_ULTRA_LOW_POWER_MODE: data = BME280_OVERSAMP_1X; break; case BME280_LOW_POWER_MODE: data = BME280_OVERSAMP_2X; break; case BME280_STANDARD_RESOLUTION_MODE: data = BME280_OVERSAMP_4X; break; case BME280_HIGH_RESOLUTION_MODE: data = BME280_OVERSAMP_8X; break; case BME280_ULTRA_HIGH_RESOLUTION_MODE: data = BME280_OVERSAMP_16X; break; default: return -1; } value = 0; ret = bme280_io_read(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } value = BME280_SET_BITS(value, BME280_CTRL_TEMP, data); ret = bme280_io_write(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } if(type == bme_280_humi){ value = 0; ret = bme280_io_read(BME280_CTRL_HUM_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } value = BME280_SET_BITS(value, BME280_CTRL_HUM, data); ret = bme280_io_write(BME280_CTRL_HUM_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } } if(type == bme_280_baro){ value = 0; ret = bme280_io_read(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } value = BME280_SET_BITS(value, BME280_CTRL_PRESS, data); ret = bme280_io_write(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } } return ret; } static int drv_bosch_bme280_set_power_mode(dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = bme280_io_read(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); 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 = bme280_io_write(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); 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 = bme280_io_write(BME280_PWR_CTRL_ADDR, &value, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } } break; default: break; } return 0; } static uint8_t drv_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_bosch_bme280_set_odr(uint8_t odr) { int ret = 0; uint8_t v_data_u8 = 0; ret = bme280_io_read(BME280_CONFIG_ADDR, &v_data_u8, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } v_data_u8 = BME280_SET_BITS(v_data_u8, BME280_STANDBY, odr); ret = bme280_io_write(BME280_CONFIG_ADDR, &v_data_u8, I2C_DATA_LEN); if (unlikely(ret)) { return ret; } return ret; } static int drv_bosch_bme280_set_default_config(void) { int ret = 0; ret = drv_bosch_bme280_set_power_mode(DEV_SLEEP); if (unlikely(ret)) { return ret; } ret = drv_bosch_bme280_set_odr(BME280_DEFAULT_ODR_1HZ); if (unlikely(ret)) { return ret; } return 0; } static int drv_bosch_bme280_comp_temp(bme280_raw_data_t* rawdata,bme280_comp_data_t* compdata) { int32_t var1; int32_t var2; int32_t temperature; int32_t temperature_min = -4000; int32_t temperature_max = 8500; if(rawdata == NULL){ return -1; } if(compdata == NULL){ return -1; } var1 = (int32_t)((rawdata->raw_t / 8) - ((int32_t)g_cali_table.dig_T1 * 2)); var1 = (var1 * ((int32_t)g_cali_table.dig_T2)) / 2048; var2 = (int32_t)((rawdata->raw_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; compdata->comp_t = (temperature/ BME280_TEMP_UNIT_RATIO_10); return 0; } static int drv_bosch_bme280_comp_humi(bme280_raw_data_t* rawdata, bme280_comp_data_t* compdata) { 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; if(rawdata == NULL){ return -1; } if(compdata == NULL){ return -1; } var1 = g_cali_table.t_fine - ((int32_t)76800); var2 = (int32_t)((rawdata->raw_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; } compdata->comp_h = (humidity * BME280_HUMI_UNIT_RATIO_10) / BME280_HUMI_UNIT_RATIO_1024; return 0; } static int drv_bosch_bme280_comp_baro(bme280_raw_data_t* rawdata, bme280_comp_data_t* compdata) { int32_t var1 = 0; int32_t var2 = 0; int32_t var3 = 0; int32_t var4 = 0; uint32_t var5 = 0; uint32_t pressure = 0; uint32_t pressure_min = 30000; uint32_t pressure_max = 110000; if(rawdata == NULL){ return -1; } if(compdata == NULL){ return -1; } var1 = (((int32_t)g_cali_table.t_fine) / 2) - (int32_t)64000; var2 = (((var1 / 4) * (var1 / 4)) / 2048) * ((int32_t)g_cali_table.dig_P6); var2 = var2 + ((var1 * ((int32_t)g_cali_table.dig_P5)) * 2); var2 = (var2 / 4) + (((int32_t)g_cali_table.dig_P4) * 65536); var3 = (g_cali_table.dig_P3 * (((var1 / 4) * (var1 / 4)) / 8192)) / 8; var4 = (((int32_t)g_cali_table.dig_P2) * var1) / 2; var1 = (var3 + var4) / 262144; var1 = (((32768 + var1)) * ((int32_t)g_cali_table.dig_P1)) / 32768; if (var1) { var5 = (uint32_t)((uint32_t)1048576) - rawdata->raw_p; pressure = ((uint32_t)(var5 - (uint32_t)(var2 / 4096))) * 3125; if (pressure < 0x80000000){ pressure = (pressure << 1) / ((uint32_t)var1); } else{ pressure = (pressure / (uint32_t)var1) * 2; } var1 = (((int32_t)g_cali_table.dig_P9) * ((int32_t)(((pressure / 8) * (pressure / 8)) / 8192))) / 4096; var2 = (((int32_t)(pressure / 4)) * ((int32_t)g_cali_table.dig_P8)) / 8192; pressure = (uint32_t)((int32_t)pressure + ((var1 + var2 + g_cali_table.dig_P7) / 16)); if (pressure < pressure_min){ pressure = pressure_min; } else if (pressure > pressure_max){ pressure = pressure_max; } } else { pressure = pressure_min; } compdata->comp_p = pressure ; return 0; } static int drv_bosch_bme280_comp(bme280_type_e type, bme280_raw_data_t* rawdata, bme280_comp_data_t* compdata) { int ret = 0; if(type >= bme_280_max){ return -1; } if(rawdata == NULL){ return -1; } if(compdata == NULL){ return -1; } ret = drv_bosch_bme280_comp_temp(rawdata,compdata); if (unlikely(ret)) { return ret; } if(type == bme_280_humi){ ret = drv_bosch_bme280_comp_humi(rawdata,compdata); if (unlikely(ret)) { return ret; } } if(type == bme_280_baro){ ret = drv_bosch_bme280_comp_baro(rawdata,compdata); if (unlikely(ret)) { return ret; } } return 0; } static int drv_bosch_bme280_read_rawdata(bme280_type_e type, bme280_raw_data_t* rawdata) { int ret = 0; uint8_t data[BME280_TEMP_DATA_LEN] = { 0 }; if(type >= bme_280_max){ return -1; } if(rawdata == NULL){ return -1; } rawdata->raw_t = 0; rawdata->raw_h = 0; rawdata->raw_p = 0; ret = bme280_io_read(BME280_TEMP_DATA_ADDR, data, BME280_TEMP_DATA_LEN); if (unlikely(ret)) { return ret; } rawdata->raw_t = (uint32_t)((uint32_t)data[0] << BME280_SHIFT_BY_12_BITS) | ((uint32_t)data[1] << BME280_SHIFT_BY_04_BITS) | ((uint32_t)data[2] >> BME280_SHIFT_BY_04_BITS); if(type == bme_280_humi){ ret = bme280_io_read(BME280_HUMI_DATA_ADDR, data, BME280_HUMI_DATA_LEN); if (unlikely(ret)) { return ret; } rawdata->raw_h = ((uint32_t)data[0] << BME280_SHIFT_BY_08_BITS) | ((uint32_t)data[1]); } if(type == bme_280_baro){ ret = bme280_io_read(BME280_BARO_DATA_ADDR, data, BME280_BARO_DATA_LEN); if (unlikely(ret)) { return ret; } rawdata->raw_p = ((uint32_t)data[0] << BME280_SHIFT_BY_12_BITS) | ((uint32_t)data[1] << BME280_SHIFT_BY_04_BITS) | ((uint32_t)data[2] >> BME280_SHIFT_BY_04_BITS) ; } 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_bosch_bme280_set_power_mode(DEV_SLEEP); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_set_work_mode(bme_280_humi,BME280_STANDARD_RESOLUTION_MODE); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_set_power_mode(DEV_POWER_ON); if (unlikely(ret)) { return -1; } return 0; } static int drv_humi_bosch_bme280_close(void) { int ret = 0; g_bme280_open_flag--; if(!g_bme280_open_flag){ ret = drv_bosch_bme280_set_power_mode(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; bme280_raw_data_t raw_data; bme280_comp_data_t comp_data; 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_bosch_bme280_read_rawdata(bme_280_humi, &raw_data); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_comp(bme_280_humi, &raw_data, &comp_data); if (unlikely(ret)) { return -1; } pdata->h = comp_data.comp_h; 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_bosch_bme280_hz2odr(arg); ret = drv_bosch_bme280_set_odr(odr); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_bosch_bme280_set_power_mode(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; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = BME280_IO_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; } if (!g_bme280_init_flag){ ret = drv_bosch_bme280_io_init(sensor.io_port); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_validate_id(BME280_CHIP_ID); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_soft_reset(); if (unlikely(ret)) { return -1; } aos_msleep(5); ret = drv_bosch_bme280_set_default_config(); if (unlikely(ret)) { return -1; } aos_msleep(5); ret = drv_bosch_bme280_get_cali_parm(); if (unlikely(ret)) { return -1; } g_bme280_init_flag = 1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_temp_bosch_bme280_irq_handle(void) { /* no handle so far */ } static int drv_temp_bosch_bme280_open(void) { int ret = 0; ret = drv_bosch_bme280_set_power_mode(DEV_SLEEP); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_set_work_mode(bme_280_temp,BME280_STANDARD_RESOLUTION_MODE); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_set_power_mode(DEV_POWER_ON); if (unlikely(ret)) { return -1; } return 0; } static int drv_temp_bosch_bme280_close(void) { int ret = 0; g_bme280_open_flag--; if(!g_bme280_open_flag){ ret = drv_bosch_bme280_set_power_mode(DEV_POWER_OFF); if (unlikely(ret)) { return -1; } } return 0; } static int drv_temp_bosch_bme280_read(void *buf, size_t len) { int ret = 0; size_t size = 0; bme280_raw_data_t raw_data; bme280_comp_data_t comp_data; 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_bosch_bme280_read_rawdata(bme_280_temp, &raw_data); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_comp(bme_280_temp, &raw_data, &comp_data); if (unlikely(ret)) { return -1; } pdata->t = comp_data.comp_t; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_bosch_bme280_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { uint8_t odr = drv_bosch_bme280_hz2odr(arg); ret = drv_bosch_bme280_set_odr(odr); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_bosch_bme280_set_power_mode(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 = 85; info->range_min = 0; info->unit = dCelsius; } break; default: break; } return 0; } int drv_temp_bosch_bme280_init(void) { int ret = 0; sensor_obj_t sensor; #if 1 memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = BME280_IO_PORT; sensor.tag = TAG_DEV_TEMP; sensor.path = dev_temp_path; sensor.open = drv_temp_bosch_bme280_open; sensor.close = drv_temp_bosch_bme280_close; sensor.read = drv_temp_bosch_bme280_read; sensor.write = NULL; sensor.ioctl = drv_temp_bosch_bme280_ioctl; sensor.irq_handle = drv_temp_bosch_bme280_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } if (!g_bme280_init_flag){ ret = drv_bosch_bme280_io_init(sensor.io_port); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_validate_id(BME280_CHIP_ID); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_soft_reset(); if (unlikely(ret)) { return -1; } aos_msleep(5); ret = drv_bosch_bme280_set_default_config(); if (unlikely(ret)) { return -1; } aos_msleep(5); ret = drv_bosch_bme280_get_cali_parm(); if (unlikely(ret)) { return -1; } g_bme280_init_flag = 1; } #endif /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_baro_bosch_bme280_irq_handle(void) { /* no handle so far */ } static int drv_baro_bosch_bme280_open(void) { int ret = 0; ret = drv_bosch_bme280_set_power_mode(DEV_SLEEP); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_set_work_mode(bme_280_baro,BME280_STANDARD_RESOLUTION_MODE); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_set_power_mode(DEV_POWER_ON); if (unlikely(ret)) { return -1; } return 0; } static int drv_baro_bosch_bme280_close(void) { int ret = 0; g_bme280_open_flag--; if(!g_bme280_open_flag){ ret = drv_bosch_bme280_set_power_mode(DEV_POWER_OFF); if (unlikely(ret)) { return -1; } } return 0; } static int drv_baro_bosch_bme280_read(void *buf, size_t len) { int ret = 0; size_t size = 0; bme280_raw_data_t raw_data; bme280_comp_data_t comp_data; 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_bosch_bme280_read_rawdata(bme_280_baro, &raw_data); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_comp(bme_280_baro, &raw_data, &comp_data); if (unlikely(ret)) { return -1; } pdata->p = comp_data.comp_p; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_baro_bosch_bme280_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { uint8_t odr = drv_bosch_bme280_hz2odr(arg); ret = drv_bosch_bme280_set_odr(odr); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_bosch_bme280_set_power_mode(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_baro_bosch_bme280_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.io_port = BME280_IO_PORT; sensor.tag = TAG_DEV_BARO; sensor.path = dev_baro_path; sensor.open = drv_baro_bosch_bme280_open; sensor.close = drv_baro_bosch_bme280_close; sensor.read = drv_baro_bosch_bme280_read; sensor.write = NULL; sensor.ioctl = drv_baro_bosch_bme280_ioctl; sensor.irq_handle = drv_baro_bosch_bme280_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } if (!g_bme280_init_flag){ ret = drv_bosch_bme280_io_init(sensor.io_port); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_validate_id(BME280_CHIP_ID); if (unlikely(ret)) { return -1; } ret = drv_bosch_bme280_soft_reset(); if (unlikely(ret)) { return -1; } aos_msleep(5); ret = drv_bosch_bme280_set_default_config(); if (unlikely(ret)) { return -1; } aos_msleep(5); ret = drv_bosch_bme280_get_cali_parm(); if (unlikely(ret)) { return -1; } g_bme280_init_flag = 1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_temp_bosch_bme280_init); SENSOR_DRV_ADD(drv_humi_bosch_bme280_init); SENSOR_DRV_ADD(drv_baro_bosch_bme280_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_baro_bosch_bme280.c
C
apache-2.0
35,246
/* * Copyright (C) 2018 Sensirion Inc. * Author: Johannes Winkelmann, jwi@sensirion.com * * Based on SHTC1 driver */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define SHT30_I2C_SLAVE_ADDR_DEFAULT 0x44 #define SHT30_I2C_SLAVE_ADDR_ALT 0x45 #define SHT30_ADDR_TRANS(n) ((n) << 1) #define SHT30_I2C_ADDR SHT30_ADDR_TRANS(SHT30_I2C_SLAVE_ADDR_DEFAULT) /* delays for non-blocking i2c commands, both in ms */ #define SHT30_NONBLOCKING_WAIT_TIME_HRM 15 #define SHT30_CMD_LENGTH 2 #define SHT30_RESPONSE_LENGTH 6 #define SHT30_DATA_READ_MIN_INTERVAL 200 /* in millisecond */ typedef enum { FLAG_INIT_TEMP = 0, FLAG_INIT_HUMI, } FLAG_INIT_BIT; /* * default port = 3 * Use "GLOBAL_DEFINES += SENSIRION_SHT30_PORT=2" in a Makefile to override */ #ifndef SENSIRION_SHT30_PORT #define SENSIRION_SHT30_PORT 3 #endif /* SENSIRION_SHT30_PORT */ i2c_dev_t sht30_ctx = { .port = SENSIRION_SHT30_PORT, .config.dev_addr = SHT30_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; typedef struct { int32_t temperature; uint32_t humidity; } sht30_sensor_data; static sht30_sensor_data g_sht30_data_new = {0}; static const uint8_t sht30_cmd_list[][SHT30_CMD_LENGTH] = { {0x2C, 0x06}, /* measure blocking hrm */ }; typedef enum { SHT30_CMD_measure_blocking_hrm, SHT30_CMD_END } CMD_SHT30_ENUM; static int drv_sht30_cmd_write(i2c_dev_t *drv, CMD_SHT30_ENUM cmd) { int ret = 0; if (cmd < SHT30_CMD_measure_blocking_hrm || cmd >= SHT30_CMD_END) { return -1; } ret = hal_i2c_master_send(drv, drv->config.dev_addr, sht30_cmd_list[cmd], SHT30_CMD_LENGTH, AOS_WAIT_FOREVER); return ret; } static int drv_sht30_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_sht30_read_raw_data(i2c_dev_t *drv, uint8_t *data) { int ret = 0; CMD_SHT30_ENUM readcmd; if (data == NULL) return -1; readcmd = SHT30_CMD_measure_blocking_hrm; ret = drv_sht30_cmd_write(drv, readcmd); if (unlikely(ret)) { return ret; } ret = drv_sht30_result_read(drv, data, SHT30_RESPONSE_LENGTH); if (unlikely(ret)) { return ret; } return ret; } static int drv_sht30_read_temp_and_humi(i2c_dev_t *drv, int32_t *temperature, uint32_t *humidity) { int ret = 0; uint8_t data[SHT30_RESPONSE_LENGTH] = {0}; int32_t temp_raw = 0; int32_t humi_raw = 0; if (temperature == NULL && humidity == NULL) return -1; ret = drv_sht30_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_sht30_update_data(i2c_dev_t *drv) { static uint32_t prev_update_tick = 0; uint32_t now_tick = 0; int ret = 0; now_tick = aos_now_ms(); if (now_tick - prev_update_tick >= SHT30_DATA_READ_MIN_INTERVAL) { ret = drv_sht30_read_temp_and_humi(drv, &g_sht30_data_new.temperature, &g_sht30_data_new.humidity); if (unlikely(ret != 0)) { return ret; } prev_update_tick = now_tick; } return 0; } static void drv_temp_sensirion_sht30_irq_handle(void) { /* no handle so far */ } static int drv_temp_sensirion_sht30_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_sensirion_sht30_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_sensirion_sht30_read(void *buf, size_t len) { int ret = 0; const size_t size = sizeof(temperature_data_t); temperature_data_t *pdata = (temperature_data_t*)buf; if (buf == NULL){ return -1; } if (len < size){ return -1; } ret = drv_sht30_update_data(&sht30_ctx); if (ret != 0) return -1; pdata->t = g_sht30_data_new.temperature / 100.0f; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_sensirion_sht30_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_temp_sensirion_sht30_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 = "SHT30"; info->unit = dCelsius; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_humi_sensirion_sht30_irq_handle(void) { /* no handle so far */ } static int drv_humi_sensirion_sht30_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_sensirion_sht30_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_sensirion_sht30_read(void *buf, size_t len) { int ret = 0; const size_t size = sizeof(humidity_data_t); humidity_data_t *pdata = (humidity_data_t*)buf; if (buf == NULL){ return -1; } if (len < size){ return -1; } ret = drv_sht30_update_data(&sht30_ctx); if (ret != 0) return -1; pdata->h = g_sht30_data_new.humidity / 100; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_humi_sensirion_sht30_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_humi_sensirion_sht30_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 = "SHT30"; info->unit = permillage; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_sensirion_sht30_init(void) { int ret = 0; sensor_obj_t sensor_temp; memset(&sensor_temp,0, sizeof(sensor_temp)); 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_sht30_open; sensor_temp.close = drv_temp_sensirion_sht30_close; sensor_temp.read = drv_temp_sensirion_sht30_read; sensor_temp.write = drv_temp_sensirion_sht30_write; sensor_temp.ioctl = drv_temp_sensirion_sht30_ioctl; sensor_temp.irq_handle = drv_temp_sensirion_sht30_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_sht30_init(void) { int ret = 0; sensor_obj_t sensor_humi; memset(&sensor_humi, 0, sizeof(sensor_humi)); 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_sht30_open; sensor_humi.close = drv_humi_sensirion_sht30_close; sensor_humi.read = drv_humi_sensirion_sht30_read; sensor_humi.write = drv_humi_sensirion_sht30_write; sensor_humi.ioctl = drv_humi_sensirion_sht30_ioctl; sensor_humi.irq_handle = drv_humi_sensirion_sht30_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; } SENSOR_DRV_ADD(drv_humi_sensirion_sht30_init); SENSOR_DRV_ADD(drv_temp_sensirion_sht30_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_sensirion_sht30.c
C
apache-2.0
8,572
/* * Copyright (C) 2018 Sensirion Inc. * Author: Johannes Winkelmann, jwi@sensirion.com * * Based on SHTC1 driver */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define SHT31_I2C_SLAVE_ADDR_DEFAULT 0x44 #define SHT31_I2C_SLAVE_ADDR_ALT 0x45 #define SHT31_ADDR_TRANS(n) ((n) << 1) #define SHT31_I2C_ADDR SHT31_ADDR_TRANS(SHT31_I2C_SLAVE_ADDR_DEFAULT) /* delays for non-blocking i2c commands, both in ms */ #define SHT31_NONBLOCKING_WAIT_TIME_HRM 15 #define SHT31_CMD_LENGTH 2 #define SHT31_RESPONSE_LENGTH 6 #define SHT31_DATA_READ_MIN_INTERVAL 200 /* in millisecond */ typedef enum { FLAG_INIT_TEMP = 0, FLAG_INIT_HUMI, } FLAG_INIT_BIT; /* * default port = 3 * Use "GLOBAL_DEFINES += SENSIRION_SHT31_PORT=2" in a Makefile to override */ #ifndef SENSIRION_SHT31_PORT #define SENSIRION_SHT31_PORT 3 #endif /* SENSIRION_SHT31_PORT */ i2c_dev_t sht31_ctx = { .port = SENSIRION_SHT31_PORT, .config.dev_addr = SHT31_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; typedef struct { int32_t temperature; uint32_t humidity; } sht31_sensor_data; static sht31_sensor_data g_sht31_data_new = {0}; static const uint8_t sht31_cmd_list[][SHT31_CMD_LENGTH] = { {0x2C, 0x06}, /* measure blocking hrm */ }; typedef enum { SHT31_CMD_measure_blocking_hrm, SHT31_CMD_END } CMD_SHT31_ENUM; static int drv_sht31_cmd_write(i2c_dev_t *drv, CMD_SHT31_ENUM cmd) { int ret = 0; if (cmd < SHT31_CMD_measure_blocking_hrm || cmd >= SHT31_CMD_END) { return -1; } ret = hal_i2c_master_send(drv, drv->config.dev_addr, sht31_cmd_list[cmd], SHT31_CMD_LENGTH, AOS_WAIT_FOREVER); return ret; } static int drv_sht31_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_sht31_read_raw_data(i2c_dev_t *drv, uint8_t *data) { int ret = 0; CMD_SHT31_ENUM readcmd; if (data == NULL) return -1; readcmd = SHT31_CMD_measure_blocking_hrm; ret = drv_sht31_cmd_write(drv, readcmd); if (unlikely(ret)) { return ret; } ret = drv_sht31_result_read(drv, data, SHT31_RESPONSE_LENGTH); if (unlikely(ret)) { return ret; } return ret; } static int drv_sht31_read_temp_and_humi(i2c_dev_t *drv, int32_t *temperature, uint32_t *humidity) { int ret = 0; uint8_t data[SHT31_RESPONSE_LENGTH] = {0}; int32_t temp_raw = 0; int32_t humi_raw = 0; if (temperature == NULL && humidity == NULL) return -1; ret = drv_sht31_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_sht31_update_data(i2c_dev_t *drv) { static uint32_t prev_update_tick = 0; uint32_t now_tick = 0; int ret = 0; now_tick = aos_now_ms(); if (now_tick - prev_update_tick >= SHT31_DATA_READ_MIN_INTERVAL) { ret = drv_sht31_read_temp_and_humi(drv, &g_sht31_data_new.temperature, &g_sht31_data_new.humidity); if (unlikely(ret != 0)) { return ret; } prev_update_tick = now_tick; } return 0; } static void drv_temp_sensirion_sht31_irq_handle(void) { /* no handle so far */ } static int drv_temp_sensirion_sht31_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_sensirion_sht31_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_sensirion_sht31_read(void *buf, size_t len) { int ret = 0; const size_t size = sizeof(temperature_data_t); temperature_data_t *pdata = (temperature_data_t*)buf; if (buf == NULL){ return -1; } if (len < size){ return -1; } ret = drv_sht31_update_data(&sht31_ctx); if (ret != 0) return -1; pdata->t = g_sht31_data_new.temperature / 100.0f; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_sensirion_sht31_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_temp_sensirion_sht31_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 = "SHT31"; info->unit = dCelsius; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_humi_sensirion_sht31_irq_handle(void) { /* no handle so far */ } static int drv_humi_sensirion_sht31_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_sensirion_sht31_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_sensirion_sht31_read(void *buf, size_t len) { int ret = 0; const size_t size = sizeof(humidity_data_t); humidity_data_t *pdata = (humidity_data_t*)buf; if (buf == NULL){ return -1; } if (len < size){ return -1; } ret = drv_sht31_update_data(&sht31_ctx); if (ret != 0) return -1; pdata->h = g_sht31_data_new.humidity / 100; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_humi_sensirion_sht31_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_humi_sensirion_sht31_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 = "SHT31"; info->unit = permillage; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_sensirion_sht31_init(void) { int ret = 0; sensor_obj_t sensor_temp; memset(&sensor_temp,0, sizeof(sensor_temp)); 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_sht31_open; sensor_temp.close = drv_temp_sensirion_sht31_close; sensor_temp.read = drv_temp_sensirion_sht31_read; sensor_temp.write = drv_temp_sensirion_sht31_write; sensor_temp.ioctl = drv_temp_sensirion_sht31_ioctl; sensor_temp.irq_handle = drv_temp_sensirion_sht31_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_sht31_init(void) { int ret = 0; sensor_obj_t sensor_humi; memset(&sensor_humi, 0, sizeof(sensor_humi)); 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_sht31_open; sensor_humi.close = drv_humi_sensirion_sht31_close; sensor_humi.read = drv_humi_sensirion_sht31_read; sensor_humi.write = drv_humi_sensirion_sht31_write; sensor_humi.ioctl = drv_humi_sensirion_sht31_ioctl; sensor_humi.irq_handle = drv_humi_sensirion_sht31_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; } SENSOR_DRV_ADD(drv_humi_sensirion_sht31_init); SENSOR_DRV_ADD(drv_temp_sensirion_sht31_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_sensirion_sht31.c
C
apache-2.0
8,572
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "ulog/ulog.h" #include <k_api.h> #include "sensor_drv_api.h" #include "sensor_hal.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) { 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 = aos_now_ms(); 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 / 100; 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 / 100; 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; memset(&sensor_temp, 0, sizeof(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; memset(&sensor_humi, 0, sizeof(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; } SENSOR_DRV_ADD(drv_humi_sensirion_shtc1_init); SENSOR_DRV_ADD(drv_temp_sensirion_shtc1_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_sensirion_shtc1.c
C
apache-2.0
10,759
/* * Copyright (C) 2015-2020 Alibaba Group Holding Limited */ #include "ulog/ulog.h" #include "aos/hal/i2c.h" #include <math.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define SI7006_I2C_ADDRESS 0x40 #define SI7006_I2C_ADDR_TRANS(n) ((n) << 1) #define SI7006_TAG 0x06 #define SI7006_MEAS_REL_HUMIDITY_MASTER_MODE 0xE5 #define SI7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE 0xF5 #define SI7006_MEAS_TEMP_MASTER_MODE 0xE3 #define SI7006_MEAS_TEMP_NO_MASTER_MODE 0xF3 #define SI7006_READ_OLD_TEMP 0xE0 #define SI7006_RESET 0xFE #define SI7006_READ_ID_LOW_0 0xFA #define SI7006_READ_ID_LOW_1 0x0F #define SI7006_READ_ID_HIGH_0 0xFC #define SI7006_READ_ID_HIGH_1 0xC9 #define SI7006_READ_Firmware_Revision_0 0x84 #define SI7006_READ_Firmware_Revision_1 0xB8 i2c_dev_t SI7006_ctx = { .port = 1, .config.address_width = I2C_HAL_ADDRESS_WIDTH_7BIT, .config.freq = I2C_BUS_BIT_RATES_100K, .config.mode = I2C_MODE_MASTER, .config.dev_addr = SI7006_I2C_ADDRESS, }; static int drv_temp_si_si7006_write(const void *buf, size_t len) { return 0; } static int drv_temp_si_si7006_read(void *buf, size_t len) { int ret = 0; size_t size; float temp; uint8_t read_data[2] = {0}; unsigned int value; temperature_data_t *pdata = (temperature_data_t *)buf; // printf("\n enter %s : %d\n", __func__, __LINE__); if (buf == NULL) { return -1; } //printf("\n enter %s : %d\n", __func__, __LINE__); size = sizeof(temperature_data_t); if (len < size) { return -1; } //printf("\n enter %s : %d\n", __func__, __LINE__); uint8_t reg = SI7006_MEAS_TEMP_NO_MASTER_MODE; // hal_i2c_master_send(&SI7006_ctx, SI7006_ctx.config.dev_addr, &reg, 1, 1000); ret = sensor_drv_i2c_master_send(&SI7006_ctx, &reg, 1, 1000); if (ret < 0) { LOG("%s Error on i2c master send\n", SENSOR_STR); return -1; } aos_msleep(30); // hal_i2c_master_recv(&SI7006_ctx, SI7006_ctx.config.dev_addr, read_data, 2, 1000); ret = sensor_drv_i2c_master_recv(&SI7006_ctx, read_data, 2, 1000); if (ret < 0) { LOG("%s Error on i2c master recv\n", SENSOR_STR); return -1; } value = (read_data[0] << 8) | read_data[1]; //LOGI("APP", "%0x -- %0x -->0x%x\n", read_data[0], read_data[1], value); //LOG("%s %0x -- %0x -->0x%x\n", SENSOR_STR, read_data[0], read_data[1], value); // A temperature measurement will always return XXXXXX00 in the LSB field. if (value & 0xFFFC) { temp = (175.72f * (float)value) / 65536.0f - 46.85f; //LOGI("APP", "temperature: %2f\n", temp); LOG("%s temperature: %2f\n", SENSOR_STR, temp); pdata->t = (int)(temp * 10); pdata->timestamp = aos_now_ms(); } else { LOG("%s Error on temp\n", SENSOR_STR); return -1; } return (int)size; } static int drv_temp_si_si7006_ioctl(int cmd, unsigned long arg) { } static void drv_temp_si_si7006_irq_handle(void) { /* no handle so far */ } static int drv_temp_si_si7006_close(void) { #if 0 int ret = 0; ret = drv_temp_si_si7006_set_power_mode(&SI7006_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } #endif LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_si_si7006_open(void) { #if 0 int ret = 0; ret = drv_temp_si_si7006_set_power_mode(&SI7006_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } #endif LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_si_si7006_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_TEMP; sensor.path = dev_temp_path; sensor.io_port = I2C_PORT; sensor.open = drv_temp_si_si7006_open; sensor.close = drv_temp_si_si7006_close; sensor.read = drv_temp_si_si7006_read; sensor.write = drv_temp_si_si7006_write; sensor.ioctl = drv_temp_si_si7006_ioctl; sensor.irq_handle = drv_temp_si_si7006_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } /* update the phy sensor info to sensor hal */ LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_si_si7006_write(const void *buf, size_t len) { return 0; } static int drv_humi_si_si7006_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t read_data[3] = {0}; unsigned int value; float humi; uint8_t reg = SI7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE; humidity_data_t *pdata = (humidity_data_t *)buf; //printf("\n enter %s : %d\n", __func__, __LINE__); if (buf == NULL) { return -1; } //printf("\n enter %s : %d\n", __func__, __LINE__); size = sizeof(humidity_data_t); if (len < size) { return -1; } //printf("\n enter %s : %d\n", __func__, __LINE__); // hal_i2c_master_send(&SI7006_ctx, SI7006_ctx.config.dev_addr, &reg, 1, 1000); ret = sensor_drv_i2c_master_send(&SI7006_ctx, &reg, 1, 1000); if (ret < 0) { LOG("%s Error on i2c master send\n", SENSOR_STR); return -1; } aos_msleep(30); // hal_i2c_master_recv(&SI7006_ctx, SI7006_ctx.config.dev_addr, read_data, 2, 1000); ret = sensor_drv_i2c_master_recv(&SI7006_ctx, read_data, 2, 1000); if (ret < 0) { LOG("%s Error on i2c master recv\n", SENSOR_STR); return -1; } value = (read_data[0] << 8) | read_data[1]; //LOGI("APP", "%0x -- %0x -->0x%x\n", read_data[0], read_data[1], value); if (value & 0xFFFE) { humi = ((125.0f * (float)value) / 65535.0f) - 6.0f; LOG("%s humidity: %2f\n", SENSOR_STR, humi); pdata->h = (int)(humi * 10); pdata->timestamp = aos_now_ms(); } else { LOG("%s Error on humidity\n", SENSOR_STR); return 1; } return (int)size; } static int drv_humi_si_si7006_ioctl(int cmd, unsigned long arg) { } static void drv_humi_si_si7006_irq_handle(void) { /* no handle so far */ } static int drv_humi_si_si7006_close(void) { #if 0 int ret = 0; ret = drv_temp_si_si7006_set_power_mode(&SI7006_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } #endif LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_si_si7006_open(void) { #if 0 int ret = 0; ret = drv_temp_si_si7006_set_power_mode(&SI7006_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } #endif LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_humi_si_si7006_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_HUMI; sensor.path = dev_humi_path; sensor.io_port = I2C_PORT; sensor.open = drv_humi_si_si7006_open; sensor.close = drv_humi_si_si7006_close; sensor.read = drv_humi_si_si7006_read; sensor.write = drv_humi_si_si7006_write; sensor.ioctl = drv_humi_si_si7006_ioctl; sensor.irq_handle = drv_humi_si_si7006_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_temp_si_si7006_init); SENSOR_DRV_ADD(drv_humi_si_si7006_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_si_si7006.c
C
apache-2.0
7,916
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" /* ST humi SENSOR REGISTER MAP */ #define HTS221_BIT(x) ((uint8_t)x) #define HTS221_I2C_ADDR1 (0x5F) #define HTS221_I2C_ADDR_TRANS(n) ((n) << 1) #define HTS221_I2C_ADDR HTS221_I2C_ADDR_TRANS(HTS221_I2C_ADDR1) #define HTS221_DriverVersion_Major (uint8_t)1 #define HTS221_DriverVersion_Minor (uint8_t)0 #define HTS221_DriverVersion_Point (uint8_t)0 // who Am I #define HTS221_WHO_AM_I_REG (uint8_t)0x0F #define HTS221_WHO_AM_I_VAL (uint8_t)0xBC // brief Humidity and temperature average mode #define HTS221_AV_CONF_REG (uint8_t)0x10 #define HTS221_AVGT_BIT HTS221_BIT(3) #define HTS221_AVGH_BIT HTS221_BIT(0) #define HTS221_AVGT_MASK (uint8_t)0x38 #define HTS221_AVGH_MASK (uint8_t)0x07 // brief Control register 1. #define HTS221_CTRL_REG1 (uint8_t)0x20 #define HTS221_PD_BIT HTS221_BIT(7) #define HTS221_BDU_BIT HTS221_BIT(2) #define HTS221_ODR_BIT HTS221_BIT(0) #define HTS221_PD_MASK (uint8_t)0x80 #define HTS221_BDU_MASK (uint8_t)0x04 #define HTS221_ODR_MASK (uint8_t)0x03 // brief Control register 2. #define HTS221_CTRL_REG2 (uint8_t)0x21 #define HTS221_BOOT_BIT HTS221_BIT(7) #define HTS221_HEATHER_BIT HTS221_BIT(1) #define HTS221_ONESHOT_BIT HTS221_BIT(0) #define HTS221_BOOT_MASK (uint8_t)0x80 #define HTS221_HEATHER_MASK (uint8_t)0x02 #define HTS221_ONE_SHOT_MASK (uint8_t)0x01 // brief Control register 3. #define HTS221_CTRL_REG3 (uint8_t)0x22 #define HTS221_DRDY_H_L_BIT HTS221_BIT(7) #define HTS221_PP_OD_BIT HTS221_BIT(6) #define HTS221_DRDY_BIT HTS221_BIT(2) #define HTS221_DRDY_H_L_MASK (uint8_t)0x80 #define HTS221_PP_OD_MASK (uint8_t)0x40 #define HTS221_DRDY_MASK (uint8_t)0x04 // brief Status register. #define HTS221_STATUS_REG (uint8_t)0x27 #define HTS221_H_DA_BIT HTS221_BIT(1) #define HTS221_T_DA_BIT HTS221_BIT(0) #define HTS221_HDA_MASK (uint8_t)0x02 #define HTS221_TDA_MASK (uint8_t)0x01 // brief Humidity data (LSB) #define HTS221_HR_OUT_L_REG (uint8_t)0x28 // brief Humidity data (MSB) #define HTS221_HR_OUT_H_REG (uint8_t)0x29 // brief Temperature data (LSB) #define HTS221_TEMP_OUT_L_REG (uint8_t)0x2A // brief Temperature data (MSB) #define HTS221_TEMP_OUT_H_REG (uint8_t)0x2B // brief Calibration registers #define HTS221_H0_RH_X2 (uint8_t)0x30 #define HTS221_H1_RH_X2 (uint8_t)0x31 #define HTS221_T0_DEGC_X8 (uint8_t)0x32 #define HTS221_T1_DEGC_X8 (uint8_t)0x33 #define HTS221_T0_T1_DEGC_H2 (uint8_t)0x35 #define HTS221_H0_T0_OUT_L (uint8_t)0x36 #define HTS221_H0_T0_OUT_H (uint8_t)0x37 #define HTS221_H1_T0_OUT_L (uint8_t)0x3A #define HTS221_H1_T0_OUT_H (uint8_t)0x3B #define HTS221_T0_OUT_L (uint8_t)0x3C #define HTS221_T0_OUT_H (uint8_t)0x3D #define HTS221_T1_OUT_L (uint8_t)0x3E #define HTS221_T1_OUT_H (uint8_t)0x3F typedef enum { HTS221_ODR_ONE_SHOT = (uint8_t)0x00, /*!< Output Data Rate: one shot */ HTS221_ODR_1HZ = (uint8_t)0x01, /*!< Output Data Rate: 1Hz */ HTS221_ODR_7HZ = (uint8_t)0x02, /*!< Output Data Rate: 7Hz */ HTS221_ODR_12_5HZ = (uint8_t)0x03, /*!< Output Data Rate: 12_5Hz */ } HTS221_odr_e; typedef enum { HTS221_BDU_CONTINUOUS_UPDATE = (uint8_t)0x00, /*!< Data updated continuously */ HTS221_BDU_NO_UPDATE = (uint8_t)0x04 /*!< Data updated after a read operation */ } HTS221_bdu_e; i2c_dev_t HTS221_ctx = { .port = 1, .config.address_width = 8, .config.freq = 400000, .config.dev_addr = HTS221_I2C_ADDR, }; static HTS221_odr_e drv_temp_humi_st_hts221_hz2odr(int hz) { if (hz > 10) return HTS221_ODR_12_5HZ; else if (hz > 5) return HTS221_ODR_7HZ; else return HTS221_ODR_1HZ; } static int drv_temp_humi_st_hts221_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, HTS221_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_temp_humi_st_hts221_set_power_mode(i2c_dev_t *drv, dev_power_mode_e mode) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (mode) { case DEV_POWER_ON: { value |= HTS221_PD_MASK; ret = sensor_i2c_write(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; case DEV_POWER_OFF: { value &= ~HTS221_PD_MASK; ret = sensor_i2c_write(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } } break; default: break; } return 0; } static int drv_temp_humi_st_hts221_set_odr(i2c_dev_t *drv, HTS221_odr_e odr) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value &= ~HTS221_ODR_MASK; value |= (uint8_t)odr; ret = sensor_i2c_write(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_temp_humi_st_hts221_set_bdu(i2c_dev_t *drv, HTS221_bdu_e bdu) { uint8_t value = 0x00; int ret = 0; ret = sensor_i2c_read(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value &= ~HTS221_BDU_MASK; value |= (uint8_t)bdu; ret = sensor_i2c_write(drv, HTS221_CTRL_REG1, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static int drv_temp_humi_st_hts221_set_default_config(i2c_dev_t *drv) { int ret = 0; ret = drv_temp_humi_st_hts221_set_power_mode(drv, DEV_POWER_OFF); if (unlikely(ret)) { return ret; } ret = drv_temp_humi_st_hts221_set_odr(drv, HTS221_ODR_1HZ); if (unlikely(ret)) { return ret; } ret = drv_temp_humi_st_hts221_set_bdu(drv, HTS221_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_temp_st_hts221_irq_handle(void) { /* no handle so far */ } static int drv_temp_st_hts221_open(void) { int ret = 0; ret = drv_temp_humi_st_hts221_set_power_mode(&HTS221_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_st_hts221_close(void) { int ret = 0; ret = drv_temp_humi_st_hts221_set_power_mode(&HTS221_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_temp_st_hts221_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t data[2], buffer[4], tmp; int16_t T0_out, T1_out, T_out, T0_degC_x8_u16, T1_degC_x8_u16; int16_t T0_degC, T1_degC; int16_t temp; temperature_data_t *pdata = (temperature_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(temperature_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&HTS221_ctx, (HTS221_T0_DEGC_X8 | 0x80), buffer, 2, I2C_OP_RETRIES); ret = sensor_i2c_read(&HTS221_ctx, HTS221_T0_T1_DEGC_H2, &tmp, I2C_DATA_LEN, I2C_OP_RETRIES); T0_degC_x8_u16 = (((uint16_t)(tmp & 0x03)) << 8) | ((uint16_t)buffer[0]); T1_degC_x8_u16 = (((uint16_t)(tmp & 0x0C)) << 6) | ((uint16_t)buffer[1]); T0_degC = T0_degC_x8_u16 >> 3; T1_degC = T1_degC_x8_u16 >> 3; ret |= sensor_i2c_read(&HTS221_ctx, (HTS221_T0_OUT_L | 0x80), buffer, 4, I2C_OP_RETRIES); T0_out = (((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]; T1_out = (((uint16_t)buffer[3]) << 8) | (uint16_t)buffer[2]; ret |= sensor_i2c_read(&HTS221_ctx, (HTS221_TEMP_OUT_L_REG | 0x80), buffer, 2, I2C_OP_RETRIES); T_out = (((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]; temp = 10 * (T_out - T0_out) * (T1_degC - T0_degC) / (T1_out - T0_out) + 10 * T0_degC; data[0] = temp & 0x0FF; data[1] = temp >> 8; if (unlikely(ret)) { return -1; } /* hatch the temp data here*/ for (int i = 0; i < 2; i++) { pdata->t |= (((uint32_t)data[i]) << (8 * i)); } pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_temp_st_hts221_write(const void *buf, size_t len) { return 0; } static int drv_temp_st_hts221_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { HTS221_odr_e odr = drv_temp_humi_st_hts221_hz2odr(arg); ret = drv_temp_humi_st_hts221_set_odr(&HTS221_ctx, odr); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_temp_humi_st_hts221_set_power_mode(&HTS221_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 = "HTS221"; info->range_max = 120; info->range_min = -40; info->unit = dCelsius; } break; default: break; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_temp_st_hts221_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_TEMP; sensor.path = dev_temp_path; sensor.io_port = I2C_PORT; sensor.open = drv_temp_st_hts221_open; sensor.close = drv_temp_st_hts221_close; sensor.read = drv_temp_st_hts221_read; sensor.write = drv_temp_st_hts221_write; sensor.ioctl = drv_temp_st_hts221_ioctl; sensor.irq_handle = drv_temp_st_hts221_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } ret = drv_temp_humi_st_hts221_validate_id(&HTS221_ctx, HTS221_WHO_AM_I_VAL); if (unlikely(ret)) { return -1; } /* set the default config for the sensor here */ ret = drv_temp_humi_st_hts221_set_default_config(&HTS221_ctx); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static void drv_humi_st_hts221_irq_handle(void) { /* no handle so far */ } static int drv_humi_st_hts221_open(void) { int ret = 0; ret = drv_temp_humi_st_hts221_set_power_mode(&HTS221_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_st_hts221_close(void) { int ret = 0; ret = drv_temp_humi_st_hts221_set_power_mode(&HTS221_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_humi_st_hts221_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t data[2], buffer[2]; int16_t H0_T0_out, H1_T0_out, H_T_out; int16_t H0_rh, H1_rh; int16_t humi; humidity_data_t *pdata = (humidity_data_t *)buf; if (buf == NULL) { return -1; } size = sizeof(humidity_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&HTS221_ctx, (HTS221_H0_RH_X2 | 0x80), buffer, 2, I2C_OP_RETRIES); H0_rh = buffer[0] >> 1; H1_rh = buffer[1] >> 1; ret |= sensor_i2c_read(&HTS221_ctx, (HTS221_H0_T0_OUT_L | 0x80), buffer, 2, I2C_OP_RETRIES); H0_T0_out = (((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]; ret |= sensor_i2c_read(&HTS221_ctx, (HTS221_H1_T0_OUT_L | 0x80), buffer, 2, I2C_OP_RETRIES); H1_T0_out = (((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]; ret |= sensor_i2c_read(&HTS221_ctx, (HTS221_HR_OUT_L_REG | 0x80), buffer, 2, I2C_OP_RETRIES); H_T_out = (((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]; humi = (H_T_out - H0_T0_out) * (H1_rh - H0_rh) / (H1_T0_out - H0_T0_out) + H0_rh; humi *= 10; humi = (humi > 1000) ? 1000 : (humi < 0) ? 0 : humi; humi /= 10; data[1] = humi >> 8; data[0] = humi & 0x0FF; if (unlikely(ret)) { return -1; } /* hatch the humi data here*/ for (int i = 0; i < 2; i++) { pdata->h |= (((uint32_t)data[i]) << (8 * i)); } pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_humi_st_hts221_write(const void *buf, size_t len) { return 0; } static int drv_humi_st_hts221_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_ODR_SET: { HTS221_odr_e odr = drv_temp_humi_st_hts221_hz2odr(arg); ret = drv_temp_humi_st_hts221_set_odr(&HTS221_ctx, odr); if (unlikely(ret)) { return -1; } } break; case SENSOR_IOCTL_SET_POWER: { ret = drv_temp_humi_st_hts221_set_power_mode(&HTS221_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 = "HTS221"; info->range_max = 100; info->range_min = 0; info->unit = permillage; } break; default: break; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_humi_st_hts221_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_HUMI; sensor.path = dev_humi_path; sensor.io_port = I2C_PORT; sensor.open = drv_humi_st_hts221_open; sensor.close = drv_humi_st_hts221_close; sensor.read = drv_humi_st_hts221_read; sensor.write = drv_humi_st_hts221_write; sensor.ioctl = drv_humi_st_hts221_ioctl; sensor.irq_handle = drv_humi_st_hts221_irq_handle; ret = sensor_create_obj(&sensor); if (unlikely(ret)) { return -1; } ret = drv_temp_humi_st_hts221_validate_id(&HTS221_ctx, HTS221_WHO_AM_I_VAL); if (unlikely(ret)) { return -1; } /* set the default config for the sensor here */ ret = drv_temp_humi_st_hts221_set_default_config(&HTS221_ctx); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_temp_st_hts221_init); SENSOR_DRV_ADD(drv_humi_st_hts221_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_temp_humi_st_hts221.c
C
apache-2.0
16,189
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define CCS811_I2C_ADDR1 (0x5A) /* When ADDR is high the 7bit I2C address is 0x5B */ #define CCS811_I2C_ADDR_TRANS(n) ((n)<<1) #define CCS811_I2C_ADDR CCS811_I2C_ADDR_TRANS(CCS811_I2C_ADDR1) /** * @brief CCS811 API Constants */ #define CCS811_REG_STATUS 0x00 #define CCS811_REG_MEAS_MODE 0x01 #define CCS811_REG_ALG_RESULT_DATA 0x02 #define CCS811_REG_RAW_DATA 0x03 #define CCS811_REG_ALG_CONFIG_DATA 0x04 #define CCS811_REG_ENVIRONMENT_DATA 0x05 #define CCS811_REG_THRESHOLDS 0x10 #define CCS811_CHIP_ID_REG 0x20 #define CCS811_HW_VERSION 0x21 #define CCS811_FW_BOOT_VERSION 0x23 #define CCS811_FW_APP_VERSION 0x24 #define CCS811_ERROR_ID 0xE0 #define CCS811_RST_REG 0xFF #define CCS811_APP_ERASE 0xF1 #define CCS811_APP_DATE 0xF2 #define CCS811_APP_VERIFY 0xF3 #define CCS811_APP_START 0xF4 #define CCS811_CHIP_ID_VAL 0x81 #define CCS811_MEASUREMENT_MODE_IDLE 0x00 #define CCS811_MEASUREMENT_MODE_VOC_1S 0x10 #define CCS811_MEASUREMENT_MODE_VOC_10S 0x20 #define CCS811_MEASUREMENT_MODE_VOC_60S 0x30 #define CCS811_VOC_DATA_SIZE 8 #define CCS811_CMD_LENGTH 1 #define CCS811_REG_LENGTH 1 #define CCS811_DATA_LENGTH 2 #define CCS811_RESET_LENGTH 4 #define CCS811_DATA_READ_MIN_INTERVAL 1000 /* in millisecond */ typedef struct { uint16_t eCO2; uint16_t voc; uint16_t adc; uint16_t current; uint32_t resistance; } ccs811_measurement_t; ccs811_measurement_t g_ccs811_data = {0}; i2c_dev_t ccs811_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = CCS811_I2C_ADDR, }; static int drv_voc_ams_ccs811_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, CCS811_CHIP_ID_REG, &value, CCS811_CMD_LENGTH, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } if (id_value != value){ return -1; } return 0; } UNUSED static int drv_voc_ams_ccs811_soft_reset(i2c_dev_t* drv) { int ret = 0; uint8_t data[4]; data[0] = 0x11; data[1] = 0xE5; data[2] = 0x72; data[3] = 0x8A; ret = sensor_i2c_write(drv,CCS811_RST_REG, &data[0],CCS811_RESET_LENGTH,I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return ret; } static int drv_voc_ams_ccs811_app_start(i2c_dev_t* drv) { int ret = 0; uint8_t value; ret = sensor_i2c_read(&ccs811_ctx, CCS811_REG_STATUS, &value, CCS811_CMD_LENGTH, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } aos_msleep(2); value = CCS811_APP_START; ret = hal_i2c_master_send(&ccs811_ctx, CCS811_I2C_ADDR, &value, CCS811_CMD_LENGTH, AOS_WAIT_FOREVER); if(unlikely(ret)){ return ret; } aos_msleep(250); return 0; } static int drv_voc_ams_ccs811_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode) { int ret = 0; uint8_t value = 0x00; switch(mode){ case DEV_POWER_OFF: case DEV_SLEEP:{ value = CCS811_MEASUREMENT_MODE_IDLE; ret = sensor_i2c_write(&ccs811_ctx, CCS811_REG_MEAS_MODE, &value, CCS811_CMD_LENGTH, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; case DEV_POWER_ON:{ value = CCS811_MEASUREMENT_MODE_VOC_1S; ret = sensor_i2c_write(&ccs811_ctx, CCS811_REG_MEAS_MODE, &value, CCS811_CMD_LENGTH, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } }break; default:break; } return 0; } static int drv_voc_ams_ccs811_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(&ccs811_ctx, CCS811_REG_STATUS, &value, CCS811_CMD_LENGTH, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } ret = drv_voc_ams_ccs811_set_power_mode(&ccs811_ctx, DEV_SLEEP); if(unlikely(ret)){ return ret; } return 0; } UNUSED static int drv_voc_ams_ccs811_set_work_mode(i2c_dev_t* drv,uint8_t mode) { uint8_t ret = 0; uint8_t value = 0; ret = sensor_i2c_read(&ccs811_ctx, CCS811_REG_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } value = mode; ret = sensor_i2c_write(&ccs811_ctx, CCS811_REG_MEAS_MODE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return ret; } return 0; } static void drv_voc_ams_ccs811_irq_handle(void) { /* no handle so far */ } static int drv_voc_ams_ccs811_open(void) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(&ccs811_ctx, CCS811_REG_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return -1; } ret = drv_voc_ams_ccs811_set_power_mode(&ccs811_ctx, DEV_POWER_ON); if(unlikely(ret)){ return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_voc_ams_ccs811_close(void) { int ret = 0; uint8_t value = 0x00; ret = sensor_i2c_read(&ccs811_ctx, CCS811_REG_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if(unlikely(ret)){ return 0; } ret = drv_voc_ams_ccs811_set_power_mode(&ccs811_ctx, DEV_SLEEP); if(unlikely(ret)){ return 0; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_voc_ams_ccs811_read(void *buf, size_t len) { int ret = 0; size_t size = 0; uint8_t buffer[8]; uint16_t data[2]; integer_data_t* pdata = (integer_data_t*)buf; if(buf == NULL){ return -1; } size = sizeof(integer_data_t); if(len < size){ return -1; } ret = sensor_i2c_read(&ccs811_ctx, CCS811_REG_ALG_RESULT_DATA, buffer, 8, I2C_OP_RETRIES); data[0] = (uint16_t)(buffer[0] << 8) | (uint16_t)(buffer[1] << 0); data[1] = (uint16_t)(buffer[2] << 8) | (uint16_t)(buffer[3] << 0); if(unlikely(ret)){ return -1; } if (data[1] > 32768) data[1] = 32768; pdata->data = data[1]; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_voc_ams_ccs811_write(const void *buf, size_t len) { return 0; } static int drv_voc_ams_ccs811_ioctl(int cmd, unsigned long arg) { int ret = 0; switch(cmd){ case SENSOR_IOCTL_SET_POWER:{ ret = drv_voc_ams_ccs811_set_power_mode(&ccs811_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 = "CCS811"; info->range_max = 32768; info->range_min = 0; //info->unit = ppb; }break; default:break; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_voc_ams_ccs811_init(void) { int ret = 0; sensor_obj_t sensor; memset(&sensor, 0, sizeof(sensor)); /* fill the sensor obj parameters here */ sensor.tag = TAG_DEV_TVOC; sensor.path = dev_tvoc_path; sensor.io_port = I2C_PORT; sensor.open = drv_voc_ams_ccs811_open; sensor.close = drv_voc_ams_ccs811_close; sensor.read = drv_voc_ams_ccs811_read; sensor.write = drv_voc_ams_ccs811_write; sensor.ioctl = drv_voc_ams_ccs811_ioctl; sensor.irq_handle = drv_voc_ams_ccs811_irq_handle; ret = sensor_create_obj(&sensor); if(unlikely(ret)){ return -1; } ret = drv_voc_ams_ccs811_validate_id(&ccs811_ctx, CCS811_CHIP_ID_VAL); if(unlikely(ret)){ return -1; } /* ret = drv_voc_ams_ccs811_soft_reset(&ccs811_ctx); if(unlikely(ret)){ return -1; } */ ret = drv_voc_ams_ccs811_app_start(&ccs811_ctx); if(unlikely(ret)){ return -1; } ret = drv_voc_ams_ccs811_set_default_config(&ccs811_ctx); if(unlikely(ret)){ return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_voc_ams_ccs811_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_tvoc_ams_ccs811.c
C
apache-2.0
8,680
/* * Copyright (C) 2018 Sensirion Inc. * Author: Johannes Winkelmann, jwi@sensirion.com * * Driver for SGP30 and SGPC3 * Based on SHTC1 driver */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define SGP30_I2C_SLAVE_ADDR 0x58 #define SGP30_ADDR_TRANS(n) ((n) << 1) #define SGP30_I2C_ADDR SGP30_ADDR_TRANS(SGP30_I2C_SLAVE_ADDR) /* delays for non-blocking i2c commands, both in ms */ #define SGP30_NONBLOCKING_WAIT_TIME 50 #define SGP30_CMD_LENGTH 2 #define SGP30_INFO_RESPONSE_LENGTH 3 #define SGP30_DATA_RESPONSE_LENGTH 6 #define SGPC3_DATA_RESPONSE_LENGTH 3 /* * default port = 3 * Use "GLOBAL_DEFINES += SENSIRION_SGP30_PORT=2" in a Makefile to override */ #ifndef SENSIRION_SGP30_PORT #define SENSIRION_SGP30_PORT 2 #endif /* SENSIRION_SGP30_PORT */ typedef enum { TYPE_SGP30, TYPE_SGPC3 } SGP30_TYPE_ENUM; static SGP30_TYPE_ENUM g_sgp_type = TYPE_SGPC3; i2c_dev_t sgp30_ctx = { .port = SENSIRION_SGP30_PORT, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = SGP30_I2C_ADDR, }; static const uint8_t sgp30_cmd_list[][SGP30_CMD_LENGTH] = { /* SGP30 */ {0x20, 0x03}, /* init air quality */ {0x20, 0x2f}, /* get feature set */ {0x20, 0x08}, /* measure air quality */ /* SGPC3 */ {0x20, 0xae} /* init air quality */ }; typedef enum { SGP30_CMD_INIT_AIR_QUALITY, SGP30_CMD_GET_FEATURE_SET, SGP30_CMD_MEASURE_AIR_QUALITY, SGPC3_CMD_INIT_AIR_QUALITY, SGP30_CMD_END } CMD_SGP30_ENUM; static void sgp30_delay_ms(uint32_t delay_time) { // TODO: krhino_task_sleep is currently blocking; therefore, I implemented // a busy wait loop // // krhino_task_sleep(krhino_ms_to_ticks(SGP30_NONBLOCKING_WAIT_TIME)); uint32_t start_ms = aos_now_ms(); while (aos_now_ms() - start_ms < delay_time) { // idle } } static int drv_sgp30_cmd_write(i2c_dev_t* drv, CMD_SGP30_ENUM cmd) { if (cmd < SGP30_CMD_INIT_AIR_QUALITY || cmd >= SGP30_CMD_END) return -1; return hal_i2c_master_send(drv, drv->config.dev_addr, sgp30_cmd_list[cmd], SGP30_CMD_LENGTH, AOS_WAIT_FOREVER); } static int drv_sgp30_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_sgp30_read_raw_data(i2c_dev_t *drv, integer_data_t *pdata) { int ret = 0; uint8_t data[SGP30_DATA_RESPONSE_LENGTH] = {0}; int data_length = (g_sgp_type == TYPE_SGP30) ? SGP30_DATA_RESPONSE_LENGTH : SGPC3_DATA_RESPONSE_LENGTH; ret = drv_sgp30_cmd_write(drv, SGP30_CMD_MEASURE_AIR_QUALITY); if (unlikely(ret)) { return ret; } sgp30_delay_ms(SGP30_NONBLOCKING_WAIT_TIME); ret = drv_sgp30_result_read(drv, data, data_length); if (unlikely(ret)) { return ret; } if (g_sgp_type == TYPE_SGP30) { pdata->data = ((uint16_t)data[3] << 8) | data[4]; } else { pdata->data = ((uint16_t)data[0] << 8) | data[1]; } return ret; } static int drv_sgp30_init_sensor(i2c_dev_t* drv) { int ret = 0; uint8_t data[SGPC3_DATA_RESPONSE_LENGTH] = {0}; ret = drv_sgp30_cmd_write(drv, SGP30_CMD_GET_FEATURE_SET); if (unlikely(ret)) { return ret; } sgp30_delay_ms(SGP30_NONBLOCKING_WAIT_TIME); ret = drv_sgp30_result_read(drv, data, SGPC3_DATA_RESPONSE_LENGTH); if (unlikely(ret)) { return ret; } CMD_SGP30_ENUM init_cmd = SGP30_CMD_INIT_AIR_QUALITY; int product_id = data[0] >> 4; int major = (data[1] & 0xe0) >> 5; int minor = data[1] & 0x1f; if (product_id == 1) { if (unlikely(major != 0 || minor < 6)) { // unsupported sensor return -1; } g_sgp_type = TYPE_SGPC3; init_cmd = SGPC3_CMD_INIT_AIR_QUALITY; } else if (product_id == 0) { if (unlikely(major != 1)) { // unsupported sensor return -1; } g_sgp_type = TYPE_SGP30; init_cmd = SGP30_CMD_INIT_AIR_QUALITY; } ret = drv_sgp30_cmd_write(drv, init_cmd); if (unlikely(ret)) { LOG("%s %s: Init air quality failed", SENSOR_STR, __func__); return ret; } return ret; } static void drv_tvoc_sensirion_sgp30_irq_handle(void) { /* no handle so far */ } static int drv_tvoc_sensirion_sgp30_open(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_tvoc_sensirion_sgp30_close(void) { LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_tvoc_sensirion_sgp30_read(void *buf, size_t len) { int ret = 0; size_t size; integer_data_t *pdata = (integer_data_t *)buf; if (buf == NULL){ return -1; } size = sizeof(integer_data_t); if (len < size){ return -1; } ret = drv_sgp30_read_raw_data(&sgp30_ctx, pdata); if (ret != 0) return -1; pdata->timestamp = aos_now_ms(); return (int)size; } static int drv_tvoc_sensirion_sgp30_write(const void *buf, size_t len) { (void)buf; (void)len; return 0; } static int drv_tvoc_sensirion_sgp30_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 = (g_sgp_type == TYPE_SGP30) ? "SGP30" : "SGPC3"; //info->unit = ppb; }break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_tvoc_sensirion_sgp30_init(void) { int ret = 0; sensor_obj_t sensor_temp; memset(&sensor_temp, 0, sizeof(sensor_temp)); ret = drv_sgp30_init_sensor(&sgp30_ctx); if (unlikely(ret)) { return -1; } /* fill the sensor_temp obj parameters here */ sensor_temp.tag = TAG_DEV_TVOC; sensor_temp.path = dev_tvoc_path; sensor_temp.io_port = I2C_PORT; sensor_temp.open = drv_tvoc_sensirion_sgp30_open; sensor_temp.close = drv_tvoc_sensirion_sgp30_close; sensor_temp.read = drv_tvoc_sensirion_sgp30_read; sensor_temp.write = drv_tvoc_sensirion_sgp30_write; sensor_temp.ioctl = drv_tvoc_sensirion_sgp30_ioctl; sensor_temp.irq_handle = drv_tvoc_sensirion_sgp30_irq_handle; ret = sensor_create_obj(&sensor_temp); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_tvoc_sensirion_sgp30_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_tvoc_sensirion_sgp30.c
C
apache-2.0
7,051
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "sensor_drv_api.h" #include "sensor_hal.h" #define LTR390_I2C_SLAVE_ADDR 0x53 #define LTR390_MAIN_CTRL 0x00 /* Operation mode control */ #define LTR390_ALS_UVS_MEAS_RATE 0x04 /* Measurement rate and resolution */ #define LTR390_ALS_UVS_GAIN 0x05 /* Analog gain range*/ #define LTR390_PART_ID 0x06 #define LTR390_MAIN_STATUS 0x07 #define LTR390_ALS_DATA_0 0x0D #define LTR390_ALS_DATA_1 0x0E #define LTR390_ALS_DATA_2 0x0F #define LTR390_UVS_DATA_0 0x10 #define LTR390_UVS_DATA_1 0x11 #define LTR390_UVS_DATA_2 0x12 #define LTR390_INT_CFG 0x19 #define LTR390_INT_PST 0x1A /* Interrupt persist setting */ #define LTR390_ALS_UVS_THRES_UP_0 0x21 /* Interrupt upper threshold, lower byte */ #define LTR390_ALS_UVS_THRES_UP_1 0x22 /* Interrupt upper threshold, middle byte */ #define LTR390_ALS_UVS_THRES_UP_2 0x23 /* Interrupt upper threshold, upper byte */ #define LTR390_ALS_UVS_THRES_LOW_0 0x24 /* Interrupt lower threshold, lower byte */ #define LTR390_ALS_UVS_THRES_LOW_1 0x25 /* Interrupt lower threshold, middle byte */ #define LTR390_ALS_UVS_THRES_LOW_2 0x26 /* Interrupt lower threshold, upper byte */ #define LTR390_ADDR_TRANS(n) ((n) << 1) #define LTR390_I2C_ADDR LTR390_ADDR_TRANS(LTR390_I2C_SLAVE_ADDR) #define LTR390_PART_ID_VAL 0xB2 #define LTR390_MAIN_CTRL_REG_ALS_UVS_EN__POS (1) #define LTR390_MAIN_CTRL_REG_ALS_UVS_EN__MSK (0x02) #define LTR390_MAIN_CTRL_REG_ALS_UVS_EN__REG (LTR390_MAIN_CTRL) #define LTR390_MAIN_CTRL_REG_UVS_MODE__POS (3) #define LTR390_MAIN_CTRL_REG_UVS_MODE__MSK (0x08) #define LTR390_MAIN_CTRL_REG_UVS_MODE__REG (LTR390_MAIN_CTRL) #define LTR390_MAIN_CTRL_REG_SW_RESET__POS (4) #define LTR390_MAIN_CTRL_REG_SW_RESET__MSK (0x10) #define LTR390_MAIN_CTRL_REG_SW_RESET__REG (LTR390_MAIN_CTRL) #define LTR390_ALS_UVS_MEAS_RATE_REG_MEAS_RATE__POS (0) #define LTR390_ALS_UVS_MEAS_RATE_REG_MEAS_RATE__MSK (0x07) #define LTR390_ALS_UVS_MEAS_RATE_REG_MEAS_RATE__REG (LTR390_ALS_UVS_MEAS_RATE) #define LTR390_ALS_UVS_MEAS_RATE_REG_RESOLUTION__POS (4) #define LTR390_ALS_UVS_MEAS_RATE_REG_RESOLUTION__MSK (0x70) #define LTR390_ALS_UVS_MEAS_RATE_REG_RESOLUTION__REG (LTR390_ALS_UVS_MEAS_RATE) #define LTR390_ALS_UVS_GAIN_REG_GAIN_RANGE__POS (0) #define LTR390_ALS_UVS_GAIN_REG_GAIN_RANGE__MSK (0x07) #define LTR390_ALS_UVS_GAIN_REG_GAIN_RANGE__REG (LTR390_ALS_UVS_GAIN) #define LTR390_MAIN_STATUS_REG_ALS_UVS_DATA_STATUS__POS (3) #define LTR390_MAIN_STATUS_REG_ALS_UVS_DATA_STATUS__MSK (0x08) #define LTR390_MAIN_STATUS_REG_ALS_UVS_DATA_STATUS__REG (LTR390_MAIN_STATUS) #define LTR390_MAIN_STATUS_REG_ALS_UVS_INT_STATUS__POS (4) #define LTR390_MAIN_STATUS_REG_ALS_UVS_INT_STATUS__MSK (0x10) #define LTR390_MAIN_STATUS_REG_ALS_UVS_INT_STATUS__REG (LTR390_MAIN_STATUS) #define LTR390_MAIN_STATUS_REG_POWER_ON_STATUS__POS (5) #define LTR390_MAIN_STATUS_REG_POWER_ON_STATUS__MSK (0x20) #define LTR390_MAIN_STATUS_REG_POWER_ON_STATUS__REG (LTR390_MAIN_STATUS) #define LTR390_INT_CFG_REG_LS_INT_EN__POS (2) #define LTR390_INT_CFG_REG_LS_INT_EN__MSK (0x04) #define LTR390_INT_CFG_REG_LS_INT_EN__REG (LTR390_INT_CFG) #define LTR390_INT_CFG_REG_LS_INT_SEL__POS (4) #define LTR390_INT_CFG_REG_LS_INT_SEL__MSK (0x30) #define LTR390_INT_CFG_REG_LS_INT_SEL__REG (LTR390_INT_CFG) #define LTR390_INT_PST_REG_ALS_UV_PERSIST__POS (4) #define LTR390_INT_PST_REG_ALS_UV_PERSIST__MSK (0xF0) #define LTR390_INT_PST_REG_ALS_UV_PERSIST__REG (LTR390_INT_PST) #define LTR390_GET_BITSLICE(regvar, bitname) ((regvar & LTR390_##bitname##__MSK) >> LTR390_##bitname##__POS) #define LTR390_SET_BITSLICE(regvar, bitname, val) ((regvar & ~LTR390_##bitname##__MSK) | ((val<<LTR390_##bitname##__POS)&LTR390_##bitname##__MSK)) #define LTR390_WAIT_TIME_PER_CHECK (10) #define LTR390_WAIT_TIME_TOTAL (100) typedef enum { LTR390_ALS_UVS_STANDBY = 0x00, LTR390_ALS_UVS_ACTIVE = 0x01, } LTR390_CFG_ALS_UVS_EN; typedef enum { LTR390_ALS_MODE = 0x00, LTR390_UVS_MODE = 0x01, } LTR390_CFG_ALS_UVS_MODE; typedef enum { LTR390_SW_RESET_FALSE = 0x00, LTR390_SW_RESET_TRUE = 0x01, } LTR390_CFG_SW_RESET; typedef enum { LTR390_ALS_UVS_MEAS_RATE_25 = 0x00, /* Measurement Repeat Rate = 25ms */ LTR390_ALS_UVS_MEAS_RATE_50 = 0x01, /* Measurement Repeat Rate = 50ms */ LTR390_ALS_UVS_MEAS_RATE_100 = 0x02, /* Measurement Repeat Rate = 100ms (default) */ LTR390_ALS_UVS_MEAS_RATE_200 = 0x03, /* Measurement Repeat Rate = 200ms */ LTR390_ALS_UVS_MEAS_RATE_500 = 0x04, /* Measurement Repeat Rate = 500ms */ LTR390_ALS_UVS_MEAS_RATE_1000 = 0x05, /* Measurement Repeat Rate = 1000ms */ LTR390_ALS_UVS_MEAS_RATE_2000 = 0x06, /* Measurement Repeat Rate = 2000ms */ } LTR390_CFG_ALS_UVS_MEAS_RATE; typedef enum { LTR390_ALS_UVS_RESOLUTION_20BIT = 0x00, /* 20 bit, conversion time = 400ms */ LTR390_ALS_UVS_RESOLUTION_19BIT = 0x01, /* 19 bit, conversion time = 200ms */ LTR390_ALS_UVS_RESOLUTION_18BIT = 0x02, /* 18 bit, conversion time = 100ms (default) */ LTR390_ALS_UVS_RESOLUTION_17BIT = 0x03, /* 17 bit, conversion time = 50ms */ LTR390_ALS_UVS_RESOLUTION_16BIT = 0x04, /* 16 bit, conversion time = 25ms */ LTR390_ALS_UVS_RESOLUTION_13BIT = 0x05, /* 13 bit, conversion time = 12.5ms */ } LTR390_CFG_ALS_UVS_RESOLUTION; typedef enum { LTR390_ALS_UVS_GAIN_RANGE_1 = 0x00, LTR390_ALS_UVS_GAIN_RANGE_3 = 0x01, LTR390_ALS_UVS_GAIN_RANGE_6 = 0x02, LTR390_ALS_UVS_GAIN_RANGE_9 = 0x03, LTR390_ALS_UVS_GAIN_RANGE_18 = 0x04, } LTR390_CFG_ALS_UVS_GAIN_RANGE; typedef enum { LTR390_ALS_UVS_DATA_STATUS_OLD = 0x00, LTR390_ALS_UVS_DATA_STATUS_NEW = 0x01, } LTR390_CFG_ALS_UVS_DATA_STATUS; typedef enum { LTR390_ALS_UVS_INT_STATUS_INACTIVE = 0x00, LTR390_ALS_UVS_INT_STATUS_ACTIVE = 0x01, } LTR390_CFG_ALS_UVS_INT_STATUS; typedef enum { LTR390_ALS_UVS_POWER_ON_STATUS_FALSE = 0x00, LTR390_ALS_UVS_POWER_ON_STATUS_TRUE = 0x01, } LTR390_CFG_ALS_UVS_POWER_ON_STATUS; typedef enum { LTR390_LS_INT_DISABLE = 0x00, LTR390_LS_INT_ENABLE = 0x01, } LTR390_CFG_LS_INT_EN; typedef enum { LTR390_LS_INT_SEL_ALS_CHANNEL = 0x01, LTR390_LS_INT_SEL_UVS_CHANNEL = 0x03, } LTR390_CFG_LS_INT_SEL; i2c_dev_t ltr390_ctx = { .port = 3, .config.address_width = 8, .config.freq = 100000, .config.dev_addr = LTR390_I2C_ADDR, }; static uint8_t g_init_bitwise = 0; static int drv_uv_liteon_ltr390_validate_id(i2c_dev_t* drv, uint8_t part_id) { int ret = 0; uint8_t part_id_value = 0; if (drv == NULL) { return -1; } ret = sensor_i2c_read(drv, LTR390_PART_ID, &part_id_value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } if (part_id_value != part_id) { return -1; } return 0; } static int drv_uv_liteon_ltr390_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, LTR390_MAIN_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } switch (mode) { case DEV_POWER_OFF: case DEV_SLEEP: dev_mode = LTR390_SET_BITSLICE(value, MAIN_CTRL_REG_ALS_UVS_EN, LTR390_ALS_UVS_STANDBY); break; case DEV_POWER_ON: dev_mode = LTR390_SET_BITSLICE(value, MAIN_CTRL_REG_ALS_UVS_EN, LTR390_ALS_UVS_ACTIVE); break; default: return -1; } ret = sensor_i2c_write(drv, LTR390_MAIN_CTRL, &dev_mode, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } UNUSED static int drv_uv_liteon_ltr390_is_ready(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR390_MAIN_STATUS, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return 0; } ret = (LTR390_GET_BITSLICE(value, MAIN_STATUS_REG_ALS_UVS_DATA_STATUS) == LTR390_ALS_UVS_DATA_STATUS_NEW) ? 1 : 0; return ret; } static int drv_uv_liteon_ltr390_set_default_config(i2c_dev_t* drv) { int ret = 0; uint8_t value = 0; ret = sensor_i2c_read(drv, LTR390_MAIN_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = LTR390_SET_BITSLICE(value, MAIN_CTRL_REG_UVS_MODE, LTR390_UVS_MODE); ret = sensor_i2c_write(drv, LTR390_MAIN_CTRL, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR390_SET_BITSLICE(value, ALS_UVS_MEAS_RATE_REG_MEAS_RATE, LTR390_ALS_UVS_MEAS_RATE_100); value = LTR390_SET_BITSLICE(value, ALS_UVS_MEAS_RATE_REG_RESOLUTION, LTR390_ALS_UVS_RESOLUTION_16BIT); ret = sensor_i2c_write(drv, LTR390_ALS_UVS_MEAS_RATE, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR390_SET_BITSLICE(value, ALS_UVS_GAIN_REG_GAIN_RANGE, LTR390_ALS_UVS_GAIN_RANGE_18); ret = sensor_i2c_write(drv, LTR390_ALS_UVS_GAIN, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } value = 0; value = LTR390_SET_BITSLICE(value, INT_CFG_REG_LS_INT_EN, LTR390_LS_INT_DISABLE); value = LTR390_SET_BITSLICE(value, INT_CFG_REG_LS_INT_SEL, LTR390_LS_INT_SEL_ALS_CHANNEL); ret = sensor_i2c_write(drv, LTR390_INT_CFG, &value, I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return ret; } return 0; } static void drv_uv_liteon_ltr390_irq_handle(void) { /* no handle so far */ } static int drv_uv_liteon_ltr390_open(void) { int ret = 0; ret = drv_uv_liteon_ltr390_set_power_mode(&ltr390_ctx, DEV_POWER_ON); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_uv_liteon_ltr390_close(void) { int ret = 0; ret = drv_uv_liteon_ltr390_set_power_mode(&ltr390_ctx, DEV_POWER_OFF); if (unlikely(ret)) { return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } static int drv_uv_liteon_ltr390_read(void *buf, size_t len) { int ret = 0; size_t size; uint8_t reg_data[3] = { 0 }; uv_data_t * pdata = (uv_data_t *) buf; if (buf == NULL) { return -1; } size = sizeof(uv_data_t); if (len < size) { return -1; } ret = sensor_i2c_read(&ltr390_ctx, LTR390_UVS_DATA_0, &reg_data[0], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr390_ctx, LTR390_UVS_DATA_1, &reg_data[1], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } ret = sensor_i2c_read(&ltr390_ctx, LTR390_UVS_DATA_2, &reg_data[2], I2C_DATA_LEN, I2C_OP_RETRIES); if (unlikely(ret)) { return -1; } pdata->uvi = ((((uint16_t) (reg_data[1] & 0xFF)) << 8) | reg_data[0]); pdata->timestamp = aos_now_ms(); return (int) size; } static int drv_uv_liteon_ltr390_write(const void *buf, size_t len) { (void) buf; (void) len; return 0; } static int drv_uv_liteon_ltr390_ioctl(int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case SENSOR_IOCTL_SET_POWER: { ret = drv_uv_liteon_ltr390_set_power_mode(&ltr390_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->vendor = DEV_SENSOR_VENDOR_LITEON; info->model = "LTR390"; info->unit = lux; } break; default: return -1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } int drv_uv_liteon_ltr390_init(void) { int ret = 0; sensor_obj_t sensor_uv; memset(&sensor_uv, 0, sizeof(sensor_uv)); if (!g_init_bitwise) { ret = drv_uv_liteon_ltr390_validate_id(&ltr390_ctx, LTR390_PART_ID_VAL); if (unlikely(ret)) { return -1; } } if (!g_init_bitwise) { /* fill the sensor_uv obj parameters here */ sensor_uv.tag = TAG_DEV_UV; sensor_uv.path = dev_uv_path; sensor_uv.io_port = I2C_PORT; sensor_uv.mode = DEV_POLLING; sensor_uv.power = DEV_POWER_OFF; sensor_uv.open = drv_uv_liteon_ltr390_open; sensor_uv.close = drv_uv_liteon_ltr390_close; sensor_uv.read = drv_uv_liteon_ltr390_read; sensor_uv.write = drv_uv_liteon_ltr390_write; sensor_uv.ioctl = drv_uv_liteon_ltr390_ioctl; sensor_uv.irq_handle = drv_uv_liteon_ltr390_irq_handle; ret = sensor_create_obj(&sensor_uv); if (unlikely(ret)) { return -1; } ret = drv_uv_liteon_ltr390_set_default_config(&ltr390_ctx); if (unlikely(ret)) { return -1; } g_init_bitwise = 1; } LOG("%s %s successfully \n", SENSOR_STR, __func__); return 0; } SENSOR_DRV_ADD(drv_uv_liteon_ltr390_init);
YifuLiu/AliOS-Things
components/sensor/drv/drv_uv_liteon_ltr390.c
C
apache-2.0
14,316
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include "aos/kernel.h" #include "sensor/sensor.h" #include "ulog/ulog.h" #include "netmgr.h" #include <uservice/uservice.h> #include <uservice/eventid.h> #define SENSOR_SAMPLE_TIME 1000 /* sensor sampling period is 1000 ms*/ #define PROP_POST_FORMAT_TEMP "{\"CurrentTemperature\":%.1f}" #define PROP_POST_FORMAT_HUMI "{\"Humidity\":%.1f}" void sensor_cloud_test_init(void) { int ret = 0; i2c_dev_t i2c_dev; i2c_dev.port = 1; i2c_dev.config.address_width = I2C_HAL_ADDRESS_WIDTH_7BIT; i2c_dev.config.freq = I2C_BUS_BIT_RATES_100K; i2c_dev.config.mode = I2C_MODE_MASTER; sensor_i2c_init(&i2c_dev); /* Sensor Hal start */ ret = sensor_hal_init(); if (ret != 0) { return; } /* Open the Humidity sensor device */ ret = sensor_hal_open(TAG_DEV_HUMI, 0); if (ret != 0) { //return; } /* Open the temperature sensor device */ ret = sensor_hal_open(TAG_DEV_TEMP, 0); if (ret != 0) { //return; } /* Set the sampling period for sensors */ sensor_hal_ioctl(TAG_DEV_HUMI, 0, SENSOR_IOCTL_ODR_SET, SENSOR_SAMPLE_TIME); sensor_hal_ioctl(TAG_DEV_TEMP, 0, SENSOR_IOCTL_ODR_SET, SENSOR_SAMPLE_TIME); } void sensor_cloud_test_start(void *dm_handle) { int ret = 0; char param[128]; temperature_data_t temp; humidity_data_t humi; /* Read the Humidity sensor data */ ret = sensor_hal_read(TAG_DEV_HUMI, 0, &humi, sizeof(humi)); if (ret > 0) { /* Print the Humidity sensor data */ printf("Humidity value : %.1f H\n", ((float)humi.h)/10); memset(param, 0, 128); /* build the report payload */ sprintf(param, PROP_POST_FORMAT_HUMI, ((float)humi.h)/10); /* Report the Humidity data to cloud */ ret = demo_send_property_post(dm_handle, (char *)param); if (ret == -1) { LOG("%s %d fail\n", __func__,__LINE__); } } /* Read the temperature sensor data */ ret = sensor_hal_read(TAG_DEV_TEMP, 0, &temp, sizeof(temp)); if (ret > 0) { /* Print the temperature sensor data */ printf("Temperature value : %.1f centidegree\n", ((float)temp.t)/10); memset(param, 0, 128); /* build the report payload */ sprintf(param, PROP_POST_FORMAT_TEMP, ((float)(temp.t))/10); /* Report the temperature data to cloud */ ret = demo_send_property_post(dm_handle, (char *)param); if (ret == -1) { LOG("%s %d fail\n", __func__,__LINE__); } } }
YifuLiu/AliOS-Things
components/sensor/example/sensor_cloud_demo.c
C
apache-2.0
2,719
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include "aos/cli.h" #include "aos/kernel.h" #include "sensor/sensor.h" #include <vfsdev/i2c_dev.h> #define SENSOR_SAMPLE_TIME 1000 /* sensor sampling period is 1000 ms */ void sensor_local_test() { int ret; temperature_data_t temp; humidity_data_t humi; /* Sensor Hal start */ ret = sensor_hal_init(); if (ret != 0) { return; } // printf("\n enter %s : %d\n", __func__, __LINE__); /* Open the acceleration sensor device */ ret = sensor_hal_open(TAG_DEV_TEMP, 0); if (ret != 0) { return; } ret = sensor_hal_open(TAG_DEV_HUMI, 0); if (ret != 0) { return; } // printf("\n enter %s : %d\n", __func__, __LINE__); /* Set the sampling period for sensors */ //(void)sensor_hal_ioctl(TAG_DEV_TEMP, 0, SENSOR_IOCTL_ODR_SET, SENSOR_SAMPLE_TIME); while(1) { // printf("\n v1.4 enter %s : %d\n", __func__, __LINE__); /* Read the temperature sensor data */ ret = sensor_hal_read(TAG_DEV_TEMP, 0, &temp, sizeof(temp)); if(ret > 0){ printf("Temperature value : %.1f centidegree\r\n", ((float)temp.t)/10); } ret = sensor_hal_read(TAG_DEV_HUMI, 0, &humi, sizeof(humi)); if(ret > 0){ printf("Humidity value : %.1f H\r\n", ((float)humi.h)/10); } else { printf("read Humidity fail , ret = %d\r\n", ret); } // printf("\n enter %s : %d\n", __func__, __LINE__); /* Task sleep */ aos_msleep(1000); } } extern int32_t sensor_i2c_init(i2c_dev_t *i2c); void i2c_init(void) { i2c_dev_t i2c_dev; i2c_dev.port = 1; i2c_dev.config.address_width = I2C_HAL_ADDRESS_WIDTH_7BIT; i2c_dev.config.freq = I2C_BUS_BIT_RATES_100K; i2c_dev.config.mode = I2C_MODE_MASTER; //i2c_dev.config.dev_addr = SI7006_I2C_ADDRESS; // hal_i2c_init(&i2c_dev); sensor_i2c_init(&i2c_dev); } static void sensor_local_demo(int argc, char **argv) { (void)argc; (void)argv; i2c_init(); /* Sensor local test sample */ sensor_local_test(); return 0; } #if AOS_COMP_CLI /* reg args: fun, cmd, description*/ ALIOS_CLI_CMD_REGISTER(sensor_local_demo, sensor_local_test, sensor local base example) #endif
YifuLiu/AliOS-Things
components/sensor/example/sensor_local_demo.c
C
apache-2.0
2,430
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #include <stdio.h> #include <string.h> #include <assert.h> #include "aos/kernel.h" #include <at/at.h> #include "gps_parse.h" typedef enum{ GPNON = 0x0000, GPGGA = 0x0001, GPGSA = 0x0002, GPGSV = 0x0004, GPRMC = 0x0008, GPVTG = 0x0010 }en_gps_type; typedef struct _gps_gpgga { char name[GPS_TYPE_NAME_LEN]; gps_time_t utc; float lat; char ns; float lon; char ew; int sig; int satinuse; float HDOP; float elv; char elv_units; float diff; char diff_units; float dgps_age; int dgps_sid; } gps_gpgga_t; #define GPS_GPGGA_T_PARA_NUM (15) typedef struct gps_inernel_data_stu{ gps_gpgga_t data_gga; }gps_inernel_data_t; gps_inernel_data_t g_gpsvalue; int g_gpstypebitmap = GPGGA; static void gps_gpgga_para_set(test_gps_data_t gpgga_index[], gps_gpgga_t* gpgga_para) { gpgga_index[0].type = GPS_TYPE_STR; gpgga_index[0].addr = &(gpgga_para->name[0]); gpgga_index[1].type = GPS_TYPE_UTC; gpgga_index[1].addr = &(gpgga_para->utc); gpgga_index[2].type = GPS_TYPE_FLOAT; gpgga_index[2].addr = &(gpgga_para->lat); gpgga_index[3].type = GPS_TYPE_UINT8; gpgga_index[3].addr = &(gpgga_para->ns); gpgga_index[4].type = GPS_TYPE_FLOAT; gpgga_index[4].addr = &(gpgga_para->lon); gpgga_index[5].type = GPS_TYPE_UINT8; gpgga_index[5].addr = &(gpgga_para->ew); gpgga_index[6].type = GPS_TYPE_INT32; gpgga_index[6].addr = &(gpgga_para->sig); gpgga_index[7].type = GPS_TYPE_INT32; gpgga_index[7].addr = &(gpgga_para->satinuse); gpgga_index[8].type = GPS_TYPE_FLOAT; gpgga_index[8].addr = &(gpgga_para->HDOP); gpgga_index[9].type = GPS_TYPE_FLOAT; gpgga_index[9].addr = &(gpgga_para->elv); gpgga_index[10].type = GPS_TYPE_UINT8; gpgga_index[10].addr = &(gpgga_para->elv_units); gpgga_index[11].type = GPS_TYPE_FLOAT; gpgga_index[11].addr = &(gpgga_para->diff); gpgga_index[12].type = GPS_TYPE_UINT8; gpgga_index[12].addr = &(gpgga_para->diff_units); gpgga_index[13].type = GPS_TYPE_FLOAT; gpgga_index[13].addr = &(gpgga_para->dgps_age); gpgga_index[14].type = GPS_TYPE_INT32; gpgga_index[14].addr = &(gpgga_para->dgps_sid); } static int gps_gpgga_data_parse(char *str, int len, gps_gpgga_t *result) { int i = 0; char data[GPS_RCV_DATA_LEN]; char* prt0; char* prt1 = &data[0]; test_gps_data_t gga_idx[GPS_GPGGA_T_PARA_NUM]; if((NULL == str) || (0 == result)){ return -1; } memcpy(data,str,len); data[len] = '\0'; memset(result, 0, sizeof(gps_gpgga_t)); gps_gpgga_para_set(gga_idx,result); for( i = 0; (i < 13) &&(NULL!=prt0); i++){ //printf("strlen(prt1) == %d\n",strlen(prt1)); prt0 = gps_strtok(prt1,&prt1,',',strlen(prt1)); //printf("prt0 == %s\n",prt0); gps_data_conv(prt0,strlen(prt0),gga_idx[i].addr,gga_idx[i].type); //printf("index %d\n\n",i); } prt0 = gps_strtok(prt1,&prt1,',',strlen(prt1)); gps_data_conv(prt0,strlen(prt0),gga_idx[i].addr,gga_idx[i].type); i++; //printf("index %d\n\n\n",i); prt0 = gps_strtok(prt1,&prt1,'*',strlen(prt1)); gps_data_conv(prt0,strlen(prt0),gga_idx[i].addr,gga_idx[i].type); //printf("index %d\n\n\n",i); //printf("time %2d:%2d:%2d.%d\n",result->utc.hour,result->utc.min,result->utc.sec,result->utc.hsec); return 0; } static int gps_gpgga_data_get(gps_gpgga_t *result,gps_data_t* pgpsdata) { if((NULL == result) || (0 == pgpsdata)){ return -1; } pgpsdata->utc.year = result->utc.year; pgpsdata->utc.mon = result->utc.mon; pgpsdata->utc.day = result->utc.day; pgpsdata->utc.hour = result->utc.hour; pgpsdata->utc.min = result->utc.min; pgpsdata->utc.sec = result->utc.sec; pgpsdata->utc.hsec = result->utc.hsec; pgpsdata->lat = ('N' == result->ns)? result->lat : -(result->lat); pgpsdata->lat = pgpsdata->lat/100; pgpsdata->lon = ('E' == result->ew)? result->lon : -(result->lon); pgpsdata->lon = pgpsdata->lon/100; pgpsdata->elv = result->elv; return 0; } int gps_gp_type_get(const char *buf, int size) { static const char *pheads[] = { "GPGGA", "GPGSA", "GPGSV", "GPRMC", "GPVTG" }; if(0 == buf){ return -1; } if(size < 5) return GPNON; else if(0 == memcmp(buf, pheads[0], 5)) return GPGGA; else if(0 == memcmp(buf, pheads[1], 5)) return GPGSA; else if(0 == memcmp(buf, pheads[2], 5)) return GPGSV; else if(0 == memcmp(buf, pheads[3], 5)) return GPRMC; else if(0 == memcmp(buf, pheads[4], 5)) return GPVTG; return GPNON; } bool gps_gp_type_filter(const char *buf, int size) { int ret = gps_gp_type_get(buf,size); return (g_gpstypebitmap&ret) ? 1:0; } static int gps_gp_parse(char* str, int len, gps_data_t* pgpsdata) { int ret; int ptype; ptype = gps_gp_type_get(str+1,len-1); switch(ptype){ case GPGGA:{ ret = gps_gpgga_data_parse(str, len,&(g_gpsvalue.data_gga)); if(0 != ret){ return -1; } ret = gps_gpgga_data_get(&(g_gpsvalue.data_gga), pgpsdata); if(0 != ret){ return -1; } break; } default: break; } return 0; } static int gps_gp_check(char* str, int len) { int i; int crc_calc = 0; int crc = 0; char* str_tmp = str; if(str_tmp[0] != '$'){ return -1; } str_tmp++; for(i = 1; (i < len) && (*str_tmp != '*'); i++,str_tmp++){ crc_calc ^= (int)(*str_tmp); } crc = gps_atoi(&str_tmp[1],2,16); if(crc != crc_calc){ LOG("crc_origin == 0x%08x, crc_calc == 0x%08x\n",crc,crc_calc); return -1; } return 0; } int gps_gp_proc(const char* str, gps_data_t* pgpsdata) { int ret; int len; char gpsdata[GPS_CALC_BUF_LEN]; if(0 == str){ return -1; } if(0 == pgpsdata){ return -1; } len = strlen(str); if(len >= GPS_RCV_DATA_LEN){ return -1; } memcpy(&gpsdata[0], str, len); gpsdata[len] = '\0'; ret = gps_gp_check(&gpsdata[0],len); if(0 != ret){ return -1; } ret = gps_gp_parse(&gpsdata[0],len, pgpsdata); if(0 != ret){ return -1; } return 0; }
YifuLiu/AliOS-Things
components/sensor/hal/gps_parse.c
C
apache-2.0
6,642
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited */ #include "sensor_drv_api.h" #include <aos/errno.h> #include <vfsdev/i2c_dev.h> static int g_i2c_fd[4] = {-1, -1, -1, -1}; int32_t vfs_i2c_init(i2c_dev_t *i2c) { int32_t ret = 0; int32_t port = 0; int32_t *p_fd = NULL; char name[16] = {0}; io_i2c_control_u i2c_ctrl; if (!i2c) { printf ("i2c is null\r\n"); return -EINVAL; } port = i2c->port; // p_fd = (int32_t *)malloc(sizeof(int32_t)); // if (!p_fd) // return -ENOMEM; // *p_fd = -1; p_fd = &g_i2c_fd[port]; if (*p_fd >= 0) { printf ("i2c port[%d] isn't ready\r\n",port); return -EALREADY; } snprintf(name, sizeof(name), "/dev/i2c%d", port); *p_fd = open(name, 0); if (*p_fd < 0) { printf ("open %s failed, fd:%d\r\n", name, *p_fd); ret = -EIO; goto out; } // printf("p_fd is %d\r\n",*p_fd); // printf("g_i2c_fd[%d] is %d\r\n",port,g_i2c_fd[port]); i2c_ctrl.c.addr = i2c->config.dev_addr; /* sensor's address */ i2c_ctrl.c.addr_width = i2c->config.address_width; /* 7-bit address */ i2c_ctrl.c.role = 1; /* master mode */ ret = ioctl(*p_fd, IOC_I2C_SET_CONFIG, (unsigned long)&i2c_ctrl); if (ret) { printf ("set i2c config on %s failed\r\n", name); goto out; } i2c_ctrl.freq = i2c->config.freq; ret = ioctl(*p_fd, IOC_I2C_SET_FREQ, (unsigned long)&i2c_ctrl); if (ret) { printf ("set i2c config on %s failed\r\n", name); goto out; } out: if (!ret) { i2c->priv = p_fd; } else { if (*p_fd >= 0) close(*p_fd); // free(p_fd); // p_fd = NULL; } return ret; } static int32_t vfs_i2c_master_send(i2c_dev_t *i2c, uint16_t dev_addr, const uint8_t *data, uint16_t size, uint32_t timeout) { int32_t *p_fd = NULL; int32_t ret = -1; io_i2c_data_t i2c_data; if (!i2c) { return -EINVAL; } p_fd = &g_i2c_fd[i2c->port]; if (!p_fd || (*p_fd < 0)) { printf ("i2c port[%d] has not been initialized\r\n",i2c->port); return -EINVAL; } i2c_data.addr = dev_addr; i2c_data.data = data; i2c_data.length = size; i2c_data.maddr = 0; i2c_data.mlength = 0; i2c_data.timeout = timeout; ret = ioctl(*p_fd, IOC_I2C_MASTER_TX, (unsigned long)&i2c_data); return ret; } static int32_t vfs_i2c_master_recv(i2c_dev_t *i2c, uint16_t dev_addr, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t port = 0; int32_t *p_fd = NULL; int32_t ret = -1; io_i2c_data_t i2c_data; if (!i2c) { printf ("i2c is null\r\n"); return -EINVAL; } p_fd = &g_i2c_fd[i2c->port]; if (!p_fd || (*p_fd < 0)) { printf ("i2c port[%d] has not been initialized\r\n",i2c->port); return -EINVAL; } i2c_data.addr = dev_addr; i2c_data.data = data; i2c_data.length = size; i2c_data.maddr = 0; i2c_data.mlength = 0; i2c_data.timeout = timeout; ret = ioctl(*p_fd, IOC_I2C_MASTER_RX, (unsigned long)&i2c_data); return 0; } static int32_t vfs_i2c_mem_write(i2c_dev_t *i2c, uint16_t dev_addr, uint16_t mem_addr, uint16_t mem_addr_size, const uint8_t *data, uint16_t size, uint32_t timeout) { int32_t port = 0; int32_t *p_fd = NULL; int32_t ret = -1; io_i2c_data_t i2c_data; if (!i2c) return -EINVAL; p_fd = &g_i2c_fd[i2c->port]; if (!p_fd || (*p_fd < 0)) { printf ("i2c port[%d] has not been initialized\r\n",i2c->port); return -EINVAL; } i2c_data.addr = dev_addr; i2c_data.data = data; i2c_data.length = size; i2c_data.maddr = mem_addr; i2c_data.mlength = mem_addr_size; i2c_data.timeout = timeout; ret = ioctl(*p_fd, IOC_I2C_MEM_TX, (unsigned long)&i2c_data); return 0; } static int32_t vfs_i2c_mem_read(i2c_dev_t *i2c, uint16_t dev_addr, uint16_t mem_addr, uint16_t mem_addr_size, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t port = 0; int32_t *p_fd = NULL; int32_t ret = -1; io_i2c_data_t i2c_data; if (!i2c) return -EINVAL; p_fd = &g_i2c_fd[i2c->port]; if (!p_fd || (*p_fd < 0)) { printf ("i2c port[%d] has not been initialized\r\n",i2c->port); return -EINVAL; } i2c_data.addr = dev_addr; i2c_data.data = data; i2c_data.length = size; i2c_data.maddr = mem_addr; i2c_data.mlength = mem_addr_size; i2c_data.timeout = timeout; ret = ioctl(*p_fd, IOC_I2C_MEM_RX, (unsigned long)&i2c_data); return 0; } static int32_t vfs_i2c_finalize(i2c_dev_t *i2c) { int32_t ret = 0; int32_t port = 0; int32_t *p_fd = NULL; if (!i2c || !i2c->priv) return -EINVAL; // p_fd = (int32_t *)i2c->priv; // if (*p_fd < 0) // return -EIO; p_fd = &g_i2c_fd[i2c->port]; if (!p_fd || (*p_fd < 0)) { printf ("i2c port[%d] has not been initialized\r\n",i2c->port); return -EINVAL; } if (*p_fd >= 0) close(*p_fd); else ret = -EALREADY; i2c->priv = NULL; *p_fd = -1; free(p_fd); return ret; } int32_t sensor_i2c_init(i2c_dev_t *i2c) { int32_t ret = 0; if (i2c == NULL) { return -1; } ret = vfs_i2c_init(i2c); return ret; } 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; } #if SENSOR_CONFIG_I2C_ENABLE ret = hal_i2c_mem_read(i2c, i2c->config.dev_addr, reg, I2C_REG_LEN, data, size, timeout); #else ret = vfs_i2c_mem_read(i2c, i2c->config.dev_addr, reg, I2C_REG_LEN, data, size, timeout); #endif 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; } #if SENSOR_CONFIG_I2C_ENABLE ret = hal_i2c_mem_write(i2c, i2c->config.dev_addr, reg, I2C_REG_LEN, data, size, timeout); #else ret = vfs_i2c_mem_write(i2c, i2c->config.dev_addr, reg, I2C_REG_LEN, data, size, timeout); #endif return ret; } int32_t sensor_drv_i2c_master_send(i2c_dev_t *i2c, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t ret = 0; if (i2c == NULL) { return -1; } #if SENSOR_CONFIG_I2C_ENABLE ret = hal_i2c_master_send(i2c, i2c->config.dev_addr, data, size, timeout); #else ret = vfs_i2c_master_send(i2c, i2c->config.dev_addr, data, size, timeout); #endif return ret; } int32_t sensor_drv_i2c_master_recv(i2c_dev_t *i2c, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t ret = 0; if (i2c == NULL) { return -1; } #if SENSOR_CONFIG_I2C_ENABLE ret = hal_i2c_master_recv(i2c, i2c->config.dev_addr, data, size, timeout); #else ret = vfs_i2c_master_recv(i2c, i2c->config.dev_addr, data, size, timeout); #endif return ret; } int32_t sensor_spi_read(spi_dev_t *spi, uint8_t *tx, uint8_t *rx, uint16_t size, uint32_t timeout) { int32_t ret = 0; if (spi == NULL) { return -1; } #if SENSOR_CONFIG_SPI_ENABLE ret = hal_spi_send_recv(spi, tx, rx, size, timeout); #endif return ret; } int32_t sensor_spi_write(spi_dev_t *spi, uint8_t *data, uint16_t size, uint32_t timeout) { int32_t ret = 0; if (spi == NULL) { return -1; } #if SENSOR_CONFIG_SPI_ENABLE ret = hal_spi_send(spi, data, size, timeout); #endif return ret; } int32_t sensor_io_read(sensor_io_dev_t* dev, uint8_t* reg, uint8_t* data, uint16_t size,uint32_t timeout) { int ret = -1; if(NULL == dev){ return -1; } if(NULL == reg){ return -1; } if(NULL == data){ return -1; } switch(dev->io_port){ case I2C_PORT:{ uint16_t addr = *((uint16_t*)reg); ret = sensor_i2c_read(&(dev->dev_i2c), addr, data, size, timeout); break; } case SPI_PORT:{ ret = sensor_spi_read(&(dev->dev_spi), reg, data, size, timeout); break; } default: break; } return ret; } int32_t sensor_io_write(sensor_io_dev_t* dev, uint8_t* reg, uint8_t *data, uint16_t size, uint32_t timeout) { int ret = -1; if(NULL == dev){ return -1; } if(NULL == data){ return -1; } switch(dev->io_port){ case I2C_PORT:{ if(NULL == reg){ return -1; } uint16_t addr = *((uint16_t*)reg); ret = sensor_i2c_write(&(dev->dev_i2c), addr, data, size, timeout); break; } case SPI_PORT:{ ret = sensor_spi_write(&(dev->dev_spi), data, size, timeout); break; } default: break; } return ret; }
YifuLiu/AliOS-Things
components/sensor/hal/sensor_drv_api.c
C
apache-2.0
9,484
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "aos/kernel.h" #include "ulog/ulog.h" #include "aos/vfs.h" #include "sensor_hal.h" #define SENSOR_MS_TO_ODR(ms) ((1000/(ms)) + 1) extern void sensor_drv_init(void); 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); file_ops_t sensor_fops = { .open = sensor_open, .close = sensor_close, .read = sensor_read, .write = sensor_write, .ioctl = sensor_ioctl, }; static bool g_sensor_init_flag = false; static SENSOR_IRQ_CALLBACK g_sensor_irq_cb = NULL; static sensor_obj_t * g_sensor_obj[SENSOR_MAX_NUM]; static char g_sensor_path[SENSOR_MAX_NUM][SENSOR_NAME_LEN]; static uint32_t g_sensor_cnt = 0; extern int g_sensor_drv_num; extern SENSOR_INIT_FUN g_sensor_func[]; UNUSED static void sensor_set_power_mode(dev_power_mode_e power, int index) { g_sensor_obj[index]->power = power; } static int sensor_set_sensor_service(SENSOR_IRQ_CALLBACK func) { if (func == NULL) { return -1; } if (g_sensor_irq_cb != NULL) { return 0; } g_sensor_irq_cb = func; return 0; } static int sensor_get_sensor_mode_config(uint32_t index, dev_sensor_config_t *config) { if (index >= g_sensor_cnt) { return -1; } if (config == NULL) { return -1; } config->mode = g_sensor_obj[index]->mode; config->data_buf = g_sensor_obj[index]->data_buf; config->data_len = g_sensor_obj[index]->data_len; return 0; } void sensor_irq_handle(void *arg) { uint32_t index = (uint32_t)arg; if (index >= SENSOR_MAX_NUM) { return; } if ((g_sensor_obj[index]->mode != DEV_FIFO) && (g_sensor_obj[index]->mode != DEV_INT) && (g_sensor_obj[index]->mode != DEV_DATA_READY)) { return; } if (NULL != g_sensor_obj[index]->irq_handle) { g_sensor_obj[index]->irq_handle(); if (NULL != g_sensor_irq_cb) { g_sensor_irq_cb(g_sensor_obj[index]->tag, g_sensor_obj[index]->instance); } } return; } static int sensor_register_irq(int index ) { int ret = -1; if (0 == g_sensor_obj[index]->data_len) { return -1; } #if SENSOR_CONFIG_INT_ENABLE ret = hal_gpio_enable_irq(&(g_sensor_obj[index]->gpio), *(gpio_irq_trigger_t*)(g_sensor_obj[index]->gpio.priv), sensor_irq_handle, (void *)index); if (unlikely(ret)) { return -1; } #endif return ret; } static int find_selected_sensor(char *path, sensor_tag_e* ptag, uint8_t* pinstance) { uint32_t i = 0; if (path == NULL) { return -1; } if (ptag == NULL) { return -1; } if (pinstance == NULL) { return -1; } for (i = 0; i < g_sensor_cnt; i++) { if(strlen(path) != strlen(g_sensor_path[i])){ continue; } if (strncmp(g_sensor_path[i], path, strlen(path)) == 0) { break; } } if (i >= g_sensor_cnt){ return -1; } *ptag = g_sensor_obj[i]->tag; *pinstance = g_sensor_obj[i]->instance; return 0; } UNUSED static int load_sensor_config(int index) { g_sensor_obj[index] = (sensor_obj_t *)aos_malloc(sizeof(sensor_obj_t)); if (g_sensor_obj[index] == NULL) { /* plan to add the other bus register here like spi */ 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) || (g_sensor_obj[index]->mode == DEV_FIFO)) { ret = sensor_register_irq(index); if (unlikely(ret)) { return -1; } } ret = aos_register_driver(g_sensor_path[index], &sensor_fops, NULL); if (unlikely(ret)) { return -1; } return 0; } int sensor_create_obj(sensor_obj_t* sensor) { int ret = 0; int index; sensor_tag_e tag; uint8_t instance; index = g_sensor_cnt; if(index >= SENSOR_MAX_NUM){ return -1; } g_sensor_obj[index] = (sensor_obj_t *)aos_malloc(sizeof(sensor_obj_t)); if (g_sensor_obj[index] == NULL) { return -1; } memset(g_sensor_obj[index], 0, sizeof(sensor_obj_t)); memset(g_sensor_path[index], 0, SENSOR_NAME_LEN); /* install the phy sensor info into the sensor object datebase here */ ret = snprintf(g_sensor_path[index], SENSOR_NAME_LEN, "%s/%d", sensor->path, sensor->instance); if(ret < 0){ goto error; } ret = find_selected_sensor(g_sensor_path[index], &tag, &instance); if(ret == 0){ goto error; } g_sensor_obj[index]->io_port = sensor->io_port; g_sensor_obj[index]->tag = sensor->tag; g_sensor_obj[index]->instance = sensor->instance; g_sensor_obj[index]->open = sensor->open; g_sensor_obj[index]->close = sensor->close; g_sensor_obj[index]->ioctl = sensor->ioctl; g_sensor_obj[index]->read = sensor->read; g_sensor_obj[index]->write = sensor->write; g_sensor_obj[index]->irq_handle = sensor->irq_handle; g_sensor_obj[index]->mode = sensor->mode; g_sensor_obj[index]->data_buf = 0; g_sensor_obj[index]->data_len = sensor->data_len; g_sensor_obj[index]->power = DEV_POWER_OFF; // will update the status later g_sensor_obj[index]->ref = 0; // count the ref of this sensor g_sensor_obj[index]->drv_index = sensor->drv_index; if ((sensor->mode == DEV_INT) || (sensor->mode == DEV_DATA_READY) || (sensor->mode == DEV_FIFO)) { g_sensor_obj[index]->gpio.port = sensor->gpio.port; g_sensor_obj[index]->gpio.config = sensor->gpio.config; g_sensor_obj[index]->gpio.priv = sensor->gpio.priv; } /* register the sensor object into the irq list and vfs */ ret = sensor_obj_register(index); if (unlikely(ret)) { goto error; } g_sensor_cnt++; return 0; error: if(g_sensor_obj[index] != NULL){ aos_free(g_sensor_obj[index]); } return -1; } static int sensor_hal_get_dev_list(void* buf) { int index; sensor_list_t *sensor_list = buf; if (buf == NULL) return -1; /* load the sensor count and tag list here */ if (sensor_list->cnt != 0) { return -1; } for(index = 0; (index < g_sensor_cnt) && (index < SENSOR_MAX_NUM); index++){ sensor_list->list[index].tag = g_sensor_obj[index]->tag; sensor_list->list[index].instance = g_sensor_obj[index]->instance; sensor_list->list[index].io_port = g_sensor_obj[index]->io_port; } sensor_list->cnt = g_sensor_cnt; return 0; } static int sensor_obj_get(sensor_tag_e tag, uint8_t instance,uint32_t* pindex) { uint32_t i; if (tag >= TAG_DEV_SENSOR_NUM_MAX){ return -1; } if (pindex == NULL){ return -1; } for (i = 0; i < g_sensor_cnt; i++) { if ((g_sensor_obj[i]->tag == tag) && (g_sensor_obj[i]->instance == instance)){ break; } } if (i >= g_sensor_cnt){ return -1; } *pindex = i; return 0; } int sensor_hal_open(sensor_tag_e tag, uint8_t instance) { int ret; uint32_t index; if (tag >= TAG_DEV_SENSOR_NUM_MAX){ return -1; } ret = sensor_obj_get(tag, instance, &index); if (unlikely(ret)){ return -1; } if( g_sensor_obj[index]->open == NULL){ return -1; } if(g_sensor_obj[index]->ref == 0){ ret = g_sensor_obj[index]->open(); if (unlikely(ret)){ return -1; } } g_sensor_obj[index]->ref++; LOGD(SENSOR_STR, "%s successfully \n", __func__); return 0; } int sensor_hal_close(sensor_tag_e tag, uint8_t instance) { int ret; uint32_t index; if (tag >= TAG_DEV_SENSOR_NUM_MAX){ return -1; } ret = sensor_obj_get(tag, instance, &index); if (unlikely(ret)){ return -1; } if( g_sensor_obj[index]->close == NULL){ return -1; } //if the ref counter is less than 2, then close the sensor if(g_sensor_obj[index]->ref < 2){ ret = g_sensor_obj[index]->close(); if (unlikely(ret)){ return -1; } } if(g_sensor_obj[index]->ref > 0){ g_sensor_obj[index]->ref--; } return 0; } ssize_t sensor_hal_read(sensor_tag_e tag, uint8_t instance, void *buf, size_t len) { int ret; uint32_t index; if (tag >= TAG_DEV_SENSOR_NUM_MAX){ goto error; } ret = sensor_obj_get(tag, instance, &index); if (unlikely(ret)){ goto error; } #if SENSOR_CONFIG_MODBUS_ENABLE if(g_sensor_obj[index]->io_port == MODBUS_PORT){ int* index_data = (int *)buf; *index_data = g_sensor_obj[index]->drv_index; if(*index_data < 0) { goto error; } } #endif if ((g_sensor_obj[index]->read == NULL)) { 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; } ssize_t sensor_hal_write(sensor_tag_e tag, uint8_t instance, const void *buf, size_t len) { /* no need this functionality recently */ return 0; } int sensor_hal_ioctl(sensor_tag_e tag, uint8_t instance, sensor_cmd_type cmd, unsigned long arg) { int ret = 0; uint32_t index = 0; unsigned long value = arg; dev_sensor_config_t *config; if (tag >= TAG_DEV_SENSOR_NUM_MAX){ return -1; } ret = sensor_obj_get(tag, instance, &index); if (unlikely(ret)){ return -1; } switch (cmd){ case SENSOR_IOCTL_GET_SENSOR_LIST: return -1; case SENSOR_IOCTL_SET_SENSOR_IRQ_CB: { config = (dev_sensor_config_t *)value; if (NULL == config) { return -1; } ret = sensor_set_sensor_service(config->irq_callback); if (unlikely(ret)) { return -1; } return 0; } case SENSOR_IOCTL_GET_SENSOR_MODE: { config = (dev_sensor_config_t *)value; if (NULL == config) { return -1; } ret = sensor_get_sensor_mode_config(index, config); if (unlikely(ret)) { return -1; } return 0; } case SENSOR_IOCTL_ODR_SET: { if (0 == value) { return -1; } value = SENSOR_MS_TO_ODR(value); break; } default : break; } if (g_sensor_obj[index]->ioctl) { g_sensor_obj[index]->ioctl(cmd, value); } LOGD(SENSOR_STR, "%s successfully \n", __func__); return 0; } int sensor_hal_init(void) { int ret = 0; int i; if(g_sensor_init_flag != false){ return 0; } g_sensor_cnt = 0; sensor_drv_init(); #if SENSOR_CONFIG_MODBUS_ENABLE modbus_init(); #endif g_sensor_init_flag = true; return 0; } static int sensor_open(inode_t *node, file_t *file) { int ret; sensor_tag_e tag; uint8_t instance; if ((node == NULL) || (file == NULL)) { return -1; } /* just open the /dev/sensor node here */ if ((strlen(node->i_name) == strlen(sensor_node_path)) && (strncmp(sensor_node_path, node->i_name, strlen(node->i_name)) == 0)){ return 0; } ret = find_selected_sensor(node->i_name, &tag, &instance); if (unlikely(ret)){ return -1; } return sensor_hal_open(tag, instance); } static int sensor_close(file_t *file) { int ret; sensor_tag_e tag; uint8_t instance; if (file == NULL) { return -1; } if (file->node == NULL) { return -1; } /* just close the /dev/sensor node here */ if ((strlen(file->node->i_name) == strlen(sensor_node_path)) && (strncmp(sensor_node_path, (file->node->i_name), strlen(file->node->i_name)) == 0)){ return 0; } ret = find_selected_sensor(file->node->i_name, &tag, &instance); if (unlikely(ret)){ return -1; } return sensor_hal_close(tag, instance); } static ssize_t sensor_read(file_t *f, void *buf, size_t len) { int ret; sensor_tag_e tag; uint8_t instance; if (f == NULL) { return 0; } if (f->node == NULL) { return 0; } if (buf == NULL) { return 0; } ret = find_selected_sensor(f->node->i_name, &tag, &instance); if (unlikely(ret)){ return 0; } return sensor_hal_read(tag, instance,buf, len); } static ssize_t sensor_write(file_t *f, const void *buf, size_t len) { int ret; sensor_tag_e tag; uint8_t instance; if (f == NULL) { return 0; } if (f->node == NULL) { return 0; } if (buf == NULL) { return 0; } ret = find_selected_sensor(f->node->i_name, &tag, &instance); if (unlikely(ret)){ return 0; } /* no need this functionality recently */ return sensor_hal_write(tag, instance,buf, len); } static int sensor_ioctl(file_t *f, int cmd, unsigned long arg) { int ret = 0; sensor_tag_e tag; uint8_t instance; if (f == NULL) { LOGD(SENSOR_STR, "%s fail line: %d\n", __func__, __LINE__); return -1; } if (cmd >= SENSOR_IOCTL_MAX) { return -1; } if (cmd == SENSOR_IOCTL_GET_SENSOR_LIST) { ret = sensor_hal_get_dev_list((void *)arg); if (unlikely(ret)) { LOGD(SENSOR_STR, "%s fail line: %d\n", __func__, __LINE__); return -1; } return 0; } if (f->node == NULL) { LOGD(SENSOR_STR, "%s fail line: %d\n", __func__, __LINE__); return -1; } ret = find_selected_sensor(f->node->i_name, &tag, &instance); if (unlikely(ret)){ return -1; } ret = sensor_hal_ioctl(tag,instance,(sensor_cmd_type)cmd,arg); if (unlikely(ret)){ 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 (unlikely(ret)) { return -1; } return 0; } int sensor_init(void) { int ret = 0; ret = sensor_hal_init(); if(unlikely(ret)){ return -1; } ret = sensor_hal_register(); if(unlikely(ret)){ return -1; } LOGD(SENSOR_STR, "%s successfully \n", __func__); return 0; }
YifuLiu/AliOS-Things
components/sensor/hal/sensor_hal.c
C
apache-2.0
15,221
#include "sensor_static_calibrate.h" #define DST_X 0 #define DST_Y 1 #define DST_Z 2 #define SRC_X 0 #define SRC_Y 0 #define SRC_Z 0 #define MAX_SRNSOR_NUM 10 typedef struct _dev_3axis_data_t { uint64_t timestamp; int32_t data[3]; }dev_3axis_data_t; typedef struct _dev_1axis_data_t { uint64_t timestamp; int32_t data; }dev_1axis_data_t; typedef struct _sensor_1axis_para_t { int offset; }sensor_1axis_para_t; typedef struct _sensor_3axis_para_t { int remap_x_coeff; int remap_y_coeff; int remap_z_coeff; int offset; }sensor_3axis_para_t; typedef struct _sensor_static_obj_t { int in_use; sensor_tag_e tag; int sensor_index; int axis; void* para; }sensor_static_obj_t; sensor_static_obj_t g_sensor_static_para[MAX_SRNSOR_NUM] = {0}; sensor_3axis_para_t default_3axis_para[] ={ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, }; sensor_1axis_para_t default_1axis_para ={0}; int findindex(sensor_tag_e tag ,int index) { } void sensor_static_calibrate_3axis_default(void *buf) { dev_3axis_data_t* pdata=(dev_3axis_data_t*)buf; dev_3axis_data_t datatmp; memcpy(&datatmp,pdata,sizeof(dev_3axis_data_t)); pdata->data[DST_X] = datatmp.data[SRC_X]* default_3axis_para[DST_X].remap_x_coeff ; pdata->data[DST_X] += datatmp.data[SRC_Y]* default_3axis_para[DST_X].remap_y_coeff; pdata->data[DST_X] += datatmp.data[SRC_Z]* default_3axis_para[DST_X].remap_z_coeff; pdata->data[DST_X] += default_3axis_para[DST_X].offset; pdata->data[DST_Y] = datatmp.data[SRC_X]* default_3axis_para[DST_Y].remap_x_coeff; pdata->data[DST_Y] += datatmp.data[SRC_Y]* default_3axis_para[DST_Y].remap_y_coeff; pdata->data[DST_Y] += datatmp.data[SRC_Z]* default_3axis_para[DST_Y].remap_z_coeff; pdata->data[DST_Y] += default_3axis_para[DST_Y].offset; pdata->data[DST_Z] = datatmp.data[SRC_X]* default_3axis_para[DST_Z].remap_x_coeff ; pdata->data[DST_Z] += datatmp.data[SRC_Y]* default_3axis_para[DST_Z].remap_y_coeff; pdata->data[DST_Z] += datatmp.data[SRC_Z]* default_3axis_para[DST_Z].remap_z_coeff; pdata->data[DST_Z] += default_3axis_para[DST_Z].offset; } void sensor_static_calibrate_3axis(void *buf,void* para) { dev_3axis_data_t* pdata=(dev_3axis_data_t*)buf; dev_3axis_data_t datatmp; sensor_3axis_para_t* ppara=(sensor_3axis_para_t*)para; memcpy(&datatmp,pdata,sizeof(dev_3axis_data_t)); pdata->data[DST_X] = datatmp.data[SRC_X]* ppara->remap_x_coeff ; pdata->data[DST_X] += datatmp.data[SRC_Y]* ppara->remap_y_coeff; pdata->data[DST_X] += datatmp.data[SRC_Z]* ppara->remap_z_coeff; pdata->data[DST_X] += ppara->offset; ppara++; pdata->data[DST_Y] = datatmp.data[SRC_X]* ppara->remap_x_coeff; pdata->data[DST_Y] += datatmp.data[SRC_Y]* ppara->remap_y_coeff; pdata->data[DST_Y] += datatmp.data[SRC_Z]* ppara->remap_z_coeff; pdata->data[DST_Y] += ppara->offset; ppara++; pdata->data[DST_Z] = datatmp.data[SRC_X]* ppara->remap_x_coeff ; pdata->data[DST_Z] += datatmp.data[SRC_Y]* ppara->remap_y_coeff; pdata->data[DST_Z] += datatmp.data[SRC_Z]* ppara->remap_z_coeff; pdata->data[DST_Z] += ppara->offset; } void sensor_static_calibrate_1axis_default(void *buf) { dev_1axis_data_t* pdata=(dev_1axis_data_t*)buf; pdata->data += default_1axis_para.offset; } void sensor_static_calibrate_1axis(void *buf,void* para) { dev_1axis_data_t* pdata=(dev_1axis_data_t*)buf; sensor_1axis_para_t* ppara=(sensor_1axis_para_t*)para; pdata->data += ppara->offset; } ssize_t sensor_static_calibrate_acc_default(int sensor_index, int axis,void* buf) { if(axis == 3) { sensor_static_calibrate_3axis_default(buf); } else if(axis == 1) { sensor_static_calibrate_1axis_default(buf); } else { return -1; } return 0; } ssize_t sensor_static_calibrate_acc(int axis, void *buf,void* para) { if(axis == 3) { sensor_static_calibrate_3axis(buf,para); } else if(axis == 1) { sensor_static_calibrate_1axis(buf,para); } else { return -1; } return 0; } /* int sensor_static_calibrate(int axis, void *buf,void *para) { int ret =-1; if(buf == NULL||para == NULL) return -1; if(tag == TAG_DEV_ACC) { ret = sensor_static_calibrate_acc(axis,buf,para); } else { } return ret; } */ int find_empty_obj() { for(int i = 0;i < MAX_SRNSOR_NUM; i++) { if(g_sensor_static_para[i].in_use==0) return i; } return -1; } int sensor_obj_init_para(sensor_tag_e tag,int sensor_index,int axis,void* para) { int index = find_empty_obj(); if(index < 0) return -1; g_sensor_static_para[index].sensor_index = sensor_index; g_sensor_static_para[index].tag = tag; g_sensor_static_para[index].para = para; g_sensor_static_para[index].axis = axis; g_sensor_static_para[index].in_use = 1; return 0; } int find_sensor_index(sensor_tag_e tag,int sensor_index,int axis) { for(int i = 0;i < MAX_SRNSOR_NUM; i++) { if(g_sensor_static_para[i].tag==tag &&g_sensor_static_para[i].sensor_index==sensor_index &&g_sensor_static_para[i].axis == axis &&g_sensor_static_para[i].in_use == 1 &&g_sensor_static_para[i].para != NULL) return i; } return -1; } int sensor_calibrate_entry(sensor_tag_e tag,int sensor_index,int axis, void *buf) { int ret = 0; if(buf == NULL) return -1; int index = find_sensor_index(tag,sensor_index,axis); if(index < 0) return -1; if(tag == TAG_DEV_ACC) { ret = sensor_static_calibrate_acc(axis,buf,g_sensor_static_para[index].para); } else { return -1; } return ret; } int sensor_calibrate_entry_default(sensor_tag_e tag,int sensor_index,int axis, void *buf) { int ret = 0; if(buf == NULL) return -1; if(tag == TAG_DEV_ACC) { ret = sensor_static_calibrate_acc_default(sensor_index,axis,buf); } else { return -1; } return ret; }
YifuLiu/AliOS-Things
components/sensor/hal/sensor_static_calibrate.c
C
apache-2.0
6,169
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited * * */ #ifndef GPS_PARSE_H #define GPS_PARSE_H #include <stdio.h> #include <stdarg.h> #include <stdlib.h> #include <stdio.h> #include <ctype.h> #include <string.h> #include <limits.h> #include "ulog/ulog.h" #include "aos/kernel.h" #include "sensor/sensor.h" #define GPS_RCV_DATA_LEN (256) #define GPS_CONV_DATA_LEN (64) #define GPS_CALC_BUF_LEN (256) #define GPS_CALC_STR_LEN (GPS_CALC_BUF_LEN-1) #define GPS_TYPE_NAME_LEN (16) #define GPS_UTC_YEAR_LEN (4) #define GPS_UTC_MON_LEN (2) #define GPS_UTC_DAY_LEN (2) #define GPS_UTC_HOUR_LEN (2) #define GPS_UTC_MIN_LEN (2) #define GPS_UTC_SEC_LEN (2) #define GPS_UTC_HSEC_LEN (3) #define GPS_UTC_POINT_LEN (1) typedef enum{ GPS_TYPE_UINT8 = 0, GPS_TYPE_INT32, GPS_TYPE_FLOAT, GPS_TYPE_STR, GPS_TYPE_UTC }gps_data_type; typedef struct test_gps_data_t{ int type; void* addr; }test_gps_data_t; static inline int gps_atoi(const char *str, int size, int radix) { int ret = 0; char *str_tmp = NULL; char buff[GPS_CONV_DATA_LEN]; if(size < GPS_CONV_DATA_LEN){ memcpy(&buff[0], str, size); buff[size] = '\0'; ret = strtol(&buff[0], &str_tmp, radix); } return ret; } static inline float gps_atof(const char *str, int len) { double ret = 0; char *str_tmp = NULL; char buff[GPS_CONV_DATA_LEN]; if(len < GPS_CONV_DATA_LEN){ memcpy(&buff[0], str, len); buff[len] = '\0'; ret = strtod(&buff[0], &str_tmp); } return (float)ret; } static inline char* gps_strtok(char* src, char** ret, char c,int len) { int i; char* str_tmp = src; for(i = 0; i < len; i++,str_tmp++){ if(c == *str_tmp){ str_tmp[0] = '\0'; *ret = str_tmp+1; return src; } } *ret = str_tmp; return src; } static inline int gps_utc_get(char *str, int len, gps_time_t* res) { char* str_tmp = NULL; switch(len){ case (sizeof("YYYYMMDDhhmmss.sss") - 1): str_tmp = str; res->year = gps_atoi(str_tmp,GPS_UTC_YEAR_LEN,10); str_tmp += GPS_UTC_YEAR_LEN; res->mon = gps_atoi(str_tmp,GPS_UTC_MON_LEN,10); str_tmp += GPS_UTC_MON_LEN; res->day = gps_atoi(str_tmp,GPS_UTC_DAY_LEN,10); str_tmp += GPS_UTC_DAY_LEN; res->hour = gps_atoi(str_tmp,GPS_UTC_HOUR_LEN,10); str_tmp += GPS_UTC_HOUR_LEN; res->min = gps_atoi(str_tmp,GPS_UTC_MIN_LEN,10); str_tmp += GPS_UTC_MIN_LEN; res->sec = gps_atoi(str_tmp,GPS_UTC_SEC_LEN,10); str_tmp += (GPS_UTC_SEC_LEN + GPS_UTC_POINT_LEN); res->hsec = gps_atoi(str_tmp,3,10); break; case (sizeof("hhmmss.sss") - 1): str_tmp = str; res->hour = gps_atoi(str_tmp,GPS_UTC_HOUR_LEN,10); str_tmp += GPS_UTC_HOUR_LEN; res->min = gps_atoi(str_tmp,GPS_UTC_MIN_LEN,10); str_tmp += GPS_UTC_MIN_LEN; res->sec = gps_atoi(str_tmp,GPS_UTC_SEC_LEN,10); str_tmp += (GPS_UTC_SEC_LEN + GPS_UTC_POINT_LEN); res->hsec = gps_atoi(str_tmp,3,10); break; default: LOG("Parse of UTC fail (format error)!"); return -1; } return 0; } static inline void gps_data_conv(void* str, int len,void* addr,int type) { switch(type){ case GPS_TYPE_FLOAT: *(float*)(addr) = (float)gps_atof(str,len); break; case GPS_TYPE_INT32: *(int*)(addr) = (int)gps_atoi(str,len,10); break; case GPS_TYPE_UINT8: *(char*)(addr) = *(char*)str; break; case GPS_TYPE_STR: memcpy(addr, str, len); ((char *)addr)[len] = '\0'; break; case GPS_TYPE_UTC: gps_utc_get(str,len,addr); break; default: break; } } #endif /* GPS_PARSE_H */
YifuLiu/AliOS-Things
components/sensor/include/gps_parse.h
C
apache-2.0
4,113
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited */ #ifndef SENSOR_H #define SENSOR_H #ifdef __cplusplus extern "C" { #endif #include <stddef.h> #include <stdint.h> #include <unistd.h> #include <sys/types.h> #include "aos/hal/gpio.h" #include "aos/hal/i2c.h" #ifndef UNUSED #if defined (__CC_ARM) #define UNUSED __attribute__((unused)) #elif defined (__ICCARM__) #define UNUSED __attribute__((unused)) #elif defined (__GNUC__) #define UNUSED __attribute__((unused)) #else #define UNUSED #endif #endif #define SENSOR_MAX_NUM 16 #define SENSOR_NAME_LEN 32 #define I2C_REG_LEN 1 #define I2C_DATA_LEN 1 #define I2C_OP_RETRIES AOS_WAIT_FOREVER /* ioctl cmd list for sensor */ typedef enum { SENSOR_IOCTL_ODR_SET = 1, SENSOR_IOCTL_RANGE_SET, SENSOR_IOCTL_GET_INFO, SENSOR_IOCTL_BIST_PROCESS, SENSOR_IOCTL_WHO_AM_I, SENSOR_IOCTL_SET_POWER, SENSOR_IOCTL_GET_SENSOR_LIST, SENSOR_IOCTL_DTC_CYCLE_SET, SENSOR_IOCTL_GET_SENSOR_MODE, SENSOR_IOCTL_SET_SENSOR_IRQ_CB, SENSOR_IOCTL_SELF_TEST, SENSOR_IOCTL_MAX } sensor_cmd_type; #ifndef likely #if defined (__CC_ARM) #define likely(x) __builtin_expect(!!(x), 1) #elif defined (__ICCARM__) #define likely(x) (x) #elif defined (__GNUC__) #define likely(x) __builtin_expect(!!(x), 1) #else #define likely(x) (x) #endif #endif #ifndef unlikely #if defined (__CC_ARM) #define unlikely(x) __builtin_expect(!!(x), 0) #elif defined (__ICCARM__) #define unlikely(x) (x) #elif defined (__GNUC__) #define unlikely(x) __builtin_expect(!!(x), 0) #else #define unlikely(x) (x) #endif #endif /* Physical generic sensor data defs generic structs here */ #define DATA_AXIS_X 0 #define DATA_AXIS_Y 1 #define DATA_AXIS_Z 2 #define ToString(x) #x #define dev_acc_path "/dev/acc" #define dev_mag_path "/dev/mag" #define dev_gyro_path "/dev/gyro" #define dev_als_path "/dev/als" #define dev_ps_path "/dev/ps" #define dev_baro_path "/dev/baro" #define dev_temp_path "/dev/temp" #define dev_uv_path "/dev/uv" #define dev_humi_path "/dev/humi" #define dev_hall_path "/dev/hall" #define dev_hr_path "/dev/hr" #define dev_gps_path "/dev/gps" #define dev_noise_path "/dev/noise" #define dev_pm25_path "/dev/pm25" #define dev_co2_path "/dev/co2" #define dev_hcho_path "/dev/hcho" #define dev_tvoc_path "/dev/tvoc" #define dev_pm10_path "/dev/pm10" #define dev_pm1_path "/dev/pm1" #define dev_ph_path "/dev/ph" #define dev_vwc_path "/dev/vwc" #define dev_ec_path "/dev/ec" /* electric conductivity */ #define dev_salinity_path "/dev/salinity" #define dev_tds_path "/dev/tds" /* total dissolved solids */ #define dev_windspeed_path "/dev/windspeed" #define dev_winddirection_path "/dev/winddirection" #define dev_rainfall_path "/dev/rainfall" #define dev_rgb_path "/dev/rgb" #define dev_gs_path "/dev/gs" #define dev_ir_path "/dev/ir" #define dev_rtc_path "/dev/rtc" #define sensor_node_path "/dev/sensor" #define GPS_STR "gps: " #define RTC_STR "rtc: " #define SENSOR_STR "sensor: " /* sensor debug header */ #define ERROR_LINE "error on line is " #define ACCELEROMETER_UNIT_FACTOR 1000 /* mg */ #define MAGNETOMETER_UNIT_FACTOR 1000 /* mGauss */ #define GYROSCOPE_UNIT_FACTOR 1000000 /* uDPS */ #define DEV_ACC_PATH(x) dev_acc_path "/" ToString(x) #define DEV_HUMI_PATH(x) dev_humi_path "/" ToString(x) #define DEV_TEMP_PATH(x) dev_temp_path "/" ToString(x) #define DEV_NOISE_PATH(x) dev_noise_path "/" ToString(x) #define DEV_BARO_PATH(x) dev_baro_path "/" ToString(x) #define DEV_HCHO_PATH(x) dev_hcho_path "/" ToString(x) #define DEV_PM25_PATH(x) dev_pm25_path "/" ToString(x) #define DEV_PM10_PATH(x) dev_pm10_path "/" ToString(x) #define DEV_PM1_PATH(x) dev_pm1_path "/" ToString(x) #define DEV_CO2_PATH(x) dev_co2_path "/" ToString(x) #define DEV_TVOC_PATH(x) dev_tvoc_path "/" ToString(x) /* add the new sensor type into the last position */ typedef enum { TAG_DEV_ACC = 0, /* Accelerometer */ TAG_DEV_MAG, /* Magnetometer */ TAG_DEV_GYRO, /* Gyroscope */ TAG_DEV_ALS, /* Ambient light sensor */ TAG_DEV_PS, /* Proximity */ TAG_DEV_BARO, /* Barometer */ TAG_DEV_TEMP, /* Temperature */ TAG_DEV_UV, /* Ultraviolet */ TAG_DEV_HUMI, /* Humidity */ TAG_DEV_NOISE, /* NoiseLoudness */ TAG_DEV_PM25, /* PM2.5 */ TAG_DEV_PM1P0, /* PM1.0 */ TAG_DEV_PM10, /* PM10 */ TAG_DEV_CO2, /* CO2 Level */ TAG_DEV_HCHO, /* HCHO Level */ TAG_DEV_TVOC, /* TVOC Level */ TAG_DEV_PH, /* PH value */ TAG_DEV_VWC, /*volumetric water content*/ TAG_DEV_EC, /* EC value */ TAG_DEV_SALINITY, /* SALINITY value */ TAG_DEV_TDS, /* Total dissolved solids */ TAG_DEV_WINDSPD, /* Total dissolved solids */ TAG_DEV_WINDDIR, /* Total dissolved solids */ TAG_DEV_RAIN, /* Total dissolved solids */ TAG_DEV_HALL, /* HALL */ TAG_DEV_HR, /* Heart Rate */ TAG_DEV_RGB, /* RGB sensor */ TAG_DEV_GS, /* Gesture sensor */ TAG_DEV_IR, /* IR sensor */ TAG_DEV_GPS, TAG_DEV_RTC, TAG_DEV_SENSOR_NUM_MAX, } sensor_tag_e; typedef enum { DEV_SENSOR_VENDOR_STM = 0, DEV_SENSOR_VENDOR_SEMTECH, DEV_SENSOR_VENDOR_AKM, DEV_SENSOR_VENDOR_CAPELLA, DEV_SENSOR_VENDOR_INVENSENSE, DEV_SENSOR_VENDOR_ROHM, DEV_SENSOR_VENDOR_BOSCH, DEV_SENSOR_VENDOR_KIONIX, DEV_SENSOR_VENDOR_LITEON, DEV_SENSOR_VENDOR_AMS, DEV_SENSOR_VENDOR_CNT_MAXIM, } vendor_id_e; typedef enum { I2C_PORT, SPI_PORT, I2S_PORT, UART_PORT, MODBUS_PORT, CAN_PORT, } dev_io_port_e; typedef enum { DEV_POWER_OFF = 0, DEV_POWER_ON, DEV_SLEEP, DEV_SUSPEND, DEV_DEEP_SUSPEND, } dev_power_mode_e; typedef enum { DEV_HEALTH_GOOD, DEV_HEALTH_SICK, } dev_health_state_e; typedef enum { DEV_POLLING = 0, DEV_INT, DEV_DATA_READY, DEV_FIFO, DEV_MODE_INVALID } work_mode_e; typedef enum { mg = 0, mGauss, udps, lux, cm, pa, permillage, bpm, dCelsius, } value_unit_e; typedef enum { GS_SENSOR_UP, GS_SENSOR_DOWN, GS_SENSOR_LEFT, GS_SENSOR_RIGHT, GS_SENSOR_CLOCKWISE, GS_SENSOR_ANTICLOCKWISE, GS_SENSOR_WAVE, GS_SENSOR_INVALID, } gs_type_e; typedef struct _dev_accel_data_t { uint64_t timestamp; int32_t data[3]; #ifdef AOS_SENSOR_ACC_SUPPORT_STEP uint32_t step; #endif } accel_data_t; typedef struct _dev_gyro_data_t { uint64_t timestamp; int32_t data[3]; } gyro_data_t; typedef struct _dev_mag_data_t { uint64_t timestamp; int32_t data[3]; } mag_data_t; typedef struct _dev_barometer_data_t { uint64_t timestamp; uint32_t p; } barometer_data_t; typedef struct _dev_temperature_data_t { uint64_t timestamp; int32_t t; } temperature_data_t; typedef struct _dev_humidity_data_t { uint64_t timestamp; uint32_t h; } humidity_data_t; typedef struct _dev_integer_data_t { uint64_t timestamp; int32_t data; } integer_data_t; typedef struct _dev_als_data_t { uint64_t timestamp; uint32_t lux; } als_data_t; typedef struct _dev_uv_data_t { uint64_t timestamp; uint16_t uvi; } uv_data_t; typedef struct _dev_proximity_data_t { uint64_t timestamp; uint32_t present; } proximity_data_t; typedef struct _dev_hall_data_t { uint64_t timestamp; uint8_t hall_level; } hall_data_t; typedef struct _dev_rgb_data_t { uint64_t timestamp; uint32_t data[3]; } rgb_data_t; typedef struct _dev_ir_data_t { uint64_t timestamp; uint32_t ir; } ir_data_t; typedef struct _dev_ecg_data_t { uint64_t timestamp; int16_t raw_data; } ecg_data_t; typedef struct _dev_heart_rate_data_t { uint64_t timestamp; uint8_t hear_rate; } heart_rate_data_t; typedef struct _dev_rtc_data_t { uint64_t timestamp; uint8_t seconds; /* !< Seconds parameter, from 00 to 59 */ uint8_t minutes; /* !< Minutes parameter, from 01 to 59 */ uint8_t hours; /* !< Hours parameter, 24Hour mode, 00 to 23 */ uint8_t day; /* !< Day in a week, from 1 to 7 */ uint8_t date; /* !< Date in a month, 1 to 31 */ uint8_t month; /* !< Month in a year, 1 to 12 */ uint8_t year; /* !< Year parameter, 00 to 99, 00 is 2000 and 99 is 2099 */ } rtc_data_t; typedef struct _dev_blood_pressure_data_t { uint64_t timestamp; uint16_t systolic; uint16_t diastolic; } blood_pressure_t; typedef struct _dev_gs_data_t { uint64_t timestamp; gs_type_e gs_type; } gs_data_t; typedef void (*SENSOR_IRQ_CALLBACK)(sensor_tag_e tag, uint8_t instance); typedef struct _dev_sensor_config_t { uint8_t id; uint32_t range; uint32_t inerval; /* polling interval */ work_mode_e mode; void *data_buf; uint32_t data_len; SENSOR_IRQ_CALLBACK irq_callback; } dev_sensor_config_t; typedef struct _sensor_identity_t { sensor_tag_e tag; uint8_t instance; dev_io_port_e io_port; }sensor_identity_t; typedef struct _sensor_list_t { uint32_t cnt; sensor_identity_t list[SENSOR_MAX_NUM]; } sensor_list_t; typedef struct _dev_sensor_info_t { vendor_id_e vendor; char *model; value_unit_e unit; uint32_t range_max; uint32_t range_min; dev_health_state_e health; int data[3]; } dev_sensor_info_t; typedef struct _dev_sensor_full_info_t { dev_sensor_info_t info; dev_sensor_config_t config; } dev_sensor_full_info_t; typedef struct _dev_sensor_data_t { uint64_t timestamp; int32_t data[3]; } dev_sensor_data_t; typedef struct _dev_sensor_pkg_t { sensor_tag_e tag; union { dev_sensor_info_t info; dev_sensor_config_t config; dev_sensor_data_t data; } allocator; } dev_sensor_pkg_t; typedef struct _sensor_obj_t { char *path; sensor_tag_e tag; uint8_t instance; dev_io_port_e io_port; work_mode_e mode; void *data_buf; uint32_t data_len; dev_power_mode_e power; gpio_dev_t gpio; dev_sensor_full_info_t info; uint8_t ref; uint8_t drv_index; int (*open)(void); int (*close)(void); int (*read)(void *, size_t); int (*write)(const void *buf, size_t len); int (*ioctl)(int cmd, unsigned long arg); void (*irq_handle)(void); } sensor_obj_t; typedef struct _sensor_node_t { sensor_tag_e tag; char *path; int fd; } sensor_node_t; typedef enum { ACC_RANGE_2G, ACC_RANGE_4G, ACC_RANGE_8G, ACC_RANGE_16G, ACC_RANGE_6G, ACC_RANGE_12G, ACC_RANGE_24G, ACC_RANGE_100G, ACC_RANGE_200G, ACC_RANGE_400G, ACC_RANGE_MAX } acc_range_e; typedef enum { GYRO_RANGE_125DPS, GYRO_RANGE_250DPS, GYRO_RANGE_500DPS, GYRO_RANGE_1000DPS, GYRO_RANGE_2000DPS, GYRO_RANGE_MAX } gyro_range_e; typedef enum { MAG_RANGE_4GAUSS, MAG_RANGE_8GAUSS, MAG_RANGE_12GAUSS, MAG_RANGE_16GAUSS, MAG_RANGE_MAX } mag_range_e; typedef struct _gps_time { int year; int mon; int day; int hour; int min; int sec; int hsec; } gps_time_t; typedef struct _dev_gps_data_t { uint64_t timestamp; gps_time_t utc; float lat; float lon; float elv; } gps_data_t; int sensor_hal_init(void); int sensor_hal_open(sensor_tag_e tag, uint8_t instance); int sensor_hal_close(sensor_tag_e tag, uint8_t instance); ssize_t sensor_hal_read(sensor_tag_e tag, uint8_t instance, void *buf, size_t len); ssize_t sensor_hal_write(sensor_tag_e tag, uint8_t instance, const void *buf, size_t len); int sensor_hal_ioctl(sensor_tag_e tag, uint8_t instance, sensor_cmd_type cmd, unsigned long arg); #ifdef __cplusplus } #endif #endif /* HAL_SENSOR_H */
YifuLiu/AliOS-Things
components/sensor/include/sensor/sensor.h
C
apache-2.0
12,341
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited */ #ifndef SENSOR_DRV_API_H #define SENSOR_DRV_API_H #include "aos/kernel.h" #include "ulog/ulog.h" #include "sensor/sensor.h" #include "aos/hal/spi.h" #include "aos/hal/i2c.h" typedef struct _sensor_io_dev_t{ dev_io_port_e io_port; union{ i2c_dev_t dev_i2c; spi_dev_t dev_spi; }; }sensor_io_dev_t; typedef struct _sensor_io_func_st { int (*read)(uint16_t reg, uint8_t *data, uint16_t size); int (*write)(uint16_t reg, uint8_t *data, uint16_t size); } sensor_io_func_st; int32_t sensor_i2c_init(i2c_dev_t *i2c); int32_t sensor_i2c_read(i2c_dev_t *i2c, uint16_t reg, uint8_t *data, uint16_t size, uint32_t timeout); int32_t sensor_i2c_write(i2c_dev_t *i2c, uint16_t reg, uint8_t *data, uint16_t size, uint32_t timeout); int32_t sensor_drv_i2c_master_send(i2c_dev_t *i2c, uint8_t *data, uint16_t size, uint32_t timeout); int32_t sensor_drv_i2c_master_recv(i2c_dev_t *i2c, uint8_t *data, uint16_t size, uint32_t timeout); int32_t sensor_spi_read(spi_dev_t *spi, uint8_t *tx, uint8_t *rx, uint16_t size, uint32_t timeout); int32_t sensor_spi_write(spi_dev_t *spi, uint8_t *data, uint16_t size, uint32_t timeout); int32_t sensor_io_read(sensor_io_dev_t* dev, uint8_t* reg, uint8_t* data, uint16_t size,uint32_t timeout); int32_t sensor_io_write(sensor_io_dev_t* dev, uint8_t* reg, uint8_t *data, uint16_t size, uint32_t timeout); #endif /* SENSOR_DRV_API_H */
YifuLiu/AliOS-Things
components/sensor/include/sensor_drv_api.h
C
apache-2.0
1,617
/* * Copyright (C) 2015-2017 Alibaba Group Holding Limited */ #ifndef SENSOR_HAL_H #define SENSOR_HAL_H #include <aos/init.h> #include <aos/errno.h> #include <aos/compiler.h> #include "ulog/ulog.h" #include "sensor/sensor.h" #define SENSOR_DRV_ADD(func) \ int __sensor_##func##_func__(void){ \ return func(); \ } typedef int (*SENSOR_INIT_FUN)(void); int sensor_init(void); int sensor_create_obj(sensor_obj_t *sensor); #if SENSOR_CONFIG_MODBUS_ENABLE int modbus_init(void); #endif #endif /* SENSOR_HAL_H */
YifuLiu/AliOS-Things
components/sensor/include/sensor_hal.h
C
apache-2.0
519
#ifndef SENSOR_CALIBRATE_H #define SENSOR_CALIBRATE_H #include "sensor/sensor.h" int sensor_calibrate_entry(sensor_tag_e tag,int sensor_index,int axis, void *buf); int sensor_calibrate_entry_default(sensor_tag_e tag,int sensor_index,int axis, void *buf); #endif
YifuLiu/AliOS-Things
components/sensor/include/sensor_static_calibrate.h
C
apache-2.0
265
/* * Copyright (C) 2015-2021 Alibaba Group Holding Limited */ #include "sntp/sntp.h" #if AOS_COMP_CLI #include "aos/cli.h" #endif static void sntp_comp_example(int argc, char **argv) { printf("sntp test \r\n"); sntp_request(NULL); sntp_time *sntp_time_get; sntp_time_get = sntp_obtain_time(); printf("%d-%d-%d: week: %d, %d:%d:%d\r\n", sntp_time_get->year, sntp_time_get->mon, sntp_time_get->day, sntp_time_get->week, sntp_time_get->hour, sntp_time_get->min, sntp_time_get->sec); } #if AOS_COMP_CLI /* reg args: fun, cmd, description*/ ALIOS_CLI_CMD_REGISTER(sntp_comp_example, sntp_example, sntp component base example) #endif
YifuLiu/AliOS-Things
components/sntp/example/sntp_example.c
C
apache-2.0
776
/* * Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. * 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef _NET_SNTP_H_ #define _NET_SNTP_H_ #include <stdint.h> #include "lwip/sockets.h" #ifdef __cplusplus extern "C" { #endif /** @defgroup sntp_api sntp * @{ */ #define SNTP_PORT 123 #define SNTP_SUPPORT_MULTIPLE_SERVERS 1 #if SNTP_SUPPORT_MULTIPLE_SERVERS #define SNTP_MAX_SERVERS 3 #endif #ifndef SNTP_RECV_TIMEOUT #define SNTP_RECV_TIMEOUT 3000 /* ms */ #endif #define SNTP_RETRY_TIMEOUT SNTP_RECV_TIMEOUT #define SNTP_RETRY_TIMES 3 #define SNTP_SERVER_ADDRESS "pool.ntp.org" typedef struct { char *server_name; /* remote server name, if this is not NULL, this will be preferred. */ int recv_timeout; /* the receive timeout from ntp server */ uint8_t retry_times; /* the retry times when receiver timeout */ } sntp_arg; typedef struct { uint8_t sec; /**< Seconds after the minute - [0,59] */ uint8_t min; /**< Minutes after the hour - [0,59] */ uint8_t hour; /**< Hours after the midnight - [0,23] */ uint8_t day; /**< Day of the month - [1,31] */ uint8_t mon; /**< Months - [1,12] */ uint8_t week; /**< Days in a week - [0,6] */ uint8_t year; /**< Years - [0,127] */ } sntp_time; int sntp_request(void *arg); sntp_time *sntp_obtain_time(void); int sntp_get_time(sntp_arg *arg, struct timeval *ntp_time); #if SNTP_SUPPORT_MULTIPLE_SERVERS int sntp_set_server(uint8_t idx, char *server_name); #endif /* * check if last sntp query is OK * @param: None * @retval: 0 success -1 fail */ int sntp_last_query_status(void); /* * set system calender time directly * @param: current time in millisecond * @retval: 0 success -1 fail */ int sntp_set_time_direct(long long now_ms); #ifdef USE_RECORD_CALENDAR_TIME /* * update calendar time from file * @param: none * @retval: none */ void update_calendar_time_from_file(void); /* * record calendar time to file * @param: current time in millisecond * @retval: none */ void record_calendar_time(long long ms); #endif #ifdef __cplusplus } #endif #endif /* _NET_SNTP_H_ */
YifuLiu/AliOS-Things
components/sntp/include/sntp/sntp.h
C
apache-2.0
3,835
/* * Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. * 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include <unistd.h> #include "sntp/sntp.h" #include "sys/socket.h" #include "netdb.h" #include "sys/time.h" #include "string.h" #include "stdlib.h" #include "errno.h" #include "ulog/ulog.h" #define TAG "sntp" #define SNTP_DEBUG(format, ...) #define SNTP_INFO(format, ...) LOGI(TAG, format, ##__VA_ARGS__) #define SNTP_ERROR(format, ...) LOGE(TAG, format, ##__VA_ARGS__) #define SNTP_WRANING(format, ...) LOGW(TAG, format, ##__VA_ARGS__) /* SNTP protocol defines */ #define SNTP_MSG_LEN 48 #define SNTP_LI_NO_WARNING 0x00 #define SNTP_VERSION 3 /* NTP Version */ #define SNTP_MODE_MASK 0x07 #define SNTP_MODE_CLIENT 0x03 #define SNTP_MODE_SERVER 0x04 #define SNTP_MODE_BROADCAST 0x05 #define SNTP_STRATUM_KOD 0x00 /* number of seconds between 1900 and 1970 */ #define DIFF_SEC_1900_1970 (2208988800UL) /* number of seconds between 1970 and Feb 7, 2036 (6:28:16 UTC) (MSB=0) */ #define DIFF_SEC_1970_2036 (2085978496UL) typedef struct { uint8_t li_vn_mode; // Eight bits. li, vn, and mode. // li. Two bits. Leap indicator. // vn. Three bits. Version number of the protocol. // mode. Three bits. Client will pick mode 3 for client. uint8_t stratum; // Eight bits. Stratum level of the local clock. uint8_t poll; // Eight bits. Maximum interval between successive messages. uint8_t precision; // Eight bits. Precision of the local clock. uint32_t rootDelay; // 32 bits. Total round trip delay time. uint32_t rootDispersion; // 32 bits. Max error aloud from primary clock source. uint32_t refId; // 32 bits. Reference clock identifier. uint32_t refTm_s; // 32 bits. Reference time-stamp seconds. uint32_t refTm_f; // 32 bits. Reference time-stamp fraction of a second. uint32_t origTm_s; // 32 bits. Originate time-stamp seconds. uint32_t origTm_f; // 32 bits. Originate time-stamp fraction of a second. uint32_t rxTm_s; // 32 bits. Received time-stamp seconds. uint32_t rxTm_f; // 32 bits. Received time-stamp fraction of a second. uint32_t txTm_s; // 32 bits and the most important field the client cares about. Transmit time-stamp seconds. uint32_t txTm_f; // 32 bits. Transmit time-stamp fraction of a second. } ntp_packet; // Total: 384 bits or 48 bytes. static sntp_time g_time; static struct timezone g_timezone = { 0, 0 }; static int g_last_query_status = -1; // Sets time zone. void sntp_set_timezone(const struct timezone *tz) { if (tz) { g_timezone = *tz; } else { g_timezone.tz_minuteswest = 0; g_timezone.tz_dsttime = 0; } } #if SNTP_SUPPORT_MULTIPLE_SERVERS typedef struct { struct in_addr addr; } sntp_server_info; static sntp_server_info sntp_servers[SNTP_MAX_SERVERS]; static const struct in_addr* sntp_get_server_addr(uint8_t idx) { if (idx < SNTP_MAX_SERVERS) { return &sntp_servers[idx].addr; } return INADDR_ANY; } static int sntp_set_server_addr(uint8_t idx, struct in_addr *server_addr) { if (idx >= SNTP_MAX_SERVERS) return -1; sntp_servers[idx].addr.s_addr = server_addr->s_addr; return 0; } /** * @brief Set the remote ntp server address by name. * @note * @param idx: numdns the index of the NTP server to set must be < SNTP_MAX_SERVERS. * arg: servers name that want to set. such as: "cn.ntp.org.cn" "118.24.4.66" * @retval 0:success -1:fail */ int sntp_set_server(uint8_t idx, char *server) { struct hostent *host; if (idx >= SNTP_MAX_SERVERS) return -1; host = gethostbyname(server); if (!host) { SNTP_ERROR("invalid address parameter '%s'",server); return -1; } sntp_set_server_addr(idx, (struct in_addr *)host->h_addr); return 0; } #endif static void sntp_init_request_packet(ntp_packet *packet) { struct timeval local_time; memset(packet, 0, sizeof(ntp_packet)); gettimeofday(&local_time, NULL); packet->li_vn_mode = SNTP_LI_NO_WARNING | SNTP_VERSION << 3 | SNTP_MODE_CLIENT; packet->txTm_s = htonl(local_time.tv_sec); packet->txTm_f = htonl(local_time.tv_usec); } static int sntp_process_time(ntp_packet *packet, struct timeval *time) { struct timeval local_time; uint32_t t0_s, t1_s, t2_s, t3_s, real_time_s; uint32_t t0_us, t1_us, t2_us, t3_us, real_time_us; int deta1, deta2, transmit_time; if (((packet->li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_SERVER) || ((packet->li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_BROADCAST)) { gettimeofday(&local_time, NULL); t0_s = ntohl(packet->origTm_s); t0_us = ntohl(packet->origTm_f); t3_s = local_time.tv_sec; t3_us = local_time.tv_usec; t1_s = ntohl(packet->rxTm_s); t1_us = ntohl(packet->rxTm_f) / 4295; t2_s = ntohl(packet->txTm_s); t2_us = ntohl(packet->txTm_f) / 4295; deta1 = (t3_s - t0_s) * 1000000 + (t3_us - t0_us); /* us */ deta2 = (t2_s - t1_s) * 1000000 + (t2_us - t1_us); /* us */ transmit_time = (deta1 - deta2) / 2; /* us */ real_time_s = t2_s + (t2_us + transmit_time) / 1000000; real_time_us = (t2_us + transmit_time) % 1000000; int is_1900_based = ((real_time_s & 0x80000000) != 0); real_time_s = is_1900_based ? (real_time_s - DIFF_SEC_1900_1970) : (real_time_s + DIFF_SEC_1970_2036); time->tv_sec = real_time_s + (g_timezone.tz_minuteswest + g_timezone.tz_dsttime * 60) * 60; time->tv_usec = real_time_us; } else { SNTP_ERROR("sntp_request: not response frame code"); return -1; } return 0; } static int sntp_query_server(sntp_arg *arg, struct timeval *ntp_time) { ntp_packet packet; int sockfd = -1; struct sockaddr_in server_addr; struct hostent *host; char *server_name = NULL; int ret = 0; struct timeval timeout_val; #if SNTP_SUPPORT_MULTIPLE_SERVERS uint8_t idx = 0; #endif memset(&server_addr, 0, sizeof(server_addr)); /* choose the right server */ do { if (arg && arg->server_name) { server_name = arg->server_name; break; } #if SNTP_SUPPORT_MULTIPLE_SERVERS while(idx < SNTP_MAX_SERVERS && sntp_get_server_addr(idx)->s_addr == INADDR_ANY) idx++; if (idx < SNTP_MAX_SERVERS) { server_name = NULL; server_addr.sin_addr.s_addr = sntp_get_server_addr(idx)->s_addr; break; } #endif server_name = SNTP_SERVER_ADDRESS; } while(0); if (server_name) { host = gethostbyname(server_name); if (!host) { SNTP_ERROR("invalid address parameter '%s'",server_name); ret = -1; goto exit; } server_addr.sin_addr.s_addr = (*(struct in_addr *)host->h_addr).s_addr; } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SNTP_PORT); sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sockfd < 0) { SNTP_ERROR("socket create err!"); ret = -1; goto exit; } int val = 1; if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int)) != 0) { SNTP_ERROR("setsockopt(SO_REUSEADDR) failed"); ret = -1; goto exit; } int timeout_ms = arg && arg->recv_timeout > 0 ? arg->recv_timeout : SNTP_RECV_TIMEOUT; timeout_val.tv_sec = timeout_ms / 1000; timeout_val.tv_usec = timeout_ms % 1000 * 1000; if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout_val, sizeof(struct timeval)) != 0) { SNTP_ERROR("setsockopt(SO_RCVTIMEO) failed %d %d", arg->recv_timeout, errno); ret = -1; goto exit; } #if SNTP_SUPPORT_MULTIPLE_SERVERS send_request: #endif SNTP_DEBUG("server name:%s", server_name ? server_name : "NULL"); SNTP_DEBUG("server ip:%s", inet_ntoa(server_addr.sin_addr)); int retry_times = arg ? arg->retry_times : SNTP_RETRY_TIMES; do { sntp_init_request_packet(&packet); ret = sendto(sockfd, &packet, sizeof(packet), 0, (struct sockaddr *)&server_addr, sizeof(server_addr)); if (ret <= 0) { SNTP_ERROR("send err,ret=%d,errno:%d", ret, errno); ret = -1; continue; } ret = recvfrom(sockfd, &packet, sizeof(packet), 0, NULL, NULL); if (ret != SNTP_MSG_LEN) { if (errno != EAGAIN) SNTP_ERROR("recv err,ret=%d,errno:%d", ret, errno); ret = -1; continue; } else { if ((ret = sntp_process_time(&packet, ntp_time)) != 0) ret = -1; else goto exit; } } while (--retry_times && retry_times > 0); #if SNTP_SUPPORT_MULTIPLE_SERVERS /* try and get the next ntp server */ if (server_name == NULL) { for (idx++; idx < SNTP_MAX_SERVERS; idx++) { if (sntp_get_server_addr(idx)->s_addr != INADDR_ANY) { server_name = NULL; server_addr.sin_addr.s_addr = sntp_get_server_addr(idx)->s_addr; goto send_request; } } } #endif exit: if (sockfd >= 0) close(sockfd); if (ret) return -1; return 0; } #define MIN_SNTP_SET_INTERVAL_MS 5000 static long long m_sntp_set_time = 0; /** * @brief Get time from the remote server. * @note This a blocking interface. * @param ntp_time: Pointer to the struct timeval. * arg: The pointer of sntp module parameter * @retval 0:success -1:fail */ int sntp_get_time(sntp_arg *arg, struct timeval *ntp_time) { int ret = 0; ret = sntp_query_server(arg, ntp_time); if (ret == 0) { if (m_sntp_set_time == 0 || aos_now_ms() - m_sntp_set_time > MIN_SNTP_SET_INTERVAL_MS) { aos_calendar_time_set(ntp_time->tv_sec * (uint64_t)1000 + (uint64_t)(ntp_time->tv_usec / 1000)); m_sntp_set_time = aos_now_ms(); } } g_last_query_status = ret; return ret; } /** * Send an SNTP request via sockets. This interface has been deprecated. * This is a very minimal implementation that does not fully conform * to the SNTPv4 RFC, especially regarding server load and error procesing. */ int sntp_request(void *arg) { struct timeval ntp_time; struct tm *gt; int ret; ret = sntp_query_server(NULL, &ntp_time); if (ret != 0) return -1; gt = gmtime(&ntp_time.tv_sec); if (gt==NULL) { return -1; } g_time.year = gt->tm_year % 100; g_time.mon = gt->tm_mon + 1; g_time.day = gt->tm_mday; g_time.week = gt->tm_wday; g_time.hour = gt->tm_hour + 8; g_time.min = gt->tm_min; g_time.sec = gt->tm_sec; return 0; } /** * obtain time * This interface has been deprecated. */ sntp_time *sntp_obtain_time(void) { return &g_time; } /* * check if last sntp query is OK * @param: None * @retval: 0 success -1 fail */ int sntp_last_query_status(void) { return g_last_query_status; } /* * set system calender time directly * @param: current time in millisecond * @retval: 0 success -1 fail */ int sntp_set_time_direct(long long now_ms) { aos_calendar_time_set(now_ms); return 0; }
YifuLiu/AliOS-Things
components/sntp/src/sntp.c
C
apache-2.0
12,081
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** ---------------------------------------------------------------------- File : Global.h Purpose : Global types In case your application already has a Global.h, you should merge the files. In order to use Segger code, the types U8, U16, U32, I8, I16, I32 need to be defined in Global.h; additional definitions do not hurt. Revision: $Rev: 12501 $ ---------------------------END-OF-HEADER------------------------------ */ #ifndef GLOBAL_H // Guard against multiple inclusion #define GLOBAL_H #define U8 unsigned char #define I8 signed char #define U16 unsigned short #define I16 signed short #ifdef __x86_64__ #define U32 unsigned #define I32 int #else #define U32 unsigned long #define I32 signed long #endif // // CC_NO_LONG_SUPPORT can be defined to compile test // without long support for compilers that do not // support C99 and its long type. // #ifdef CC_NO_LONG_SUPPORT #define PTR_ADDR U32 #else // Supports long type. #if defined(_WIN32) && !defined(__clang__) && !defined(__MINGW32__) // // Microsoft VC6 compiler related // #define U64 unsigned __int64 #define U128 unsigned __int128 #define I64 __int64 #define I128 __int128 #if _MSC_VER <= 1200 #define U64_C(x) x##UI64 #else #define U64_C(x) x##ULL #endif #else // // C99 compliant compiler // #define U64 unsigned long long #define I64 signed long long #define U64_C(x) x##ULL #endif #if (defined(_WIN64) || defined(__LP64__)) // 64-bit symbols used by Visual Studio and GCC, maybe others as well. #define PTR_ADDR U64 #else #define PTR_ADDR U32 #endif #endif // Supports long type. #endif // Avoid multiple inclusion /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/Config/Global.h
C
apache-2.0
5,263
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** ---------------------------END-OF-HEADER------------------------------ File : SEGGER_RTT_Conf.h Purpose : Implementation of SEGGER real-time transfer (RTT) which allows real-time communication on targets which support debugger memory accesses while the CPU is running. Revision: $Rev: 21386 $ */ #ifndef SEGGER_RTT_CONF_H #define SEGGER_RTT_CONF_H #ifdef __IAR_SYSTEMS_ICC__ #include <intrinsics.h> #endif /********************************************************************* * * Defines, configurable * ********************************************************************** */ // // Take in and set to correct values for Cortex-A systems with CPU cache // //#define SEGGER_RTT_CPU_CACHE_LINE_SIZE (32) // Largest cache line size (in bytes) in the current system //#define SEGGER_RTT_UNCACHED_OFF (0xFB000000) // Address alias where RTT CB and buffers can be accessed uncached // // Most common case: // Up-channel 0: RTT // Up-channel 1: SystemView // #ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS #define SEGGER_RTT_MAX_NUM_UP_BUFFERS (3) // Max. number of up-buffers (T->H) available on this target (Default: 3) #endif // // Most common case: // Down-channel 0: RTT // Down-channel 1: SystemView // #ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (3) // Max. number of down-buffers (H->T) available on this target (Default: 3) #endif #ifndef BUFFER_SIZE_UP #define BUFFER_SIZE_UP (1024) // Size of the buffer for terminal output of target, up to host (Default: 1k) #endif #ifndef BUFFER_SIZE_DOWN #define BUFFER_SIZE_DOWN (16) // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16) #endif #ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE #define SEGGER_RTT_PRINTF_BUFFER_SIZE (64u) // Size of buffer for RTT printf to bulk-send chars via RTT (Default: 64) #endif #ifndef SEGGER_RTT_MODE_DEFAULT #define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0) #endif /********************************************************************* * * RTT memcpy configuration * * memcpy() is good for large amounts of data, * but the overhead is big for small amounts, which are usually stored via RTT. * With SEGGER_RTT_MEMCPY_USE_BYTELOOP a simple byte loop can be used instead. * * SEGGER_RTT_MEMCPY() can be used to replace standard memcpy() in RTT functions. * This is may be required with memory access restrictions, * such as on Cortex-A devices with MMU. */ #ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP #define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0 // 0: Use memcpy/SEGGER_RTT_MEMCPY, 1: Use a simple byte-loop #endif // // Example definition of SEGGER_RTT_MEMCPY to external memcpy with GCC toolchains and Cortex-A targets // //#if ((defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)) && (defined (__ARM_ARCH_7A__)) // #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) SEGGER_memcpy((pDest), (pSrc), (NumBytes)) //#endif // // Target is not allowed to perform other RTT operations while string still has not been stored completely. // Otherwise we would probably end up with a mixed string in the buffer. // If using RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here. // // SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4. // Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches. // When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly. // (Higher priority = lower priority number) // Default value for embOS: 128u // Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) ) // In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC // or define SEGGER_RTT_LOCK() to completely disable interrupts. // #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20) #endif /********************************************************************* * * RTT lock configuration for SEGGER Embedded Studio, * Rowley CrossStudio and GCC */ #if ((defined(__SES_ARM) || defined(__SES_RISCV) || defined(__CROSSWORKS_ARM) || defined(__GNUC__) || defined(__clang__)) && !defined (__CC_ARM) && !defined(WIN32)) #if (defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_8M_BASE__)) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ __asm volatile ("mrs %0, primask \n\t" \ "movs r1, #1 \n\t" \ "msr primask, r1 \n\t" \ : "=r" (_SEGGER_RTT__LockState) \ : \ : "r1", "cc" \ ); #define SEGGER_RTT_UNLOCK() __asm volatile ("msr primask, %0 \n\t" \ : \ : "r" (_SEGGER_RTT__LockState) \ : \ ); \ } #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__)) #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #endif #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ __asm volatile ("mrs %0, basepri \n\t" \ "mov r1, %1 \n\t" \ "msr basepri, r1 \n\t" \ : "=r" (_SEGGER_RTT__LockState) \ : "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY) \ : "r1", "cc" \ ); #define SEGGER_RTT_UNLOCK() __asm volatile ("msr basepri, %0 \n\t" \ : \ : "r" (_SEGGER_RTT__LockState) \ : \ ); \ } #elif defined(__ARM_ARCH_7A__) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ __asm volatile ("mrs r1, CPSR \n\t" \ "mov %0, r1 \n\t" \ "orr r1, r1, #0xC0 \n\t" \ "msr CPSR_c, r1 \n\t" \ : "=r" (_SEGGER_RTT__LockState) \ : \ : "r1", "cc" \ ); #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \ "mrs r1, CPSR \n\t" \ "bic r1, r1, #0xC0 \n\t" \ "and r0, r0, #0xC0 \n\t" \ "orr r1, r1, r0 \n\t" \ "msr CPSR_c, r1 \n\t" \ : \ : "r" (_SEGGER_RTT__LockState) \ : "r0", "r1", "cc" \ ); \ } #elif defined(__riscv) || defined(__riscv_xlen) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ __asm volatile ("csrr %0, mstatus \n\t" \ "csrci mstatus, 8 \n\t" \ "andi %0, %0, 8 \n\t" \ : "=r" (_SEGGER_RTT__LockState) \ : \ : \ ); #define SEGGER_RTT_UNLOCK() __asm volatile ("csrr a1, mstatus \n\t" \ "or %0, %0, a1 \n\t" \ "csrs mstatus, %0 \n\t" \ : \ : "r" (_SEGGER_RTT__LockState) \ : "a1" \ ); \ } #else #define SEGGER_RTT_LOCK() #define SEGGER_RTT_UNLOCK() #endif #endif /********************************************************************* * * RTT lock configuration for IAR EWARM */ #ifdef __ICCARM__ #if (defined (__ARM6M__) && (__CORE__ == __ARM6M__)) || \ (defined (__ARM8M_BASELINE__) && (__CORE__ == __ARM8M_BASELINE__)) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = __get_PRIMASK(); \ __set_PRIMASK(1); #define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \ } #elif (defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) || \ (defined (__ARM7M__) && (__CORE__ == __ARM7M__)) || \ (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) || \ (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #endif #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = __get_BASEPRI(); \ __set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY); #define SEGGER_RTT_UNLOCK() __set_BASEPRI(_SEGGER_RTT__LockState); \ } #elif (defined (__ARM7A__) && (__CORE__ == __ARM7A__)) || \ (defined (__ARM7R__) && (__CORE__ == __ARM7R__)) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ __asm volatile ("mrs r1, CPSR \n\t" \ "mov %0, r1 \n\t" \ "orr r1, r1, #0xC0 \n\t" \ "msr CPSR_c, r1 \n\t" \ : "=r" (_SEGGER_RTT__LockState) \ : \ : "r1", "cc" \ ); #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \ "mrs r1, CPSR \n\t" \ "bic r1, r1, #0xC0 \n\t" \ "and r0, r0, #0xC0 \n\t" \ "orr r1, r1, r0 \n\t" \ "msr CPSR_c, r1 \n\t" \ : \ : "r" (_SEGGER_RTT__LockState) \ : "r0", "r1", "cc" \ ); \ } #endif #endif /********************************************************************* * * RTT lock configuration for IAR RX */ #ifdef __ICCRX__ #define SEGGER_RTT_LOCK() { \ unsigned long _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = __get_interrupt_state(); \ __disable_interrupt(); #define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \ } #endif /********************************************************************* * * RTT lock configuration for IAR RL78 */ #ifdef __ICCRL78__ #define SEGGER_RTT_LOCK() { \ __istate_t _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = __get_interrupt_state(); \ __disable_interrupt(); #define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \ } #endif /********************************************************************* * * RTT lock configuration for KEIL ARM */ #ifdef __CC_ARM #if (defined __TARGET_ARCH_6S_M) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ register unsigned char _SEGGER_RTT__PRIMASK __asm( "primask"); \ _SEGGER_RTT__LockState = _SEGGER_RTT__PRIMASK; \ _SEGGER_RTT__PRIMASK = 1u; \ __schedule_barrier(); #define SEGGER_RTT_UNLOCK() _SEGGER_RTT__PRIMASK = _SEGGER_RTT__LockState; \ __schedule_barrier(); \ } #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M)) #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #endif #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ register unsigned char BASEPRI __asm( "basepri"); \ _SEGGER_RTT__LockState = BASEPRI; \ BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY; \ __schedule_barrier(); #define SEGGER_RTT_UNLOCK() BASEPRI = _SEGGER_RTT__LockState; \ __schedule_barrier(); \ } #endif #endif /********************************************************************* * * RTT lock configuration for TI ARM */ #ifdef __TI_ARM__ #if defined (__TI_ARM_V6M0__) #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = __get_PRIMASK(); \ __set_PRIMASK(1); #define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \ } #elif (defined (__TI_ARM_V7M3__) || defined (__TI_ARM_V7M4__)) #ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) #endif #define SEGGER_RTT_LOCK() { \ unsigned int _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = _set_interrupt_priority(SEGGER_RTT_MAX_INTERRUPT_PRIORITY); #define SEGGER_RTT_UNLOCK() _set_interrupt_priority(_SEGGER_RTT__LockState); \ } #endif #endif /********************************************************************* * * RTT lock configuration for CCRX */ #ifdef __RX #include <machine.h> #define SEGGER_RTT_LOCK() { \ unsigned long _SEGGER_RTT__LockState; \ _SEGGER_RTT__LockState = get_psw() & 0x010000; \ clrpsw_i(); #define SEGGER_RTT_UNLOCK() set_psw(get_psw() | _SEGGER_RTT__LockState); \ } #endif /********************************************************************* * * RTT lock configuration for embOS Simulation on Windows * (Can also be used for generic RTT locking with embOS) */ #if defined(WIN32) || defined(SEGGER_RTT_LOCK_EMBOS) void OS_SIM_EnterCriticalSection(void); void OS_SIM_LeaveCriticalSection(void); #define SEGGER_RTT_LOCK() { \ OS_SIM_EnterCriticalSection(); #define SEGGER_RTT_UNLOCK() OS_SIM_LeaveCriticalSection(); \ } #endif /********************************************************************* * * RTT lock configuration fallback */ #ifndef SEGGER_RTT_LOCK #define SEGGER_RTT_LOCK() // Lock RTT (nestable) (i.e. disable interrupts) #endif #ifndef SEGGER_RTT_UNLOCK #define SEGGER_RTT_UNLOCK() // Unlock RTT (nestable) (i.e. enable previous interrupt lock state) #endif #endif /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/Config/SEGGER_RTT_Conf.h
C
apache-2.0
25,797
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2019 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW_AliOSThings.c Purpose : Interface between AliOS Things and SystemView. Revision: $Rev: 7947 $ */ #include "k_api.h" #include "SEGGER_SYSVIEW.h" /********************************************************************* * * SYSVIEW_SendTaskInfo() * * Function description * Record task information. */ static void SYSVIEW_SendTaskInfo(U32 TaskID, const char* sName, unsigned Prio, U32 StackBase, unsigned StackSize) { SEGGER_SYSVIEW_TASKINFO TaskInfo; memset(&TaskInfo, 0, sizeof(TaskInfo)); // Fill all elements with 0 to allow extending the structure in future version without breaking the code TaskInfo.TaskID = TaskID; TaskInfo.sName = sName; TaskInfo.Prio = Prio; TaskInfo.StackBase = StackBase; TaskInfo.StackSize = StackSize; SEGGER_SYSVIEW_SendTaskInfo(&TaskInfo); } /********************************************************************* * * _cbSendTaskList() * * Function description * This function is part of the link between AliOS Things and SYSVIEW. * Called from SystemView when asked by the host, it uses SYSVIEW * functions to send the entire task list to the host. */ static void _cbSendTaskList(void) { klist_t *taskhead = &g_kobj_list.task_head; klist_t *taskend = taskhead; klist_t *tmp; ktask_t *task; krhino_sched_disable(); for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next) { task = krhino_list_entry(tmp, ktask_t, task_stats_item); SYSVIEW_SendTaskInfo((U32)task, task->task_name, task->prio, (U32)task->task_stack_base, task->stack_size); } krhino_sched_enable(); } /********************************************************************* * * _cbGetTime() * * Function description * This function is part of the link between AliOS Things and SYSVIEW. * Called from SystemView when asked by the host, returns the * current system time in micro seconds. */ static U64 _cbGetTime(void) { return aos_now_ms(); } /********************************************************************* * * Public API structures * ********************************************************************** */ // Callbacks provided to SYSTEMVIEW by AliOS Things const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI = { _cbGetTime, _cbSendTaskList, }; /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/Config/SEGGER_SYSVIEW_AliOSThings.c
C
apache-2.0
5,926
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW_Conf.h Purpose : SEGGER SystemView configuration file. Set defines which deviate from the defaults (see SEGGER_SYSVIEW_ConfDefaults.h) here. Revision: $Rev: 21292 $ Additional information: Required defines which must be set are: SEGGER_SYSVIEW_GET_TIMESTAMP SEGGER_SYSVIEW_GET_INTERRUPT_ID For known compilers and cores, these might be set to good defaults in SEGGER_SYSVIEW_ConfDefaults.h. SystemView needs a (nestable) locking mechanism. If not defined, the RTT locking mechanism is used, which then needs to be properly configured. */ #ifndef SEGGER_SYSVIEW_CONF_H #define SEGGER_SYSVIEW_CONF_H /********************************************************************* * * Defines, configurable * ********************************************************************** */ /********************************************************************* * TODO: Add your defines here. * ********************************************************************** */ #endif // SEGGER_SYSVIEW_CONF_H /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/Config/SEGGER_SYSVIEW_Conf.h
C
apache-2.0
4,665
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2019 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW_Config_AliOSThings.c Purpose : Sample setup configuration of SystemView with AliOSThings. Revision: $Rev: 7745 $ */ #include "SEGGER_SYSVIEW.h" extern const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI; /********************************************************************* * * Defines, configurable * ********************************************************************** */ // The application name to be displayed in SystemViewer #define SYSVIEW_APP_NAME "trace" // The target device name #define SYSVIEW_DEVICE_NAME "Cortex-M33" // Frequency of the timestamp. Must match SEGGER_SYSVIEW_GET_TIMESTAMP in SEGGER_SYSVIEW_Conf.h #define SYSVIEW_TIMESTAMP_FREQ (hal_sys_timer_calc_cpu_freq(5, 0)) // System Frequency. SystemcoreClock is used in most CMSIS compatible projects. #define SYSVIEW_CPU_FREQ (hal_sys_timer_calc_cpu_freq(5, 0)) // The lowest RAM address used for IDs (pointers) #define SYSVIEW_RAM_BASE (0x10000000) /********************************************************************* * * Defines, fixed * ********************************************************************** */ #define DEMCR (*(volatile U32*) (0xE000EDFCuL)) // Debug Exception and Monitor Control Register #define TRACEENA_BIT (1uL << 24) // Trace enable bit #define DWT_CTRL (*(volatile unsigned int*) (0xE0001000uL)) // DWT Control Register #define NOCYCCNT_BIT (1uL << 25) // Cycle counter support bit #define CYCCNTENA_BIT (1uL << 0) // Cycle counter enable bit // If events will be recorded without a debug probe (J-Link) attached, // enable the cycle counter // #define ENABLE_DWT_CYCCNT (SEGGER_SYSVIEW_POST_MORTEM_MODE || SEGGER_SYSVIEW_USE_INTERNAL_RECORDER) /********************************************************************* * * _cbSendSystemDesc() * * Function description * Sends SystemView description strings. */ static void _cbSendSystemDesc(void) { SEGGER_SYSVIEW_SendSysDesc("N="SYSVIEW_APP_NAME",D="SYSVIEW_DEVICE_NAME",O=AliOSThings"); SEGGER_SYSVIEW_SendSysDesc("I#34=SysTick"); } /********************************************************************* * * Global functions * ********************************************************************** */ void SEGGER_SYSVIEW_Conf(void) { #if ENABLE_DWT_CYCCNT // If no debugger is connected, the DWT must be enabled by the application // if ((DEMCR & TRACEENA_BIT) == 0) { DEMCR |= TRACEENA_BIT; } #endif // // The cycle counter must be activated in order // to use time related functions. // if ((DWT_CTRL & NOCYCCNT_BIT) == 0) { // Cycle counter supported? if ((DWT_CTRL & CYCCNTENA_BIT) == 0) { // Cycle counter not enabled? DWT_CTRL |= CYCCNTENA_BIT; // Enable Cycle counter } } SEGGER_SYSVIEW_Init(SYSVIEW_TIMESTAMP_FREQ, SYSVIEW_CPU_FREQ, &SYSVIEW_X_OS_TraceAPI, _cbSendSystemDesc); SEGGER_SYSVIEW_SetRAMBase(SYSVIEW_RAM_BASE); #if SEGGER_SYSVIEW_START_ON_INIT SEGGER_SYSVIEW_Start(); // Start recording to catch system initialization. #endif } /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/Config/SEGGER_SYSVIEW_Config_AliOSThings.c
C
apache-2.0
6,815
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** ---------------------------------------------------------------------- File : SEGGER.h Purpose : Global types etc & general purpose utility functions Revision: $Rev: 18102 $ ---------------------------END-OF-HEADER------------------------------ */ #ifndef SEGGER_H // Guard against multiple inclusion #define SEGGER_H #include <stdarg.h> // For va_list. #include "Global.h" // Type definitions: U8, U16, U32, I8, I16, I32 #if defined(__cplusplus) extern "C" { /* Make sure we have C-declarations in C++ programs */ #endif /********************************************************************* * * Keywords/specifiers * ********************************************************************** */ #ifndef INLINE #if (defined(__ICCARM__) || defined(__RX) || defined(__ICCRX__)) // // Other known compilers. // #define INLINE inline #else #if (defined(_WIN32) && !defined(__clang__)) // // Microsoft VC6 and newer. // Force inlining without cost checking. // #define INLINE __forceinline #elif defined(__GNUC__) || defined(__clang__) // // Force inlining with GCC + clang // #define INLINE inline __attribute__((always_inline)) #elif (defined(__CC_ARM)) // // Force inlining with ARMCC (Keil) // #define INLINE __inline #else // // Unknown compilers. // #define INLINE #endif #endif #endif /********************************************************************* * * Function-like macros * ********************************************************************** */ #define SEGGER_COUNTOF(a) (sizeof((a))/sizeof((a)[0])) #define SEGGER_MIN(a,b) (((a) < (b)) ? (a) : (b)) #define SEGGER_MAX(a,b) (((a) > (b)) ? (a) : (b)) #ifndef SEGGER_USE_PARA // Some compiler complain about unused parameters. #define SEGGER_USE_PARA(Para) (void)Para // This works for most compilers. #endif #define SEGGER_ADDR2PTR(Type, Addr) (/*lint -e(923) -e(9078)*/((Type*)((PTR_ADDR)(Addr)))) // Allow cast from address to pointer. #define SEGGER_PTR2ADDR(p) (/*lint -e(923) -e(9078)*/((PTR_ADDR)(p))) // Allow cast from pointer to address. #define SEGGER_PTR2PTR(Type, p) (/*lint -e(740) -e(826) -e(9079) -e(9087)*/((Type*)(p))) // Allow cast from one pointer type to another (ignore different size). #define SEGGER_PTR_DISTANCE(p0, p1) (SEGGER_PTR2ADDR(p0) - SEGGER_PTR2ADDR(p1)) /********************************************************************* * * Defines * ********************************************************************** */ #define SEGGER_PRINTF_FLAG_ADJLEFT (1 << 0) #define SEGGER_PRINTF_FLAG_SIGNFORCE (1 << 1) #define SEGGER_PRINTF_FLAG_SIGNSPACE (1 << 2) #define SEGGER_PRINTF_FLAG_PRECEED (1 << 3) #define SEGGER_PRINTF_FLAG_ZEROPAD (1 << 4) #define SEGGER_PRINTF_FLAG_NEGATIVE (1 << 5) /********************************************************************* * * Types * ********************************************************************** */ typedef struct { char* pBuffer; int BufferSize; int Cnt; } SEGGER_BUFFER_DESC; typedef struct { unsigned int CacheLineSize; // 0: No Cache. Most Systems such as ARM9 use a 32 bytes cache line size. void (*pfDMB) (void); // Optional DMB function for Data Memory Barrier to make sure all memory operations are completed. void (*pfClean) (void *p, unsigned long NumBytes); // Optional clean function for cached memory. void (*pfInvalidate)(void *p, unsigned long NumBytes); // Optional invalidate function for cached memory. } SEGGER_CACHE_CONFIG; typedef struct SEGGER_SNPRINTF_CONTEXT_struct SEGGER_SNPRINTF_CONTEXT; struct SEGGER_SNPRINTF_CONTEXT_struct { void* pContext; // Application specific context. SEGGER_BUFFER_DESC* pBufferDesc; // Buffer descriptor to use for output. void (*pfFlush)(SEGGER_SNPRINTF_CONTEXT* pContext); // Callback executed once the buffer is full. Callback decides if the buffer gets cleared to store more or not. }; typedef struct { void (*pfStoreChar) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, char c); int (*pfPrintUnsigned) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, U32 v, unsigned Base, char Flags, int Width, int Precision); int (*pfPrintInt) (SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, I32 v, unsigned Base, char Flags, int Width, int Precision); } SEGGER_PRINTF_API; typedef void (*SEGGER_pFormatter)(SEGGER_BUFFER_DESC* pBufferDesc, SEGGER_SNPRINTF_CONTEXT* pContext, const SEGGER_PRINTF_API* pApi, va_list* pParamList, char Lead, int Width, int Precision); typedef struct SEGGER_PRINTF_FORMATTER { struct SEGGER_PRINTF_FORMATTER* pNext; // Pointer to next formatter. SEGGER_pFormatter pfFormatter; // Formatter function. char Specifier; // Format specifier. } SEGGER_PRINTF_FORMATTER; typedef struct { U32 (*pfGetHPTimestamp)(void); // Mandatory, pfGetHPTimestamp int (*pfGetUID) (U8 abUID[16]); // Optional, pfGetUID } SEGGER_BSP_API; /********************************************************************* * * Utility functions * ********************************************************************** */ // // Memory operations. // void SEGGER_ARM_memcpy(void* pDest, const void* pSrc, int NumBytes); void SEGGER_memcpy (void* pDest, const void* pSrc, unsigned NumBytes); void SEGGER_memxor (void* pDest, const void* pSrc, unsigned NumBytes); // // String functions. // int SEGGER_atoi (const char* s); int SEGGER_isalnum (int c); int SEGGER_isalpha (int c); unsigned SEGGER_strlen (const char* s); int SEGGER_tolower (int c); int SEGGER_strcasecmp (const char* sText1, const char* sText2); int SEGGER_strncasecmp(const char *sText1, const char *sText2, unsigned Count); // // Buffer/printf related. // void SEGGER_StoreChar (SEGGER_BUFFER_DESC* pBufferDesc, char c); void SEGGER_PrintUnsigned(SEGGER_BUFFER_DESC* pBufferDesc, U32 v, unsigned Base, int Precision); void SEGGER_PrintInt (SEGGER_BUFFER_DESC* pBufferDesc, I32 v, unsigned Base, int Precision); int SEGGER_snprintf (char* pBuffer, int BufferSize, const char* sFormat, ...); int SEGGER_vsnprintf (char* pBuffer, int BufferSize, const char* sFormat, va_list ParamList); int SEGGER_vsnprintfEx (SEGGER_SNPRINTF_CONTEXT* pContext, const char* sFormat, va_list ParamList); int SEGGER_PRINTF_AddFormatter (SEGGER_PRINTF_FORMATTER* pFormatter, SEGGER_pFormatter pfFormatter, char c); void SEGGER_PRINTF_AddDoubleFormatter (void); void SEGGER_PRINTF_AddIPFormatter (void); void SEGGER_PRINTF_AddBLUEFormatter (void); void SEGGER_PRINTF_AddCONNECTFormatter(void); void SEGGER_PRINTF_AddSSLFormatter (void); void SEGGER_PRINTF_AddSSHFormatter (void); void SEGGER_PRINTF_AddHTMLFormatter (void); // // BSP abstraction API. // int SEGGER_BSP_GetUID (U8 abUID[16]); int SEGGER_BSP_GetUID32(U32* pUID); void SEGGER_BSP_SetAPI (const SEGGER_BSP_API* pAPI); void SEGGER_BSP_SeedUID (void); // // Other API. // void SEGGER_VERSION_GetString(char acText[8], unsigned Version); #if defined(__cplusplus) } /* Make sure we have C-declarations in C++ programs */ #endif #endif // Avoid multiple inclusion /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER.h
C
apache-2.0
11,298
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** ---------------------------END-OF-HEADER------------------------------ File : SEGGER_RTT.c Purpose : Implementation of SEGGER real-time transfer (RTT) which allows real-time communication on targets which support debugger memory accesses while the CPU is running. Revision: $Rev: 22333 $ Additional information: Type "int" is assumed to be 32-bits in size H->T Host to target communication T->H Target to host communication RTT channel 0 is always present and reserved for Terminal usage. Name is fixed to "Terminal" Effective buffer size: SizeOfBuffer - 1 WrOff == RdOff: Buffer is empty WrOff == (RdOff - 1): Buffer is full WrOff > RdOff: Free space includes wrap-around WrOff < RdOff: Used space includes wrap-around (WrOff == (SizeOfBuffer - 1)) && (RdOff == 0): Buffer full and wrap-around after next byte ---------------------------------------------------------------------- */ #include "SEGGER_RTT.h" #include <string.h> // for memcpy /********************************************************************* * * Configuration, default values * ********************************************************************** */ #if SEGGER_RTT_CPU_CACHE_LINE_SIZE #ifdef SEGGER_RTT_CB_ALIGN #error "Custom SEGGER_RTT_CB_ALIGN() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #ifdef SEGGER_RTT_BUFFER_ALIGN #error "Custom SEGGER_RTT_BUFFER_ALIGN() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #ifdef SEGGER_RTT_PUT_CB_SECTION #error "Custom SEGGER_RTT_PUT_CB_SECTION() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #ifdef SEGGER_RTT_PUT_BUFFER_SECTION #error "Custom SEGGER_RTT_PUT_BUFFER_SECTION() is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #ifdef SEGGER_RTT_BUFFER_ALIGNMENT #error "Custom SEGGER_RTT_BUFFER_ALIGNMENT is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #ifdef SEGGER_RTT_ALIGNMENT #error "Custom SEGGER_RTT_ALIGNMENT is not supported for SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #endif #ifndef BUFFER_SIZE_UP #define BUFFER_SIZE_UP 1024 // Size of the buffer for terminal output of target, up to host #endif #ifndef BUFFER_SIZE_DOWN #define BUFFER_SIZE_DOWN 16 // Size of the buffer for terminal input to target from host (Usually keyboard input) #endif #ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS #define SEGGER_RTT_MAX_NUM_UP_BUFFERS 2 // Number of up-buffers (T->H) available on this target #endif #ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS 2 // Number of down-buffers (H->T) available on this target #endif #ifndef SEGGER_RTT_BUFFER_SECTION #if defined(SEGGER_RTT_SECTION) #define SEGGER_RTT_BUFFER_SECTION SEGGER_RTT_SECTION #endif #endif #ifndef SEGGER_RTT_ALIGNMENT #define SEGGER_RTT_ALIGNMENT SEGGER_RTT_CPU_CACHE_LINE_SIZE #endif #ifndef SEGGER_RTT_BUFFER_ALIGNMENT #define SEGGER_RTT_BUFFER_ALIGNMENT SEGGER_RTT_CPU_CACHE_LINE_SIZE #endif #ifndef SEGGER_RTT_MODE_DEFAULT #define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_SKIP #endif #ifndef SEGGER_RTT_LOCK #define SEGGER_RTT_LOCK() #endif #ifndef SEGGER_RTT_UNLOCK #define SEGGER_RTT_UNLOCK() #endif #ifndef STRLEN #define STRLEN(a) strlen((a)) #endif #ifndef STRCPY #define STRCPY(pDest, pSrc) strcpy((pDest), (pSrc)) #endif #ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP #define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0 #endif #ifndef SEGGER_RTT_MEMCPY #ifdef MEMCPY #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) MEMCPY((pDest), (pSrc), (NumBytes)) #else #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) memcpy((pDest), (pSrc), (NumBytes)) #endif #endif #ifndef MIN #define MIN(a, b) (((a) < (b)) ? (a) : (b)) #endif #ifndef MAX #define MAX(a, b) (((a) > (b)) ? (a) : (b)) #endif // // For some environments, NULL may not be defined until certain headers are included // #ifndef NULL #define NULL 0 #endif /********************************************************************* * * Defines, fixed * ********************************************************************** */ #if (defined __ICCARM__) || (defined __ICCRX__) #define RTT_PRAGMA(P) _Pragma(#P) #endif #if SEGGER_RTT_ALIGNMENT || SEGGER_RTT_BUFFER_ALIGNMENT #if (defined __GNUC__) #define SEGGER_RTT_ALIGN(Var, Alignment) Var __attribute__ ((aligned (Alignment))) #elif (defined __ICCARM__) || (defined __ICCRX__) #define PRAGMA(A) _Pragma(#A) #define SEGGER_RTT_ALIGN(Var, Alignment) RTT_PRAGMA(data_alignment=Alignment) \ Var #elif (defined __CC_ARM) #define SEGGER_RTT_ALIGN(Var, Alignment) Var __attribute__ ((aligned (Alignment))) #else #error "Alignment not supported for this compiler." #endif #else #define SEGGER_RTT_ALIGN(Var, Alignment) Var #endif #if defined(SEGGER_RTT_SECTION) || defined (SEGGER_RTT_BUFFER_SECTION) #if (defined __GNUC__) #define SEGGER_RTT_PUT_SECTION(Var, Section) __attribute__ ((section (Section))) Var #elif (defined __ICCARM__) || (defined __ICCRX__) #define SEGGER_RTT_PUT_SECTION(Var, Section) RTT_PRAGMA(location=Section) \ Var #elif (defined __CC_ARM) #define SEGGER_RTT_PUT_SECTION(Var, Section) __attribute__ ((section (Section), zero_init)) Var #else #error "Section placement not supported for this compiler." #endif #else #define SEGGER_RTT_PUT_SECTION(Var, Section) Var #endif #if SEGGER_RTT_ALIGNMENT #define SEGGER_RTT_CB_ALIGN(Var) SEGGER_RTT_ALIGN(Var, SEGGER_RTT_ALIGNMENT) #else #define SEGGER_RTT_CB_ALIGN(Var) Var #endif #if SEGGER_RTT_BUFFER_ALIGNMENT #define SEGGER_RTT_BUFFER_ALIGN(Var) SEGGER_RTT_ALIGN(Var, SEGGER_RTT_BUFFER_ALIGNMENT) #else #define SEGGER_RTT_BUFFER_ALIGN(Var) Var #endif #if defined(SEGGER_RTT_SECTION) #define SEGGER_RTT_PUT_CB_SECTION(Var) SEGGER_RTT_PUT_SECTION(Var, SEGGER_RTT_SECTION) #else #define SEGGER_RTT_PUT_CB_SECTION(Var) Var #endif #if defined(SEGGER_RTT_BUFFER_SECTION) #define SEGGER_RTT_PUT_BUFFER_SECTION(Var) SEGGER_RTT_PUT_SECTION(Var, SEGGER_RTT_BUFFER_SECTION) #else #define SEGGER_RTT_PUT_BUFFER_SECTION(Var) Var #endif /********************************************************************* * * Static const data * ********************************************************************** */ static unsigned char _aTerminalId[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; /********************************************************************* * * Static data * ********************************************************************** */ // // RTT Control Block and allocate buffers for channel 0 // SEGGER_RTT_PUT_CB_SECTION(SEGGER_RTT_CB_ALIGN(SEGGER_RTT_CB _SEGGER_RTT)); SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(static char _acUpBuffer [SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_UP)])); SEGGER_RTT_PUT_BUFFER_SECTION(SEGGER_RTT_BUFFER_ALIGN(static char _acDownBuffer[SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(BUFFER_SIZE_DOWN)])); static unsigned char _ActiveTerminal; /********************************************************************* * * Static functions * ********************************************************************** */ /********************************************************************* * * _DoInit() * * Function description * Initializes the control block an buffers. * May only be called via INIT() to avoid overriding settings. * */ #define INIT() { \ volatile SEGGER_RTT_CB* pRTTCBInit; \ pRTTCBInit = (volatile SEGGER_RTT_CB*)((char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); \ do { \ if (pRTTCBInit->acID[0] == '\0') { \ _DoInit(); \ } \ } while (0); \ } static void _DoInit(void) { volatile SEGGER_RTT_CB* p; // Volatile to make sure that compiler cannot change the order of accesses to the control block // // Initialize control block // p = (volatile SEGGER_RTT_CB*)((char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access control block uncached so that nothing in the cache ever becomes dirty and all changes are visible in HW directly p->MaxNumUpBuffers = SEGGER_RTT_MAX_NUM_UP_BUFFERS; p->MaxNumDownBuffers = SEGGER_RTT_MAX_NUM_DOWN_BUFFERS; // // Initialize up buffer 0 // p->aUp[0].sName = "Terminal"; p->aUp[0].pBuffer = _acUpBuffer; p->aUp[0].SizeOfBuffer = BUFFER_SIZE_UP; p->aUp[0].RdOff = 0u; p->aUp[0].WrOff = 0u; p->aUp[0].Flags = SEGGER_RTT_MODE_DEFAULT; // // Initialize down buffer 0 // p->aDown[0].sName = "Terminal"; p->aDown[0].pBuffer = _acDownBuffer; p->aDown[0].SizeOfBuffer = BUFFER_SIZE_DOWN; p->aDown[0].RdOff = 0u; p->aDown[0].WrOff = 0u; p->aDown[0].Flags = SEGGER_RTT_MODE_DEFAULT; // // Finish initialization of the control block. // Copy Id string in three steps to make sure "SEGGER RTT" is not found // in initializer memory (usually flash) by J-Link // STRCPY((char*)&p->acID[7], "RTT"); RTT__DMB(); // Force order of memory accessed inside core for cores that allow to change the order STRCPY((char*)&p->acID[0], "SEGGER"); RTT__DMB(); // Force order of memory accessed inside core for cores that allow to change the order p->acID[6] = ' '; RTT__DMB(); // Force order of memory accessed inside core for cores that allow to change the order } /********************************************************************* * * _WriteBlocking() * * Function description * Stores a specified number of characters in SEGGER RTT ring buffer * and updates the associated write pointer which is periodically * read by the host. * The caller is responsible for managing the write chunk sizes as * _WriteBlocking() will block until all data has been posted successfully. * * Parameters * pRing Ring buffer to post to. * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Return value * >= 0 - Number of bytes written into buffer. */ static unsigned _WriteBlocking(SEGGER_RTT_BUFFER_UP* pRing, const char* pBuffer, unsigned NumBytes) { unsigned NumBytesToWrite; unsigned NumBytesWritten; unsigned RdOff; unsigned WrOff; volatile char* pDst; // // Write data to buffer and handle wrap-around if necessary // NumBytesWritten = 0u; WrOff = pRing->WrOff; do { RdOff = pRing->RdOff; // May be changed by host (debug probe) in the meantime if (RdOff > WrOff) { NumBytesToWrite = RdOff - WrOff - 1u; } else { NumBytesToWrite = pRing->SizeOfBuffer - (WrOff - RdOff + 1u); } NumBytesToWrite = MIN(NumBytesToWrite, (pRing->SizeOfBuffer - WrOff)); // Number of bytes that can be written until buffer wrap-around NumBytesToWrite = MIN(NumBytesToWrite, NumBytes); pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP NumBytesWritten += NumBytesToWrite; NumBytes -= NumBytesToWrite; WrOff += NumBytesToWrite; while (NumBytesToWrite--) { *pDst++ = *pBuffer++; }; #else SEGGER_RTT_MEMCPY((void*)pDst, pBuffer, NumBytesToWrite); NumBytesWritten += NumBytesToWrite; pBuffer += NumBytesToWrite; NumBytes -= NumBytesToWrite; WrOff += NumBytesToWrite; #endif if (WrOff == pRing->SizeOfBuffer) { WrOff = 0u; } RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff; } while (NumBytes); return NumBytesWritten; } /********************************************************************* * * _WriteNoCheck() * * Function description * Stores a specified number of characters in SEGGER RTT ring buffer * and updates the associated write pointer which is periodically * read by the host. * It is callers responsibility to make sure data actually fits in buffer. * * Parameters * pRing Ring buffer to post to. * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Notes * (1) If there might not be enough space in the "Up"-buffer, call _WriteBlocking */ static void _WriteNoCheck(SEGGER_RTT_BUFFER_UP* pRing, const char* pData, unsigned NumBytes) { unsigned NumBytesAtOnce; unsigned WrOff; unsigned Rem; volatile char* pDst; WrOff = pRing->WrOff; Rem = pRing->SizeOfBuffer - WrOff; if (Rem > NumBytes) { // // All data fits before wrap around // pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP WrOff += NumBytes; while (NumBytes--) { *pDst++ = *pData++; }; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff; #else SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytes); RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff + NumBytes; #endif } else { // // We reach the end of the buffer, so need to wrap around // #if SEGGER_RTT_MEMCPY_USE_BYTELOOP pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; NumBytesAtOnce = Rem; while (NumBytesAtOnce--) { *pDst++ = *pData++; }; pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF; NumBytesAtOnce = NumBytes - Rem; while (NumBytesAtOnce--) { *pDst++ = *pData++; }; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = NumBytes - Rem; #else NumBytesAtOnce = Rem; pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytesAtOnce); NumBytesAtOnce = NumBytes - Rem; pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF; SEGGER_RTT_MEMCPY((void*)pDst, pData + Rem, NumBytesAtOnce); RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = NumBytesAtOnce; #endif } } /********************************************************************* * * _PostTerminalSwitch() * * Function description * Switch terminal to the given terminal ID. It is the caller's * responsibility to ensure the terminal ID is correct and there is * enough space in the buffer for this to complete successfully. * * Parameters * pRing Ring buffer to post to. * TerminalId Terminal ID to switch to. */ static void _PostTerminalSwitch(SEGGER_RTT_BUFFER_UP* pRing, unsigned char TerminalId) { unsigned char ac[2]; ac[0] = 0xFFu; ac[1] = _aTerminalId[TerminalId]; // Caller made already sure that TerminalId does not exceed our terminal limit _WriteBlocking(pRing, (const char*)ac, 2u); } /********************************************************************* * * _GetAvailWriteSpace() * * Function description * Returns the number of bytes that can be written to the ring * buffer without blocking. * * Parameters * pRing Ring buffer to check. * * Return value * Number of bytes that are free in the buffer. */ static unsigned _GetAvailWriteSpace(SEGGER_RTT_BUFFER_UP* pRing) { unsigned RdOff; unsigned WrOff; unsigned r; // // Avoid warnings regarding volatile access order. It's not a problem // in this case, but dampen compiler enthusiasm. // RdOff = pRing->RdOff; WrOff = pRing->WrOff; if (RdOff <= WrOff) { r = pRing->SizeOfBuffer - 1u - WrOff + RdOff; } else { r = RdOff - WrOff - 1u; } return r; } /********************************************************************* * * Public code * ********************************************************************** */ /********************************************************************* * * SEGGER_RTT_ReadUpBufferNoLock() * * Function description * Reads characters from SEGGER real-time-terminal control block * which have been previously stored by the application. * Do not lock against interrupts and multiple access. * Used to do the same operation that J-Link does, to transfer * RTT data via other channels, such as TCP/IP or UART. * * Parameters * BufferIndex Index of Up-buffer to be used. * pBuffer Pointer to buffer provided by target application, to copy characters from RTT-up-buffer to. * BufferSize Size of the target application buffer. * * Return value * Number of bytes that have been read. * * Additional information * This function must not be called when J-Link might also do RTT. */ unsigned SEGGER_RTT_ReadUpBufferNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) { unsigned NumBytesRem; unsigned NumBytesRead; unsigned RdOff; unsigned WrOff; unsigned char* pBuffer; SEGGER_RTT_BUFFER_UP* pRing; volatile char* pSrc; INIT(); pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly pBuffer = (unsigned char*)pData; RdOff = pRing->RdOff; WrOff = pRing->WrOff; NumBytesRead = 0u; // // Read from current read position to wrap-around of buffer, first // if (RdOff > WrOff) { NumBytesRem = pRing->SizeOfBuffer - RdOff; NumBytesRem = MIN(NumBytesRem, BufferSize); pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP NumBytesRead += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; while (NumBytesRem--) { *pBuffer++ = *pSrc++; }; #else SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); NumBytesRead += NumBytesRem; pBuffer += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; #endif // // Handle wrap-around of buffer // if (RdOff == pRing->SizeOfBuffer) { RdOff = 0u; } } // // Read remaining items of buffer // NumBytesRem = WrOff - RdOff; NumBytesRem = MIN(NumBytesRem, BufferSize); if (NumBytesRem > 0u) { pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP NumBytesRead += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; while (NumBytesRem--) { *pBuffer++ = *pSrc++; }; #else SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); NumBytesRead += NumBytesRem; pBuffer += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; #endif } // // Update read offset of buffer // if (NumBytesRead) { pRing->RdOff = RdOff; } // return NumBytesRead; } /********************************************************************* * * SEGGER_RTT_ReadNoLock() * * Function description * Reads characters from SEGGER real-time-terminal control block * which have been previously stored by the host. * Do not lock against interrupts and multiple access. * * Parameters * BufferIndex Index of Down-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to buffer provided by target application, to copy characters from RTT-down-buffer to. * BufferSize Size of the target application buffer. * * Return value * Number of bytes that have been read. */ unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) { unsigned NumBytesRem; unsigned NumBytesRead; unsigned RdOff; unsigned WrOff; unsigned char* pBuffer; SEGGER_RTT_BUFFER_DOWN* pRing; volatile char* pSrc; // INIT(); pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly pBuffer = (unsigned char*)pData; RdOff = pRing->RdOff; WrOff = pRing->WrOff; NumBytesRead = 0u; // // Read from current read position to wrap-around of buffer, first // if (RdOff > WrOff) { NumBytesRem = pRing->SizeOfBuffer - RdOff; NumBytesRem = MIN(NumBytesRem, BufferSize); pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP NumBytesRead += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; while (NumBytesRem--) { *pBuffer++ = *pSrc++; }; #else SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); NumBytesRead += NumBytesRem; pBuffer += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; #endif // // Handle wrap-around of buffer // if (RdOff == pRing->SizeOfBuffer) { RdOff = 0u; } } // // Read remaining items of buffer // NumBytesRem = WrOff - RdOff; NumBytesRem = MIN(NumBytesRem, BufferSize); if (NumBytesRem > 0u) { pSrc = (pRing->pBuffer + RdOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP NumBytesRead += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; while (NumBytesRem--) { *pBuffer++ = *pSrc++; }; #else SEGGER_RTT_MEMCPY(pBuffer, (void*)pSrc, NumBytesRem); NumBytesRead += NumBytesRem; pBuffer += NumBytesRem; BufferSize -= NumBytesRem; RdOff += NumBytesRem; #endif } if (NumBytesRead) { pRing->RdOff = RdOff; } // return NumBytesRead; } /********************************************************************* * * SEGGER_RTT_ReadUpBuffer * * Function description * Reads characters from SEGGER real-time-terminal control block * which have been previously stored by the application. * Used to do the same operation that J-Link does, to transfer * RTT data via other channels, such as TCP/IP or UART. * * Parameters * BufferIndex Index of Up-buffer to be used. * pBuffer Pointer to buffer provided by target application, to copy characters from RTT-up-buffer to. * BufferSize Size of the target application buffer. * * Return value * Number of bytes that have been read. * * Additional information * This function must not be called when J-Link might also do RTT. * This function locks against all other RTT operations. I.e. during * the read operation, writing is also locked. * If only one consumer reads from the up buffer, * call sEGGER_RTT_ReadUpBufferNoLock() instead. */ unsigned SEGGER_RTT_ReadUpBuffer(unsigned BufferIndex, void* pBuffer, unsigned BufferSize) { unsigned NumBytesRead; SEGGER_RTT_LOCK(); // // Call the non-locking read function // NumBytesRead = SEGGER_RTT_ReadUpBufferNoLock(BufferIndex, pBuffer, BufferSize); // // Finish up. // SEGGER_RTT_UNLOCK(); // return NumBytesRead; } /********************************************************************* * * SEGGER_RTT_Read * * Function description * Reads characters from SEGGER real-time-terminal control block * which have been previously stored by the host. * * Parameters * BufferIndex Index of Down-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to buffer provided by target application, to copy characters from RTT-down-buffer to. * BufferSize Size of the target application buffer. * * Return value * Number of bytes that have been read. */ unsigned SEGGER_RTT_Read(unsigned BufferIndex, void* pBuffer, unsigned BufferSize) { unsigned NumBytesRead; SEGGER_RTT_LOCK(); // // Call the non-locking read function // NumBytesRead = SEGGER_RTT_ReadNoLock(BufferIndex, pBuffer, BufferSize); // // Finish up. // SEGGER_RTT_UNLOCK(); // return NumBytesRead; } /********************************************************************* * * SEGGER_RTT_WriteWithOverwriteNoLock * * Function description * Stores a specified number of characters in SEGGER RTT * control block. * SEGGER_RTT_WriteWithOverwriteNoLock does not lock the application * and overwrites data if the data does not fit into the buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Notes * (1) If there is not enough space in the "Up"-buffer, data is overwritten. * (2) For performance reasons this function does not call Init() * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. * (3) Do not use SEGGER_RTT_WriteWithOverwriteNoLock if a J-Link * connection reads RTT data. */ void SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { const char* pData; SEGGER_RTT_BUFFER_UP* pRing; unsigned Avail; volatile char* pDst; // // Get "to-host" ring buffer and copy some elements into local variables. // pData = (const char *)pBuffer; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // Check if we will overwrite data and need to adjust the RdOff. // if (pRing->WrOff == pRing->RdOff) { Avail = pRing->SizeOfBuffer - 1u; } else if ( pRing->WrOff < pRing->RdOff) { Avail = pRing->RdOff - pRing->WrOff - 1u; } else { Avail = pRing->RdOff - pRing->WrOff - 1u + pRing->SizeOfBuffer; } if (NumBytes > Avail) { pRing->RdOff += (NumBytes - Avail); while (pRing->RdOff >= pRing->SizeOfBuffer) { pRing->RdOff -= pRing->SizeOfBuffer; } } // // Write all data, no need to check the RdOff, but possibly handle multiple wrap-arounds // Avail = pRing->SizeOfBuffer - pRing->WrOff; do { if (Avail > NumBytes) { // // Last round // pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP Avail = NumBytes; while (NumBytes--) { *pDst++ = *pData++; }; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff += Avail; #else SEGGER_RTT_MEMCPY((void*)pDst, pData, NumBytes); RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff += NumBytes; #endif break; } else { // // Wrap-around necessary, write until wrap-around and reset WrOff // pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; #if SEGGER_RTT_MEMCPY_USE_BYTELOOP NumBytes -= Avail; while (Avail--) { *pDst++ = *pData++; }; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = 0; #else SEGGER_RTT_MEMCPY((void*)pDst, pData, Avail); pData += Avail; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = 0; NumBytes -= Avail; #endif Avail = (pRing->SizeOfBuffer - 1); } } while (NumBytes); } /********************************************************************* * * SEGGER_RTT_WriteSkipNoLock * * Function description * Stores a specified number of characters in SEGGER RTT * control block which is then read by the host. * SEGGER_RTT_WriteSkipNoLock does not lock the application and * skips all data, if the data does not fit into the buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * MUST be > 0!!! * This is done for performance reasons, so no initial check has do be done. * * Return value * 1: Data has been copied * 0: No space, data has not been copied * * Notes * (1) If there is not enough space in the "Up"-buffer, all data is dropped. * (2) For performance reasons this function does not call Init() * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. */ #if (RTT_USE_ASM == 0) unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { const char* pData; SEGGER_RTT_BUFFER_UP* pRing; unsigned Avail; unsigned RdOff; unsigned WrOff; unsigned Rem; volatile char* pDst; // // Cases: // 1) RdOff <= WrOff => Space until wrap-around is sufficient // 2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks) // 3) RdOff < WrOff => No space in buf // 4) RdOff > WrOff => Space is sufficient // 5) RdOff > WrOff => No space in buf // // 1) is the most common case for large buffers and assuming that J-Link reads the data fast enough // pData = (const char *)pBuffer; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly RdOff = pRing->RdOff; WrOff = pRing->WrOff; if (RdOff <= WrOff) { // Case 1), 2) or 3) Avail = pRing->SizeOfBuffer - WrOff - 1u; // Space until wrap-around (assume 1 byte not usable for case that RdOff == 0) if (Avail >= NumBytes) { // Case 1)? CopyStraight: pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; memcpy((void*)pDst, pData, NumBytes); RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff + NumBytes; return 1; } Avail += RdOff; // Space incl. wrap-around if (Avail >= NumBytes) { // Case 2? => If not, we have case 3) (does not fit) Rem = pRing->SizeOfBuffer - WrOff; // Space until end of buffer pDst = (pRing->pBuffer + WrOff) + SEGGER_RTT_UNCACHED_OFF; memcpy((void*)pDst, pData, Rem); // Copy 1st chunk NumBytes -= Rem; // // Special case: First check that assumed RdOff == 0 calculated that last element before wrap-around could not be used // But 2nd check (considering space until wrap-around and until RdOff) revealed that RdOff is not 0, so we can use the last element // In this case, we may use a copy straight until buffer end anyway without needing to copy 2 chunks // Therefore, check if 2nd memcpy is necessary at all // if (NumBytes) { pDst = pRing->pBuffer + SEGGER_RTT_UNCACHED_OFF; memcpy((void*)pDst, pData + Rem, NumBytes); } RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = NumBytes; return 1; } } else { // Potential case 4) Avail = RdOff - WrOff - 1u; if (Avail >= NumBytes) { // Case 4)? => If not, we have case 5) (does not fit) goto CopyStraight; } } return 0; // No space in buffer } #endif /********************************************************************* * * SEGGER_RTT_WriteDownBufferNoLock * * Function description * Stores a specified number of characters in SEGGER RTT * control block inside a <Down> buffer. * SEGGER_RTT_WriteDownBufferNoLock does not lock the application. * Used to do the same operation that J-Link does, to transfer * RTT data from other channels, such as TCP/IP or UART. * * Parameters * BufferIndex Index of "Down"-buffer to be used. * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Return value * Number of bytes which have been stored in the "Down"-buffer. * * Notes * (1) Data is stored according to buffer flags. * (2) For performance reasons this function does not call Init() * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. * * Additional information * This function must not be called when J-Link might also do RTT. */ unsigned SEGGER_RTT_WriteDownBufferNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { unsigned Status; unsigned Avail; const char* pData; SEGGER_RTT_BUFFER_UP* pRing; // // Get "to-target" ring buffer. // It is save to cast that to a "to-host" buffer. Up and Down buffer differ in volatility of offsets that might be modified by J-Link. // pData = (const char *)pBuffer; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // How we output depends upon the mode... // switch (pRing->Flags) { case SEGGER_RTT_MODE_NO_BLOCK_SKIP: // // If we are in skip mode and there is no space for the whole // of this output, don't bother. // Avail = _GetAvailWriteSpace(pRing); if (Avail < NumBytes) { Status = 0u; } else { Status = NumBytes; _WriteNoCheck(pRing, pData, NumBytes); } break; case SEGGER_RTT_MODE_NO_BLOCK_TRIM: // // If we are in trim mode, trim to what we can output without blocking. // Avail = _GetAvailWriteSpace(pRing); Status = Avail < NumBytes ? Avail : NumBytes; _WriteNoCheck(pRing, pData, Status); break; case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL: // // If we are in blocking mode, output everything. // Status = _WriteBlocking(pRing, pData, NumBytes); break; default: Status = 0u; break; } // // Finish up. // return Status; } /********************************************************************* * * SEGGER_RTT_WriteNoLock * * Function description * Stores a specified number of characters in SEGGER RTT * control block which is then read by the host. * SEGGER_RTT_WriteNoLock does not lock the application. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Return value * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) Data is stored according to buffer flags. * (2) For performance reasons this function does not call Init() * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. */ unsigned SEGGER_RTT_WriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { unsigned Status; unsigned Avail; const char* pData; SEGGER_RTT_BUFFER_UP* pRing; // // Get "to-host" ring buffer. // pData = (const char *)pBuffer; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // How we output depends upon the mode... // switch (pRing->Flags) { case SEGGER_RTT_MODE_NO_BLOCK_SKIP: // // If we are in skip mode and there is no space for the whole // of this output, don't bother. // Avail = _GetAvailWriteSpace(pRing); if (Avail < NumBytes) { Status = 0u; } else { Status = NumBytes; _WriteNoCheck(pRing, pData, NumBytes); } break; case SEGGER_RTT_MODE_NO_BLOCK_TRIM: // // If we are in trim mode, trim to what we can output without blocking. // Avail = _GetAvailWriteSpace(pRing); Status = Avail < NumBytes ? Avail : NumBytes; _WriteNoCheck(pRing, pData, Status); break; case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL: // // If we are in blocking mode, output everything. // Status = _WriteBlocking(pRing, pData, NumBytes); break; default: Status = 0u; break; } // // Finish up. // return Status; } /********************************************************************* * * SEGGER_RTT_WriteDownBuffer * * Function description * Stores a specified number of characters in SEGGER RTT control block in a <Down> buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Return value * Number of bytes which have been stored in the "Down"-buffer. * * Notes * (1) Data is stored according to buffer flags. * * Additional information * This function must not be called when J-Link might also do RTT. * This function locks against all other RTT operations. I.e. during * the write operation, writing from the application is also locked. * If only one consumer writes to the down buffer, * call SEGGER_RTT_WriteDownBufferNoLock() instead. */ unsigned SEGGER_RTT_WriteDownBuffer(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { unsigned Status; INIT(); SEGGER_RTT_LOCK(); Status = SEGGER_RTT_WriteDownBufferNoLock(BufferIndex, pBuffer, NumBytes); // Call the non-locking write function SEGGER_RTT_UNLOCK(); return Status; } /********************************************************************* * * SEGGER_RTT_Write * * Function description * Stores a specified number of characters in SEGGER RTT * control block which is then read by the host. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * * Return value * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) Data is stored according to buffer flags. */ unsigned SEGGER_RTT_Write(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { unsigned Status; INIT(); SEGGER_RTT_LOCK(); Status = SEGGER_RTT_WriteNoLock(BufferIndex, pBuffer, NumBytes); // Call the non-locking write function SEGGER_RTT_UNLOCK(); return Status; } /********************************************************************* * * SEGGER_RTT_WriteString * * Function description * Stores string in SEGGER RTT control block. * This data is read by the host. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * s Pointer to string. * * Return value * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) Data is stored according to buffer flags. * (2) String passed to this function has to be \0 terminated * (3) \0 termination character is *not* stored in RTT buffer */ unsigned SEGGER_RTT_WriteString(unsigned BufferIndex, const char* s) { unsigned Len; Len = STRLEN(s); return SEGGER_RTT_Write(BufferIndex, s, Len); } /********************************************************************* * * SEGGER_RTT_PutCharSkipNoLock * * Function description * Stores a single character/byte in SEGGER RTT buffer. * SEGGER_RTT_PutCharSkipNoLock does not lock the application and * skips the byte, if it does not fit into the buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * c Byte to be stored. * * Return value * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) If there is not enough space in the "Up"-buffer, the character is dropped. * (2) For performance reasons this function does not call Init() * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. */ unsigned SEGGER_RTT_PutCharSkipNoLock(unsigned BufferIndex, char c) { SEGGER_RTT_BUFFER_UP* pRing; unsigned WrOff; unsigned Status; volatile char* pDst; // // Get "to-host" ring buffer. // pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // Get write position and handle wrap-around if necessary // WrOff = pRing->WrOff + 1; if (WrOff == pRing->SizeOfBuffer) { WrOff = 0; } // // Output byte if free space is available // if (WrOff != pRing->RdOff) { pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; *pDst = c; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff; Status = 1; } else { Status = 0; } // return Status; } /********************************************************************* * * SEGGER_RTT_PutCharSkip * * Function description * Stores a single character/byte in SEGGER RTT buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * c Byte to be stored. * * Return value * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) If there is not enough space in the "Up"-buffer, the character is dropped. */ unsigned SEGGER_RTT_PutCharSkip(unsigned BufferIndex, char c) { SEGGER_RTT_BUFFER_UP* pRing; unsigned WrOff; unsigned Status; volatile char* pDst; // // Prepare // INIT(); SEGGER_RTT_LOCK(); // // Get "to-host" ring buffer. // pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // Get write position and handle wrap-around if necessary // WrOff = pRing->WrOff + 1; if (WrOff == pRing->SizeOfBuffer) { WrOff = 0; } // // Output byte if free space is available // if (WrOff != pRing->RdOff) { pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; *pDst = c; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff; Status = 1; } else { Status = 0; } // // Finish up. // SEGGER_RTT_UNLOCK(); // return Status; } /********************************************************************* * * SEGGER_RTT_PutChar * * Function description * Stores a single character/byte in SEGGER RTT buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * c Byte to be stored. * * Return value * Number of bytes which have been stored in the "Up"-buffer. * * Notes * (1) Data is stored according to buffer flags. */ unsigned SEGGER_RTT_PutChar(unsigned BufferIndex, char c) { SEGGER_RTT_BUFFER_UP* pRing; unsigned WrOff; unsigned Status; volatile char* pDst; // // Prepare // INIT(); SEGGER_RTT_LOCK(); // // Get "to-host" ring buffer. // pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // Get write position and handle wrap-around if necessary // WrOff = pRing->WrOff + 1; if (WrOff == pRing->SizeOfBuffer) { WrOff = 0; } // // Wait for free space if mode is set to blocking // if (pRing->Flags == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) { while (WrOff == pRing->RdOff) { ; } } // // Output byte if free space is available // if (WrOff != pRing->RdOff) { pDst = (pRing->pBuffer + pRing->WrOff) + SEGGER_RTT_UNCACHED_OFF; *pDst = c; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses pRing->WrOff = WrOff; Status = 1; } else { Status = 0; } // // Finish up. // SEGGER_RTT_UNLOCK(); return Status; } /********************************************************************* * * SEGGER_RTT_GetKey * * Function description * Reads one character from the SEGGER RTT buffer. * Host has previously stored data there. * * Return value * < 0 - No character available (buffer empty). * >= 0 - Character which has been read. (Possible values: 0 - 255) * * Notes * (1) This function is only specified for accesses to RTT buffer 0. */ int SEGGER_RTT_GetKey(void) { char c; int r; r = (int)SEGGER_RTT_Read(0u, &c, 1u); if (r == 1) { r = (int)(unsigned char)c; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_WaitKey * * Function description * Waits until at least one character is avaible in the SEGGER RTT buffer. * Once a character is available, it is read and this function returns. * * Return value * >=0 - Character which has been read. * * Notes * (1) This function is only specified for accesses to RTT buffer 0 * (2) This function is blocking if no character is present in RTT buffer */ int SEGGER_RTT_WaitKey(void) { int r; do { r = SEGGER_RTT_GetKey(); } while (r < 0); return r; } /********************************************************************* * * SEGGER_RTT_HasKey * * Function description * Checks if at least one character for reading is available in the SEGGER RTT buffer. * * Return value * == 0 - No characters are available to read. * == 1 - At least one character is available. * * Notes * (1) This function is only specified for accesses to RTT buffer 0 */ int SEGGER_RTT_HasKey(void) { SEGGER_RTT_BUFFER_DOWN* pRing; unsigned RdOff; int r; INIT(); pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[0] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly RdOff = pRing->RdOff; if (RdOff != pRing->WrOff) { r = 1; } else { r = 0; } return r; } /********************************************************************* * * SEGGER_RTT_HasData * * Function description * Check if there is data from the host in the given buffer. * * Return value: * ==0: No data * !=0: Data in buffer * */ unsigned SEGGER_RTT_HasData(unsigned BufferIndex) { SEGGER_RTT_BUFFER_DOWN* pRing; unsigned v; pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly v = pRing->WrOff; return v - pRing->RdOff; } /********************************************************************* * * SEGGER_RTT_HasDataUp * * Function description * Check if there is data remaining to be sent in the given buffer. * * Return value: * ==0: No data * !=0: Data in buffer * */ unsigned SEGGER_RTT_HasDataUp(unsigned BufferIndex) { SEGGER_RTT_BUFFER_UP* pRing; unsigned v; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly v = pRing->RdOff; return pRing->WrOff - v; } /********************************************************************* * * SEGGER_RTT_AllocDownBuffer * * Function description * Run-time configuration of the next down-buffer (H->T). * The next buffer, which is not used yet is configured. * This includes: Buffer address, size, name, flags, ... * * Parameters * sName Pointer to a constant name string. * pBuffer Pointer to a buffer to be used. * BufferSize Size of the buffer. * Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). * * Return value * >= 0 - O.K. Buffer Index * < 0 - Error */ int SEGGER_RTT_AllocDownBuffer(const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { int BufferIndex; volatile SEGGER_RTT_CB* pRTTCB; INIT(); SEGGER_RTT_LOCK(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly BufferIndex = 0; do { if (pRTTCB->aDown[BufferIndex].pBuffer == NULL) { break; } BufferIndex++; } while (BufferIndex < pRTTCB->MaxNumDownBuffers); if (BufferIndex < pRTTCB->MaxNumDownBuffers) { pRTTCB->aDown[BufferIndex].sName = sName; pRTTCB->aDown[BufferIndex].pBuffer = (char*)pBuffer; pRTTCB->aDown[BufferIndex].SizeOfBuffer = BufferSize; pRTTCB->aDown[BufferIndex].RdOff = 0u; pRTTCB->aDown[BufferIndex].WrOff = 0u; pRTTCB->aDown[BufferIndex].Flags = Flags; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses } else { BufferIndex = -1; } SEGGER_RTT_UNLOCK(); return BufferIndex; } /********************************************************************* * * SEGGER_RTT_AllocUpBuffer * * Function description * Run-time configuration of the next up-buffer (T->H). * The next buffer, which is not used yet is configured. * This includes: Buffer address, size, name, flags, ... * * Parameters * sName Pointer to a constant name string. * pBuffer Pointer to a buffer to be used. * BufferSize Size of the buffer. * Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). * * Return value * >= 0 - O.K. Buffer Index * < 0 - Error */ int SEGGER_RTT_AllocUpBuffer(const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { int BufferIndex; volatile SEGGER_RTT_CB* pRTTCB; INIT(); SEGGER_RTT_LOCK(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly BufferIndex = 0; do { if (pRTTCB->aUp[BufferIndex].pBuffer == NULL) { break; } BufferIndex++; } while (BufferIndex < pRTTCB->MaxNumUpBuffers); if (BufferIndex < pRTTCB->MaxNumUpBuffers) { pRTTCB->aUp[BufferIndex].sName = sName; pRTTCB->aUp[BufferIndex].pBuffer = (char*)pBuffer; pRTTCB->aUp[BufferIndex].SizeOfBuffer = BufferSize; pRTTCB->aUp[BufferIndex].RdOff = 0u; pRTTCB->aUp[BufferIndex].WrOff = 0u; pRTTCB->aUp[BufferIndex].Flags = Flags; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses } else { BufferIndex = -1; } SEGGER_RTT_UNLOCK(); return BufferIndex; } /********************************************************************* * * SEGGER_RTT_ConfigUpBuffer * * Function description * Run-time configuration of a specific up-buffer (T->H). * Buffer to be configured is specified by index. * This includes: Buffer address, size, name, flags, ... * * Parameters * BufferIndex Index of the buffer to configure. * sName Pointer to a constant name string. * pBuffer Pointer to a buffer to be used. * BufferSize Size of the buffer. * Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). * * Return value * >= 0 - O.K. * < 0 - Error * * Additional information * Buffer 0 is configured on compile-time. * May only be called once per buffer. * Buffer name and flags can be reconfigured using the appropriate functions. */ int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { int r; volatile SEGGER_RTT_CB* pRTTCB; volatile SEGGER_RTT_BUFFER_UP* pUp; INIT(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { SEGGER_RTT_LOCK(); pUp = &pRTTCB->aUp[BufferIndex]; if (BufferIndex) { pUp->sName = sName; pUp->pBuffer = (char*)pBuffer; pUp->SizeOfBuffer = BufferSize; pUp->RdOff = 0u; pUp->WrOff = 0u; } pUp->Flags = Flags; SEGGER_RTT_UNLOCK(); r = 0; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_ConfigDownBuffer * * Function description * Run-time configuration of a specific down-buffer (H->T). * Buffer to be configured is specified by index. * This includes: Buffer address, size, name, flags, ... * * Parameters * BufferIndex Index of the buffer to configure. * sName Pointer to a constant name string. * pBuffer Pointer to a buffer to be used. * BufferSize Size of the buffer. * Flags Operating modes. Define behavior if buffer is full (not enough space for entire message). * * Return value * >= 0 O.K. * < 0 Error * * Additional information * Buffer 0 is configured on compile-time. * May only be called once per buffer. * Buffer name and flags can be reconfigured using the appropriate functions. */ int SEGGER_RTT_ConfigDownBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { int r; volatile SEGGER_RTT_CB* pRTTCB; volatile SEGGER_RTT_BUFFER_DOWN* pDown; INIT(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { SEGGER_RTT_LOCK(); pDown = &pRTTCB->aDown[BufferIndex]; if (BufferIndex) { pDown->sName = sName; pDown->pBuffer = (char*)pBuffer; pDown->SizeOfBuffer = BufferSize; pDown->RdOff = 0u; pDown->WrOff = 0u; } pDown->Flags = Flags; RTT__DMB(); // Force data write to be complete before writing the <WrOff>, in case CPU is allowed to change the order of memory accesses SEGGER_RTT_UNLOCK(); r = 0; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_SetNameUpBuffer * * Function description * Run-time configuration of a specific up-buffer name (T->H). * Buffer to be configured is specified by index. * * Parameters * BufferIndex Index of the buffer to renamed. * sName Pointer to a constant name string. * * Return value * >= 0 O.K. * < 0 Error */ int SEGGER_RTT_SetNameUpBuffer(unsigned BufferIndex, const char* sName) { int r; volatile SEGGER_RTT_CB* pRTTCB; volatile SEGGER_RTT_BUFFER_UP* pUp; INIT(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { SEGGER_RTT_LOCK(); pUp = &pRTTCB->aUp[BufferIndex]; pUp->sName = sName; SEGGER_RTT_UNLOCK(); r = 0; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_SetNameDownBuffer * * Function description * Run-time configuration of a specific Down-buffer name (T->H). * Buffer to be configured is specified by index. * * Parameters * BufferIndex Index of the buffer to renamed. * sName Pointer to a constant name string. * * Return value * >= 0 O.K. * < 0 Error */ int SEGGER_RTT_SetNameDownBuffer(unsigned BufferIndex, const char* sName) { int r; volatile SEGGER_RTT_CB* pRTTCB; volatile SEGGER_RTT_BUFFER_DOWN* pDown; INIT(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { SEGGER_RTT_LOCK(); pDown = &pRTTCB->aDown[BufferIndex]; pDown->sName = sName; SEGGER_RTT_UNLOCK(); r = 0; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_SetFlagsUpBuffer * * Function description * Run-time configuration of specific up-buffer flags (T->H). * Buffer to be configured is specified by index. * * Parameters * BufferIndex Index of the buffer. * Flags Flags to set for the buffer. * * Return value * >= 0 O.K. * < 0 Error */ int SEGGER_RTT_SetFlagsUpBuffer(unsigned BufferIndex, unsigned Flags) { int r; volatile SEGGER_RTT_CB* pRTTCB; volatile SEGGER_RTT_BUFFER_UP* pUp; INIT(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) { SEGGER_RTT_LOCK(); pUp = &pRTTCB->aUp[BufferIndex]; pUp->Flags = Flags; SEGGER_RTT_UNLOCK(); r = 0; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_SetFlagsDownBuffer * * Function description * Run-time configuration of specific Down-buffer flags (T->H). * Buffer to be configured is specified by index. * * Parameters * BufferIndex Index of the buffer to renamed. * Flags Flags to set for the buffer. * * Return value * >= 0 O.K. * < 0 Error */ int SEGGER_RTT_SetFlagsDownBuffer(unsigned BufferIndex, unsigned Flags) { int r; volatile SEGGER_RTT_CB* pRTTCB; volatile SEGGER_RTT_BUFFER_DOWN* pDown; INIT(); pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) { SEGGER_RTT_LOCK(); pDown = &pRTTCB->aDown[BufferIndex]; pDown->Flags = Flags; SEGGER_RTT_UNLOCK(); r = 0; } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_Init * * Function description * Initializes the RTT Control Block. * Should be used in RAM targets, at start of the application. * */ void SEGGER_RTT_Init (void) { _DoInit(); } /********************************************************************* * * SEGGER_RTT_SetTerminal * * Function description * Sets the terminal to be used for output on channel 0. * * Parameters * TerminalId Index of the terminal. * * Return value * >= 0 O.K. * < 0 Error (e.g. if RTT is configured for non-blocking mode and there was no space in the buffer to set the new terminal Id) * * Notes * (1) Buffer 0 is always reserved for terminal I/O, so we can use index 0 here, fixed */ int SEGGER_RTT_SetTerminal (unsigned char TerminalId) { unsigned char ac[2]; SEGGER_RTT_BUFFER_UP* pRing; unsigned Avail; int r; INIT(); r = 0; ac[0] = 0xFFu; if (TerminalId < sizeof(_aTerminalId)) { // We only support a certain number of channels ac[1] = _aTerminalId[TerminalId]; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[0] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly SEGGER_RTT_LOCK(); // Lock to make sure that no other task is writing into buffer, while we are and number of free bytes in buffer does not change downwards after checking and before writing if ((pRing->Flags & SEGGER_RTT_MODE_MASK) == SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL) { _ActiveTerminal = TerminalId; _WriteBlocking(pRing, (const char*)ac, 2u); } else { // Skipping mode or trim mode? => We cannot trim this command so handling is the same for both modes Avail = _GetAvailWriteSpace(pRing); if (Avail >= 2) { _ActiveTerminal = TerminalId; // Only change active terminal in case of success _WriteNoCheck(pRing, (const char*)ac, 2u); } else { r = -1; } } SEGGER_RTT_UNLOCK(); } else { r = -1; } return r; } /********************************************************************* * * SEGGER_RTT_TerminalOut * * Function description * Writes a string to the given terminal * without changing the terminal for channel 0. * * Parameters * TerminalId Index of the terminal. * s String to be printed on the terminal. * * Return value * >= 0 - Number of bytes written. * < 0 - Error. * */ int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s) { int Status; unsigned FragLen; unsigned Avail; SEGGER_RTT_BUFFER_UP* pRing; // INIT(); // // Validate terminal ID. // if (TerminalId < (char)sizeof(_aTerminalId)) { // We only support a certain number of channels // // Get "to-host" ring buffer. // pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[0] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly // // Need to be able to change terminal, write data, change back. // Compute the fixed and variable sizes. // FragLen = STRLEN(s); // // How we output depends upon the mode... // SEGGER_RTT_LOCK(); Avail = _GetAvailWriteSpace(pRing); switch (pRing->Flags & SEGGER_RTT_MODE_MASK) { case SEGGER_RTT_MODE_NO_BLOCK_SKIP: // // If we are in skip mode and there is no space for the whole // of this output, don't bother switching terminals at all. // if (Avail < (FragLen + 4u)) { Status = 0; } else { _PostTerminalSwitch(pRing, TerminalId); Status = (int)_WriteBlocking(pRing, s, FragLen); _PostTerminalSwitch(pRing, _ActiveTerminal); } break; case SEGGER_RTT_MODE_NO_BLOCK_TRIM: // // If we are in trim mode and there is not enough space for everything, // trim the output but always include the terminal switch. If no room // for terminal switch, skip that totally. // if (Avail < 4u) { Status = -1; } else { _PostTerminalSwitch(pRing, TerminalId); Status = (int)_WriteBlocking(pRing, s, (FragLen < (Avail - 4u)) ? FragLen : (Avail - 4u)); _PostTerminalSwitch(pRing, _ActiveTerminal); } break; case SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL: // // If we are in blocking mode, output everything. // _PostTerminalSwitch(pRing, TerminalId); Status = (int)_WriteBlocking(pRing, s, FragLen); _PostTerminalSwitch(pRing, _ActiveTerminal); break; default: Status = -1; break; } // // Finish up. // SEGGER_RTT_UNLOCK(); } else { Status = -1; } return Status; } /********************************************************************* * * SEGGER_RTT_GetAvailWriteSpace * * Function description * Returns the number of bytes available in the ring buffer. * * Parameters * BufferIndex Index of the up buffer. * * Return value * Number of bytes that are free in the selected up buffer. */ unsigned SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex) { SEGGER_RTT_BUFFER_UP* pRing; pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF); // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly return _GetAvailWriteSpace(pRing); } /********************************************************************* * * SEGGER_RTT_GetBytesInBuffer() * * Function description * Returns the number of bytes currently used in the up buffer. * * Parameters * BufferIndex Index of the up buffer. * * Return value * Number of bytes that are used in the buffer. */ unsigned SEGGER_RTT_GetBytesInBuffer(unsigned BufferIndex) { unsigned RdOff; unsigned WrOff; unsigned r; volatile SEGGER_RTT_CB* pRTTCB; // // Avoid warnings regarding volatile access order. It's not a problem // in this case, but dampen compiler enthusiasm. // pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly RdOff = pRTTCB->aUp[BufferIndex].RdOff; WrOff = pRTTCB->aUp[BufferIndex].WrOff; if (RdOff <= WrOff) { r = WrOff - RdOff; } else { r = pRTTCB->aUp[BufferIndex].SizeOfBuffer - (WrOff - RdOff); } return r; } /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_RTT.c
C
apache-2.0
74,188
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** ---------------------------END-OF-HEADER------------------------------ File : SEGGER_RTT.h Purpose : Implementation of SEGGER real-time transfer which allows real-time communication on targets which support debugger memory accesses while the CPU is running. Revision: $Rev: 20869 $ ---------------------------------------------------------------------- */ #ifndef SEGGER_RTT_H #define SEGGER_RTT_H #include "SEGGER_RTT_Conf.h" /********************************************************************* * * Defines, defaults * ********************************************************************** */ #ifndef RTT_USE_ASM #if (defined __SES_ARM) // SEGGER Embedded Studio #define _CC_HAS_RTT_ASM_SUPPORT 1 #elif (defined __CROSSWORKS_ARM) // Rowley Crossworks #define _CC_HAS_RTT_ASM_SUPPORT 1 #elif (defined __ARMCC_VERSION) // ARM compiler #if (__ARMCC_VERSION >= 6000000) // ARM compiler V6.0 and later is clang based #define _CC_HAS_RTT_ASM_SUPPORT 1 #else #define _CC_HAS_RTT_ASM_SUPPORT 0 #endif #elif (defined __GNUC__) // GCC #define _CC_HAS_RTT_ASM_SUPPORT 1 #elif (defined __clang__) // Clang compiler #define _CC_HAS_RTT_ASM_SUPPORT 1 #elif ((defined __IASMARM__) || (defined __ICCARM__)) // IAR assembler/compiler #define _CC_HAS_RTT_ASM_SUPPORT 1 #else #define _CC_HAS_RTT_ASM_SUPPORT 0 #endif #if ((defined __IASMARM__) || (defined __ICCARM__)) // IAR assembler/compiler // // IAR assembler / compiler // #if (__VER__ < 6300000) #define VOLATILE #else #define VOLATILE volatile #endif #if (defined __ARM7M__) // Needed for old versions that do not know the define yet #if (__CORE__ == __ARM7M__) // Cortex-M3 #define _CORE_HAS_RTT_ASM_SUPPORT 1 #endif #endif #if (defined __ARM7EM__) // Needed for old versions that do not know the define yet #if (__CORE__ == __ARM7EM__) // Cortex-M4/M7 #define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_NEEDS_DMB 1 #define RTT__DMB() asm VOLATILE ("DMB"); #endif #endif #if (defined __ARM8M_BASELINE__) // Needed for old versions that do not know the define yet #if (__CORE__ == __ARM8M_BASELINE__) // Cortex-M23 #define _CORE_HAS_RTT_ASM_SUPPORT 0 #define _CORE_NEEDS_DMB 1 #define RTT__DMB() asm VOLATILE ("DMB"); #endif #endif #if (defined __ARM8M_MAINLINE__) // Needed for old versions that do not know the define yet #if (__CORE__ == __ARM8M_MAINLINE__) // Cortex-M33 #define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_NEEDS_DMB 1 #define RTT__DMB() asm VOLATILE ("DMB"); #endif #endif #else // // GCC / Clang // #if (defined __ARM_ARCH_7M__) // Cortex-M3 #define _CORE_HAS_RTT_ASM_SUPPORT 1 #elif (defined __ARM_ARCH_7EM__) // Cortex-M4/M7 #define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_NEEDS_DMB 1 #define RTT__DMB() __asm volatile ("dmb\n" : : :); #elif (defined __ARM_ARCH_8M_BASE__) // Cortex-M23 #define _CORE_HAS_RTT_ASM_SUPPORT 0 #define _CORE_NEEDS_DMB 1 #define RTT__DMB() __asm volatile ("dmb\n" : : :); #elif (defined __ARM_ARCH_8M_MAIN__) // Cortex-M33 #define _CORE_HAS_RTT_ASM_SUPPORT 1 #define _CORE_NEEDS_DMB 1 #define RTT__DMB() __asm volatile ("dmb\n" : : :); #else #define _CORE_HAS_RTT_ASM_SUPPORT 0 #endif #endif // // If IDE and core support the ASM version, enable ASM version by default // #ifndef _CORE_HAS_RTT_ASM_SUPPORT #define _CORE_HAS_RTT_ASM_SUPPORT 0 // Default for unknown cores #endif #if (_CC_HAS_RTT_ASM_SUPPORT && _CORE_HAS_RTT_ASM_SUPPORT) #define RTT_USE_ASM (1) #else #define RTT_USE_ASM (0) #endif #endif // // We need to know if a DMB is needed to make sure that on Cortex-M7 etc. // the order of accesses to the ring buffers is guaranteed // Needed for: Cortex-M7, Cortex-M23, Cortex-M33 // #ifndef _CORE_NEEDS_DMB #define _CORE_NEEDS_DMB 0 #endif #ifndef RTT__DMB #if _CORE_NEEDS_DMB #error "Don't know how to place inline assembly for DMB" #else #define RTT__DMB() #endif #endif #ifndef SEGGER_RTT_CPU_CACHE_LINE_SIZE #define SEGGER_RTT_CPU_CACHE_LINE_SIZE (0) // On most target systems where RTT is used, we do not have a CPU cache, therefore 0 is a good default here #endif #ifndef SEGGER_RTT_UNCACHED_OFF #if SEGGER_RTT_CPU_CACHE_LINE_SIZE // #error "SEGGER_RTT_UNCACHED_OFF must be defined when setting SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #else #define SEGGER_RTT_UNCACHED_OFF (0) #endif #endif #if RTT_USE_ASM #if SEGGER_RTT_CPU_CACHE_LINE_SIZE // #error "RTT_USE_ASM is not available if SEGGER_RTT_CPU_CACHE_LINE_SIZE != 0" #endif #endif #ifndef SEGGER_RTT_ASM // defined when SEGGER_RTT.h is included from assembly file #include <stdlib.h> #include <stdarg.h> /********************************************************************* * * Defines, fixed * ********************************************************************** */ // // Determine how much we must pad the control block to make it a multiple of a cache line in size // Assuming: U8 = 1B // U16 = 2B // U32 = 4B // U8/U16/U32* = 4B // #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (NumBytes) /* #if SEGGER_RTT_CPU_CACHE_LINE_SIZE // Avoid division by zero in case we do not have any cache #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (((NumBytes + SEGGER_RTT_CPU_CACHE_LINE_SIZE - 1) / SEGGER_RTT_CPU_CACHE_LINE_SIZE) * SEGGER_RTT_CPU_CACHE_LINE_SIZE) #else #define SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(NumBytes) (NumBytes) #endif */ #define SEGGER_RTT__CB_SIZE (16 + 4 + 4 + (SEGGER_RTT_MAX_NUM_UP_BUFFERS * 24) + (SEGGER_RTT_MAX_NUM_DOWN_BUFFERS * 24)) #define SEGGER_RTT__CB_PADDING (SEGGER_RTT__ROUND_UP_2_CACHE_LINE_SIZE(SEGGER_RTT__CB_SIZE) - SEGGER_RTT__CB_SIZE) /********************************************************************* * * Types * ********************************************************************** */ // // Description for a circular buffer (also called "ring buffer") // which is used as up-buffer (T->H) // typedef struct { const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4" char* pBuffer; // Pointer to start of buffer unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty. unsigned WrOff; // Position of next item to be written by either target. volatile unsigned RdOff; // Position of next item to be read by host. Must be volatile since it may be modified by host. unsigned Flags; // Contains configuration flags } SEGGER_RTT_BUFFER_UP; // // Description for a circular buffer (also called "ring buffer") // which is used as down-buffer (H->T) // typedef struct { const char* sName; // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4" char* pBuffer; // Pointer to start of buffer unsigned SizeOfBuffer; // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty. volatile unsigned WrOff; // Position of next item to be written by host. Must be volatile since it may be modified by host. unsigned RdOff; // Position of next item to be read by target (down-buffer). unsigned Flags; // Contains configuration flags } SEGGER_RTT_BUFFER_DOWN; // // RTT control block which describes the number of buffers available // as well as the configuration for each buffer // // typedef struct { char acID[16]; // Initialized to "SEGGER RTT" int MaxNumUpBuffers; // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2) int MaxNumDownBuffers; // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2) SEGGER_RTT_BUFFER_UP aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS]; // Up buffers, transferring information up from target via debug probe to host SEGGER_RTT_BUFFER_DOWN aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS]; // Down buffers, transferring information down from host via debug probe to target #if SEGGER_RTT__CB_PADDING unsigned char aDummy[SEGGER_RTT__CB_PADDING]; #endif } SEGGER_RTT_CB; /********************************************************************* * * Global data * ********************************************************************** */ extern SEGGER_RTT_CB _SEGGER_RTT; /********************************************************************* * * RTT API functions * ********************************************************************** */ #ifdef __cplusplus extern "C" { #endif int SEGGER_RTT_AllocDownBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_AllocUpBuffer (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_ConfigUpBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_ConfigDownBuffer (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags); int SEGGER_RTT_GetKey (void); unsigned SEGGER_RTT_HasData (unsigned BufferIndex); int SEGGER_RTT_HasKey (void); unsigned SEGGER_RTT_HasDataUp (unsigned BufferIndex); void SEGGER_RTT_Init (void); unsigned SEGGER_RTT_Read (unsigned BufferIndex, void* pBuffer, unsigned BufferSize); unsigned SEGGER_RTT_ReadNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize); int SEGGER_RTT_SetNameDownBuffer (unsigned BufferIndex, const char* sName); int SEGGER_RTT_SetNameUpBuffer (unsigned BufferIndex, const char* sName); int SEGGER_RTT_SetFlagsDownBuffer (unsigned BufferIndex, unsigned Flags); int SEGGER_RTT_SetFlagsUpBuffer (unsigned BufferIndex, unsigned Flags); int SEGGER_RTT_WaitKey (void); unsigned SEGGER_RTT_Write (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_ASM_WriteSkipNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteString (unsigned BufferIndex, const char* s); void SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_PutChar (unsigned BufferIndex, char c); unsigned SEGGER_RTT_PutCharSkip (unsigned BufferIndex, char c); unsigned SEGGER_RTT_PutCharSkipNoLock (unsigned BufferIndex, char c); unsigned SEGGER_RTT_GetAvailWriteSpace (unsigned BufferIndex); unsigned SEGGER_RTT_GetBytesInBuffer (unsigned BufferIndex); // // Function macro for performance optimization // #define SEGGER_RTT_HASDATA(n) (((SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) #if RTT_USE_ASM #define SEGGER_RTT_WriteSkipNoLock SEGGER_RTT_ASM_WriteSkipNoLock #endif /********************************************************************* * * RTT transfer functions to send RTT data via other channels. * ********************************************************************** */ unsigned SEGGER_RTT_ReadUpBuffer (unsigned BufferIndex, void* pBuffer, unsigned BufferSize); unsigned SEGGER_RTT_ReadUpBufferNoLock (unsigned BufferIndex, void* pData, unsigned BufferSize); unsigned SEGGER_RTT_WriteDownBuffer (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); unsigned SEGGER_RTT_WriteDownBufferNoLock (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes); #define SEGGER_RTT_HASDATA_UP(n) (((SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->WrOff - ((SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[n] + SEGGER_RTT_UNCACHED_OFF))->RdOff) // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly /********************************************************************* * * RTT "Terminal" API functions * ********************************************************************** */ int SEGGER_RTT_SetTerminal (unsigned char TerminalId); int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s); /********************************************************************* * * RTT printf functions (require SEGGER_RTT_printf.c) * ********************************************************************** */ int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...); int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList); #ifdef __cplusplus } #endif #endif // ifndef(SEGGER_RTT_ASM) /********************************************************************* * * Defines * ********************************************************************** */ // // Operating modes. Define behavior if buffer is full (not enough space for entire message) // #define SEGGER_RTT_MODE_NO_BLOCK_SKIP (0) // Skip. Do not block, output nothing. (Default) #define SEGGER_RTT_MODE_NO_BLOCK_TRIM (1) // Trim: Do not block, output as much as fits. #define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL (2) // Block: Wait until there is space in the buffer. #define SEGGER_RTT_MODE_MASK (3) // // Control sequences, based on ANSI. // Can be used to control color, and clear the screen // #define RTT_CTRL_RESET "\x1B[0m" // Reset to default colors #define RTT_CTRL_CLEAR "\x1B[2J" // Clear screen, reposition cursor to top left #define RTT_CTRL_TEXT_BLACK "\x1B[2;30m" #define RTT_CTRL_TEXT_RED "\x1B[2;31m" #define RTT_CTRL_TEXT_GREEN "\x1B[2;32m" #define RTT_CTRL_TEXT_YELLOW "\x1B[2;33m" #define RTT_CTRL_TEXT_BLUE "\x1B[2;34m" #define RTT_CTRL_TEXT_MAGENTA "\x1B[2;35m" #define RTT_CTRL_TEXT_CYAN "\x1B[2;36m" #define RTT_CTRL_TEXT_WHITE "\x1B[2;37m" #define RTT_CTRL_TEXT_BRIGHT_BLACK "\x1B[1;30m" #define RTT_CTRL_TEXT_BRIGHT_RED "\x1B[1;31m" #define RTT_CTRL_TEXT_BRIGHT_GREEN "\x1B[1;32m" #define RTT_CTRL_TEXT_BRIGHT_YELLOW "\x1B[1;33m" #define RTT_CTRL_TEXT_BRIGHT_BLUE "\x1B[1;34m" #define RTT_CTRL_TEXT_BRIGHT_MAGENTA "\x1B[1;35m" #define RTT_CTRL_TEXT_BRIGHT_CYAN "\x1B[1;36m" #define RTT_CTRL_TEXT_BRIGHT_WHITE "\x1B[1;37m" #define RTT_CTRL_BG_BLACK "\x1B[24;40m" #define RTT_CTRL_BG_RED "\x1B[24;41m" #define RTT_CTRL_BG_GREEN "\x1B[24;42m" #define RTT_CTRL_BG_YELLOW "\x1B[24;43m" #define RTT_CTRL_BG_BLUE "\x1B[24;44m" #define RTT_CTRL_BG_MAGENTA "\x1B[24;45m" #define RTT_CTRL_BG_CYAN "\x1B[24;46m" #define RTT_CTRL_BG_WHITE "\x1B[24;47m" #define RTT_CTRL_BG_BRIGHT_BLACK "\x1B[4;40m" #define RTT_CTRL_BG_BRIGHT_RED "\x1B[4;41m" #define RTT_CTRL_BG_BRIGHT_GREEN "\x1B[4;42m" #define RTT_CTRL_BG_BRIGHT_YELLOW "\x1B[4;43m" #define RTT_CTRL_BG_BRIGHT_BLUE "\x1B[4;44m" #define RTT_CTRL_BG_BRIGHT_MAGENTA "\x1B[4;45m" #define RTT_CTRL_BG_BRIGHT_CYAN "\x1B[4;46m" #define RTT_CTRL_BG_BRIGHT_WHITE "\x1B[4;47m" #endif /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_RTT.h
C
apache-2.0
20,668
/********************************************************************* * (c) SEGGER Microcontroller GmbH * * The Embedded Experts * * www.segger.com * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_RTT_ASM_ARMv7M.S Purpose : Assembler implementation of RTT functions for ARMv7M Additional information: This module is written to be assembler-independent and works with GCC and clang (Embedded Studio) and IAR. */ #define SEGGER_RTT_ASM // Used to control processed input from header file #include "SEGGER_RTT.h" /********************************************************************* * * Defines, fixed * ********************************************************************** */ #define _CCIAR 0 #define _CCCLANG 1 #if (defined __SES_ARM) || (defined __GNUC__) || (defined __clang__) #define _CC_TYPE _CCCLANG #define _PUB_SYM .global #define _EXT_SYM .extern #define _END .end #define _WEAK .weak #define _THUMB_FUNC .thumb_func #define _THUMB_CODE .code 16 #define _WORD .word #define _SECTION(Sect, Type, AlignExp) .section Sect ##, "ax" #define _ALIGN(Exp) .align Exp #define _PLACE_LITS .ltorg #define _DATA_SECT_START #define _C_STARTUP _start #define _STACK_END __stack_end__ #define _RAMFUNC // // .text => Link to flash // .fast => Link to RAM // OtherSect => Usually link to RAM // Alignment is 2^x // #elif defined (__IASMARM__) #define _CC_TYPE _CCIAR #define _PUB_SYM PUBLIC #define _EXT_SYM EXTERN #define _END END #define _WEAK _WEAK #define _THUMB_FUNC #define _THUMB_CODE THUMB #define _WORD DCD #define _SECTION(Sect, Type, AlignExp) SECTION Sect ## : ## Type ## :REORDER:NOROOT ## (AlignExp) #define _ALIGN(Exp) alignrom Exp #define _PLACE_LITS #define _DATA_SECT_START DATA #define _C_STARTUP __iar_program_start #define _STACK_END sfe(CSTACK) #define _RAMFUNC SECTION_TYPE SHT_PROGBITS, SHF_WRITE | SHF_EXECINSTR // // .text => Link to flash // .textrw => Link to RAM // OtherSect => Usually link to RAM // NOROOT => Allows linker to throw away the function, if not referenced // Alignment is 2^x // #endif #if (_CC_TYPE == _CCIAR) NAME SEGGER_RTT_ASM_ARMv7M #else .syntax unified #endif #if defined (RTT_USE_ASM) && (RTT_USE_ASM == 1) #define SHT_PROGBITS 0x1 /********************************************************************* * * Public / external symbols * ********************************************************************** */ _EXT_SYM __aeabi_memcpy _EXT_SYM __aeabi_memcpy4 _EXT_SYM _SEGGER_RTT _PUB_SYM SEGGER_RTT_ASM_WriteSkipNoLock /********************************************************************* * * SEGGER_RTT_WriteSkipNoLock * * Function description * Stores a specified number of characters in SEGGER RTT * control block which is then read by the host. * SEGGER_RTT_WriteSkipNoLock does not lock the application and * skips all data, if the data does not fit into the buffer. * * Parameters * BufferIndex Index of "Up"-buffer to be used (e.g. 0 for "Terminal"). * pBuffer Pointer to character array. Does not need to point to a \0 terminated string. * NumBytes Number of bytes to be stored in the SEGGER RTT control block. * MUST be > 0!!! * This is done for performance reasons, so no initial check has do be done. * * Return value * 1: Data has been copied * 0: No space, data has not been copied * * Notes * (1) If there is not enough space in the "Up"-buffer, all data is dropped. * (2) For performance reasons this function does not call Init() * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. */ _SECTION(.text, CODE, 2) _ALIGN(2) _THUMB_FUNC SEGGER_RTT_ASM_WriteSkipNoLock: // unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pData, unsigned NumBytes) { // // Cases: // 1) RdOff <= WrOff => Space until wrap-around is sufficient // 2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks) // 3) RdOff < WrOff => No space in buf // 4) RdOff > WrOff => Space is sufficient // 5) RdOff > WrOff => No space in buf // // 1) is the most common case for large buffers and assuming that J-Link reads the data fast enough // // Register usage: // R0 Temporary needed as RdOff, <Tmp> register later on // R1 pData // R2 <NumBytes> // R3 <Tmp> register. Hold free for subroutine calls // R4 <Rem> // R5 pRing->pBuffer // R6 pRing (Points to active struct SEGGER_RTT_BUFFER_DOWN) // R7 WrOff // PUSH {R4-R7} ADD R3,R0,R0, LSL #+1 LDR.W R0,=_SEGGER_RTT // pRing = &_SEGGER_RTT.aUp[BufferIndex]; ADD R0,R0,R3, LSL #+3 ADD R6,R0,#+24 LDR R0,[R6, #+16] // RdOff = pRing->RdOff; LDR R7,[R6, #+12] // WrOff = pRing->WrOff; LDR R5,[R6, #+4] // pRing->pBuffer CMP R7,R0 BCC.N _CheckCase4 // if (RdOff <= WrOff) { => Case 1), 2) or 3) // // Handling for case 1, later on identical to case 4 // LDR R3,[R6, #+8] // Avail = pRing->SizeOfBuffer - WrOff - 1u; => Space until wrap-around (assume 1 byte not usable for case that RdOff == 0) SUBS R4,R3,R7 // <Rem> (Used in case we jump into case 2 afterwards) SUBS R3,R4,#+1 // <Avail> CMP R3,R2 BCC.N _CheckCase2 // if (Avail >= NumBytes) { => Case 1)? _Case4: ADDS R5,R7,R5 // pBuffer += WrOff ADDS R0,R2,R7 // v = WrOff + NumBytes // // 2x unrolling for the copy loop that is used most of the time // This is a special optimization for small SystemView packets and makes them even faster // _ALIGN(2) _LoopCopyStraight: // memcpy(pRing->pBuffer + WrOff, pData, NumBytes); LDRB R3,[R1], #+1 STRB R3,[R5], #+1 // *pDest++ = *pSrc++ SUBS R2,R2,#+1 BEQ _CSDone LDRB R3,[R1], #+1 STRB R3,[R5], #+1 // *pDest++ = *pSrc++ SUBS R2,R2,#+1 BNE _LoopCopyStraight _CSDone: #if _CORE_NEEDS_DMB // Do not slow down cores that do not need a DMB instruction here DMB // Cortex-M7 may delay memory writes and also change the order in which the writes happen. Therefore, make sure that all buffer writes are finished, before updating the <WrOff> in the struct #endif STR R0,[R6, #+12] // pRing->WrOff = WrOff + NumBytes; MOVS R0,#+1 POP {R4-R7} BX LR // Return 1 _CheckCase2: ADDS R0,R0,R3 // Avail += RdOff; => Space incl. wrap-around CMP R0,R2 BCC.N _Case3 // if (Avail >= NumBytes) { => Case 2? => If not, we have case 3) (does not fit) // // Handling for case 2 // ADDS R0,R7,R5 // v = pRing->pBuffer + WrOff => Do not change pRing->pBuffer here because 2nd chunk needs org. value SUBS R2,R2,R4 // NumBytes -= Rem; (Rem = pRing->SizeOfBuffer - WrOff; => Space until end of buffer) _LoopCopyBeforeWrapAround: // memcpy(pRing->pBuffer + WrOff, pData, Rem); => Copy 1st chunk LDRB R3,[R1], #+1 STRB R3,[R0], #+1 // *pDest++ = *pSrc++ SUBS R4,R4,#+1 BNE _LoopCopyBeforeWrapAround // // Special case: First check that assumed RdOff == 0 calculated that last element before wrap-around could not be used // But 2nd check (considering space until wrap-around and until RdOff) revealed that RdOff is not 0, so we can use the last element // In this case, we may use a copy straight until buffer end anyway without needing to copy 2 chunks // Therefore, check if 2nd memcpy is necessary at all // ADDS R4,R2,#+0 // Save <NumBytes> (needed as counter in loop but must be written to <WrOff> after the loop). Also use this inst to update the flags to skip 2nd loop if possible BEQ.N _No2ChunkNeeded // if (NumBytes) { _LoopCopyAfterWrapAround: // memcpy(pRing->pBuffer, pData + Rem, NumBytes); LDRB R3,[R1], #+1 // pData already points to the next src byte due to copy loop increment before this loop STRB R3,[R5], #+1 // *pDest++ = *pSrc++ SUBS R2,R2,#+1 BNE _LoopCopyAfterWrapAround _No2ChunkNeeded: #if _CORE_NEEDS_DMB // Do not slow down cores that do not need a DMB instruction here DMB // Cortex-M7 may delay memory writes and also change the order in which the writes happen. Therefore, make sure that all buffer writes are finished, before updating the <WrOff> in the struct #endif STR R4,[R6, #+12] // pRing->WrOff = NumBytes; => Must be written after copying data because J-Link may read control block asynchronously while writing into buffer MOVS R0,#+1 POP {R4-R7} BX LR // Return 1 _CheckCase4: SUBS R0,R0,R7 SUBS R0,R0,#+1 // Avail = RdOff - WrOff - 1u; CMP R0,R2 BCS.N _Case4 // if (Avail >= NumBytes) { => Case 4) == 1) ? => If not, we have case 5) == 3) (does not fit) _Case3: MOVS R0,#+0 POP {R4-R7} BX LR // Return 0 _PLACE_LITS #endif // defined (RTT_USE_ASM) && (RTT_USE_ASM == 1) _END /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_RTT_ASM_ARMv7M.S
Unix Assembly
apache-2.0
11,352
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** ---------------------------END-OF-HEADER------------------------------ File : SEGGER_RTT_printf.c Purpose : Replacement for printf to write formatted data via RTT Revision: $Rev: 17697 $ ---------------------------------------------------------------------- */ #include "SEGGER_RTT.h" #include "SEGGER_RTT_Conf.h" /********************************************************************* * * Defines, configurable * ********************************************************************** */ #ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE #define SEGGER_RTT_PRINTF_BUFFER_SIZE (64) #endif #include <stdlib.h> #include <stdarg.h> #define FORMAT_FLAG_LEFT_JUSTIFY (1u << 0) #define FORMAT_FLAG_PAD_ZERO (1u << 1) #define FORMAT_FLAG_PRINT_SIGN (1u << 2) #define FORMAT_FLAG_ALTERNATE (1u << 3) /********************************************************************* * * Types * ********************************************************************** */ typedef struct { char* pBuffer; unsigned BufferSize; unsigned Cnt; int ReturnValue; unsigned RTTBufferIndex; } SEGGER_RTT_PRINTF_DESC; /********************************************************************* * * Function prototypes * ********************************************************************** */ /********************************************************************* * * Static code * ********************************************************************** */ /********************************************************************* * * _StoreChar */ static void _StoreChar(SEGGER_RTT_PRINTF_DESC * p, char c) { unsigned Cnt; Cnt = p->Cnt; if ((Cnt + 1u) <= p->BufferSize) { *(p->pBuffer + Cnt) = c; p->Cnt = Cnt + 1u; p->ReturnValue++; } // // Write part of string, when the buffer is full // if (p->Cnt == p->BufferSize) { if (SEGGER_RTT_Write(p->RTTBufferIndex, p->pBuffer, p->Cnt) != p->Cnt) { p->ReturnValue = -1; } else { p->Cnt = 0u; } } } /********************************************************************* * * _PrintUnsigned */ static void _PrintUnsigned(SEGGER_RTT_PRINTF_DESC * pBufferDesc, unsigned v, unsigned Base, unsigned NumDigits, unsigned FieldWidth, unsigned FormatFlags) { static const char _aV2C[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; unsigned Div; unsigned Digit; unsigned Number; unsigned Width; char c; Number = v; Digit = 1u; // // Get actual field width // Width = 1u; while (Number >= Base) { Number = (Number / Base); Width++; } if (NumDigits > Width) { Width = NumDigits; } // // Print leading chars if necessary // if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u) { if (FieldWidth != 0u) { if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && (NumDigits == 0u)) { c = '0'; } else { c = ' '; } while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, c); if (pBufferDesc->ReturnValue < 0) { break; } } } } if (pBufferDesc->ReturnValue >= 0) { // // Compute Digit. // Loop until Digit has the value of the highest digit required. // Example: If the output is 345 (Base 10), loop 2 times until Digit is 100. // while (1) { if (NumDigits > 1u) { // User specified a min number of digits to print? => Make sure we loop at least that often, before checking anything else (> 1 check avoids problems with NumDigits being signed / unsigned) NumDigits--; } else { Div = v / Digit; if (Div < Base) { // Is our divider big enough to extract the highest digit from value? => Done break; } } Digit *= Base; } // // Output digits // do { Div = v / Digit; v -= Div * Digit; _StoreChar(pBufferDesc, _aV2C[Div]); if (pBufferDesc->ReturnValue < 0) { break; } Digit /= Base; } while (Digit); // // Print trailing spaces if necessary // if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == FORMAT_FLAG_LEFT_JUSTIFY) { if (FieldWidth != 0u) { while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, ' '); if (pBufferDesc->ReturnValue < 0) { break; } } } } } } /********************************************************************* * * _PrintInt */ static void _PrintInt(SEGGER_RTT_PRINTF_DESC * pBufferDesc, int v, unsigned Base, unsigned NumDigits, unsigned FieldWidth, unsigned FormatFlags) { unsigned Width; int Number; Number = (v < 0) ? -v : v; // // Get actual field width // Width = 1u; while (Number >= (int)Base) { Number = (Number / (int)Base); Width++; } if (NumDigits > Width) { Width = NumDigits; } if ((FieldWidth > 0u) && ((v < 0) || ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN))) { FieldWidth--; } // // Print leading spaces if necessary // if ((((FormatFlags & FORMAT_FLAG_PAD_ZERO) == 0u) || (NumDigits != 0u)) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u)) { if (FieldWidth != 0u) { while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, ' '); if (pBufferDesc->ReturnValue < 0) { break; } } } } // // Print sign if necessary // if (pBufferDesc->ReturnValue >= 0) { if (v < 0) { v = -v; _StoreChar(pBufferDesc, '-'); } else if ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN) { _StoreChar(pBufferDesc, '+'); } else { } if (pBufferDesc->ReturnValue >= 0) { // // Print leading zeros if necessary // if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u) && (NumDigits == 0u)) { if (FieldWidth != 0u) { while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, '0'); if (pBufferDesc->ReturnValue < 0) { break; } } } } if (pBufferDesc->ReturnValue >= 0) { // // Print number without sign // _PrintUnsigned(pBufferDesc, (unsigned)v, Base, NumDigits, FieldWidth, FormatFlags); } } } } /********************************************************************* * * Public code * ********************************************************************** */ /********************************************************************* * * SEGGER_RTT_vprintf * * Function description * Stores a formatted string in SEGGER RTT control block. * This data is read by the host. * * Parameters * BufferIndex Index of "Up"-buffer to be used. (e.g. 0 for "Terminal") * sFormat Pointer to format string * pParamList Pointer to the list of arguments for the format string * * Return values * >= 0: Number of bytes which have been stored in the "Up"-buffer. * < 0: Error */ int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList) { char c; SEGGER_RTT_PRINTF_DESC BufferDesc; int v; unsigned NumDigits; unsigned FormatFlags; unsigned FieldWidth; char acBuffer[SEGGER_RTT_PRINTF_BUFFER_SIZE]; BufferDesc.pBuffer = acBuffer; BufferDesc.BufferSize = SEGGER_RTT_PRINTF_BUFFER_SIZE; BufferDesc.Cnt = 0u; BufferDesc.RTTBufferIndex = BufferIndex; BufferDesc.ReturnValue = 0; do { c = *sFormat; sFormat++; if (c == 0u) { break; } if (c == '%') { // // Filter out flags // FormatFlags = 0u; v = 1; do { c = *sFormat; switch (c) { case '-': FormatFlags |= FORMAT_FLAG_LEFT_JUSTIFY; sFormat++; break; case '0': FormatFlags |= FORMAT_FLAG_PAD_ZERO; sFormat++; break; case '+': FormatFlags |= FORMAT_FLAG_PRINT_SIGN; sFormat++; break; case '#': FormatFlags |= FORMAT_FLAG_ALTERNATE; sFormat++; break; default: v = 0; break; } } while (v); // // filter out field with // FieldWidth = 0u; do { c = *sFormat; if ((c < '0') || (c > '9')) { break; } sFormat++; FieldWidth = (FieldWidth * 10u) + ((unsigned)c - '0'); } while (1); // // Filter out precision (number of digits to display) // NumDigits = 0u; c = *sFormat; if (c == '.') { sFormat++; do { c = *sFormat; if ((c < '0') || (c > '9')) { break; } sFormat++; NumDigits = NumDigits * 10u + ((unsigned)c - '0'); } while (1); } // // Filter out length modifier // c = *sFormat; do { if ((c == 'l') || (c == 'h')) { sFormat++; c = *sFormat; } else { break; } } while (1); // // Handle specifiers // switch (c) { case 'c': { char c0; v = va_arg(*pParamList, int); c0 = (char)v; _StoreChar(&BufferDesc, c0); break; } case 'd': v = va_arg(*pParamList, int); _PrintInt(&BufferDesc, v, 10u, NumDigits, FieldWidth, FormatFlags); break; case 'u': v = va_arg(*pParamList, int); _PrintUnsigned(&BufferDesc, (unsigned)v, 10u, NumDigits, FieldWidth, FormatFlags); break; case 'x': case 'X': v = va_arg(*pParamList, int); _PrintUnsigned(&BufferDesc, (unsigned)v, 16u, NumDigits, FieldWidth, FormatFlags); break; case 's': { const char * s = va_arg(*pParamList, const char *); do { c = *s; s++; if (c == '\0') { break; } _StoreChar(&BufferDesc, c); } while (BufferDesc.ReturnValue >= 0); } break; case 'p': v = va_arg(*pParamList, int); _PrintUnsigned(&BufferDesc, (unsigned)v, 16u, 8u, 8u, 0u); break; case '%': _StoreChar(&BufferDesc, '%'); break; default: break; } sFormat++; } else { _StoreChar(&BufferDesc, c); } } while (BufferDesc.ReturnValue >= 0); if (BufferDesc.ReturnValue > 0) { // // Write remaining data, if any // if (BufferDesc.Cnt != 0u) { SEGGER_RTT_Write(BufferIndex, acBuffer, BufferDesc.Cnt); } BufferDesc.ReturnValue += (int)BufferDesc.Cnt; } return BufferDesc.ReturnValue; } /********************************************************************* * * SEGGER_RTT_printf * * Function description * Stores a formatted string in SEGGER RTT control block. * This data is read by the host. * * Parameters * BufferIndex Index of "Up"-buffer to be used. (e.g. 0 for "Terminal") * sFormat Pointer to format string, followed by the arguments for conversion * * Return values * >= 0: Number of bytes which have been stored in the "Up"-buffer. * < 0: Error * * Notes * (1) Conversion specifications have following syntax: * %[flags][FieldWidth][.Precision]ConversionSpecifier * (2) Supported flags: * -: Left justify within the field width * +: Always print sign extension for signed conversions * 0: Pad with 0 instead of spaces. Ignored when using '-'-flag or precision * Supported conversion specifiers: * c: Print the argument as one char * d: Print the argument as a signed integer * u: Print the argument as an unsigned integer * x: Print the argument as an hexadecimal integer * s: Print the string pointed to by the argument * p: Print the argument as an 8-digit hexadecimal integer. (Argument shall be a pointer to void.) */ int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...) { int r; va_list ParamList; va_start(ParamList, sFormat); r = SEGGER_RTT_vprintf(BufferIndex, sFormat, &ParamList); va_end(ParamList); return r; } /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_RTT_printf.c
C
apache-2.0
16,335
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW.c Purpose : System visualization API implementation. Revision: $Rev: 22278 $ Additional information: Packet format: Packets with IDs 0..23 are standard packets with known structure. For efficiency, they do *NOT* contain a length field. <ID><Data><TimeStampDelta> Packets with IDs 24..31 are standard packets with extendible structure and contain a length field. <ID><Lenght><Data><TimeStampDelta> Packet ID 31 is used for SystemView extended events. <ID><Lenght><ID_EX><Data><TimeStampDelta> Packets with IDs >= 32 always contain a length field. <ID><Length><Data><TimeStampDelta> Packet IDs: 0.. 31 : Standard packets, known by SystemView. 32..1023 : OS-definable packets, described in a SystemView description file. 1024..2047 : User-definable packets, described in a SystemView description file. 2048..32767: Undefined. Data encoding: Basic types (int, short, char, ...): Basic types are encoded little endian with most-significant bit variant encoding. Each encoded byte contains 7 data bits [6:0] and the MSB continuation bit. The continuation bit indicates whether the next byte belongs to the data (bit set) or this is the last byte (bit clear). The most significant bits of data are encoded first, proceeding to the least significant bits in the final byte (little endian). Example encoding: Data: 0x1F4 (500) Encoded: 0xF4 (First 7 data bits 74 | Continuation bit) 0x03 (Second 7 data bits 03, no continuation) Data: 0xFFFFFFFF Encoded: 0xFF 0xFF 0xFF 0xFF 0x0F Data: 0xA2 (162), 0x03 (3), 0x7000 Encoded: 0xA2 0x01 0x03 0x80 0xE0 0x01 Byte arrays and strings: Byte arrays and strings are encoded as <NumBytes> followed by the raw data. NumBytes is encoded as a basic type with a theoretical maximum of 4G. Example encoding: Data: "Hello World\0" (0x48 0x65 0x6C 0x6C 0x6F 0x20 0x57 0x6F 0x72 0x6C 0x64 0x00) Encoded: 0x0B 0x48 0x65 0x6C 0x6C 0x6F 0x20 0x57 0x6F 0x72 0x6C 0x64 Examples packets: 01 F4 03 80 80 10 // Overflow packet. Data is a single U32. This packet means: 500 packets lost, Timestamp is 0x40000 02 0F 50 // ISR(15) Enter. Timestamp 80 (0x50) 03 20 // ISR Exit. Timestamp 32 (0x20) (Shortest possible packet.) Sample code for user defined Packets: #define MY_ID 0x400 // Any value between 0x400 and 0x7FF void SendMyPacket(unsigned Para0, unsigned Para1, const char* s) { U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + MAX_STR_LEN + 1]; U8* pPayload; // pPayload = SEGGER_SYSVIEW_PPREPARE_PACKET(aPacket); // Prepare the packet for SystemView pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para0); // Add the first parameter to the packet pPayload = SEGGER_SYSVIEW_EncodeU32(pPayload, Para1); // Add the second parameter to the packet pPayload = SEGGER_SYSVIEW_EncodeString(pPayload, s, MAX_STR_LEN); // Add the string to the packet // SEGGER_SYSVIEW_SendPacket(&aPacket[0], pPayload, MY_ID); // Send the packet with EventId = MY_ID } #define MY_ID_1 0x401 void SendOnePara(unsigned Para0) { SEGGER_SYSVIEW_RecordU32(MY_ID_1, Para0); } */ /********************************************************************* * * #include section * ********************************************************************** */ #define SEGGER_SYSVIEW_C // For EXTERN statements in SEGGER_SYSVIEW.h #include <string.h> #include <stdlib.h> #include <stdarg.h> #include "SEGGER_SYSVIEW_Int.h" #include "SEGGER_RTT.h" /********************************************************************* * * Defines, fixed * ********************************************************************** */ #if SEGGER_SYSVIEW_ID_SHIFT #define SHRINK_ID(Id) (((Id) - _SYSVIEW_Globals.RAMBaseAddress) >> SEGGER_SYSVIEW_ID_SHIFT) #else #define SHRINK_ID(Id) ((Id) - _SYSVIEW_Globals.RAMBaseAddress) #endif #if SEGGER_SYSVIEW_RTT_CHANNEL > 0 #define CHANNEL_ID_UP SEGGER_SYSVIEW_RTT_CHANNEL #define CHANNEL_ID_DOWN SEGGER_SYSVIEW_RTT_CHANNEL #else #define CHANNEL_ID_UP _SYSVIEW_Globals.UpChannel #define CHANNEL_ID_DOWN _SYSVIEW_Globals.DownChannel #endif #if SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE #if (SEGGER_SYSVIEW_RTT_BUFFER_SIZE % SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE) #error "SEGGER_SYSVIEW_RTT_BUFFER_SIZE must be a multiple of SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE" #endif #endif /********************************************************************* * * Defines, configurable * ********************************************************************** */ // Timestamps may be less than full 32-bits, in which case we need to zero // the unused bits to properly handle overflows. // Note that this is a quite common scenario, as a 32-bit time such as // SysTick might be scaled down to reduce bandwith // or a 16-bit hardware time might be used. #if SEGGER_SYSVIEW_TIMESTAMP_BITS < 32 // Eliminate unused bits in case hardware timestamps are less than 32 bits #define MAKE_DELTA_32BIT(Delta) Delta <<= 32 - SEGGER_SYSVIEW_TIMESTAMP_BITS; \ Delta >>= 32 - SEGGER_SYSVIEW_TIMESTAMP_BITS; #else #define MAKE_DELTA_32BIT(Delta) #endif /********************************************************************* * * Defines, fixed * ********************************************************************** */ #define ENABLE_STATE_OFF 0 #define ENABLE_STATE_ON 1 #define ENABLE_STATE_DROPPING 2 #define FORMAT_FLAG_LEFT_JUSTIFY (1u << 0) #define FORMAT_FLAG_PAD_ZERO (1u << 1) #define FORMAT_FLAG_PRINT_SIGN (1u << 2) #define FORMAT_FLAG_ALTERNATE (1u << 3) #define MODULE_EVENT_OFFSET (512) /********************************************************************* * * Types, local * ********************************************************************** */ typedef struct { U8* pBuffer; U8* pPayload; U8* pPayloadStart; U32 Options; unsigned Cnt; } SEGGER_SYSVIEW_PRINTF_DESC; typedef struct { U8 EnableState; // 0: Disabled, 1: Enabled, (2: Dropping) U8 UpChannel; U8 RecursionCnt; U32 SysFreq; U32 CPUFreq; U32 LastTxTimeStamp; U32 RAMBaseAddress; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) U32 PacketCount; #else U32 DropCount; U8 DownChannel; #endif U32 DisabledEvents; const SEGGER_SYSVIEW_OS_API* pOSAPI; SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC* pfSendSysDesc; } SEGGER_SYSVIEW_GLOBALS; /********************************************************************* * * Function prototypes, required * ********************************************************************** */ static void _SendPacket(U8* pStartPacket, U8* pEndPacket, unsigned int EventId); /********************************************************************* * * Static data * ********************************************************************** */ static const U8 _abSync[10] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; #if SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE #ifdef SEGGER_SYSVIEW_SECTION // // Alignment + special section required // #if (defined __GNUC__) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE))) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE))) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __ICCARM__) || (defined __ICCRX__) #pragma location=SEGGER_SYSVIEW_SECTION #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) #pragma location=SEGGER_SYSVIEW_SECTION #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __CC_ARM) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE), zero_init)) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE), zero_init)) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #else #error "Do not know how to place SystemView buffers in specific section" #endif #else // // Only alignment required // #if (defined __GNUC__) __attribute__ ((aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE))) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE))) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __ICCARM__) || (defined __ICCRX__) #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __CC_ARM) __attribute__ ((aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE), zero_init)) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE), zero_init)) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #else #error "Do not know how to align SystemView buffers to cache line size" #endif #endif #else #ifdef SEGGER_SYSVIEW_SECTION // // Only special section required // #if (defined __GNUC__) __attribute__ ((section (SEGGER_SYSVIEW_SECTION))) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((section (SEGGER_SYSVIEW_SECTION))) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __ICCARM__) || (defined __ICCRX__) #pragma location=SEGGER_SYSVIEW_SECTION static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) #pragma location=SEGGER_SYSVIEW_SECTION static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __CC_ARM) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), zero_init)) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), zero_init)) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #else #error "Do not know how to place SystemView buffers in specific section" #endif #else // // Neither special section nor alignment required // static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #endif #endif #ifdef SEGGER_SYSVIEW_SECTION #if (defined __GNUC__) __attribute__ ((section (SEGGER_SYSVIEW_SECTION))) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((section (SEGGER_SYSVIEW_SECTION))) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #elif (defined __ICCARM__) || (defined __ICCRX__) #pragma location=SEGGER_SYSVIEW_SECTION static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #pragma location=SEGGER_SYSVIEW_SECTION static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #elif (defined __CC_ARM) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), zero_init)) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) __attribute__ ((section (SEGGER_SYSVIEW_SECTION), zero_init)) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #else static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #endif #else #if SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE #if (defined __GNUC__) static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE] __attribute__ ((aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE))); #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) static char _DownBuffer[8] __attribute__ ((aligned (SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE))); // Small, fixed-size buffer, for back-channel comms #endif #elif (defined(__ICCARM__)) #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) #pragma data_alignment=SEGGER_RTT_CPU_CACHE_LINE_SIZE static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #else #error "Don't know how to place _SEGGER_RTT, _acUpBuffer, _acDownBuffer cache-line aligned" #endif #else static char _UpBuffer [SEGGER_SYSVIEW_RTT_BUFFER_SIZE]; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) static char _DownBuffer[8]; // Small, fixed-size buffer, for back-channel comms #endif #endif #endif static SEGGER_SYSVIEW_GLOBALS _SYSVIEW_Globals; static SEGGER_SYSVIEW_MODULE* _pFirstModule; static U8 _NumModules; /********************************************************************* * * Static code * ********************************************************************** */ #define ENCODE_U32(pDest, Value) { \ U8* pSysviewPointer; \ U32 SysViewData; \ pSysviewPointer = pDest; \ SysViewData = Value; \ while(SysViewData > 0x7F) { \ *pSysviewPointer++ = (U8)(SysViewData | 0x80); \ SysViewData >>= 7; \ }; \ *pSysviewPointer++ = (U8)SysViewData; \ pDest = pSysviewPointer; \ }; #if (SEGGER_SYSVIEW_USE_STATIC_BUFFER == 1) static U8 _aPacket[SEGGER_SYSVIEW_MAX_PACKET_SIZE]; #define RECORD_START(PacketSize) SEGGER_SYSVIEW_LOCK(); \ pPayloadStart = _PreparePacket(_aPacket); #define RECORD_END() SEGGER_SYSVIEW_UNLOCK() #else #define RECORD_START(PacketSize) U8 aPacket[(PacketSize)]; \ pPayloadStart = _PreparePacket(aPacket); \ #define RECORD_END() #endif /********************************************************************* * * _EncodeData() * * Function description * Encode a byte buffer in variable-length format. * * Parameters * pPayload - Pointer to where string will be encoded. * pSrc - Pointer to data buffer to be encoded. * NumBytes - Number of bytes in the buffer to be encoded. * * Return value * Pointer to the byte following the value, i.e. the first free * byte in the payload and the next position to store payload * content. * * Additional information * The data is encoded as a count byte followed by the contents * of the data buffer. * Make sure NumBytes + 1 bytes are free for the payload. */ static U8* _EncodeData(U8* pPayload, const char* pSrc, unsigned int NumBytes) { unsigned int n; // n = 0; *pPayload++ = NumBytes; while (n < NumBytes) { *pPayload++ = *pSrc++; n++; } return pPayload; } /********************************************************************* * * _EncodeStr() * * Function description * Encode a string in variable-length format. * * Parameters * pPayload - Pointer to where string will be encoded. * pText - String to encode. * Limit - Maximum number of characters to encode from string. * * Return value * Pointer to the byte following the value, i.e. the first free * byte in the payload and the next position to store payload * content. * * Additional information * The string is encoded as a count byte followed by the contents * of the string. * No more than 1 + Limit bytes will be encoded to the payload. */ static U8 *_EncodeStr(U8 *pPayload, const char *pText, unsigned int Limit) { unsigned int n; unsigned int Len; // // Compute string len // Len = 0; if (pText != NULL) { while(*(pText + Len) != 0) { Len++; } if (Len > Limit) { Len = Limit; } } // // Write Len // if (Len < 255) { *pPayload++ = Len; } else { *pPayload++ = 255; *pPayload++ = (Len & 255); *pPayload++ = ((Len >> 8) & 255); } // // copy string // n = 0; while (n < Len) { *pPayload++ = *pText++; n++; } return pPayload; } /********************************************************************* * * _PreparePacket() * * Function description * Prepare a SystemView event packet header. * * Parameters * pPacket - Pointer to start of packet to initialize. * * Return value * Pointer to first byte of packet payload. * * Additional information * The payload length and evnetId are not initialized. * PreparePacket only reserves space for them and they are * computed and filled in by the sending function. */ static U8* _PreparePacket(U8* pPacket) { return pPacket + 4; } /********************************************************************* * * _HandleIncomingPacket() * * Function description * Read an incoming command from the down channel and process it. * * Additional information * This function is called each time after sending a packet. * Processing incoming packets is done asynchronous. SystemView might * already have sent event packets after the host has sent a command. */ #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) static void _HandleIncomingPacket(void) { U8 Cmd; int Status; // Status = SEGGER_RTT_ReadNoLock(CHANNEL_ID_DOWN, &Cmd, 1); if (Status > 0) { switch (Cmd) { case SEGGER_SYSVIEW_COMMAND_ID_START: SEGGER_SYSVIEW_Start(); break; case SEGGER_SYSVIEW_COMMAND_ID_STOP: SEGGER_SYSVIEW_Stop(); break; case SEGGER_SYSVIEW_COMMAND_ID_GET_SYSTIME: SEGGER_SYSVIEW_RecordSystime(); break; case SEGGER_SYSVIEW_COMMAND_ID_GET_TASKLIST: SEGGER_SYSVIEW_SendTaskList(); break; case SEGGER_SYSVIEW_COMMAND_ID_GET_SYSDESC: SEGGER_SYSVIEW_GetSysDesc(); break; case SEGGER_SYSVIEW_COMMAND_ID_GET_NUMMODULES: SEGGER_SYSVIEW_SendNumModules(); break; case SEGGER_SYSVIEW_COMMAND_ID_GET_MODULEDESC: SEGGER_SYSVIEW_SendModuleDescription(); break; case SEGGER_SYSVIEW_COMMAND_ID_GET_MODULE: Status = SEGGER_RTT_ReadNoLock(CHANNEL_ID_DOWN, &Cmd, 1); if (Status > 0) { SEGGER_SYSVIEW_SendModule(Cmd); } break; case SEGGER_SYSVIEW_COMMAND_ID_HEARTBEAT: break; default: if (Cmd >= 128) { // Unknown extended command. Dummy read its parameter. SEGGER_RTT_ReadNoLock(CHANNEL_ID_DOWN, &Cmd, 1); } break; } } } #endif // (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) /********************************************************************* * * _TrySendOverflowPacket() * * Function description * Try to transmit an SystemView Overflow packet containing the * number of dropped packets. * * Additional information * Format as follows: * 01 <DropCnt><TimeStamp> Max. packet len is 1 + 5 + 5 = 11 * * Example packets sent * 01 20 40 * * Return value * !=0: Success, Message sent (stored in RTT-Buffer) * ==0: Buffer full, Message *NOT* stored * */ #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) static int _TrySendOverflowPacket(void) { U32 TimeStamp; I32 Delta; int Status; U8 aPacket[11]; U8* pPayload; aPacket[0] = SYSVIEW_EVTID_OVERFLOW; // 1 pPayload = &aPacket[1]; ENCODE_U32(pPayload, _SYSVIEW_Globals.DropCount); // // Compute time stamp delta and append it to packet. // TimeStamp = SEGGER_SYSVIEW_GET_TIMESTAMP(); Delta = TimeStamp - _SYSVIEW_Globals.LastTxTimeStamp; MAKE_DELTA_32BIT(Delta); ENCODE_U32(pPayload, Delta); // // Try to store packet in RTT buffer and update time stamp when this was successful // Status = SEGGER_RTT_WriteSkipNoLock(CHANNEL_ID_UP, aPacket, pPayload - aPacket); SEGGER_SYSVIEW_ON_EVENT_RECORDED(pPayload - aPacket); if (Status) { _SYSVIEW_Globals.LastTxTimeStamp = TimeStamp; _SYSVIEW_Globals.EnableState--; // EnableState has been 2, will be 1. Always. } else { _SYSVIEW_Globals.DropCount++; } // return Status; } #endif // (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) /********************************************************************* * * _SendSyncInfo() * * Function description * Send SystemView sync packet and system information in * post mortem mode. * * Additional information * Sync is 10 * 0x00 without timestamp */ #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) static void _SendSyncInfo(void) { // // Add sync packet ( 10 * 0x00) // Send system description // Send system time // Send task list // Send module description // Send module information // SEGGER_RTT_WriteWithOverwriteNoLock(CHANNEL_ID_UP, _abSync, 10); SEGGER_SYSVIEW_ON_EVENT_RECORDED(10); SEGGER_SYSVIEW_RecordVoid(SYSVIEW_EVTID_TRACE_START); { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, _SYSVIEW_Globals.SysFreq); ENCODE_U32(pPayload, _SYSVIEW_Globals.CPUFreq); ENCODE_U32(pPayload, _SYSVIEW_Globals.RAMBaseAddress); ENCODE_U32(pPayload, SEGGER_SYSVIEW_ID_SHIFT); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_INIT); RECORD_END(); } if (_SYSVIEW_Globals.pfSendSysDesc) { _SYSVIEW_Globals.pfSendSysDesc(); } SEGGER_SYSVIEW_RecordSystime(); SEGGER_SYSVIEW_SendTaskList(); if (_NumModules > 0) { int n; SEGGER_SYSVIEW_SendNumModules(); for (n = 0; n < _NumModules; n++) { SEGGER_SYSVIEW_SendModule(n); } SEGGER_SYSVIEW_SendModuleDescription(); } } #endif // (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) /********************************************************************* * * _SendPacket() * * Function description * Send a SystemView packet over RTT. RTT channel and mode are * configured by macros when the SystemView component is initialized. * This function takes care of maintaining the packet drop count * and sending overflow packets when necessary. * The packet must be passed without Id and Length because this * function prepends it to the packet before transmission. * * Parameters * pStartPacket - Pointer to start of packet payload. * There must be at least 4 bytes free to prepend Id and Length. * pEndPacket - Pointer to end of packet payload. * EventId - Id of the event to send. * */ static void _SendPacket(U8* pStartPacket, U8* pEndPacket, unsigned int EventId) { unsigned int NumBytes; U32 TimeStamp; U32 Delta; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) int Status; #endif #if (SEGGER_SYSVIEW_USE_STATIC_BUFFER == 0) SEGGER_SYSVIEW_LOCK(); #endif #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) if (_SYSVIEW_Globals.EnableState == 0) { goto SendDone; } #else if (_SYSVIEW_Globals.EnableState == 1) { // Enabled, no dropped packets remaining goto Send; } if (_SYSVIEW_Globals.EnableState == 0) { goto SendDone; } // // Handle buffer full situations: // Have packets been dropped before because buffer was full? // In this case try to send and overflow packet. // if (_SYSVIEW_Globals.EnableState == 2) { _TrySendOverflowPacket(); if (_SYSVIEW_Globals.EnableState != 1) { goto SendDone; } } Send: #endif // // Check if event is disabled from being recorded. // if (EventId < 32) { if (_SYSVIEW_Globals.DisabledEvents & ((U32)1u << EventId)) { goto SendDone; } } // // Prepare actual packet. // If it is a known packet, prepend eventId only, // otherwise prepend packet length and eventId. // if (EventId < 24) { *--pStartPacket = EventId; } else { NumBytes = pEndPacket - pStartPacket; if (NumBytes > 127) { *--pStartPacket = (NumBytes >> 7); *--pStartPacket = NumBytes | 0x80; } else { *--pStartPacket = NumBytes; } if (EventId > 127) { *--pStartPacket = (EventId >> 7); *--pStartPacket = EventId | 0x80; } else { *--pStartPacket = EventId; } } // // Compute time stamp delta and append it to packet. // TimeStamp = SEGGER_SYSVIEW_GET_TIMESTAMP(); Delta = TimeStamp - _SYSVIEW_Globals.LastTxTimeStamp; MAKE_DELTA_32BIT(Delta); ENCODE_U32(pEndPacket, Delta); #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) // // Store packet in RTT buffer by overwriting old data and update time stamp // SEGGER_RTT_WriteWithOverwriteNoLock(CHANNEL_ID_UP, pStartPacket, pEndPacket - pStartPacket); SEGGER_SYSVIEW_ON_EVENT_RECORDED(pEndPacket - pStartPacket); _SYSVIEW_Globals.LastTxTimeStamp = TimeStamp; #else // // Try to store packet in RTT buffer and update time stamp when this was successful // Status = SEGGER_RTT_WriteSkipNoLock(CHANNEL_ID_UP, pStartPacket, pEndPacket - pStartPacket); SEGGER_SYSVIEW_ON_EVENT_RECORDED(pEndPacket - pStartPacket); if (Status) { _SYSVIEW_Globals.LastTxTimeStamp = TimeStamp; } else { _SYSVIEW_Globals.EnableState++; // EnableState has been 1, will be 2. Always. } #endif #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) // // Add sync and system information periodically if we are in post mortem mode // if (_SYSVIEW_Globals.RecursionCnt == 0) { // Avoid uncontrolled nesting. This way, this routine can call itself once, but no more often than that. _SYSVIEW_Globals.RecursionCnt = 1; if (_SYSVIEW_Globals.PacketCount++ & (1 << SEGGER_SYSVIEW_SYNC_PERIOD_SHIFT)) { _SendSyncInfo(); _SYSVIEW_Globals.PacketCount = 0; } _SYSVIEW_Globals.RecursionCnt = 0; } SendDone: ; // Avoid "label at end of compound statement" error when using static buffer #else SendDone: // // Check if host is sending data which needs to be processed. // Note that since this code is called for every packet, it is very time critical, so we do // only what is really needed here, which is checking if there is any data // if (SEGGER_RTT_HASDATA(CHANNEL_ID_DOWN)) { if (_SYSVIEW_Globals.RecursionCnt == 0) { // Avoid uncontrolled nesting. This way, this routine can call itself once, but no more often than that. _SYSVIEW_Globals.RecursionCnt = 1; _HandleIncomingPacket(); _SYSVIEW_Globals.RecursionCnt = 0; } } #endif // #if (SEGGER_SYSVIEW_USE_STATIC_BUFFER == 0) SEGGER_SYSVIEW_UNLOCK(); // We are done. Unlock and return #endif } #ifndef SEGGER_SYSVIEW_EXCLUDE_PRINTF // Define in project to avoid warnings about variable parameter list /********************************************************************* * * _VPrintHost() * * Function description * Send a format string and its parameters to the host. * * Parameters * s Pointer to format string. * Options Options to be sent to the host. * pParamList Pointer to the list of arguments for the format string. */ static int _VPrintHost(const char* s, U32 Options, va_list* pParamList) { U32 aParas[SEGGER_SYSVIEW_MAX_ARGUMENTS]; U32* pParas; U32 NumArguments; const char* p; char c; U8* pPayload; U8* pPayloadStart; #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT U8 HasNonScalar; HasNonScalar = 0; #endif // // Count number of arguments by counting '%' characters in string. // If enabled, check for non-scalar modifier flags to format string on the target. // p = s; NumArguments = 0; for (;;) { c = *p++; if (c == 0) { break; } if (c == '%') { c = *p; #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT == 0 aParas[NumArguments++] = va_arg(*pParamList, int); if (NumArguments == SEGGER_SYSVIEW_MAX_ARGUMENTS) { break; } #else if (c == 's') { HasNonScalar = 1; break; } else { aParas[NumArguments++] = va_arg(*pParamList, int); if (NumArguments == SEGGER_SYSVIEW_MAX_ARGUMENTS) { break; } } #endif } } #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT if (HasNonScalar) { return -1; } #endif // // Send string and parameters to host // { RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_MAX_STRING_LEN + 2 * SEGGER_SYSVIEW_QUANTA_U32 + SEGGER_SYSVIEW_MAX_ARGUMENTS * SEGGER_SYSVIEW_QUANTA_U32); pPayload = _EncodeStr(pPayloadStart, s, SEGGER_SYSVIEW_MAX_STRING_LEN); ENCODE_U32(pPayload, Options); ENCODE_U32(pPayload, NumArguments); pParas = aParas; while (NumArguments--) { ENCODE_U32(pPayload, (*pParas)); pParas++; } _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_PRINT_FORMATTED); RECORD_END(); } return 0; } /********************************************************************* * * _StoreChar() * * Function description * Stores a character in the printf-buffer and sends the buffer when * it is filled. * * Parameters * p Pointer to the buffer description. * c Character to be printed. */ static void _StoreChar(SEGGER_SYSVIEW_PRINTF_DESC * p, char c) { unsigned int Cnt; U8* pPayload; U32 Options; Cnt = p->Cnt; if ((Cnt + 1u) <= SEGGER_SYSVIEW_MAX_STRING_LEN) { *(p->pPayload++) = c; p->Cnt = Cnt + 1u; } // // Write part of string, when the buffer is full // if (p->Cnt == SEGGER_SYSVIEW_MAX_STRING_LEN) { *(p->pPayloadStart) = p->Cnt; pPayload = p->pPayload; Options = p->Options; ENCODE_U32(pPayload, Options); ENCODE_U32(pPayload, 0); _SendPacket(p->pPayloadStart, pPayload, SYSVIEW_EVTID_PRINT_FORMATTED); p->pPayloadStart = _PreparePacket(p->pBuffer); p->pPayload = p->pPayloadStart + 1u; p->Cnt = 0u; } } /********************************************************************* * * _PrintUnsigned() * * Function description * Print an unsigned integer with the given formatting into the * formatted string. * * Parameters * pBufferDesc Pointer to the buffer description. * v Value to be printed. * Base Base of the value. * NumDigits Number of digits to be printed. * FieldWidth Width of the printed field. * FormatFlags Flags for formatting the value. */ static void _PrintUnsigned(SEGGER_SYSVIEW_PRINTF_DESC * pBufferDesc, unsigned int v, unsigned int Base, unsigned int NumDigits, unsigned int FieldWidth, unsigned int FormatFlags) { static const char _aV2C[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; unsigned int Div; unsigned int Digit; unsigned int Number; unsigned int Width; char c; Number = v; Digit = 1u; // // Get actual field width // Width = 1u; while (Number >= Base) { Number = (Number / Base); Width++; } if (NumDigits > Width) { Width = NumDigits; } // // Print leading chars if necessary // if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u) { if (FieldWidth != 0u) { if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && (NumDigits == 0u)) { c = '0'; } else { c = ' '; } while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, c); } } } // // Compute Digit. // Loop until Digit has the value of the highest digit required. // Example: If the output is 345 (Base 10), loop 2 times until Digit is 100. // while (1) { if (NumDigits > 1u) { // User specified a min number of digits to print? => Make sure we loop at least that often, before checking anything else (> 1 check avoids problems with NumDigits being signed / unsigned) NumDigits--; } else { Div = v / Digit; if (Div < Base) { // Is our divider big enough to extract the highest digit from value? => Done break; } } Digit *= Base; } // // Output digits // do { Div = v / Digit; v -= Div * Digit; _StoreChar(pBufferDesc, _aV2C[Div]); Digit /= Base; } while (Digit); // // Print trailing spaces if necessary // if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == FORMAT_FLAG_LEFT_JUSTIFY) { if (FieldWidth != 0u) { while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, ' '); } } } } /********************************************************************* * * _PrintInt() * * Function description * Print a signed integer with the given formatting into the * formatted string. * * Parameters * pBufferDesc Pointer to the buffer description. * v Value to be printed. * Base Base of the value. * NumDigits Number of digits to be printed. * FieldWidth Width of the printed field. * FormatFlags Flags for formatting the value. */ static void _PrintInt(SEGGER_SYSVIEW_PRINTF_DESC * pBufferDesc, int v, unsigned int Base, unsigned int NumDigits, unsigned int FieldWidth, unsigned int FormatFlags) { unsigned int Width; int Number; Number = (v < 0) ? -v : v; // // Get actual field width // Width = 1u; while (Number >= (int)Base) { Number = (Number / (int)Base); Width++; } if (NumDigits > Width) { Width = NumDigits; } if ((FieldWidth > 0u) && ((v < 0) || ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN))) { FieldWidth--; } // // Print leading spaces if necessary // if ((((FormatFlags & FORMAT_FLAG_PAD_ZERO) == 0u) || (NumDigits != 0u)) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u)) { if (FieldWidth != 0u) { while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, ' '); } } } // // Print sign if necessary // if (v < 0) { v = -v; _StoreChar(pBufferDesc, '-'); } else if ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN) { _StoreChar(pBufferDesc, '+'); } else { } // // Print leading zeros if necessary // if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u) && (NumDigits == 0u)) { if (FieldWidth != 0u) { while ((FieldWidth != 0u) && (Width < FieldWidth)) { FieldWidth--; _StoreChar(pBufferDesc, '0'); } } } // // Print number without sign // _PrintUnsigned(pBufferDesc, (unsigned int)v, Base, NumDigits, FieldWidth, FormatFlags); } /********************************************************************* * * _VPrintTarget() * * Function description * Stores a formatted string. * This data is read by the host. * * Parameters * sFormat Pointer to format string. * Options Options to be sent to the host. * pParamList Pointer to the list of arguments for the format string. */ static void _VPrintTarget(const char* sFormat, U32 Options, va_list* pParamList) { SEGGER_SYSVIEW_PRINTF_DESC BufferDesc; char c; int v; unsigned int NumDigits; unsigned int FormatFlags; unsigned int FieldWidth; U8* pPayloadStart; #if SEGGER_SYSVIEW_USE_STATIC_BUFFER == 0 RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_MAX_STRING_LEN + 1 + 2 * SEGGER_SYSVIEW_QUANTA_U32); SEGGER_SYSVIEW_LOCK(); #else RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_MAX_STRING_LEN + 1 + 2 * SEGGER_SYSVIEW_QUANTA_U32); #endif #if SEGGER_SYSVIEW_USE_STATIC_BUFFER == 0 BufferDesc.pBuffer = aPacket; #else BufferDesc.pBuffer = _aPacket; #endif BufferDesc.Cnt = 0u; BufferDesc.pPayloadStart = pPayloadStart; BufferDesc.pPayload = BufferDesc.pPayloadStart + 1u; BufferDesc.Options = Options; do { c = *sFormat; sFormat++; if (c == 0u) { break; } if (c == '%') { // // Filter out flags // FormatFlags = 0u; v = 1; do { c = *sFormat; switch (c) { case '-': FormatFlags |= FORMAT_FLAG_LEFT_JUSTIFY; sFormat++; break; case '0': FormatFlags |= FORMAT_FLAG_PAD_ZERO; sFormat++; break; case '+': FormatFlags |= FORMAT_FLAG_PRINT_SIGN; sFormat++; break; case '#': FormatFlags |= FORMAT_FLAG_ALTERNATE; sFormat++; break; default: v = 0; break; } } while (v); // // filter out field with // FieldWidth = 0u; do { c = *sFormat; if ((c < '0') || (c > '9')) { break; } sFormat++; FieldWidth = (FieldWidth * 10u) + ((unsigned int)c - '0'); } while (1); // // Filter out precision (number of digits to display) // NumDigits = 0u; c = *sFormat; if (c == '.') { sFormat++; do { c = *sFormat; if ((c < '0') || (c > '9')) { break; } sFormat++; NumDigits = NumDigits * 10u + ((unsigned int)c - '0'); } while (1); } // // Filter out length modifier // c = *sFormat; do { if ((c == 'l') || (c == 'h')) { c = *sFormat; sFormat++; } else { break; } } while (1); // // Handle specifiers // switch (c) { case 'c': { char c0; v = va_arg(*pParamList, int); c0 = (char)v; _StoreChar(&BufferDesc, c0); break; } case 'd': v = va_arg(*pParamList, int); _PrintInt(&BufferDesc, v, 10u, NumDigits, FieldWidth, FormatFlags); break; case 'u': v = va_arg(*pParamList, int); _PrintUnsigned(&BufferDesc, (unsigned int)v, 10u, NumDigits, FieldWidth, FormatFlags); break; case 'x': case 'X': v = va_arg(*pParamList, int); _PrintUnsigned(&BufferDesc, (unsigned int)v, 16u, NumDigits, FieldWidth, FormatFlags); break; case 'p': v = va_arg(*pParamList, int); _PrintUnsigned(&BufferDesc, (unsigned int)v, 16u, 8u, 8u, 0u); break; case '%': _StoreChar(&BufferDesc, '%'); break; default: break; } sFormat++; } else { _StoreChar(&BufferDesc, c); } } while (*sFormat); // // Write remaining data, if any // if (BufferDesc.Cnt != 0u) { *(BufferDesc.pPayloadStart) = BufferDesc.Cnt; ENCODE_U32(BufferDesc.pPayload, BufferDesc.Options); ENCODE_U32(BufferDesc.pPayload, 0); _SendPacket(BufferDesc.pPayloadStart, BufferDesc.pPayload, SYSVIEW_EVTID_PRINT_FORMATTED); } #if SEGGER_SYSVIEW_USE_STATIC_BUFFER == 0 SEGGER_SYSVIEW_UNLOCK(); RECORD_END(); #else RECORD_END(); #endif } #endif // SEGGER_SYSVIEW_EXCLUDE_PRINTF /********************************************************************* * * Public code * ********************************************************************** */ /********************************************************************* * * SEGGER_SYSVIEW_Init() * * Function description * Initializes the SYSVIEW module. * Must be called before the Systemview Application connects to * the system. * * Parameters * SysFreq - Frequency of timestamp, usually CPU core clock frequency. * CPUFreq - CPU core clock frequency. * pOSAPI - Pointer to the API structure for OS-specific functions. * pfSendSysDesc - Pointer to record system description callback function. * * Additional information * This function initializes the RTT channel used to transport * SEGGER SystemView packets. * The channel is assigned the label "SysView" for client software * to identify the SystemView channel. * * The channel is configured with the macro SEGGER_SYSVIEW_RTT_CHANNEL. */ void SEGGER_SYSVIEW_Init(U32 SysFreq, U32 CPUFreq, const SEGGER_SYSVIEW_OS_API *pOSAPI, SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC pfSendSysDesc) { #ifdef SEGGER_RTT_SECTION // // Explicitly initialize the RTT Control Block if it is in its dedicated section. // SEGGER_RTT_Init(); #endif #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) #if SEGGER_SYSVIEW_RTT_CHANNEL > 0 SEGGER_RTT_ConfigUpBuffer(SEGGER_SYSVIEW_RTT_CHANNEL, "SysView", &_UpBuffer[0], sizeof(_UpBuffer), SEGGER_RTT_MODE_NO_BLOCK_SKIP); #else _SYSVIEW_Globals.UpChannel = SEGGER_RTT_AllocUpBuffer ("SysView", &_UpBuffer[0], sizeof(_UpBuffer), SEGGER_RTT_MODE_NO_BLOCK_SKIP); #endif _SYSVIEW_Globals.RAMBaseAddress = SEGGER_SYSVIEW_ID_BASE; _SYSVIEW_Globals.LastTxTimeStamp = SEGGER_SYSVIEW_GET_TIMESTAMP(); _SYSVIEW_Globals.pOSAPI = pOSAPI; _SYSVIEW_Globals.SysFreq = SysFreq; _SYSVIEW_Globals.CPUFreq = CPUFreq; _SYSVIEW_Globals.pfSendSysDesc = pfSendSysDesc; _SYSVIEW_Globals.EnableState = 0; _SYSVIEW_Globals.PacketCount = 0; #else // (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) #if SEGGER_SYSVIEW_RTT_CHANNEL > 0 SEGGER_RTT_ConfigUpBuffer (SEGGER_SYSVIEW_RTT_CHANNEL, "SysView", &_UpBuffer[0], sizeof(_UpBuffer), SEGGER_RTT_MODE_NO_BLOCK_SKIP); SEGGER_RTT_ConfigDownBuffer (SEGGER_SYSVIEW_RTT_CHANNEL, "SysView", &_DownBuffer[0], sizeof(_DownBuffer), SEGGER_RTT_MODE_NO_BLOCK_SKIP); #else _SYSVIEW_Globals.UpChannel = SEGGER_RTT_AllocUpBuffer ("SysView", &_UpBuffer[0], sizeof(_UpBuffer), SEGGER_RTT_MODE_NO_BLOCK_SKIP); _SYSVIEW_Globals.DownChannel = _SYSVIEW_Globals.UpChannel; SEGGER_RTT_ConfigDownBuffer (_SYSVIEW_Globals.DownChannel, "SysView", &_DownBuffer[0], sizeof(_DownBuffer), SEGGER_RTT_MODE_NO_BLOCK_SKIP); #endif _SYSVIEW_Globals.RAMBaseAddress = SEGGER_SYSVIEW_ID_BASE; _SYSVIEW_Globals.LastTxTimeStamp = SEGGER_SYSVIEW_GET_TIMESTAMP(); _SYSVIEW_Globals.pOSAPI = pOSAPI; _SYSVIEW_Globals.SysFreq = SysFreq; _SYSVIEW_Globals.CPUFreq = CPUFreq; _SYSVIEW_Globals.pfSendSysDesc = pfSendSysDesc; _SYSVIEW_Globals.EnableState = 0; #endif // (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) } /********************************************************************* * * SEGGER_SYSVIEW_SetRAMBase() * * Function description * Sets the RAM base address, which is subtracted from IDs in order * to save bandwidth. * * Parameters * RAMBaseAddress - Lowest RAM Address. (i.e. 0x20000000 on most Cortex-M) */ void SEGGER_SYSVIEW_SetRAMBase(U32 RAMBaseAddress) { _SYSVIEW_Globals.RAMBaseAddress = RAMBaseAddress; } /********************************************************************* * * SEGGER_SYSVIEW_RecordVoid() * * Function description * Formats and sends a SystemView packet with an empty payload. * * Parameters * EventID - SystemView event ID. */ void SEGGER_SYSVIEW_RecordVoid(unsigned int EventID) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // _SendPacket(pPayloadStart, pPayloadStart, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_Record_StringU32() * * Function description * Formats and sends a SystemView packet containing a String and U32 * parameter payload. * * Parameters * EventID - SystemView event ID. * pString - The string to be sent in the SystemView packet payload. * Value - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_Record_StringU32(unsigned int EventID, const char* pString, U32 Value) { U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN + SEGGER_SYSVIEW_QUANTA_U32]; U8 *pPayload; pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket); // Prepare the packet for SystemView pPayload = SEGGER_SYSVIEW_EncodeString(pPayload, pString, SEGGER_SYSVIEW_MAX_STRING_LEN); // Add object name ENCODE_U32(pPayload, Value); SEGGER_SYSVIEW_SendPacket(&aPacket[0], pPayload, EventID); // Send the packet } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32() * * Function description * Formats and sends a SystemView packet containing a single U32 * parameter payload. * * Parameters * EventID - SystemView event ID. * Value - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32(unsigned int EventID, U32 Value) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Value); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x2() * * Function description * Formats and sends a SystemView packet containing 2 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x2(unsigned int EventID, U32 Para0, U32 Para1) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x3() * * Function description * Formats and sends a SystemView packet containing 3 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x3(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 3 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x4() * * Function description * Formats and sends a SystemView packet containing 4 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x4(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x5() * * Function description * Formats and sends a SystemView packet containing 5 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. * Para4 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x5(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 5 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); ENCODE_U32(pPayload, Para4); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x6() * * Function description * Formats and sends a SystemView packet containing 6 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. * Para4 - The 32-bit parameter encoded to SystemView packet payload. * Para5 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x6(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 6 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); ENCODE_U32(pPayload, Para4); ENCODE_U32(pPayload, Para5); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x7() * * Function description * Formats and sends a SystemView packet containing 7 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. * Para4 - The 32-bit parameter encoded to SystemView packet payload. * Para5 - The 32-bit parameter encoded to SystemView packet payload. * Para6 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x7(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 7 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); ENCODE_U32(pPayload, Para4); ENCODE_U32(pPayload, Para5); ENCODE_U32(pPayload, Para6); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x8() * * Function description * Formats and sends a SystemView packet containing 8 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. * Para4 - The 32-bit parameter encoded to SystemView packet payload. * Para5 - The 32-bit parameter encoded to SystemView packet payload. * Para6 - The 32-bit parameter encoded to SystemView packet payload. * Para7 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x8(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 8 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); ENCODE_U32(pPayload, Para4); ENCODE_U32(pPayload, Para5); ENCODE_U32(pPayload, Para6); ENCODE_U32(pPayload, Para7); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x9() * * Function description * Formats and sends a SystemView packet containing 9 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. * Para4 - The 32-bit parameter encoded to SystemView packet payload. * Para5 - The 32-bit parameter encoded to SystemView packet payload. * Para6 - The 32-bit parameter encoded to SystemView packet payload. * Para7 - The 32-bit parameter encoded to SystemView packet payload. * Para8 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x9(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 9 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); ENCODE_U32(pPayload, Para4); ENCODE_U32(pPayload, Para5); ENCODE_U32(pPayload, Para6); ENCODE_U32(pPayload, Para7); ENCODE_U32(pPayload, Para8); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordU32x10() * * Function description * Formats and sends a SystemView packet containing 10 U32 parameter payload. * * Parameters * EventID - SystemView event ID. * Para0 - The 32-bit parameter encoded to SystemView packet payload. * Para1 - The 32-bit parameter encoded to SystemView packet payload. * Para2 - The 32-bit parameter encoded to SystemView packet payload. * Para3 - The 32-bit parameter encoded to SystemView packet payload. * Para4 - The 32-bit parameter encoded to SystemView packet payload. * Para5 - The 32-bit parameter encoded to SystemView packet payload. * Para6 - The 32-bit parameter encoded to SystemView packet payload. * Para7 - The 32-bit parameter encoded to SystemView packet payload. * Para8 - The 32-bit parameter encoded to SystemView packet payload. * Para9 - The 32-bit parameter encoded to SystemView packet payload. */ void SEGGER_SYSVIEW_RecordU32x10(unsigned int EventID, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8, U32 Para9) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 10 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, Para0); ENCODE_U32(pPayload, Para1); ENCODE_U32(pPayload, Para2); ENCODE_U32(pPayload, Para3); ENCODE_U32(pPayload, Para4); ENCODE_U32(pPayload, Para5); ENCODE_U32(pPayload, Para6); ENCODE_U32(pPayload, Para7); ENCODE_U32(pPayload, Para8); ENCODE_U32(pPayload, Para9); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordString() * * Function description * Formats and sends a SystemView packet containing a string. * * Parameters * EventID - SystemView event ID. * pString - The string to be sent in the SystemView packet payload. * * Additional information * The string is encoded as a count byte followed by the contents * of the string. * No more than SEGGER_SYSVIEW_MAX_STRING_LEN bytes will be encoded to the payload. */ void SEGGER_SYSVIEW_RecordString(unsigned int EventID, const char* pString) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = _EncodeStr(pPayloadStart, pString, SEGGER_SYSVIEW_MAX_STRING_LEN); _SendPacket(pPayloadStart, pPayload, EventID); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_Start() * * Function description * Start recording SystemView events. * * This function is triggered by the SystemView Application on connect. * For single-shot or post-mortem mode recording, it needs to be called * by the application. * * Additional information * This function enables transmission of SystemView packets recorded * by subsequent trace calls and records a SystemView Start event. * * As part of start, a SystemView Init packet is sent, containing the system * frequency. The list of current tasks, the current system time and the * system description string is sent, too. * * Notes * SEGGER_SYSVIEW_Start and SEGGER_SYSVIEW_Stop do not nest. * When SEGGER_SYSVIEW_CAN_RESTART is 1, each received start command * records the system information. This is required to enable restart * of recordings when SystemView unexpectedly disconnects without sending * a stop command before. */ void SEGGER_SYSVIEW_Start(void) { #if (SEGGER_SYSVIEW_CAN_RESTART == 0) if (_SYSVIEW_Globals.EnableState == 0) { #endif _SYSVIEW_Globals.EnableState = 1; #if (SEGGER_SYSVIEW_POST_MORTEM_MODE == 1) _SendSyncInfo(); #else SEGGER_SYSVIEW_LOCK(); SEGGER_RTT_WriteSkipNoLock(CHANNEL_ID_UP, _abSync, 10); SEGGER_SYSVIEW_UNLOCK(); SEGGER_SYSVIEW_ON_EVENT_RECORDED(10); SEGGER_SYSVIEW_RecordVoid(SYSVIEW_EVTID_TRACE_START); { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, _SYSVIEW_Globals.SysFreq); ENCODE_U32(pPayload, _SYSVIEW_Globals.CPUFreq); ENCODE_U32(pPayload, _SYSVIEW_Globals.RAMBaseAddress); ENCODE_U32(pPayload, SEGGER_SYSVIEW_ID_SHIFT); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_INIT); RECORD_END(); } if (_SYSVIEW_Globals.pfSendSysDesc) { _SYSVIEW_Globals.pfSendSysDesc(); } SEGGER_SYSVIEW_RecordSystime(); SEGGER_SYSVIEW_SendTaskList(); SEGGER_SYSVIEW_SendNumModules(); #endif #if (SEGGER_SYSVIEW_CAN_RESTART == 0) } #endif } /********************************************************************* * * SEGGER_SYSVIEW_Stop() * * Function description * Stop recording SystemView events. * * This function is triggered by the SystemView Application on disconnect. * For single-shot or post-mortem mode recording, it can be called * by the application. * * Additional information * This function disables transmission of SystemView packets recorded * by subsequent trace calls. If transmission is enabled when * this function is called, a single SystemView Stop event is recorded * to the trace, send, and then trace transmission is halted. */ void SEGGER_SYSVIEW_Stop(void) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // if (_SYSVIEW_Globals.EnableState) { _SendPacket(pPayloadStart, pPayloadStart, SYSVIEW_EVTID_TRACE_STOP); _SYSVIEW_Globals.EnableState = 0; } RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_GetChannelID() * * Function description * Returns the RTT <Up> / <Down> channel ID used by SystemView. */ int SEGGER_SYSVIEW_GetChannelID(void) { return CHANNEL_ID_UP; } /********************************************************************* * * SEGGER_SYSVIEW_GetSysDesc() * * Function description * Triggers a send of the system information and description. * */ void SEGGER_SYSVIEW_GetSysDesc(void) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, _SYSVIEW_Globals.SysFreq); ENCODE_U32(pPayload, _SYSVIEW_Globals.CPUFreq); ENCODE_U32(pPayload, _SYSVIEW_Globals.RAMBaseAddress); ENCODE_U32(pPayload, SEGGER_SYSVIEW_ID_SHIFT); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_INIT); RECORD_END(); if (_SYSVIEW_Globals.pfSendSysDesc) { _SYSVIEW_Globals.pfSendSysDesc(); } } /********************************************************************* * * SEGGER_SYSVIEW_SendTaskInfo() * * Function description * Send a Task Info Packet, containing TaskId for identification, * task priority and task name. * * Parameters * pInfo - Pointer to task information to send. */ void SEGGER_SYSVIEW_SendTaskInfo(const SEGGER_SYSVIEW_TASKINFO *pInfo) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32 + 1 + 32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, SHRINK_ID(pInfo->TaskID)); ENCODE_U32(pPayload, pInfo->Prio); pPayload = _EncodeStr(pPayload, pInfo->sName, 32); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TASK_INFO); // pPayload = pPayloadStart; ENCODE_U32(pPayload, SHRINK_ID(pInfo->TaskID)); ENCODE_U32(pPayload, pInfo->StackBase); ENCODE_U32(pPayload, pInfo->StackSize); ENCODE_U32(pPayload, 0); // Stack End, future use _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_STACK_INFO); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_SendTaskList() * * Function description * Send all tasks descriptors to the host. */ void SEGGER_SYSVIEW_SendTaskList(void) { if (_SYSVIEW_Globals.pOSAPI && _SYSVIEW_Globals.pOSAPI->pfSendTaskList) { _SYSVIEW_Globals.pOSAPI->pfSendTaskList(); } } /********************************************************************* * * SEGGER_SYSVIEW_SendSysDesc() * * Function description * Send the system description string to the host. * The system description is used by the Systemview Application * to identify the current application and handle events accordingly. * * The system description is usually called by the system description * callback, to ensure it is only sent when the SystemView Application * is connected. * * Parameters * sSysDesc - Pointer to the 0-terminated system description string. * * Additional information * One system description string may not exceed SEGGER_SYSVIEW_MAX_STRING_LEN characters. * Multiple description strings can be recorded. * * The Following items can be described in a system description string. * Each item is identified by its identifier, followed by '=' and the value. * Items are separated by ','. */ void SEGGER_SYSVIEW_SendSysDesc(const char *sSysDesc) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = _EncodeStr(pPayloadStart, sSysDesc, SEGGER_SYSVIEW_MAX_STRING_LEN); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_SYSDESC); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordSystime() * * Function description * Formats and sends a SystemView Systime containing a single U64 or U32 * parameter payload. */ void SEGGER_SYSVIEW_RecordSystime(void) { U64 Systime; if (_SYSVIEW_Globals.pOSAPI && _SYSVIEW_Globals.pOSAPI->pfGetTime) { Systime = _SYSVIEW_Globals.pOSAPI->pfGetTime(); SEGGER_SYSVIEW_RecordU32x2(SYSVIEW_EVTID_SYSTIME_US, (U32)(Systime), (U32)(Systime >> 32)); } else { SEGGER_SYSVIEW_RecordU32(SYSVIEW_EVTID_SYSTIME_CYCLES, SEGGER_SYSVIEW_GET_TIMESTAMP()); } } /********************************************************************* * * SEGGER_SYSVIEW_RecordEnterISR() * * Function description * Format and send an ISR entry event. * * Additional information * Example packets sent * 02 0F 50 // ISR(15) Enter. Timestamp is 80 (0x50) */ void SEGGER_SYSVIEW_RecordEnterISR(void) { unsigned v; U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; v = SEGGER_SYSVIEW_GET_INTERRUPT_ID(); ENCODE_U32(pPayload, v); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_ISR_ENTER); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordExitISR() * * Function description * Format and send an ISR exit event. * * Additional information * Format as follows: * 03 <TimeStamp> // Max. packet len is 6 * * Example packets sent * 03 20 // ISR Exit. Timestamp is 32 (0x20) */ void SEGGER_SYSVIEW_RecordExitISR(void) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // _SendPacket(pPayloadStart, pPayloadStart, SYSVIEW_EVTID_ISR_EXIT); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordExitISRToScheduler() * * Function description * Format and send an ISR exit into scheduler event. * * Additional information * Format as follows: * 18 <TimeStamp> // Max. packet len is 6 * * Example packets sent * 18 20 // ISR Exit to Scheduler. Timestamp is 32 (0x20) */ void SEGGER_SYSVIEW_RecordExitISRToScheduler(void) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // _SendPacket(pPayloadStart, pPayloadStart, SYSVIEW_EVTID_ISR_TO_SCHEDULER); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordEnterTimer() * * Function description * Format and send a Timer entry event. * * Parameters * TimerId - Id of the timer which starts. */ void SEGGER_SYSVIEW_RecordEnterTimer(U32 TimerId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, SHRINK_ID(TimerId)); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TIMER_ENTER); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordExitTimer() * * Function description * Format and send a Timer exit event. */ void SEGGER_SYSVIEW_RecordExitTimer(void) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // _SendPacket(pPayloadStart, pPayloadStart, SYSVIEW_EVTID_TIMER_EXIT); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordEndCall() * * Function description * Format and send an End API Call event without return value. * * Parameters * EventID - Id of API function which ends. */ void SEGGER_SYSVIEW_RecordEndCall(unsigned int EventID) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, EventID); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_END_CALL); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordEndCallU32() * * Function description * Format and send an End API Call event with return value. * * Parameters * EventID - Id of API function which ends. * Para0 - Return value which will be returned by the API function. */ void SEGGER_SYSVIEW_RecordEndCallU32(unsigned int EventID, U32 Para0) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, EventID); ENCODE_U32(pPayload, Para0); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_END_CALL); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnIdle() * * Function description * Record an Idle event. */ void SEGGER_SYSVIEW_OnIdle(void) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // _SendPacket(pPayloadStart, pPayloadStart, SYSVIEW_EVTID_IDLE); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnTaskCreate() * * Function description * Record a Task Create event. The Task Create event corresponds * to creating a task in the OS. * * Parameters * TaskId - Task ID of created task. */ void SEGGER_SYSVIEW_OnTaskCreate(U32 TaskId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; TaskId = SHRINK_ID(TaskId); ENCODE_U32(pPayload, TaskId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TASK_CREATE); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnTaskTerminate() * * Function description * Record a Task termination event. * The Task termination event corresponds to terminating a task in * the OS. If the TaskId is the currently active task, * SEGGER_SYSVIEW_OnTaskStopExec may be used, either. * * Parameters * TaskId - Task ID of terminated task. */ void SEGGER_SYSVIEW_OnTaskTerminate(U32 TaskId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; TaskId = SHRINK_ID(TaskId); ENCODE_U32(pPayload, TaskId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TASK_TERMINATE); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnTaskStartExec() * * Function description * Record a Task Start Execution event. The Task Start event * corresponds to when a task has started to execute rather than * when it is ready to execute. * * Parameters * TaskId - Task ID of task that started to execute. */ void SEGGER_SYSVIEW_OnTaskStartExec(U32 TaskId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; TaskId = SHRINK_ID(TaskId); ENCODE_U32(pPayload, TaskId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TASK_START_EXEC); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnTaskStopExec() * * Function description * Record a Task Stop Execution event. The Task Stop event * corresponds to when a task stops executing and terminates. */ void SEGGER_SYSVIEW_OnTaskStopExec(void) { U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE); // _SendPacket(pPayloadStart, pPayloadStart, SYSVIEW_EVTID_TASK_STOP_EXEC); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnTaskStartReady() * * Function description * Record a Task Start Ready event. * * Parameters * TaskId - Task ID of task that started to execute. */ void SEGGER_SYSVIEW_OnTaskStartReady(U32 TaskId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; TaskId = SHRINK_ID(TaskId); ENCODE_U32(pPayload, TaskId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TASK_START_READY); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_OnTaskStopReady() * * Function description * Record a Task Stop Ready event. * * Parameters * TaskId - Task ID of task that completed execution. * Cause - Reason for task to stop (i.e. Idle/Sleep) */ void SEGGER_SYSVIEW_OnTaskStopReady(U32 TaskId, unsigned int Cause) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; TaskId = SHRINK_ID(TaskId); ENCODE_U32(pPayload, TaskId); ENCODE_U32(pPayload, Cause); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_TASK_STOP_READY); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_MarkStart() * * Function description * Record a Performance Marker Start event to start measuring runtime. * * Parameters * MarkerId - User defined ID for the marker. */ void SEGGER_SYSVIEW_MarkStart(unsigned MarkerId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, MarkerId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_MARK_START); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_MarkStop() * * Function description * Record a Performance Marker Stop event to stop measuring runtime. * * Parameters * MarkerId - User defined ID for the marker. */ void SEGGER_SYSVIEW_MarkStop(unsigned MarkerId) { U8 * pPayload; U8 * pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, MarkerId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_MARK_STOP); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_Mark() * * Function description * Record a Performance Marker intermediate event. * * Parameters * MarkerId - User defined ID for the marker. */ void SEGGER_SYSVIEW_Mark(unsigned int MarkerId) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32); // pPayload = pPayloadStart; ENCODE_U32(pPayload, SYSVIEW_EVTID_EX_MARK); ENCODE_U32(pPayload, MarkerId); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_EX); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_NameMarker() * * Function description * Send the name of a Performance Marker to be displayed in SystemView. * * Marker names are usually set in the system description * callback, to ensure it is only sent when the SystemView Application * is connected. * * Parameters * MarkerId - User defined ID for the marker. * sName - Pointer to the marker name. (Max. SEGGER_SYSVIEW_MAX_STRING_LEN Bytes) */ void SEGGER_SYSVIEW_NameMarker(unsigned int MarkerId, const char* sName) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = pPayloadStart; ENCODE_U32(pPayload, SYSVIEW_EVTID_EX_NAME_MARKER); ENCODE_U32(pPayload, MarkerId); pPayload = _EncodeStr(pPayload, sName, SEGGER_SYSVIEW_MAX_STRING_LEN); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_EX); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_NameResource() * * Function description * Send the name of a resource to be displayed in SystemView. * * Marker names are usually set in the system description * callback, to ensure it is only sent when the SystemView Application * is connected. * * Parameters * ResourceId - Id of the resource to be named. i.e. its address. * sName - Pointer to the resource name. (Max. SEGGER_SYSVIEW_MAX_STRING_LEN Bytes) */ void SEGGER_SYSVIEW_NameResource(U32 ResourceId, const char* sName) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_QUANTA_U32 + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = pPayloadStart; ENCODE_U32(pPayload, SHRINK_ID(ResourceId)); pPayload = _EncodeStr(pPayload, sName, SEGGER_SYSVIEW_MAX_STRING_LEN); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_NAME_RESOURCE); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_SendPacket() * * Function description * Send an event packet. * * Parameters * pPacket - Pointer to the start of the packet. * pPayloadEnd - Pointer to the end of the payload. * Make sure there are at least 5 bytes free after the payload. * EventId - Id of the event packet. * * Return value * !=0: Success, Message sent. * ==0: Buffer full, Message *NOT* sent. */ int SEGGER_SYSVIEW_SendPacket(U8* pPacket, U8* pPayloadEnd, unsigned int EventId) { #if (SEGGER_SYSVIEW_USE_STATIC_BUFFER == 1) SEGGER_SYSVIEW_LOCK(); #endif _SendPacket(pPacket + 4, pPayloadEnd, EventId); #if (SEGGER_SYSVIEW_USE_STATIC_BUFFER == 1) SEGGER_SYSVIEW_UNLOCK(); #endif return 0; } /********************************************************************* * * SEGGER_SYSVIEW_EncodeU32() * * Function description * Encode a U32 in variable-length format. * * Parameters * pPayload - Pointer to where U32 will be encoded. * Value - The 32-bit value to be encoded. * * Return value * Pointer to the byte following the value, i.e. the first free * byte in the payload and the next position to store payload * content. */ U8* SEGGER_SYSVIEW_EncodeU32(U8* pPayload, U32 Value) { ENCODE_U32(pPayload, Value); return pPayload; } /********************************************************************* * * SEGGER_SYSVIEW_EncodeString() * * Function description * Encode a string in variable-length format. * * Parameters * pPayload - Pointer to where string will be encoded. * s - String to encode. * MaxLen - Maximum number of characters to encode from string. * * Return value * Pointer to the byte following the value, i.e. the first free * byte in the payload and the next position to store payload * content. * * Additional information * The string is encoded as a count byte followed by the contents * of the string. * No more than 1 + MaxLen bytes will be encoded to the payload. */ U8* SEGGER_SYSVIEW_EncodeString(U8* pPayload, const char* s, unsigned int MaxLen) { return _EncodeStr(pPayload, s, MaxLen); } /********************************************************************* * * SEGGER_SYSVIEW_EncodeData() * * Function description * Encode a byte buffer in variable-length format. * * Parameters * pPayload - Pointer to where string will be encoded. * pSrc - Pointer to data buffer to be encoded. * NumBytes - Number of bytes in the buffer to be encoded. * * Return value * Pointer to the byte following the value, i.e. the first free * byte in the payload and the next position to store payload * content. * * Additional information * The data is encoded as a count byte followed by the contents * of the data buffer. * Make sure NumBytes + 1 bytes are free for the payload. */ U8* SEGGER_SYSVIEW_EncodeData(U8 *pPayload, const char* pSrc, unsigned int NumBytes) { return _EncodeData(pPayload, pSrc, NumBytes); } /********************************************************************* * * SEGGER_SYSVIEW_EncodeId() * * Function description * Encode a 32-bit Id in shrunken variable-length format. * * Parameters * pPayload - Pointer to where the Id will be encoded. * Id - The 32-bit value to be encoded. * * Return value * Pointer to the byte following the value, i.e. the first free * byte in the payload and the next position to store payload * content. * * Additional information * The parameters to shrink an Id can be configured in * SEGGER_SYSVIEW_Conf.h and via SEGGER_SYSVIEW_SetRAMBase(). * SEGGER_SYSVIEW_ID_BASE: Lowest Id reported by the application. * (i.e. 0x20000000 when all Ids are an address in this RAM) * SEGGER_SYSVIEW_ID_SHIFT: Number of bits to shift the Id to * save bandwidth. (i.e. 2 when Ids are 4 byte aligned) */ U8* SEGGER_SYSVIEW_EncodeId(U8* pPayload, U32 Id) { Id = SHRINK_ID(Id); ENCODE_U32(pPayload, Id); return pPayload; } /********************************************************************* * * SEGGER_SYSVIEW_ShrinkId() * * Function description * Get the shrunken value of an Id for further processing like in * SEGGER_SYSVIEW_NameResource(). * * Parameters * Id - The 32-bit value to be shrunken. * * Return value * Shrunken Id. * * Additional information * The parameters to shrink an Id can be configured in * SEGGER_SYSVIEW_Conf.h and via SEGGER_SYSVIEW_SetRAMBase(). * SEGGER_SYSVIEW_ID_BASE: Lowest Id reported by the application. * (i.e. 0x20000000 when all Ids are an address in this RAM) * SEGGER_SYSVIEW_ID_SHIFT: Number of bits to shift the Id to * save bandwidth. (i.e. 2 when Ids are 4 byte aligned) */ U32 SEGGER_SYSVIEW_ShrinkId(U32 Id) { return SHRINK_ID(Id); } /********************************************************************* * * SEGGER_SYSVIEW_RegisterModule() * * Function description * Register a middleware module for recording its events. * * Parameters * pModule - The middleware module information. * * Additional information * SEGGER_SYSVIEW_MODULE elements: * sDescription - Pointer to a string containing the module name and optionally the module event description. * NumEvents - Number of events the module wants to register. * EventOffset - Offset to be added to the event Ids. Out parameter, set by this function. Do not modify after calling this function. * pfSendModuleDesc - Callback function pointer to send more detailed module description to SystemView Application. * pNext - Pointer to next registered module. Out parameter, set by this function. Do not modify after calling this function. */ void SEGGER_SYSVIEW_RegisterModule(SEGGER_SYSVIEW_MODULE* pModule) { SEGGER_SYSVIEW_LOCK(); if (_pFirstModule == 0) { // // No module registered, yet. // Start list with new module. // EventOffset is the base offset for modules // pModule->EventOffset = MODULE_EVENT_OFFSET; pModule->pNext = 0; _pFirstModule = pModule; _NumModules = 1; } else { // // Registreded module(s) present. // Prepend new module in list. // EventOffset set from number of events and offset of previous module. // pModule->EventOffset = _pFirstModule->EventOffset + _pFirstModule->NumEvents; pModule->pNext = _pFirstModule; _pFirstModule = pModule; _NumModules++; } SEGGER_SYSVIEW_SendModule(0); if (pModule->pfSendModuleDesc) { pModule->pfSendModuleDesc(); } SEGGER_SYSVIEW_UNLOCK(); } /********************************************************************* * * SEGGER_SYSVIEW_RecordModuleDescription() * * Function description * Sends detailed information of a registered module to the host. * * Parameters * pModule - Pointer to the described module. * sDescription - Pointer to a description string. */ void SEGGER_SYSVIEW_RecordModuleDescription(const SEGGER_SYSVIEW_MODULE* pModule, const char* sDescription) { U8 ModuleId; SEGGER_SYSVIEW_MODULE* p; p = _pFirstModule; ModuleId = 0; do { if (p == pModule) { break; } ModuleId++; p = p->pNext; } while (p); { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = pPayloadStart; // // Send module description // Send event offset and number of events // ENCODE_U32(pPayload, ModuleId); ENCODE_U32(pPayload, (pModule->EventOffset)); pPayload = _EncodeStr(pPayload, sDescription, SEGGER_SYSVIEW_MAX_STRING_LEN); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_MODULEDESC); RECORD_END(); } } /********************************************************************* * * SEGGER_SYSVIEW_SendModule() * * Function description * Sends the information of a registered module to the host. * * Parameters * ModuleId - Id of the requested module. */ void SEGGER_SYSVIEW_SendModule(U8 ModuleId) { SEGGER_SYSVIEW_MODULE* pModule; U32 n; if (_pFirstModule != 0) { pModule = _pFirstModule; for (n = 0; n < ModuleId; n++) { pModule = pModule->pNext; if (pModule == 0) { break; } } if (pModule != 0) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + 1 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = pPayloadStart; // // Send module description // Send event offset and number of events // ENCODE_U32(pPayload, ModuleId); ENCODE_U32(pPayload, (pModule->EventOffset)); pPayload = _EncodeStr(pPayload, pModule->sModule, SEGGER_SYSVIEW_MAX_STRING_LEN); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_MODULEDESC); RECORD_END(); } } } /********************************************************************* * * SEGGER_SYSVIEW_SendModuleDescription() * * Function description * Triggers a send of the registered module descriptions. * */ void SEGGER_SYSVIEW_SendModuleDescription(void) { SEGGER_SYSVIEW_MODULE* pModule; if (_pFirstModule != 0) { pModule = _pFirstModule; do { if (pModule->pfSendModuleDesc) { pModule->pfSendModuleDesc(); } pModule = pModule->pNext; } while (pModule); } } /********************************************************************* * * SEGGER_SYSVIEW_SendNumModules() * * Function description * Send the number of registered modules to the host. */ void SEGGER_SYSVIEW_SendNumModules(void) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2*SEGGER_SYSVIEW_QUANTA_U32); pPayload = pPayloadStart; ENCODE_U32(pPayload, _NumModules); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_NUMMODULES); RECORD_END(); } #ifndef SEGGER_SYSVIEW_EXCLUDE_PRINTF // Define in project to avoid warnings about variable parameter list /********************************************************************* * * SEGGER_SYSVIEW_PrintfHostEx() * * Function description * Print a string which is formatted on the host by the SystemView Application * with Additional information. * * Parameters * s - String to be formatted. * Options - Options for the string. i.e. Log level. * * Additional information * All format arguments are treated as 32-bit scalar values. */ void SEGGER_SYSVIEW_PrintfHostEx(const char* s, U32 Options, ...) { va_list ParamList; #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT int r; va_start(ParamList, Options); r = _VPrintHost(s, Options, &ParamList); va_end(ParamList); if (r == -1) { va_start(ParamList, Options); _VPrintTarget(s, Options, &ParamList); va_end(ParamList); } #else va_start(ParamList, Options); _VPrintHost(s, Options, &ParamList); va_end(ParamList); #endif } /********************************************************************* * * SEGGER_SYSVIEW_PrintfHost() * * Function description * Print a string which is formatted on the host by the SystemView Application. * * Parameters * s - String to be formatted. * * Additional information * All format arguments are treated as 32-bit scalar values. */ void SEGGER_SYSVIEW_PrintfHost(const char* s, ...) { va_list ParamList; #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT int r; va_start(ParamList, s); r = _VPrintHost(s, SEGGER_SYSVIEW_LOG, &ParamList); va_end(ParamList); if (r == -1) { va_start(ParamList, s); _VPrintTarget(s, SEGGER_SYSVIEW_LOG, &ParamList); va_end(ParamList); } #else va_start(ParamList, s); _VPrintHost(s, SEGGER_SYSVIEW_LOG, &ParamList); va_end(ParamList); #endif } /********************************************************************* * * SEGGER_SYSVIEW_WarnfHost() * * Function description * Print a warnin string which is formatted on the host by * the SystemView Application. * * Parameters * s - String to be formatted. * * Additional information * All format arguments are treated as 32-bit scalar values. */ void SEGGER_SYSVIEW_WarnfHost(const char* s, ...) { va_list ParamList; #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT int r; va_start(ParamList, s); r = _VPrintHost(s, SEGGER_SYSVIEW_WARNING, &ParamList); va_end(ParamList); if (r == -1) { va_start(ParamList, s); _VPrintTarget(s, SEGGER_SYSVIEW_WARNING, &ParamList); va_end(ParamList); } #else va_start(ParamList, s); _VPrintHost(s, SEGGER_SYSVIEW_WARNING, &ParamList); va_end(ParamList); #endif } /********************************************************************* * * SEGGER_SYSVIEW_ErrorfHost() * * Function description * Print an error string which is formatted on the host by * the SystemView Application. * * Parameters * s - String to be formatted. * * Additional information * All format arguments are treated as 32-bit scalar values. */ void SEGGER_SYSVIEW_ErrorfHost(const char* s, ...) { va_list ParamList; #if SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT int r; va_start(ParamList, s); r = _VPrintHost(s, SEGGER_SYSVIEW_ERROR, &ParamList); va_end(ParamList); if (r == -1) { va_start(ParamList, s); _VPrintTarget(s, SEGGER_SYSVIEW_ERROR, &ParamList); va_end(ParamList); } #else va_start(ParamList, s); _VPrintHost(s, SEGGER_SYSVIEW_ERROR, &ParamList); va_end(ParamList); #endif } /********************************************************************* * * SEGGER_SYSVIEW_PrintfTargetEx() * * Function description * Print a string which is formatted on the target before sent to * the host with Additional information. * * Parameters * s - String to be formatted. * Options - Options for the string. i.e. Log level. */ void SEGGER_SYSVIEW_PrintfTargetEx(const char* s, U32 Options, ...) { va_list ParamList; va_start(ParamList, Options); _VPrintTarget(s, Options, &ParamList); va_end(ParamList); } /********************************************************************* * * SEGGER_SYSVIEW_PrintfTarget() * * Function description * Print a string which is formatted on the target before sent to * the host. * * Parameters * s - String to be formatted. */ void SEGGER_SYSVIEW_PrintfTarget(const char* s, ...) { va_list ParamList; va_start(ParamList, s); _VPrintTarget(s, SEGGER_SYSVIEW_LOG, &ParamList); va_end(ParamList); } /********************************************************************* * * SEGGER_SYSVIEW_WarnfTarget() * * Function description * Print a warning string which is formatted on the target before * sent to the host. * * Parameters * s - String to be formatted. */ void SEGGER_SYSVIEW_WarnfTarget(const char* s, ...) { va_list ParamList; va_start(ParamList, s); _VPrintTarget(s, SEGGER_SYSVIEW_WARNING, &ParamList); va_end(ParamList); } /********************************************************************* * * SEGGER_SYSVIEW_ErrorfTarget() * * Function description * Print an error string which is formatted on the target before * sent to the host. * * Parameters * s - String to be formatted. */ void SEGGER_SYSVIEW_ErrorfTarget(const char* s, ...) { va_list ParamList; va_start(ParamList, s); _VPrintTarget(s, SEGGER_SYSVIEW_ERROR, &ParamList); va_end(ParamList); } #endif // SEGGER_SYSVIEW_EXCLUDE_PRINTF /********************************************************************* * * SEGGER_SYSVIEW_Print() * * Function description * Print a string to the host. * * Parameters * s - String to sent. */ void SEGGER_SYSVIEW_Print(const char* s) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = _EncodeStr(pPayloadStart, s, SEGGER_SYSVIEW_MAX_STRING_LEN); ENCODE_U32(pPayload, SEGGER_SYSVIEW_LOG); ENCODE_U32(pPayload, 0); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_PRINT_FORMATTED); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_Warn() * * Function description * Print a warning string to the host. * * Parameters * s - String to sent. */ void SEGGER_SYSVIEW_Warn(const char* s) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = _EncodeStr(pPayloadStart, s, SEGGER_SYSVIEW_MAX_STRING_LEN); ENCODE_U32(pPayload, SEGGER_SYSVIEW_WARNING); ENCODE_U32(pPayload, 0); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_PRINT_FORMATTED); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_Error() * * Function description * Print an error string to the host. * * Parameters * s - String to sent. */ void SEGGER_SYSVIEW_Error(const char* s) { U8* pPayload; U8* pPayloadStart; RECORD_START(SEGGER_SYSVIEW_INFO_SIZE + 2 * SEGGER_SYSVIEW_QUANTA_U32 + SEGGER_SYSVIEW_MAX_STRING_LEN); // pPayload = _EncodeStr(pPayloadStart, s, SEGGER_SYSVIEW_MAX_STRING_LEN); ENCODE_U32(pPayload, SEGGER_SYSVIEW_ERROR); ENCODE_U32(pPayload, 0); _SendPacket(pPayloadStart, pPayload, SYSVIEW_EVTID_PRINT_FORMATTED); RECORD_END(); } /********************************************************************* * * SEGGER_SYSVIEW_EnableEvents() * * Function description * Enable standard SystemView events to be generated. * * Parameters * EnableMask - Events to be enabled. */ void SEGGER_SYSVIEW_EnableEvents(U32 EnableMask) { _SYSVIEW_Globals.DisabledEvents &= ~EnableMask; } /********************************************************************* * * SEGGER_SYSVIEW_DisableEvents() * * Function description * Disable standard SystemView events to not be generated. * * Parameters * DisableMask - Events to be disabled. */ void SEGGER_SYSVIEW_DisableEvents(U32 DisableMask) { _SYSVIEW_Globals.DisabledEvents |= DisableMask; } /********************************************************************* * * SEGGER_SYSVIEW_IsStarted() * * Function description * Handle incoming packets if any and check if recording is started. * * Return value * 0: Recording not started. * > 0: Recording started. */ int SEGGER_SYSVIEW_IsStarted(void) { #if (SEGGER_SYSVIEW_POST_MORTEM_MODE != 1) // // Check if host is sending data which needs to be processed. // if (SEGGER_RTT_HASDATA(CHANNEL_ID_DOWN)) { if (_SYSVIEW_Globals.RecursionCnt == 0) { // Avoid uncontrolled nesting. This way, this routine can call itself once, but no more often than that. _SYSVIEW_Globals.RecursionCnt = 1; _HandleIncomingPacket(); _SYSVIEW_Globals.RecursionCnt = 0; } } #endif return _SYSVIEW_Globals.EnableState; } /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_SYSVIEW.c
C
apache-2.0
104,139
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW.h Purpose : System visualization API. Revision: $Rev: 21292 $ */ #ifndef SEGGER_SYSVIEW_H #define SEGGER_SYSVIEW_H /********************************************************************* * * #include Section * ********************************************************************** */ #include "SEGGER.h" #include "SEGGER_SYSVIEW_ConfDefaults.h" #ifdef __cplusplus extern "C" { #endif /********************************************************************* * * Defines, fixed * ********************************************************************** */ #define SEGGER_SYSVIEW_MAJOR 3 #define SEGGER_SYSVIEW_MINOR 10 #define SEGGER_SYSVIEW_REV 0 #define SEGGER_SYSVIEW_VERSION ((SEGGER_SYSVIEW_MAJOR * 10000) + (SEGGER_SYSVIEW_MINOR * 100) + SEGGER_SYSVIEW_REV) #define SEGGER_SYSVIEW_INFO_SIZE 9 // Minimum size, which has to be reserved for a packet. 1-2 byte of message type, 0-2 byte of payload length, 1-5 bytes of timestamp. #define SEGGER_SYSVIEW_QUANTA_U32 5 // Maximum number of bytes to encode a U32, should be reserved for each 32-bit value in a packet. #define SEGGER_SYSVIEW_LOG (0u) #define SEGGER_SYSVIEW_WARNING (1u) #define SEGGER_SYSVIEW_ERROR (2u) #define SEGGER_SYSVIEW_FLAG_APPEND (1u << 6) #define SEGGER_SYSVIEW_PREPARE_PACKET(p) (p) + 4 // // SystemView events. First 32 IDs from 0 .. 31 are reserved for these // #define SYSVIEW_EVTID_NOP 0 // Dummy packet. #define SYSVIEW_EVTID_OVERFLOW 1 #define SYSVIEW_EVTID_ISR_ENTER 2 #define SYSVIEW_EVTID_ISR_EXIT 3 #define SYSVIEW_EVTID_TASK_START_EXEC 4 #define SYSVIEW_EVTID_TASK_STOP_EXEC 5 #define SYSVIEW_EVTID_TASK_START_READY 6 #define SYSVIEW_EVTID_TASK_STOP_READY 7 #define SYSVIEW_EVTID_TASK_CREATE 8 #define SYSVIEW_EVTID_TASK_INFO 9 #define SYSVIEW_EVTID_TRACE_START 10 #define SYSVIEW_EVTID_TRACE_STOP 11 #define SYSVIEW_EVTID_SYSTIME_CYCLES 12 #define SYSVIEW_EVTID_SYSTIME_US 13 #define SYSVIEW_EVTID_SYSDESC 14 #define SYSVIEW_EVTID_MARK_START 15 #define SYSVIEW_EVTID_MARK_STOP 16 #define SYSVIEW_EVTID_IDLE 17 #define SYSVIEW_EVTID_ISR_TO_SCHEDULER 18 #define SYSVIEW_EVTID_TIMER_ENTER 19 #define SYSVIEW_EVTID_TIMER_EXIT 20 #define SYSVIEW_EVTID_STACK_INFO 21 #define SYSVIEW_EVTID_MODULEDESC 22 #define SYSVIEW_EVTID_INIT 24 #define SYSVIEW_EVTID_NAME_RESOURCE 25 #define SYSVIEW_EVTID_PRINT_FORMATTED 26 #define SYSVIEW_EVTID_NUMMODULES 27 #define SYSVIEW_EVTID_END_CALL 28 #define SYSVIEW_EVTID_TASK_TERMINATE 29 #define SYSVIEW_EVTID_EX 31 // // SystemView extended events. Sent with ID 31. // #define SYSVIEW_EVTID_EX_MARK 0 #define SYSVIEW_EVTID_EX_NAME_MARKER 1 // // Event masks to disable/enable events // #define SYSVIEW_EVTMASK_NOP (1 << SYSVIEW_EVTID_NOP) #define SYSVIEW_EVTMASK_OVERFLOW (1 << SYSVIEW_EVTID_OVERFLOW) #define SYSVIEW_EVTMASK_ISR_ENTER (1 << SYSVIEW_EVTID_ISR_ENTER) #define SYSVIEW_EVTMASK_ISR_EXIT (1 << SYSVIEW_EVTID_ISR_EXIT) #define SYSVIEW_EVTMASK_TASK_START_EXEC (1 << SYSVIEW_EVTID_TASK_START_EXEC) #define SYSVIEW_EVTMASK_TASK_STOP_EXEC (1 << SYSVIEW_EVTID_TASK_STOP_EXEC) #define SYSVIEW_EVTMASK_TASK_START_READY (1 << SYSVIEW_EVTID_TASK_START_READY) #define SYSVIEW_EVTMASK_TASK_STOP_READY (1 << SYSVIEW_EVTID_TASK_STOP_READY) #define SYSVIEW_EVTMASK_TASK_CREATE (1 << SYSVIEW_EVTID_TASK_CREATE) #define SYSVIEW_EVTMASK_TASK_INFO (1 << SYSVIEW_EVTID_TASK_INFO) #define SYSVIEW_EVTMASK_TRACE_START (1 << SYSVIEW_EVTID_TRACE_START) #define SYSVIEW_EVTMASK_TRACE_STOP (1 << SYSVIEW_EVTID_TRACE_STOP) #define SYSVIEW_EVTMASK_SYSTIME_CYCLES (1 << SYSVIEW_EVTID_SYSTIME_CYCLES) #define SYSVIEW_EVTMASK_SYSTIME_US (1 << SYSVIEW_EVTID_SYSTIME_US) #define SYSVIEW_EVTMASK_SYSDESC (1 << SYSVIEW_EVTID_SYSDESC) #define SYSVIEW_EVTMASK_USER_START (1 << SYSVIEW_EVTID_USER_START) #define SYSVIEW_EVTMASK_USER_STOP (1 << SYSVIEW_EVTID_USER_STOP) #define SYSVIEW_EVTMASK_IDLE (1 << SYSVIEW_EVTID_IDLE) #define SYSVIEW_EVTMASK_ISR_TO_SCHEDULER (1 << SYSVIEW_EVTID_ISR_TO_SCHEDULER) #define SYSVIEW_EVTMASK_TIMER_ENTER (1 << SYSVIEW_EVTID_TIMER_ENTER) #define SYSVIEW_EVTMASK_TIMER_EXIT (1 << SYSVIEW_EVTID_TIMER_EXIT) #define SYSVIEW_EVTMASK_STACK_INFO (1 << SYSVIEW_EVTID_STACK_INFO) #define SYSVIEW_EVTMASK_MODULEDESC (1 << SYSVIEW_EVTID_MODULEDESC) #define SYSVIEW_EVTMASK_INIT (1 << SYSVIEW_EVTID_INIT) #define SYSVIEW_EVTMASK_NAME_RESOURCE (1 << SYSVIEW_EVTID_NAME_RESOURCE) #define SYSVIEW_EVTMASK_PRINT_FORMATTED (1 << SYSVIEW_EVTID_PRINT_FORMATTED) #define SYSVIEW_EVTMASK_NUMMODULES (1 << SYSVIEW_EVTID_NUMMODULES) #define SYSVIEW_EVTMASK_END_CALL (1 << SYSVIEW_EVTID_END_CALL) #define SYSVIEW_EVTMASK_TASK_TERMINATE (1 << SYSVIEW_EVTID_TASK_TERMINATE) #define SYSVIEW_EVTMASK_EX (1 << SYSVIEW_EVTID_EX) #define SYSVIEW_EVTMASK_ALL_INTERRUPTS ( SYSVIEW_EVTMASK_ISR_ENTER \ | SYSVIEW_EVTMASK_ISR_EXIT \ | SYSVIEW_EVTMASK_ISR_TO_SCHEDULER) #define SYSVIEW_EVTMASK_ALL_TASKS ( SYSVIEW_EVTMASK_TASK_START_EXEC \ | SYSVIEW_EVTMASK_TASK_STOP_EXEC \ | SYSVIEW_EVTMASK_TASK_START_READY \ | SYSVIEW_EVTMASK_TASK_STOP_READY \ | SYSVIEW_EVTMASK_TASK_CREATE \ | SYSVIEW_EVTMASK_TASK_INFO \ | SYSVIEW_EVTMASK_STACK_INFO \ | SYSVIEW_EVTMASK_TASK_TERMINATE) /********************************************************************* * * Structures * ********************************************************************** */ typedef struct { U32 TaskID; const char* sName; U32 Prio; U32 StackBase; U32 StackSize; } SEGGER_SYSVIEW_TASKINFO; typedef struct SEGGER_SYSVIEW_MODULE_STRUCT SEGGER_SYSVIEW_MODULE; struct SEGGER_SYSVIEW_MODULE_STRUCT { const char* sModule; U32 NumEvents; U32 EventOffset; void (*pfSendModuleDesc)(void); SEGGER_SYSVIEW_MODULE* pNext; }; typedef void (SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC)(void); /********************************************************************* * * Global data * ********************************************************************** */ #ifdef EXTERN #undef EXTERN #endif #ifndef SEGGER_SYSVIEW_C // Defined in SEGGER_SYSVIEW.c which includes this header beside other C-files #define EXTERN extern #else #define EXTERN #endif EXTERN unsigned int SEGGER_SYSVIEW_TickCnt; EXTERN unsigned int SEGGER_SYSVIEW_InterruptId; #undef EXTERN /********************************************************************* * * API functions * ********************************************************************** */ typedef struct { U64 (*pfGetTime) (void); void (*pfSendTaskList) (void); } SEGGER_SYSVIEW_OS_API; /********************************************************************* * * Control and initialization functions */ void SEGGER_SYSVIEW_Init (U32 SysFreq, U32 CPUFreq, const SEGGER_SYSVIEW_OS_API *pOSAPI, SEGGER_SYSVIEW_SEND_SYS_DESC_FUNC pfSendSysDesc); void SEGGER_SYSVIEW_SetRAMBase (U32 RAMBaseAddress); void SEGGER_SYSVIEW_Start (void); void SEGGER_SYSVIEW_Stop (void); void SEGGER_SYSVIEW_GetSysDesc (void); void SEGGER_SYSVIEW_SendTaskList (void); void SEGGER_SYSVIEW_SendTaskInfo (const SEGGER_SYSVIEW_TASKINFO* pInfo); void SEGGER_SYSVIEW_SendSysDesc (const char* sSysDesc); int SEGGER_SYSVIEW_IsStarted (void); int SEGGER_SYSVIEW_GetChannelID (void); /********************************************************************* * * Event recording functions */ void SEGGER_SYSVIEW_RecordVoid (unsigned int EventId); void SEGGER_SYSVIEW_RecordU32 (unsigned int EventId, U32 Para0); void SEGGER_SYSVIEW_RecordU32x2 (unsigned int EventId, U32 Para0, U32 Para1); void SEGGER_SYSVIEW_RecordU32x3 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2); void SEGGER_SYSVIEW_RecordU32x4 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3); void SEGGER_SYSVIEW_RecordU32x5 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4); void SEGGER_SYSVIEW_RecordU32x6 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5); void SEGGER_SYSVIEW_RecordU32x7 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6); void SEGGER_SYSVIEW_RecordU32x8 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7); void SEGGER_SYSVIEW_RecordU32x9 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8); void SEGGER_SYSVIEW_RecordU32x10 (unsigned int EventId, U32 Para0, U32 Para1, U32 Para2, U32 Para3, U32 Para4, U32 Para5, U32 Para6, U32 Para7, U32 Para8, U32 Para9); void SEGGER_SYSVIEW_RecordString (unsigned int EventId, const char* pString); void SEGGER_SYSVIEW_RecordSystime (void); void SEGGER_SYSVIEW_RecordEnterISR (void); void SEGGER_SYSVIEW_RecordExitISR (void); void SEGGER_SYSVIEW_RecordExitISRToScheduler (void); void SEGGER_SYSVIEW_RecordEnterTimer (U32 TimerId); void SEGGER_SYSVIEW_RecordExitTimer (void); void SEGGER_SYSVIEW_RecordEndCall (unsigned int EventID); void SEGGER_SYSVIEW_RecordEndCallU32 (unsigned int EventID, U32 Para0); void SEGGER_SYSVIEW_Record_StringU32 (unsigned int EventID, const char* pString, U32 Value); void SEGGER_SYSVIEW_OnIdle (void); void SEGGER_SYSVIEW_OnTaskCreate (U32 TaskId); void SEGGER_SYSVIEW_OnTaskTerminate (U32 TaskId); void SEGGER_SYSVIEW_OnTaskStartExec (U32 TaskId); void SEGGER_SYSVIEW_OnTaskStopExec (void); void SEGGER_SYSVIEW_OnTaskStartReady (U32 TaskId); void SEGGER_SYSVIEW_OnTaskStopReady (U32 TaskId, unsigned int Cause); void SEGGER_SYSVIEW_MarkStart (unsigned int MarkerId); void SEGGER_SYSVIEW_MarkStop (unsigned int MarkerId); void SEGGER_SYSVIEW_Mark (unsigned int MarkerId); void SEGGER_SYSVIEW_NameMarker (unsigned int MarkerId, const char* sName); void SEGGER_SYSVIEW_NameResource (U32 ResourceId, const char* sName); int SEGGER_SYSVIEW_SendPacket (U8* pPacket, U8* pPayloadEnd, unsigned int EventId); /********************************************************************* * * Event parameter encoding functions */ U8* SEGGER_SYSVIEW_EncodeU32 (U8* pPayload, U32 Value); U8* SEGGER_SYSVIEW_EncodeData (U8* pPayload, const char* pSrc, unsigned int Len); U8* SEGGER_SYSVIEW_EncodeString (U8* pPayload, const char* s, unsigned int MaxLen); U8* SEGGER_SYSVIEW_EncodeId (U8* pPayload, U32 Id); U32 SEGGER_SYSVIEW_ShrinkId (U32 Id); /********************************************************************* * * Middleware module registration */ void SEGGER_SYSVIEW_RegisterModule (SEGGER_SYSVIEW_MODULE* pModule); void SEGGER_SYSVIEW_RecordModuleDescription (const SEGGER_SYSVIEW_MODULE* pModule, const char* sDescription); void SEGGER_SYSVIEW_SendModule (U8 ModuleId); void SEGGER_SYSVIEW_SendModuleDescription (void); void SEGGER_SYSVIEW_SendNumModules (void); /********************************************************************* * * printf-Style functions */ #ifndef SEGGER_SYSVIEW_EXCLUDE_PRINTF // Define in project to avoid warnings about variable parameter list void SEGGER_SYSVIEW_PrintfHostEx (const char* s, U32 Options, ...); void SEGGER_SYSVIEW_PrintfTargetEx (const char* s, U32 Options, ...); void SEGGER_SYSVIEW_PrintfHost (const char* s, ...); void SEGGER_SYSVIEW_PrintfTarget (const char* s, ...); void SEGGER_SYSVIEW_WarnfHost (const char* s, ...); void SEGGER_SYSVIEW_WarnfTarget (const char* s, ...); void SEGGER_SYSVIEW_ErrorfHost (const char* s, ...); void SEGGER_SYSVIEW_ErrorfTarget (const char* s, ...); #endif void SEGGER_SYSVIEW_Print (const char* s); void SEGGER_SYSVIEW_Warn (const char* s); void SEGGER_SYSVIEW_Error (const char* s); /********************************************************************* * * Run-time configuration functions */ void SEGGER_SYSVIEW_EnableEvents (U32 EnableMask); void SEGGER_SYSVIEW_DisableEvents (U32 DisableMask); /********************************************************************* * * Application-provided functions */ void SEGGER_SYSVIEW_Conf (void); U32 SEGGER_SYSVIEW_X_GetTimestamp (void); U32 SEGGER_SYSVIEW_X_GetInterruptId (void); void SEGGER_SYSVIEW_X_StartComm (void); void SEGGER_SYSVIEW_X_OnEventRecorded (unsigned NumBytes); #ifdef __cplusplus } #endif /********************************************************************* * * Compatibility API defines */ #define SEGGER_SYSVIEW_OnUserStart SEGGER_SYSVIEW_MarkStart #define SEGGER_SYSVIEW_OnUserStop SEGGER_SYSVIEW_MarkStop #endif /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_SYSVIEW.h
C
apache-2.0
18,658
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW_ConfDefaults.h Purpose : Defines defaults for configurable defines used in SEGGER SystemView. Revision: $Rev: 21319 $ */ #ifndef SEGGER_SYSVIEW_CONFDEFAULTS_H #define SEGGER_SYSVIEW_CONFDEFAULTS_H /********************************************************************* * * #include Section * ********************************************************************** */ #include "SEGGER_SYSVIEW_Conf.h" #include "SEGGER_RTT_Conf.h" #ifdef __cplusplus extern "C" { #endif /********************************************************************* * * Defines, fixed * ********************************************************************** */ // // Use auto-detection for SEGGER_SYSVIEW_CORE define // based on compiler-/toolchain-specific defines // to define SEGGER_SYSVIEW_GET_INTERRUPT_ID and SEGGER_SYSVIEW_GET_TIMESTAMP // #define SEGGER_SYSVIEW_CORE_OTHER 0 #define SEGGER_SYSVIEW_CORE_CM0 1 // Cortex-M0/M0+/M1 #define SEGGER_SYSVIEW_CORE_CM3 2 // Cortex-M3/M4/M7 #define SEGGER_SYSVIEW_CORE_RX 3 // Renesas RX #ifndef SEGGER_SYSVIEW_CORE #if (defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __SEGGER_CC__) || (defined __GNUC__) || (defined __clang__) #if (defined __ARM_ARCH_6M__) || (defined __ARM_ARCH_8M_BASE__) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0 #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__)) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3 #endif #elif defined(__ICCARM__) #if (defined (__ARM6M__) && (__CORE__ == __ARM6M__)) \ || (defined (__ARM8M_BASELINE__) && (__CORE__ == __ARM8M_BASELINE__)) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0 #elif (defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) \ || (defined (__ARM7M__) && (__CORE__ == __ARM7M__)) \ || (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) \ || (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3 #endif #elif defined(__CC_ARM) #if (defined(__TARGET_ARCH_6S_M)) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0 #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M)) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3 #endif #elif defined(__TI_ARM__) #ifdef __TI_ARM_V6M0__ #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM0 #elif (defined(__TI_ARM_V7M3__) || defined(__TI_ARM_V7M4__)) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_CM3 #endif #elif defined(__ICCRX__) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_RX #elif defined(__RX) #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_RX #endif #ifndef SEGGER_SYSVIEW_CORE #define SEGGER_SYSVIEW_CORE SEGGER_SYSVIEW_CORE_OTHER #endif #endif /********************************************************************* * * Defines, defaults * ********************************************************************** */ /********************************************************************* * * Define: SEGGER_SYSVIEW_APP_NAME * * Description * The application name to be displayed in SystemView. * Default * "SystemView-enabled Application" * Notes * Convenience define to be used for SEGGER_SYSVIEW_SendSysDesc(). */ #ifndef SEGGER_SYSVIEW_APP_NAME #define SEGGER_SYSVIEW_APP_NAME "SystemView-enabled Application" #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_DEVICE_NAME * * Description * The target device name to be displayed in SystemView. * Default * "undefined device" * Notes * Convenience define to be used for SEGGER_SYSVIEW_SendSysDesc(). */ #ifndef SEGGER_SYSVIEW_DEVICE_NAME #define SEGGER_SYSVIEW_DEVICE_NAME "undefined device" #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_GET_INTERRUPT_ID() * * Description * Function macro to retrieve the Id of the currently active * interrupt. * Default * Call user-supplied function SEGGER_SYSVIEW_X_GetInterruptId(). * Notes * For some known compilers and cores, a ready-to-use, core-specific * default is set. * ARMv7M: Read ICSR[8:0] (active vector) * ARMv6M: Read ICSR[5:0] (active vector) */ #ifndef SEGGER_SYSVIEW_GET_INTERRUPT_ID #if SEGGER_SYSVIEW_CORE == SEGGER_SYSVIEW_CORE_CM3 #define SEGGER_SYSVIEW_GET_INTERRUPT_ID() ((*(U32*)(0xE000ED04)) & 0x1FF) // Get the currently active interrupt Id. (i.e. read Cortex-M ICSR[8:0] = active vector) #elif SEGGER_SYSVIEW_CORE == SEGGER_SYSVIEW_CORE_CM0 #if defined(__ICCARM__) #if (__VER__ > 6010000) #define SEGGER_SYSVIEW_GET_INTERRUPT_ID() (__get_IPSR()) // Workaround for IAR, which might do a byte-access to 0xE000ED04. Read IPSR instead. #else #define SEGGER_SYSVIEW_GET_INTERRUPT_ID() ((*(U32*)(0xE000ED04)) & 0x3F) // Older versions of IAR do not include __get_IPSR, but might also not optimize to byte-access. #endif #else #define SEGGER_SYSVIEW_GET_INTERRUPT_ID() ((*(U32*)(0xE000ED04)) & 0x3F) // Get the currently active interrupt Id. (i.e. read Cortex-M ICSR[5:0] = active vector) #endif #else #define SEGGER_SYSVIEW_GET_INTERRUPT_ID() SEGGER_SYSVIEW_X_GetInterruptId() // Get the currently active interrupt Id from the user-provided function. #endif #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_GET_TIMESTAMP() * * Description * Function macro to retrieve a system timestamp for SYSVIEW events. * Default * Call user-supplied function SEGGER_SYSVIEW_X_GetTimestamp(). * Notes * For some known compilers and cores, a ready-to-use, core-specific * default is set. * ARMv7M: Read Cortex-M Cycle Count register. * * The system timestamp clock frequency has to be passed in * SEGGER_SYSVIEW_Init(). */ #ifndef SEGGER_SYSVIEW_GET_TIMESTAMP #if defined (SEGGER_SYSVIEW_CORE) && (SEGGER_SYSVIEW_CORE == SEGGER_SYSVIEW_CORE_CM3) #define SEGGER_SYSVIEW_GET_TIMESTAMP() (*(U32 *)(0xE0001004)) // Retrieve a system timestamp. Cortex-M cycle counter. #else #define SEGGER_SYSVIEW_GET_TIMESTAMP() SEGGER_SYSVIEW_X_GetTimestamp() // Retrieve a system timestamp via user-defined function #endif #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_TIMESTAMP_BITS * * Description * Number of valid (low-order) bits delivered in system timestamp. * Default * 32 * Notes * Value has to match system timestamp clock source. */ // Define number of valid bits low-order delivered by clock source. #ifndef SEGGER_SYSVIEW_TIMESTAMP_BITS #define SEGGER_SYSVIEW_TIMESTAMP_BITS 32 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_RTT_CHANNEL * * Description * The RTT channel that SystemView will use. * Default * 0: Auto selection. * Notes * Value has to be lower than SEGGER_RTT_MAX_NUM_UP_BUFFERS. */ #ifndef SEGGER_SYSVIEW_RTT_CHANNEL #define SEGGER_SYSVIEW_RTT_CHANNEL 0 #endif // Sanity check of RTT channel #if (SEGGER_SYSVIEW_RTT_CHANNEL == 0) && (SEGGER_RTT_MAX_NUM_UP_BUFFERS < 2) #error "SEGGER_RTT_MAX_NUM_UP_BUFFERS in SEGGER_RTT_Conf.h has to be > 1!" #elif (SEGGER_SYSVIEW_RTT_CHANNEL >= SEGGER_RTT_MAX_NUM_UP_BUFFERS) #error "SEGGER_RTT_MAX_NUM_UP_BUFFERS in SEGGER_RTT_Conf.h has to be > SEGGER_SYSVIEW_RTT_CHANNEL!" #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_RTT_BUFFER_SIZE * * Description * Number of bytes that SystemView uses for the RTT buffer. * Default * 1024 */ #ifndef SEGGER_SYSVIEW_RTT_BUFFER_SIZE #define SEGGER_SYSVIEW_RTT_BUFFER_SIZE 1024 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_SECTION * * Description * Section to place the SystemView RTT Buffer into. * Default * undefined: Do not place into a specific section. * Notes * If SEGGER_RTT_SECTION is defined, the default changes to use * this section for the SystemView RTT Buffer, too. */ #if !(defined SEGGER_SYSVIEW_SECTION) && (defined SEGGER_RTT_SECTION) #define SEGGER_SYSVIEW_SECTION SEGGER_RTT_SECTION #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE * * Description * Largest cache line size (in bytes) in the target system. * Default * 0 * Notes * Required in systems with caches to make sure that the SystemView * RTT buffer can be aligned accordingly. */ #ifndef SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE #define SEGGER_SYSVIEW_CPU_CACHE_LINE_SIZE 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_ID_BASE * * Description * Lowest Id reported by the application. * Default * 0 * Notes * Value is usually subtracted from mailboxes, semaphores, tasks, * .... addresses, to compress event parameters. * Should be the lowest RAM address of the system. */ #ifndef SEGGER_SYSVIEW_ID_BASE #define SEGGER_SYSVIEW_ID_BASE 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_ID_SHIFT * * Description * Number of bits to shift Ids. * Default * 0 * Notes * Ids are shifted to compress event parameters. * Should match the alignment of Ids (addresses), * e.g. 2 when Ids are 4 byte aligned. */ #ifndef SEGGER_SYSVIEW_ID_SHIFT #define SEGGER_SYSVIEW_ID_SHIFT 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_MAX_ARGUMENTS * * Description * Maximum number of arguments which are handled with SystemView * print routines or may be encoded in one recording function. * routines. * Default * 16 */ #ifndef SEGGER_SYSVIEW_MAX_ARGUMENTS #define SEGGER_SYSVIEW_MAX_ARGUMENTS 16 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_MAX_STRING_LEN * * Description * Maximum string length which can be used in SystemView print and * system description routines. * Default * 128 */ #ifndef SEGGER_SYSVIEW_MAX_STRING_LEN #define SEGGER_SYSVIEW_MAX_STRING_LEN 128 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT * * Description * If enabled, on SEGGER_SYSVIEW_PrintHost, check the format string * and if it includes unsupported formatters, use formatting on the * target instead. * Default * 0: Disabled. */ #ifndef SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT #define SEGGER_SYSVIEW_PRINTF_IMPLICIT_FORMAT 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_USE_INTERNAL_RECORDER * * Description * If set, an internal recorder, such as UART or IP is used. * Default * 0: Disabled. * Notes * Convenience define to be used by SEGGER_SYSVIEW_Conf(), * such as in embOS configuration to enable Cortex-M cycle counter. */ #ifndef SEGGER_SYSVIEW_USE_INTERNAL_RECORDER #define SEGGER_SYSVIEW_USE_INTERNAL_RECORDER 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_CAN_RESTART * * Description * If enabled, send the SystemView start sequence on every start * command, not just on the first one. * Enables restart when SystemView disconnected unexpectedly. * Default * 1: Enabled */ #ifndef SEGGER_SYSVIEW_CAN_RESTART #define SEGGER_SYSVIEW_CAN_RESTART 1 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_START_ON_INIT * * Description * Enable calling SEGGER_SYSVIEW_Start() after initialization. * Default * 0: Disabled. * Notes * Convenience define to be used by SEGGER_SYSVIEW_Conf(), * such as in embOS configuration. */ #ifndef SEGGER_SYSVIEW_START_ON_INIT #define SEGGER_SYSVIEW_START_ON_INIT 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_USE_STATIC_BUFFER * * Description * If enabled, use a static buffer instead of a buffer on the stack * for SystemView event packets. * Default * 1: Enabled. * Notes * If enabled, the static memory use by SystemView is increased by * the maximum packet size. SystemView is locked on entry of a * recording function. * If disabled, the stack usage by SystemView recording functions * might be increased by up to the maximum packet size. SystemView * is locked when writing the packet to the RTT buffer. */ #ifndef SEGGER_SYSVIEW_USE_STATIC_BUFFER #define SEGGER_SYSVIEW_USE_STATIC_BUFFER 1 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_MAX_PACKET_SIZE * * Description * Maximum packet size for a SystemView event. * Default * Automatically calculated. * Notes * The maximum packet size is mainly defined by the maximum string * length and the maximum number of arguments. */ #ifndef SEGGER_SYSVIEW_MAX_PACKET_SIZE #define SEGGER_SYSVIEW_MAX_PACKET_SIZE (SEGGER_SYSVIEW_INFO_SIZE + SEGGER_SYSVIEW_MAX_STRING_LEN + 2 * SEGGER_SYSVIEW_QUANTA_U32 + SEGGER_SYSVIEW_MAX_ARGUMENTS * SEGGER_SYSVIEW_QUANTA_U32) #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_POST_MORTEM_MODE * * Description * If enabled, SystemView records for post-mortem analysis instead * of real-time analysis. * Default * 0: Disabled. * Notes * For more information refer to * https://www.segger.com/products/development-tools/systemview/technology/post-mortem-mode */ #ifndef SEGGER_SYSVIEW_POST_MORTEM_MODE #define SEGGER_SYSVIEW_POST_MORTEM_MODE 0 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_SYNC_PERIOD_SHIFT * * Description * Configure how frequently syncronization is sent in post-mortem * mode. * Default * 8: (1 << 8) = Every 256 Events. * Notes * In post-mortem mode, at least one sync has to be in the RTT buffer. * Recommended sync frequency: Buffer Size / 16 * For more information refer to * https://www.segger.com/products/development-tools/systemview/technology/post-mortem-mode */ #ifndef SEGGER_SYSVIEW_SYNC_PERIOD_SHIFT #define SEGGER_SYSVIEW_SYNC_PERIOD_SHIFT 8 #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_ON_EVENT_RECORDED() * * Description * Function macro to notify recorder about a new event in buffer. * Default * undefined: Do not notify recorder. * Notes * Used for non-J-Link recorder, * such as to enable transmission via UART or notify IP task. */ #ifndef SEGGER_SYSVIEW_ON_EVENT_RECORDED #define SEGGER_SYSVIEW_ON_EVENT_RECORDED(NumBytes) #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_LOCK() * * Description * Function macro to (nestable) lock SystemView recording. * Default * Use RTT Locking mechanism (defined by SEGGER_RTT_LOCK()). * Notes * If SystemView recording is not locked, recording events from * interrupts and tasks may lead to unpredictable, undefined, event * data. */ #ifndef SEGGER_SYSVIEW_LOCK #define SEGGER_SYSVIEW_LOCK() SEGGER_RTT_LOCK() #endif /********************************************************************* * * Define: SEGGER_SYSVIEW_UNLOCK * * Description * Function macro to unlock SystemView recording. * Default * Use RTT Unlocking mechanism (defined by SEGGER_RTT_UNLOCK()). */ #ifndef SEGGER_SYSVIEW_UNLOCK #define SEGGER_SYSVIEW_UNLOCK() SEGGER_RTT_UNLOCK() #endif #ifdef __cplusplus } #endif #endif /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_SYSVIEW_ConfDefaults.h
C
apache-2.0
20,523
/********************************************************************* * SEGGER Microcontroller GmbH * * The Embedded Experts * ********************************************************************** * * * (c) 1995 - 2021 SEGGER Microcontroller GmbH * * * * www.segger.com Support: support@segger.com * * * ********************************************************************** * * * SEGGER SystemView * Real-time application analysis * * * ********************************************************************** * * * All rights reserved. * * * * SEGGER strongly recommends to not make any changes * * to or modify the source code of this software in order to stay * * compatible with the SystemView and RTT protocol, and J-Link. * * * * Redistribution and use in source and binary forms, with or * * without modification, are permitted provided that the following * * condition is met: * * * * o Redistributions of source code must retain the above copyright * * notice, this condition and the following disclaimer. * * * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR * * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * * DAMAGE. * * * ********************************************************************** * * * SystemView version: 3.30 * * * ********************************************************************** -------------------------- END-OF-HEADER ----------------------------- File : SEGGER_SYSVIEW_Int.h Purpose : SEGGER SystemView internal header. Revision: $Rev: 21281 $ */ #ifndef SEGGER_SYSVIEW_INT_H #define SEGGER_SYSVIEW_INT_H /********************************************************************* * * #include Section * ********************************************************************** */ #include "SEGGER_SYSVIEW.h" #ifdef __cplusplus extern "C" { #endif /********************************************************************* * * Private data types * ********************************************************************** */ // // Commands that Host can send to target // typedef enum { SEGGER_SYSVIEW_COMMAND_ID_START = 1, SEGGER_SYSVIEW_COMMAND_ID_STOP, SEGGER_SYSVIEW_COMMAND_ID_GET_SYSTIME, SEGGER_SYSVIEW_COMMAND_ID_GET_TASKLIST, SEGGER_SYSVIEW_COMMAND_ID_GET_SYSDESC, SEGGER_SYSVIEW_COMMAND_ID_GET_NUMMODULES, SEGGER_SYSVIEW_COMMAND_ID_GET_MODULEDESC, SEGGER_SYSVIEW_COMMAND_ID_HEARTBEAT = 127, // Extended commands: Commands >= 128 have a second parameter SEGGER_SYSVIEW_COMMAND_ID_GET_MODULE = 128 } SEGGER_SYSVIEW_COMMAND_ID; #ifdef __cplusplus } #endif #endif /*************************** End of file ****************************/
YifuLiu/AliOS-Things
components/trace/SEGGER/SEGGER_SYSVIEW_Int.h
C
apache-2.0
4,729
#include "k_api.h" #include "SEGGER_SYSVIEW.h" #include "SEGGER_RTT.h" #include <stdio.h> #ifdef AOS_COMP_TRACE void SendTaskInfo(ktask_t *task) { SEGGER_SYSVIEW_TASKINFO TaskInfo; memset(&TaskInfo, 0, sizeof(TaskInfo)); // Fill all elements with 0 to allow extending the structure in future version without breaking the code TaskInfo.TaskID = (U32)task; TaskInfo.sName = task->task_name; TaskInfo.Prio = task->prio; TaskInfo.StackBase = (U32)task->task_stack_base; TaskInfo.StackSize = task->stack_size; SEGGER_SYSVIEW_SendTaskInfo(&TaskInfo); } void SEGGER_SYSVIEW_RecordObject(unsigned EventID, blk_obj_t *object) { U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32]; U8 *pPayload; pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket); // Prepare the packet for SystemView pPayload = SEGGER_SYSVIEW_EncodeString(pPayload, object->name, SEGGER_SYSVIEW_MAX_STRING_LEN); // Add object name SEGGER_SYSVIEW_SendPacket(&aPacket[0], pPayload, EventID); // Send the packet } void SEGGER_SYSVIEW_RecordObject_Name(unsigned EventID, const name_t *name) { U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + 4 * SEGGER_SYSVIEW_QUANTA_U32]; U8 *pPayload; pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket); // Prepare the packet for SystemView pPayload = SEGGER_SYSVIEW_EncodeString(pPayload, name, 128); // Add object name SEGGER_SYSVIEW_SendPacket(&aPacket[0], pPayload, EventID); // Send the packet } void trace_task_start_ready(ktask_t *task) { SEGGER_SYSVIEW_OnTaskStartReady((unsigned)task); } void trace_task_stop_ready(ktask_t *task) { SEGGER_SYSVIEW_OnTaskStopReady((unsigned)task, 0); } void trace_task_resume(ktask_t *task, ktask_t *task_resumed) { // SEGGER_SYSVIEW_OnTaskStartReady((unsigned)task_resumed); } void trace_task_suspend(ktask_t *task, ktask_t *task_suspended) { // SEGGER_SYSVIEW_OnTaskStopExec(); } void trace_task_create(ktask_t *task) { SEGGER_SYSVIEW_OnTaskCreate((unsigned)task); SendTaskInfo(task); SEGGER_SYSVIEW_OnTaskStartReady((unsigned)task); } void trace_task_wait_abort(ktask_t *task, ktask_t *task_abort) { SEGGER_SYSVIEW_OnTaskTerminate((unsigned)task_abort); } void trace_task_switch(ktask_t *from, ktask_t *to) { SEGGER_SYSVIEW_OnTaskStopReady((unsigned)from, 0); SEGGER_SYSVIEW_OnTaskStartExec((unsigned)to); } void trace_intrpt_task_switch(ktask_t *from, ktask_t *to) { SEGGER_SYSVIEW_RecordExitISRToScheduler(); trace_task_switch(from, to); } void trace_intrpt_exit(void) { SEGGER_SYSVIEW_RecordExitISR(); } void trace_intrpt_enter(void) { SEGGER_SYSVIEW_RecordEnterISR(); } void trace_init(void) { SEGGER_SYSVIEW_Conf(); printf("_SEGGER_RTT:%p\n", &_SEGGER_RTT); #ifdef TRACE_BY_UART uart_port_init(); #endif } void trace_sem_create(ktask_t *task, ksem_t *sem) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_CREATE, &sem->blk_obj); } void trace_sem_overflow(ktask_t *task, ksem_t *sem) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_OVERFLOW, &sem->blk_obj); } void trace_sem_cnt_increase(ktask_t *task, ksem_t *sem) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_CNT_INCREASE, &sem->blk_obj); } void trace_sem_get_success(ktask_t *task, ksem_t *sem) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_GET_SUCCESS, &sem->blk_obj); } void trace_sem_get_blk(ktask_t *task, ksem_t *sem) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_GET_BLK, &sem->blk_obj); } void trace_sem_task_wake(ktask_t *task, ktask_t *task_waked_up, ksem_t *sem, uint8_t opt_wake_all) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_TASK_WAKE, &sem->blk_obj); } void trace_sem_del(ktask_t *task, ksem_t *sem) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_SEM_DEL, &sem->blk_obj); } void trace_sem_give(ksem_t *sem, uint8_t opt_wake_all) { SEGGER_SYSVIEW_Record_StringU32(SYSVIEW_TRACE_ID_SEM_GIVE, sem->blk_obj.name, opt_wake_all); } void trace_mutex_create(ktask_t *task, kmutex_t *mutex, const name_t *name) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_CREATE, &mutex->blk_obj); } void trace_mutex_release(ktask_t *task, ktask_t *task_release, uint8_t new_pri) { // SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_RELEASE, ); } void trace_mutex_get(ktask_t *task, kmutex_t *mutex, tick_t wait_option) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_GET, &mutex->blk_obj); } void trace_task_pri_inv(ktask_t *task, ktask_t *mtxtsk) { // SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_TASK_PRI_INV, ); } void trace_mutex_get_blk(ktask_t *task, kmutex_t *mutex, tick_t wait_option) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_GET_BLK, &mutex->blk_obj); } void trace_mutex_release_success(ktask_t *task, kmutex_t *mutex) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_RELEASE_SUCCESS, &mutex->blk_obj); } void trace_mutex_task_wake(ktask_t *task, ktask_t *task_waked_up, kmutex_t *mutex) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_TASK_WAKE, &mutex->blk_obj); } void trace_mutex_del(ktask_t *task, kmutex_t *mutex) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_MUTEX_DEL, &mutex->blk_obj); } void trace_event_create(ktask_t *task, kevent_t *event, const name_t *name, uint32_t flags_init) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_EVENT_CREATE, &event->blk_obj); } void trace_event_get(ktask_t *task, kevent_t *event) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_EVENT_GET, &event->blk_obj); } void trace_event_get_blk(ktask_t *task, kevent_t *event, tick_t wait_option) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_EVENT_GET_BLK, &event->blk_obj); } void trace_event_task_wake(ktask_t *task, ktask_t *task_waked_up, kevent_t *event) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_EVENT_TASK_WAKE, &event->blk_obj); } void trace_event_del(ktask_t *task, kevent_t *event) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_EVENT_DEL, &event->blk_obj); } void trace_buf_queue_create(ktask_t *task, kbuf_queue_t *buf_queue) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_BUF_QUEUE_CREATE, &buf_queue->blk_obj); } void trace_buf_queue_max(ktask_t *task, kbuf_queue_t *buf_queue, void *msg, size_t msg_size) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_BUF_QUEUE_MAX, &buf_queue->blk_obj); } void trace_buf_queue_post(ktask_t *task, kbuf_queue_t *buf_queue, void *msg, size_t msg_size) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_BUF_QUEUE_POST, &buf_queue->blk_obj); } void trace_buf_queue_task_wake(ktask_t *task, ktask_t *task_waked_up, kbuf_queue_t *buf_queue) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_BUF_QUEUE_TASK_WAKE, &buf_queue->blk_obj); } void trace_buf_queue_get_blk(ktask_t *task, kbuf_queue_t *buf_queue, tick_t wait_option) { SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_BUF_QUEUE_GET_BLK, &buf_queue->blk_obj); } void trace_workqueue_init(ktask_t *task, kwork_t *work) { // SEGGER_SYSVIEW_RecordObject(SYSVIEW_TRACE_ID_WORKQUEUE_INIT, ); } void trace_workqueue_create(ktask_t *task, kworkqueue_t *workqueue) { SEGGER_SYSVIEW_RecordObject_Name(SYSVIEW_TRACE_ID_WORKQUEUE_CREATE, workqueue->name); } void trace_workqueue_del(ktask_t *task, kworkqueue_t *workqueue) { SEGGER_SYSVIEW_RecordObject_Name(SYSVIEW_TRACE_ID_WORKQUEUE_DEL, workqueue->name); } #endif
YifuLiu/AliOS-Things
components/trace/k_trace.c
C
apache-2.0
7,438
/* * Copyright (C) 2015-2020 Alibaba Group Holding Limited */ #include <stdio.h> #include <stdlib.h> #include <aos/errno.h> #include <aos/kernel.h> #include "aos/init.h" #include "board.h" #include <k_api.h> #include "aos/hal/uart.h" #include "k_trace.h" #include "SEGGER_SYSVIEW.h" #include "SEGGER_RTT.h" #define SYSVIEW_SINGLE_TX 1024 #define UART_TX_TIMEOUT 100 #define TASK_SENDDATA_NAME "senddata" #define TASK_SENDDATA_STACKSIZE 4096 #define TASK_SENDDATA_PRI 50 #define TASK_RECVDATA_NAME "revdata" #define TASK_RECVDATA_STACKSIZE 1024 #define TASK_RECVDATA_PRI 50 #define _SERVER_HELLO_SIZE (4) #define _TARGET_HELLO_SIZE (4) static const U8 _abHelloMsg[_TARGET_HELLO_SIZE] = { 'S', 'V', (SEGGER_SYSVIEW_VERSION / 10000), (SEGGER_SYSVIEW_VERSION / 1000) % 10 }; // "Hello" message expected by SysView: [ 'S', 'V', <PROTOCOL_MAJOR>, <PROTOCOL_MINOR> ] static uart_dev_t uart_demo; /* task entry */ static void task_senddata_entry(void *arg) { int ret = 0; int channel_id = SEGGER_SYSVIEW_GetChannelID(); uint32_t num = 0; uint8_t bytes = 0; uint8_t tx_buf[SYSVIEW_SINGLE_TX]; int length = 0; int len_read = 0; SEGGER_SYSVIEW_Start(); ret = hal_uart_send(&uart_demo, _abHelloMsg, _SERVER_HELLO_SIZE, UART_TX_TIMEOUT); if (ret != 0) { printf("uart data send error!\n"); } while (1) { bytes = SEGGER_RTT_GetBytesInBuffer(channel_id); if(bytes >= SYSVIEW_SINGLE_TX) { printf("bytes:%d!\n", bytes); } if(bytes == 0) { printf("bytes is 0!\n"); aos_msleep(1); break; } num = SEGGER_RTT_ReadUpBufferNoLock(channel_id, tx_buf, bytes); hal_trace_output_block(tx_buf, num); usleep(1); } } static void task_recvdata_entry(void *arg) { int i; int ret; int rev_length; char rev_buf[1] = {0}; int channel_id = SEGGER_SYSVIEW_GetChannelID(); while (1) { ret = hal_uart_recv_II(&uart_demo, rev_buf, sizeof(rev_buf), &rev_length, HAL_WAIT_FOREVER); if (ret == 0) { SEGGER_RTT_WriteDownBuffer(channel_id, rev_buf, 1); } } } int uart_port_init(void) { int ret = 0; /* task handle */ aos_task_t task_recvdata; aos_task_t task_senddata; uart_demo.port = 0; uart_demo.config.baud_rate = 1500000; uart_demo.config.mode = MODE_TX_RX; uart_demo.config.flow_control = FLOW_CONTROL_DISABLED; uart_demo.config.stop_bits = STOP_BITS_1; uart_demo.config.parity = NO_PARITY; uart_demo.config.data_width = DATA_WIDTH_8BIT; ret = hal_uart_init(&uart_demo); if(ret != 0) { printf("init uart error\r\n"); return -1; } /* Create the task to receive data */ ret = aos_task_new_ext(&task_recvdata, TASK_RECVDATA_NAME, task_recvdata_entry, NULL, TASK_RECVDATA_STACKSIZE, TASK_RECVDATA_PRI); if (ret != 0) { hal_uart_finalize(&uart_demo); printf("create uart data recv task error\r\n"); return; } /* Create the task to send data */ ret = aos_task_new_ext(&task_senddata, TASK_SENDDATA_NAME, task_senddata_entry, NULL, TASK_SENDDATA_STACKSIZE, TASK_SENDDATA_PRI); if (ret != 0) { hal_uart_finalize(&uart_demo); printf("create uart data recv task error\r\n"); return; } return ret; }
YifuLiu/AliOS-Things
components/trace/uart_send.c
C
apache-2.0
3,340
#include <stdio.h> #include <stdlib.h> #include "aos/kernel.h" #include "uagent.h" #include "aos/errno.h" #if AOS_COMP_CLI #include "aos/cli.h" #endif static int test_uagent_register_normal(void) { const int ret = uagent_register(UAGENT_MOD_ULOG, "ulog", "", UAGENT_FUNC_USER_BASE, "dummy", NULL, NULL); return ret; } static int test_uagent_register_error_input(void) { const int ret = uagent_register(UAGENT_MOD_ULOG, NULL, NULL, UAGENT_FUNC_USER_BASE, NULL, NULL, NULL); return ret; } static int test_uagent_unregister_normal(void) { const int ret = uagent_unregister(UAGENT_MOD_ULOG, UAGENT_FUNC_USER_BASE); return ret; } static int test_uagent_request_service_normal(void) { const int ret = uagent_request_service(UAGENT_MOD_UAGENT, UAGENT_MOD_ULOG, UAGENT_FUNC_USER_BASE, strlen("ulog level=5") + 1, "ulog level=5"); return ret; } static int test_uagent_request_service_error_input_1(void) { const int ret = uagent_request_service(UAGENT_MOD_UAGENT, UAGENT_MOD_ULOG, UAGENT_FUNC_USER_BASE, 12, NULL); return ret; } static int test_uagent_request_service_error_input_2(void) { const int ret = uagent_request_service(UAGENT_MOD_UAGENT, UAGENT_MOD_ULOG, UAGENT_FUNC_USER_BASE, 65535, "ulog level=5"); return ret; } static int test_uagent_send_normal(void) { const int ret = uagent_send(UAGENT_MOD_ULOG, UAGENT_FUNC_USER_BASE, strlen("helloworld") + 1, "helloworld", 0); return ret; } static int test_uagent_send_error_input(void) { const int ret = uagent_send(UAGENT_MOD_ULOG, UAGENT_FUNC_USER_BASE, strlen("helloworld") + 1, NULL, 0); return ret; } static int test_uagent_ext_comm_start_normal(char *pk, char *dn) { const int ret = uagent_ext_comm_start(pk, dn); return ret; } static int test_uagent_ext_comm_start_error_input(void) { const int ret = uagent_ext_comm_start(NULL, NULL); return ret; } int test_uagent_init(void *handle, char *pk, char *dn) { int ret = 0; ret = uagent_init(); if (ret != 0) { printf("uAgent Init Failed ret = %d\n", ret); return ret; } ret = uagent_mqtt_client_set(handle); if (ret != 0) { printf("uAgent mqtt handle set failed ret = %d\n", ret); return ret; } ret = uagent_ext_comm_start(pk, dn); if (ret != 0) { printf("uAgent ext comm start failed ret = %d\n", ret); return ret; } return 0; } void test_uagent_start(int argc, char **argv) { int ret = 0; ret = test_uagent_register_normal(); aos_msleep(2000); ret = test_uagent_register_error_input(); aos_msleep(2000); ret = test_uagent_request_service_normal(); aos_msleep(2000); ret = test_uagent_request_service_error_input_1(); aos_msleep(2000); ret = test_uagent_request_service_error_input_2(); aos_msleep(2000); ret = test_uagent_ext_comm_start_error_input(); aos_msleep(2000); ret = test_uagent_send_normal(); aos_msleep(2000); ret = test_uagent_send_error_input(); aos_msleep(2000); ret = test_uagent_unregister_normal(); aos_msleep(2000); return 0; } #if AOS_COMP_CLI /* reg args: fun, cmd, description*/ ALIOS_CLI_CMD_REGISTER(test_uagent_start, uagent_example, uagent component base example) #endif
YifuLiu/AliOS-Things
components/uagent/example/uagent_example.c
C
apache-2.0
3,325
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #ifndef UAGENT_H #define UAGENT_H #include "uagent_type.h" #ifdef __cplusplus extern "C" { #endif /** * Register service routine from customer into uagent for delegate * Update the cb if the same mod and func alreay registered before. * * @param[in] mod Module type, reference @ua_mod_t * @param[in] mod_name Name of module, only user module fill this, pre-define module use NULL. * @param[in] version Version of module, usually comes from aos.mk * @param[in] func Service Name * @param[in] func_name Name of service * @param[in] cb Service Routine * @param[in] arg Argument of the function. * * @return 0: Success, -EINVAL: invalid parameter, -EIO: Service mapping table * has no enough room for new service */ int uagent_register(const ua_mod_t mod, const char *mod_name, char *version, const ua_func_t func, const char *func_name, on_customer_service cb, void *arg); /** * Un-register service routine * * @param[in] mod Module type, reference @ua_mod_t * @param[in] func Service Name * * @return 0: Success, -1: Fail */ int uagent_unregister(const ua_mod_t mod, const ua_func_t func); /** * Request other's module's service. * Remark: Customer can call any service(in case of the service exist), * even this customer doesn't offer any service * * @param[in] src Source module type, reference @ua_mod_t * @param[in] target Target module type, reference @ua_mod_t * @param[in] func Function type, include pre-define func and customer's define * @param[in] len Argument string's length * @param[in] info_str Argument string * * @return 0: Success, -EINVAL: invalid parameter, -EIO: Service mapping table * has no enough room for new service */ int uagent_request_service(const ua_mod_t src, const ua_mod_t target, const ua_func_t func, const unsigned short len, const void *info_str); /** * Publish customer's info. * Remark: Customer can call any service(in case of the service exist), even this * customer doesn't offer any service * * * @param[in] mod Source module type, reference @ua_mod_t * @param[in] type Type indicates info_str, not necessary * @param[in] len Argument string's length * @param[in] info_str Argument string * @param[in] policy Values are constructed by a bitwise-inclusive OR of flags * from the @send_policy_bit_ctrl_t * * @return 0: Success, -EINVAL: invalid parameter, -EIO: Service mapping table * has no enough room for new service */ int uagent_send(const ua_mod_t mod, const ua_func_t type, const unsigned short len, const void *info_str, const ua_send_policy_t policy); /** * Initial uagent function * * @return 0: Success */ int uagent_init(void); /** * Start uagent ext comm service * Remark: Event return 0 doesn't indicates the connection already build * * @param[in] pk Product Key * @param[in] dn Device Name * * @return 0: Success, -1 fail */ int uagent_ext_comm_start(const char *pk, const char *dn); #ifdef __cplusplus } #endif #endif /* UAGENT_H */
YifuLiu/AliOS-Things
components/uagent/include/uagent.h
C
apache-2.0
3,300
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #ifndef UAGENT_CONFIG_H #define UAGENT_CONFIG_H #define PK_STR_SIZE 16 /* PK LEN currently is 11 */ #define DN_STR_SIZE 36 /* DN LEN currently is 32 */ /* 11Bytes PK + MAX 32bytes DN + payload */ #define UAGENT_TOPIC_MAX_LEN 64 /* uagent support main service in max */ #define UAGENT_SERVICE_SIZE 32 /* uagent support mod in max, uLog uND uOTA CLI */ #define UAGENT_MOD_SIZE 8 #define UAGENT_PAYLOAD_CMD_SIZE 520 #define UAGENT_PAYLOAD_CMD_STR_SIZE 512 #define UAGENT_QUEUE_COUNT 4 #ifndef UAGENT_CONFIG_INFO_PAYLOAD_SIZE #define UAGENT_INFO_PAYLOAD_SIZE 1200 #else #define UAGENT_INFO_PAYLOAD_SIZE UAGENT_CONFIG_INFO_PAYLOAD_SIZE #endif #define UAGENT_INFO_PAYLOAD_BASE64_SIZE 1000 #define UAGENT_INFO_NEAR_FULL 600 #define UAGENT_ROUTINE_TASK_STACK_DEPTH 4096 #define UAGENT_INITED (char)1 #define UAGENT_REGISTER (char)1 #define UAGENT_UNREGISTER (char)0 #define UAGENT_CHECK_COMM_CYCLE 200 #define UAGENT_WAIT_BUFFER 500 #define UAGENT_MSG_IDX_INVALID 0xFFFFFFFF #define TOPIC_AGENT_MAN "/sys/%s/%s/_thing/service/invoke" #define TOPIC_AGENT_POST_REPLY "/sys/%s/%s/_thing/service/post_reply" #define TOPIC_AGENT_INFO "/sys/%s/%s/_thing/service/post" #define UAGENT_LOG_TAG "AGENT" #define UAGENT_INFO_STR \ "{\"id\":%lu, \"version\":\"1.0\",\ \"params\":\ {\"identifier\": \"_Devops.alios.uagent\",\ \"serviceParams\": \ {\"id\":%lu, \"srcdev\":\"%s\",\"show\":%d,\"mod\":%d,\"func\":%d,\"param\":\"%s\"},\ \"method\": \"_thing.service.post\"\ }}" #define UAGENT_FORMAT_PRE \ "{\"id\":%lu, \"version\":\"1.0\",\ \"method\": \"_thing.service.post\",\ \"params\":\ {\"identifier\": \"_Devops.alios.uagent\",\ \"serviceParams\": \ {\"id\":%lu, \"srcdev\":\"%s\",\"show\":%d,\"mod\":%d,\"func\":%d,\"param\":" #define UAGENT_FORMAT_STR_SUFFIX "\"}}}" #define UAGENT_FORMAT_OBJ_SUFFIX "}}}" #define UAGENT_INFO_ACK_OK \ "{\"id\":%lu, \"version\":\"1.0\",\ \"params\":\ {\"identifier\": \"_Devops.alios.uagent\",\ \"serviceParams\": \ {\"srcdev\":\"%s\",\"show\":%d,\"mod\":%d,\"func\":%d,\"ack\":%d, \"id\":%lu},\ \"method\": \"_thing.service.post\"\ }}" #define UAGENT_INFO_ACK_FAIL \ "{\"id\":%lu, \"version\":\"1.0\",\"params\":\ {\"identifier\": \"_Devops.alios.uagent\",\ \"serviceParams\": \ {\"srcdev\":\"%s\",\"show\":%d,\"mod\":%d,\"func\":%d,\"ack\":%d, \"param\":\"%s\", \"id\":%lu},\ \"method\": \"_thing.service.post\"\ }}" #endif /* !UAGENT_CONFIG_H */
YifuLiu/AliOS-Things
components/uagent/include/uagent_config.h
C
apache-2.0
2,533
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #ifndef UAGENT_TYPE_H #define UAGENT_TYPE_H /* type define */ typedef unsigned short ua_mod_t; typedef unsigned short ua_func_t; typedef unsigned char service_agent_rlt_t; #define SERVICE_AGENT_FAIL (service_agent_rlt_t)0x00 #define SERVICE_AGENT_OK (service_agent_rlt_t)0x01 /* uagent support function name size, include null-terminated */ #define UAGENT_FUNC_NAME_SIZE 12 /* Values for ua_send_policy_t are constructed by a bitwise-inclusive OR of flags * from the @send_policy_bit_ctrl_t */ typedef unsigned char ua_send_policy_t; typedef enum { send_policy_save_cloud = 0x01, send_policy_trans_guarantee = 0x02, send_policy_object = 0x04, send_policy_delay = 0x08, send_policy_delay_dump = 0x10, } send_policy_bit_ctrl_t; #define POLICY_SET(POLICY, MASK) ((POLICY&MASK) == MASK) /* uAgent module name */ #define UAGENT_MOD_UAGENT (ua_mod_t)0 /* externel module - cloud */ #define UAGENT_MOD_CLOUD (ua_mod_t)5 /* uND module */ #define UAGENT_MOD_UND (ua_mod_t)0x10 /* uLog module */ #define UAGENT_MOD_ULOG (ua_mod_t)0x11 /* uOTA module */ #define UAGENT_MOD_OTA (ua_mod_t)0x12 /* CLI module */ #define UAGENT_MOD_CLI (ua_mod_t)0x13 #define UAGENT_MOD_BROAD_CAST (ua_mod_t)0xff /* ------------------------ Function List ------------------------ */ /* Inner function type used to register module */ #define UAGENT_FUNC_UA_REGISTER (ua_func_t)0x0001 #define UAGENT_FUNC_UA_UNREGISTER (ua_func_t)0x0002 #define UAGENT_FUNC_UA_RQST_CONN (ua_func_t)0x0003 #define UAGENT_FUNC_UA_DUMP_DELAY_SEND (ua_func_t)0x0004 #define UAGENT_FUNC_UA_DUMP_DELAY_SEND_PARAM (ua_func_t)0x0005 /** * Nofity connect build, format is {"comm conn":1}/ {"comm conn":0}. * Refer @UAGENT_NOTICE_CONNECT for format when using. * Remark: the cb will be called to indicates current situation right now when register. */ #define UAGENT_FUNC_NOTIFY_CLOUD_CONN (ua_func_t)0x0011 #define UAGENT_FUNC_INT_TEL (ua_func_t)0x0021 #define UAGENT_FUNC_UA_SHOW_LIST (ua_func_t)0x0051 /* aquire high level service is enable executed */ #define UAGENT_FUNC_UA_APPLY (ua_func_t)0x8000 /* reboot */ #define UAGENT_FUNC_REBOOT (ua_func_t)0x8002 /* Auth high level service is enable executed */ #define UAGENT_FUNC_UA_AUTH (ua_func_t)0x8055 /* user only can use [H]BASE~[H]BASE+0x100 */ #define UAGENT_USER_FUNC_SIZE (ua_func_t)0x100 /* base of user define function */ #define UAGENT_FUNC_USER_BASE (ua_func_t)0x0400 /* base of user define function, which shall be authrized */ #define UAGENT_FUNC_AUTH_USER_BASE (ua_func_t)0x8400 /* user service function, this call-back will be called if related telegram received * (inner telegram or externel telegram */ typedef int (*on_customer_service)(void *arg, const unsigned short len, void *str); typedef struct { ua_mod_t mod; unsigned char func_count; char *name; char *version; } uagent_mod_info_t; typedef struct _uagent_func_node_t { ua_func_t func; char func_name[UAGENT_FUNC_NAME_SIZE]; on_customer_service service; void *argu; struct _uagent_func_node_t *next; } uagent_func_node_t; typedef struct { uagent_mod_info_t mod_info; uagent_func_node_t *header; } mod_func_t; #define UAGENT_NOTICE_CONNECT "{\"comm conn\":%d}" #endif /* UAGENT_TYPE_H */
YifuLiu/AliOS-Things
components/uagent/include/uagent_type.h
C
apache-2.0
3,602
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #ifndef UAGENT_API_H #define UAGENT_API_H #include <stdbool.h> #include <stdio.h> #include "uagent_config.h" #include "uagent_type.h" #ifdef __cplusplus extern "C" { #endif typedef struct { char initd; char service_started; ua_send_policy_t to_console; char cloud_connect; char pk[PK_STR_SIZE]; char dn[DN_STR_SIZE]; } uagent_service_attr_t; extern uagent_service_attr_t uagent_service_attr; #define UAGENT_INITED_FINISH (UAGENT_INITED == uagent_service_attr.initd) void uagent_init_mutex(void); bool uagent_get_mutex(void); void uagent_release_mutex(void); int add_list(mod_func_t *mod_func_tree, const ua_func_t func, char *func_name); int del_list(mod_func_t *mod_func_tree, const ua_func_t func); typedef int (*on_recv_handler) (const unsigned short len, const char* str); int uagent_ext_comm_init(const char pk[12], const char dn[36], on_recv_handler handler); int uagent_ext_comm_publish(const unsigned short len, void* data, const bool conn_orient); int uagent_ack(const service_agent_rlt_t rlt, const unsigned long id, const ua_mod_t mod, const ua_func_t type, const void* info_str); /* REMARK: return 1 indicates connecting */ char check_connect(); void start_monitor_delay_out(); void stop_monitor_delay_out(); #define UAGENT_DEBUG(fmt, ...) //printf("<D>UA %s[%d]: "fmt"\r\n", __func__, __LINE__, ##__VA_ARGS__) #define UAGENT_INFO(fmt, ...) printf("<I>UA %s[%d]: "fmt"\r\n", __func__, __LINE__, ##__VA_ARGS__) #define UAGENT_ERR(fmt, ...) printf("<E>UA %s[%d]: "fmt"\r\n", __func__, __LINE__, ##__VA_ARGS__) #ifdef __cplusplus } #endif #endif /* !UAGENT_API_H */
YifuLiu/AliOS-Things
components/uagent/internal/uagent_inner_api.h
C
apache-2.0
1,699
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "uagent_config.h" #include "uagent_inner_api.h" #include "aos/kernel.h" #include "aos/errno.h" #include "core_mqtt.h" static char mqtt_topic_up[UAGENT_TOPIC_MAX_LEN]; static char mqtt_topic_dn[UAGENT_TOPIC_MAX_LEN]; static char mqtt_topic_up_reply[UAGENT_TOPIC_MAX_LEN]; static on_recv_handler recv_handler = NULL; static char mqtt_comm_init = 0; static void *mqtt_client = NULL; static void uagent_up_reply_handler(void *handle, const aiot_mqtt_recv_t *packet, void *userdata) { } static void uagent_handler(void *handle, const aiot_mqtt_recv_t *packet, void *userdata) { switch (packet->type) { case AIOT_MQTTRECV_PUB: { /* print topic name and topic message */ UAGENT_DEBUG("Topic: '%.*s' (Length: %d)", packet->data.pub.topic_len, packet->data.pub.topic, packet->data.pub.topic_len); UAGENT_DEBUG("Payload: '%.*s' (Length: %d)", packet->data.pub.payload_len, packet->data.pub.payload, packet->data.pub.payload_len); if (NULL != packet->data.pub.payload) { recv_handler(packet->data.pub.payload_len , packet->data.pub.payload); } } break; default: { } break; } } int uagent_ext_comm_init(const char pk[12], const char dn[36], on_recv_handler handler) { int rc = -EINVAL; /* todo retry if construct fail or subscribe fail */ if (0==mqtt_comm_init && NULL != pk && NULL != dn) { UAGENT_INFO("[uA]prepare start uagent comm %s %s\n", pk, dn); /* Construct a MQTT client with default parameter */ if (mqtt_client != NULL) { snprintf(mqtt_topic_up, UAGENT_TOPIC_MAX_LEN, TOPIC_AGENT_INFO, pk, dn); snprintf(mqtt_topic_dn, UAGENT_TOPIC_MAX_LEN, TOPIC_AGENT_MAN, pk, dn); snprintf(mqtt_topic_up_reply, UAGENT_TOPIC_MAX_LEN, TOPIC_AGENT_POST_REPLY, pk, dn); #ifdef SP_BROADCAST_TOPIC char broadcast_topic_dn[UAGENT_TOPIC_MAX_LEN]; snprintf(broadcast_topic_dn, UAGENT_TOPIC_MAX_LEN, "/broadcast/%s/deviceman", pk); #endif recv_handler = handler; UAGENT_INFO("[uA]Subsrcibe TOPIC %s\r\n", mqtt_topic_dn); /* Subscribe the specific topic */ rc = aiot_mqtt_sub(mqtt_client, mqtt_topic_dn , uagent_handler, CORE_MQTT_QOS0, NULL); if (rc < 0) { UAGENT_ERR("[uA]IOT_MQTT_Subscribe(%s) failed, rc = %d\r\n", mqtt_topic_dn, rc); } else { UAGENT_INFO("[uA]IOT_MQTT_Subscribe(%s) success\r\n", mqtt_topic_dn); rc = 0; } /* Subscribe the specific topic */ rc = aiot_mqtt_sub(mqtt_client, mqtt_topic_up_reply, uagent_up_reply_handler, CORE_MQTT_QOS0 , NULL); if (rc < 0) { UAGENT_ERR("[uA]IOT_MQTT_Subscribe(%s) failed, rc = %d\r\n", mqtt_topic_up_reply, rc); } else { UAGENT_INFO("[uA]IOT_MQTT_Subscribe(%s) success\r\n", mqtt_topic_up_reply); rc = 0; } #ifdef SP_BROADCAST_TOPIC UAGENT_INFO("[uA]Subsrcibe TOPIC %s", broadcast_topic_dn); // rc = IOT_MQTT_Subscribe(NULL, broadcast_topic_dn, IOTX_MQTT_QOS1, uagent_handler, NULL); rc = aiot_mqtt_sub(mqtt_client, broadcast_topic_dn, uagent_handler, CORE_MQTT_QOS1 , NULL); if (rc < 0) { UAGENT_ERR("[uA]IOT_MQTT_Subscribe() failed, rc = %d\r\n", rc); } else { UAGENT_INFO("[uA]IOT_MQTT_Subscribe(%s) success\r\n", broadcast_topic_dn); } #endif mqtt_comm_init = 1; } else { UAGENT_ERR("[uA]### MQTT construct Fail"); } } else { UAGENT_ERR("[uA]invalid argument or uagent_comm already build"); } return rc; } int uagent_ext_comm_publish(const unsigned short len, void* data, const bool conn_orient) { int rc = 0; if (mqtt_client != NULL) { rc = aiot_mqtt_pub(mqtt_client, mqtt_topic_up, data, len, conn_orient ? CORE_MQTT_QOS1 : CORE_MQTT_QOS0); } else { UAGENT_ERR("[uA]mqtt client not init"); rc = -1; } return rc; } char check_connect() { char rc = 0; if (NULL != mqtt_client) { core_mqtt_handle_t *mqtt_handle = mqtt_client; if (mqtt_handle->disconnected == 0 && mqtt_handle->has_connected == 1) { rc = 1; } else { rc = 0; } } return rc; } int uagent_mqtt_client_set(void *mqtt_client_handle) { int rc = 0; if (NULL != mqtt_client_handle) { mqtt_client = mqtt_client_handle; rc = 0; } else { UAGENT_ERR("[uA] mqtt client is NULL"); rc = -1; } return rc; }
YifuLiu/AliOS-Things
components/uagent/src/uagent_comm_mqtt.c
C
apache-2.0
4,946
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #include <string.h> #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include "uagent.h" #include "uagent_inner_api.h" #include "aos/kernel.h" #include "aos/errno.h" #include "k_config.h" #include "cJSON.h" typedef struct { ua_mod_t mod; ua_func_t func; on_customer_service service; void* arg; } uagent_service_node; typedef struct { ua_mod_t mod; ua_func_t func; unsigned long id; ua_mod_t src; /* not apply to down stream */ unsigned short len; }uagent_exchange_header_t; typedef struct { ua_func_t func; char func_name[UAGENT_FUNC_NAME_SIZE]; on_customer_service service; void* arg; }uagent_exchange_service_t; uagent_service_attr_t uagent_service_attr = { 0, 0 }; static uagent_service_node *uagent_service_tb[UAGENT_SERVICE_SIZE] = { NULL }; static mod_func_t *mod_func[UAGENT_MOD_SIZE] = { NULL }; static aos_queue_t uagent_queue; static uint8_t* uagent_queue_buffer; static aos_task_t uagent_task; static aos_timer_t timer_request_cloud_connect; static aos_timer_t timer_monitor_output_queue; /* Private Operation Declaration */ static int update_create_uagent_service_node(const ua_mod_t mod, const ua_func_t func, on_customer_service service, void *arg, const char add); static int uagent_on_recv_handler(const unsigned short len, const char *str); static void uagent_routine(void *para); /* pre-define service of uAgent */ static void service_check_connect(void); static void service_report_func_list(void); static void service_update_delay_send_param(const unsigned short len, void *str); static void uagent_timer_service(void *timer, void *para) { if (NULL != timer) { if (timer == (&timer_request_cloud_connect)) { uagent_request_service(UAGENT_MOD_UAGENT, UAGENT_MOD_UAGENT, UAGENT_FUNC_UA_RQST_CONN, 0, NULL); } else if (timer == (&timer_monitor_output_queue)) { uagent_request_service(UAGENT_MOD_UAGENT, UAGENT_MOD_UAGENT, UAGENT_FUNC_UA_DUMP_DELAY_SEND, 0, NULL); } } } void start_monitor_delay_out(void) { aos_timer_start(&timer_monitor_output_queue); } void stop_monitor_delay_out(void) { aos_timer_stop(&timer_monitor_output_queue); } /* Public Operation Implementation */ int uagent_init(void) { int rc = 0; if (!UAGENT_INITED_FINISH) { uagent_init_mutex(); rc = -1; /* initial uagent queue */ uagent_queue_buffer = aos_malloc(UAGENT_PAYLOAD_CMD_SIZE*UAGENT_QUEUE_COUNT); if (NULL != uagent_queue_buffer) { if (0 == aos_queue_new(&uagent_queue, uagent_queue_buffer, UAGENT_PAYLOAD_CMD_SIZE*UAGENT_QUEUE_COUNT, UAGENT_PAYLOAD_CMD_SIZE)) { if (0 == aos_task_new_ext(&uagent_task, "uagent", uagent_routine, NULL, UAGENT_ROUTINE_TASK_STACK_DEPTH, RHINO_CONFIG_USER_PRI_MAX - 2)) { uagent_service_attr.initd = UAGENT_INITED; rc = 0; } else { aos_queue_free(&uagent_queue); aos_free(uagent_queue_buffer); uagent_queue_buffer = NULL; } } else { aos_free(uagent_queue_buffer); uagent_queue_buffer = NULL; } } } return rc; } int uagent_ext_comm_start(const char *pk, const char *dn) { int rc = -EINVAL; if (uagent_service_attr.service_started==0 && NULL != pk && NULL != dn && strlen(pk)>0 && strlen(dn)>0 && UAGENT_INITED_FINISH) { strncpy(uagent_service_attr.pk, pk, sizeof(uagent_service_attr.pk) - 1); strncpy(uagent_service_attr.dn, dn, sizeof(uagent_service_attr.dn) - 1); rc = uagent_ext_comm_init(uagent_service_attr.pk, uagent_service_attr.dn, uagent_on_recv_handler); /* todo: re-try in routine if start fail */ #if UAGENT_CHECK_COMM_CYCLE!=0 if (0 != aos_timer_new(&timer_request_cloud_connect, uagent_timer_service, NULL, UAGENT_CHECK_COMM_CYCLE, 1)) { UAGENT_ERR("[uA]uagent start timer fail\n"); } #endif if (0 != aos_timer_new_ext(&timer_monitor_output_queue, uagent_timer_service, NULL, UAGENT_WAIT_BUFFER, 0, 0)) { UAGENT_ERR("[uA]uagent start timer fail\n"); } uagent_service_attr.service_started = 1; } return rc; } int uagent_register(const ua_mod_t mod, const char *mod_name, char *version, const ua_func_t func, const char *func_name, on_customer_service cb, void *arg) { if (UAGENT_INITED_FINISH) { /* pre handle special event require */ switch (func) { case UAGENT_FUNC_NOTIFY_CLOUD_CONN: { char buf[UAGENT_PAYLOAD_CMD_STR_SIZE]; snprintf(buf, UAGENT_PAYLOAD_CMD_STR_SIZE, UAGENT_NOTICE_CONNECT, uagent_service_attr.cloud_connect); if (NULL != cb) { cb(arg, strlen(buf) + 1, buf); } } break; default: break; } uagent_exchange_service_t uagent_exchange_service = { func, "", cb, arg }; memset(uagent_exchange_service.func_name, 0, sizeof(uagent_exchange_service.func_name)); strncpy(uagent_exchange_service.func_name, func_name==NULL?"":func_name, sizeof(uagent_exchange_service.func_name) - 1); if (func >= UAGENT_FUNC_USER_BASE) { if (NULL != mod_name && NULL != version) { unsigned char i = 0; for (; i < UAGENT_MOD_SIZE; i++) { if (mod_func[i] == NULL) { mod_func[i] = (mod_func_t*)aos_malloc(sizeof(mod_func_t)); if (mod_func[i] != NULL) { mod_func[i]->header = NULL; mod_func[i]->mod_info.mod = mod; mod_func[i]->mod_info.func_count = 0; mod_func[i]->mod_info.name = (char*)aos_malloc(strlen(mod_name) + 1); if (NULL != mod_func[i]->mod_info.name) { strncpy(mod_func[i]->mod_info.name, mod_name, strlen(mod_name)); mod_func[i]->mod_info.name[strlen(mod_name)] = '\0'; } mod_func[i]->mod_info.version = (char*)aos_malloc(strlen(version) + 1); if (NULL != mod_func[i]->mod_info.version) { strncpy(mod_func[i]->mod_info.version, version, strlen(mod_name)); mod_func[i]->mod_info.version[strlen(version)] = '\0'; } } break; } else { if (mod_func[i]->mod_info.mod == mod) { /* already exist */ break; } } } } } return uagent_request_service(mod, UAGENT_MOD_UAGENT, UAGENT_FUNC_UA_REGISTER, sizeof(uagent_exchange_service), &uagent_exchange_service); } return -1; } int uagent_unregister(const ua_mod_t mod, const ua_func_t func) { if (UAGENT_INITED_FINISH) { uagent_exchange_service_t uagent_exchange_service = { func, "", NULL, NULL }; return uagent_request_service(mod, UAGENT_MOD_UAGENT, UAGENT_FUNC_UA_UNREGISTER, sizeof(uagent_exchange_service), &uagent_exchange_service); } return -1; } int uagent_request_service(const ua_mod_t src, const ua_mod_t target, const ua_func_t func, const unsigned short len, const void *data) { int rc = -EINVAL; if (len == 0 || NULL != data) { rc = -1; if (UAGENT_INITED_FINISH) { /* make uagent info */ char tmp_buf[UAGENT_PAYLOAD_CMD_SIZE]; uagent_exchange_header_t *p = (uagent_exchange_header_t *)tmp_buf; p->src = src; p->mod = target; p->id = UAGENT_MSG_IDX_INVALID; p->func = func; p->len = len < UAGENT_PAYLOAD_CMD_SIZE - sizeof(uagent_exchange_header_t) - 1 ? len : UAGENT_PAYLOAD_CMD_SIZE - sizeof(uagent_exchange_header_t) - 1; memcpy(&tmp_buf[sizeof(uagent_exchange_header_t)], data, p->len); if (UAGENT_MOD_UAGENT != target && UAGENT_FUNC_UA_RQST_CONN != func) { UAGENT_INFO("[uA]call %s src 0x%x func 0x%x len %d\n", __func__, p->src, p->func, p->len); } tmp_buf[p->len + sizeof(uagent_exchange_header_t)] = 0; rc = aos_queue_send(&uagent_queue, p, p->len + sizeof(uagent_exchange_header_t) + 1); } } return rc; } /** * update or create uagent service node * * * @param[in] mod Module type, reference @ua_mod_t * @param[in] func Service Name * @param[in] service Service routine * @param[in] add add(update) or remove * * @return >=0: Success, -EINVAL: invalid parameter, -ENOMEN: no enough to malloc -EIO: Table is full * */ static int update_create_uagent_service_node(const ua_mod_t mod, const ua_func_t func, on_customer_service service, void *arg, const char add) { int rc = -EIO; unsigned char i = 0; while (i < UAGENT_SERVICE_SIZE) { if (uagent_service_tb[i] != NULL) { if (uagent_service_tb[i]->mod == mod && uagent_service_tb[i]->func == func) { break; } } i++; } UAGENT_INFO("[uA]Register Service mod 0x%x func 0x%x\n", mod, func); if (UAGENT_SERVICE_SIZE == i) { /* no found it */ if (add != 0) { /* create it */ i = 0; while (i < UAGENT_SERVICE_SIZE) { if (uagent_service_tb[i] == NULL) { break; } i++; } if (i < UAGENT_SERVICE_SIZE) { uagent_service_tb[i] = (uagent_service_node*)aos_malloc(sizeof(uagent_service_node)); if (uagent_service_tb[i] == NULL) { rc = -ENOMEM; } else { uagent_service_tb[i]->mod = mod; uagent_service_tb[i]->func = func; uagent_service_tb[i]->service = service; uagent_service_tb[i]->arg = arg; rc = i; } } else { rc = -EIO; } } else { rc = 0; } } else { /* found it in list, */ if (add != 0) { /* update call back */ uagent_service_tb[i]->service = service; uagent_service_tb[i]->arg = arg; rc = i; } else { aos_free(uagent_service_tb[i]); uagent_service_tb[i] = NULL; rc = i; } } return rc; } static void update_func_list(const ua_mod_t mod, const ua_func_t func, char *func_name, const char add) { unsigned char i = 0; while (mod_func[i] != NULL) { if (mod_func[i]->mod_info.mod == mod) { if (add) { add_list(mod_func[i], func, func_name); } else { del_list(mod_func[i], func); } } i++; } } static int ext_request_service(const ua_mod_t src, const ua_mod_t target, const ua_func_t func, const unsigned long id, const unsigned short len, const void *data) { int rc = -1; if (UAGENT_INITED_FINISH) { /* make uagent info */ char tmp_buf[UAGENT_PAYLOAD_CMD_SIZE]; uagent_exchange_header_t* p = (uagent_exchange_header_t*)tmp_buf; p->src = src; p->mod = target; p->id = id; p->func = func; p->len = len < UAGENT_PAYLOAD_CMD_SIZE - sizeof(uagent_exchange_header_t) - 1 ? len : UAGENT_PAYLOAD_CMD_SIZE - sizeof(uagent_exchange_header_t) - 1; memcpy(&tmp_buf[sizeof(uagent_exchange_header_t)], data, p->len); if (UAGENT_MOD_UAGENT != target && UAGENT_FUNC_UA_RQST_CONN != func) { UAGENT_DEBUG("[uA]%s src 0x%x func 0x%x len %d\n", __func__, p->src, p->func, p->len); } tmp_buf[p->len + sizeof(uagent_exchange_header_t)] = 0; rc = aos_queue_send(&uagent_queue, p, p->len + sizeof(uagent_exchange_header_t) + 1); } return rc; } static void uagent_routine(void *para) { char tmp_buf[UAGENT_PAYLOAD_CMD_SIZE]; unsigned int rcv_size = 0; while (true) { if (0 == aos_queue_recv(&uagent_queue, AOS_WAIT_FOREVER, tmp_buf, &rcv_size)) { if (rcv_size >= sizeof(uagent_exchange_header_t)) { const uagent_exchange_header_t* p = (uagent_exchange_header_t*)tmp_buf; /* handle on pre-define service by UAGENT self */ if (UAGENT_MOD_UAGENT == p->mod) { int rc = -1; switch (p->func) { case UAGENT_FUNC_UA_REGISTER: if (sizeof(uagent_exchange_service_t) == p->len) { uagent_exchange_service_t* service_info = (uagent_exchange_service_t*)&tmp_buf[sizeof(uagent_exchange_header_t)]; if (0 > (rc = update_create_uagent_service_node(p->src, service_info->func, service_info->service, service_info->arg, UAGENT_REGISTER))) { UAGENT_ERR("[uA]register mod 0x%x, func str %s fail %d\n", p->src, service_info->func_name, rc); } else { update_func_list(p->src, service_info->func, service_info->func_name, UAGENT_FUNC_UA_REGISTER); } } break; case UAGENT_FUNC_UA_UNREGISTER: if (sizeof(uagent_exchange_service_t) == p->len) { uagent_exchange_service_t* service_info = (uagent_exchange_service_t*)&tmp_buf[sizeof(uagent_exchange_header_t)]; if (0 > (rc = update_create_uagent_service_node(p->src, service_info->func, NULL, NULL, UAGENT_UNREGISTER))) { UAGENT_ERR("[uA]un-register mod 0x%x, func %d fail %d\n", p->src, service_info->func, rc); } else { update_func_list(p->src, service_info->func, service_info->func_name, UAGENT_FUNC_UA_UNREGISTER); } } break; case UAGENT_FUNC_UA_RQST_CONN: service_check_connect(); break; case UAGENT_FUNC_UA_SHOW_LIST: UAGENT_DEBUG("[uA]call %s get request show list plen %d", __func__, p->len); if (p->len > 0) { if (strncmp(&tmp_buf[sizeof(uagent_exchange_header_t)], "?", 2) == 0) { service_report_func_list(); } else { UAGENT_ERR("[uA]call %s illegal cmd str %s\n", __func__, &tmp_buf[sizeof(uagent_exchange_header_t)]); } } break; case UAGENT_FUNC_UA_DUMP_DELAY_SEND: uagent_send(UAGENT_MOD_CLI, UAGENT_FUNC_USER_BASE, 0, NULL, send_policy_delay_dump | send_policy_delay); break; case UAGENT_FUNC_UA_DUMP_DELAY_SEND_PARAM: service_update_delay_send_param(p->len, &tmp_buf[sizeof(uagent_exchange_header_t)]); break; default: break; } } else { unsigned char i = 0; while (i < UAGENT_SERVICE_SIZE) { if (NULL != uagent_service_tb[i]) { /* no break for broadcast function */ if (p->mod == UAGENT_MOD_BROAD_CAST) { if (p->func == uagent_service_tb[i]->func) { UAGENT_DEBUG("handler mod 0x%x, func 0x%x, str %s @ %d\n", p->mod, p->func, &tmp_buf[sizeof(uagent_exchange_header_t)], i); if (NULL != uagent_service_tb[i]->service) { uagent_service_tb[i]->service(uagent_service_tb[i]->arg, p->len, &tmp_buf[sizeof(uagent_exchange_header_t)]); } } } else if ((p->mod == uagent_service_tb[i]->mod) && (p->func == uagent_service_tb[i]->func)) { UAGENT_DEBUG("handler mod 0x%x, func 0x%x, str %s @ %d\n", p->mod, p->func, &tmp_buf[sizeof(uagent_exchange_header_t)], i); if (NULL != uagent_service_tb[i]->service) { uagent_service_tb[i]->service(uagent_service_tb[i]->arg, p->len, &tmp_buf[sizeof(uagent_exchange_header_t)]); if (UAGENT_MSG_IDX_INVALID != p->id) { uagent_ack(SERVICE_AGENT_OK, p->id, p->mod, p->func, NULL); } } else { if (UAGENT_MSG_IDX_INVALID != p->id) { uagent_ack(SERVICE_AGENT_FAIL, p->id, p->mod, p->func, "no service"); } UAGENT_ERR("[uA]found mod 0x%x func 0x%x but service is null\n", p->mod, p->func); } break; } } i++; } if (p->mod != UAGENT_MOD_BROAD_CAST && (UAGENT_SERVICE_SIZE == i)) { UAGENT_ERR("[uA]no found mod 0x%x func 0x%x id %ld\n", p->mod, p->func, p->id); if (UAGENT_MSG_IDX_INVALID != p->id) { uagent_ack(SERVICE_AGENT_FAIL, p->id, p->mod, p->func, "no service"); } } } } } else { UAGENT_ERR("[uA]uagent routine recv msg fail\n"); } } } static int uagent_on_recv_handler(const unsigned short len, const char *str) { int rc = -1; cJSON *root = NULL; root = cJSON_Parse(str); if (NULL != root) { cJSON *params = cJSON_GetObjectItem(root, "params"); if (params != NULL) { cJSON *value_text = cJSON_GetObjectItem(params, "value"); if (value_text != NULL) { cJSON *msgid = cJSON_GetObjectItem(value_text, "id"); /* even no id can call service, w/o ack */ unsigned long id = UAGENT_MSG_IDX_INVALID; if (NULL != msgid) { if(cJSON_IsNumber(msgid)) { id = msgid->valueint; } else if(cJSON_IsString(msgid)) { id = strtoul(msgid->valuestring, NULL, 10); } } else { UAGENT_ERR("[uA]call %s no id in payload\n", __func__); } cJSON *mod = cJSON_GetObjectItem(value_text, "mod"); cJSON *func = cJSON_GetObjectItem(value_text, "func"); if (NULL != mod && NULL != func) { cJSON *param = cJSON_GetObjectItem(value_text, "param"); if (NULL != param) { if (cJSON_IsObject(param)) {/* param is json object */ UAGENT_INFO("Json object\n"); char* value_str = cJSON_PrintUnformatted(param); if (NULL != value_str) { rc = 0; ext_request_service(UAGENT_MOD_CLOUD, mod->valueint, func->valueint, id, strlen(value_str), value_str); cJSON_free(value_str); value_str = NULL; } } else if (cJSON_IsString(param)) {/* param is string */ UAGENT_INFO("String %s\n", param->valuestring); rc = 0; ext_request_service(UAGENT_MOD_CLOUD, mod->valueint, func->valueint, id, strlen(param->valuestring), param->valuestring); } else { UAGENT_ERR("[uA]Not support format\n"); } } else { UAGENT_ERR("[uA]missing param\n"); } } else { /* print topic name and topic message */ char* json_str = cJSON_Print(value_text); if (NULL != json_str) { UAGENT_ERR("[uA]LLEGAL FORMAT %s\n", json_str); cJSON_free(json_str); json_str = NULL; } } } else { UAGENT_ERR("[uA]call %s no value in payload\n", __func__); } } else { UAGENT_ERR("[uA]call %s no params in payload\n", __func__); } cJSON_Delete(root); root = NULL; } else { UAGENT_ERR("[uA]ILLEGAL FORMAT, Not Json Object\n"); } return rc; } static void service_check_connect() { if (uagent_service_attr.cloud_connect != check_connect()) { UAGENT_INFO("[uA]cloud connect change %d->%d\n", uagent_service_attr.cloud_connect, check_connect()); uagent_service_attr.cloud_connect = check_connect(); /* make connect string */ char buf[32]; sprintf(buf, UAGENT_NOTICE_CONNECT, uagent_service_attr.cloud_connect); uagent_request_service(UAGENT_MOD_UAGENT, UAGENT_MOD_BROAD_CAST, UAGENT_FUNC_NOTIFY_CLOUD_CONN, strlen(buf) + 1, buf); if (uagent_service_attr.cloud_connect) { service_report_func_list(); } } } static void service_report_func_list() { unsigned char mod_idx = 0; cJSON *root = NULL; char *out = NULL; cJSON *mod_obj[UAGENT_MOD_SIZE]; char init_mod_report = 0; root = cJSON_CreateObject(); if (NULL == root) { UAGENT_ERR("[uA] creat root json fail \r\n"); return ; } while (NULL != mod_func[mod_idx]) { init_mod_report = 0; UAGENT_INFO("[uA]mod %s have func %d\n", mod_func[mod_idx]->mod_info.name, mod_func[mod_idx]->mod_info.func_count); uagent_func_node_t *p = mod_func[mod_idx]->header; cJSON *arr = NULL, *json = NULL; while (NULL != p) { if (p->func >= UAGENT_FUNC_USER_BASE) { UAGENT_INFO("[uA]Summit func %d name %s\n", p->func, p->func_name); if (0 == init_mod_report) { init_mod_report = 1; cJSON_AddItemToObject(root, mod_func[mod_idx]->mod_info.name, mod_obj[mod_idx] = cJSON_CreateObject()); cJSON_AddNumberToObject(mod_obj[mod_idx], "module", mod_func[mod_idx]->mod_info.mod); cJSON_AddStringToObject(mod_obj[mod_idx], "version", mod_func[mod_idx]->mod_info.version); cJSON_AddItemToObject(mod_obj[mod_idx], "funclist", arr = cJSON_CreateArray()); } json = cJSON_CreateObject(); cJSON_AddNumberToObject(json, "func", p->func); cJSON_AddStringToObject(json, "funcname", p->func_name); cJSON_AddItemToArray(arr, json); } else { UAGENT_DEBUG("[uA]call %s Not summit func %d name %s\n", __func__, p->func, p->func_name); } p = p->next; } mod_idx++; } out = cJSON_PrintUnformatted(root); if (out == NULL) { UAGENT_ERR("[uA] %s %d json print unformate fail\r\n", __FILE__, __LINE__); return ; } UAGENT_INFO("[uA]up uA List %s\n", out); uagent_send(UAGENT_MOD_UAGENT, UAGENT_FUNC_UA_SHOW_LIST, strlen(out), out, send_policy_trans_guarantee | send_policy_object); cJSON_free(out); cJSON_Delete(root); } static void service_update_delay_send_param(const unsigned short len, void *str) { if (len > 0 && NULL != str) { char* str_value = NULL; if (NULL != (str_value = strstr(str, "cli cloud timeout="))) { UAGENT_DEBUG("call %s str value %s\n", __func__, str_value); const int timeout = strtoul(&str_value[strlen("cli cloud timeout=")], NULL, 10); if (timeout >= 20 && timeout <= 5000) { UAGENT_DEBUG("call %s delay timeout %d\n", __func__, timeout); aos_timer_change(&timer_monitor_output_queue, timeout); } } } }
YifuLiu/AliOS-Things
components/uagent/src/uagent_core.c
C
apache-2.0
26,526
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #include <string.h> #include "uagent.h" #include "uagent_inner_api.h" #include "aos/kernel.h" #include "aos/errno.h" #include "k_config.h" #include "uagent_config.h" #define UAGENT_CONFIG_SUPPORT_BASE64 1 static int pub_info(const unsigned short len, void *str, const bool trans_guarantee); static char msg_pub[UAGENT_INFO_PAYLOAD_SIZE]; #ifdef UAGENT_CONFIG_SUPPORT_BASE64 #include "mbedtls/base64.h" static unsigned char msg_pub_base64[UAGENT_INFO_PAYLOAD_BASE64_SIZE]; #endif static char *msg_delay_pub = NULL; static unsigned short msg_delay_pub_len = 0; static unsigned long out_msg_index = 0; static unsigned long uganet_send_id = 0; static int delay_send(const ua_mod_t mod, const ua_func_t func, const unsigned short len, const void *data, const ua_send_policy_t policy) { int rc = -1; bool send_directly = false; bool append_new = false; char *out = (char*)data; UAGENT_DEBUG("call %s policy 0x%x len %d, old %d\n",__func__,policy, len,msg_delay_pub_len); if(NULL==msg_delay_pub){ msg_delay_pub = (char*)aos_malloc(UAGENT_INFO_PAYLOAD_SIZE); if(NULL==msg_delay_pub){ UAGENT_ERR("[uA]allock memory for delay send fail\n"); return -ENOMEM; } } if (POLICY_SET(policy, send_policy_delay_dump)) { if (msg_delay_pub_len != 0) { out = msg_delay_pub; send_directly = true; } } else { if (0 == msg_delay_pub_len) { if (len < UAGENT_INFO_NEAR_FULL) { memset(msg_delay_pub, 0, UAGENT_INFO_PAYLOAD_SIZE); append_new = true; } else { /* send out right now */ send_directly = true; } } else { if ((len + msg_delay_pub_len) >= UAGENT_INFO_PAYLOAD_SIZE) { send_directly = true; out = msg_delay_pub; append_new = true; } else if ((len + msg_delay_pub_len) >= UAGENT_INFO_NEAR_FULL) { send_directly = true; out = msg_delay_pub; memcpy(&msg_delay_pub[msg_delay_pub_len], data, len); msg_delay_pub_len += len; } else { append_new = true; } } } if (send_directly) { UAGENT_DEBUG("call %s will pop out (%d)\n",__func__,msg_delay_pub_len); if (msg_delay_pub_len != 0) { /* stop the alarm */ stop_monitor_delay_out(); } if (uagent_get_mutex()) { int msg_len = 0; #ifdef UAGENT_CONFIG_SUPPORT_BASE64 size_t actual_len = 0; memset(msg_pub_base64, 0, UAGENT_INFO_PAYLOAD_BASE64_SIZE); if(0==mbedtls_base64_encode(msg_pub_base64, UAGENT_INFO_PAYLOAD_BASE64_SIZE, &actual_len, (unsigned char *)out, strlen(out)) && actual_len<=UAGENT_INFO_PAYLOAD_BASE64_SIZE){ msg_len = snprintf(msg_pub, sizeof(msg_pub), UAGENT_INFO_STR, uganet_send_id++, out_msg_index++, uagent_service_attr.dn, uagent_service_attr.to_console, mod, func, msg_pub_base64); } else { msg_len = snprintf(msg_pub, sizeof(msg_pub), UAGENT_INFO_STR, uganet_send_id++, out_msg_index++, uagent_service_attr.dn, uagent_service_attr.to_console, mod, func, out); } #else msg_len = snprintf(msg_pub, sizeof(msg_pub), UAGENT_INFO_STR, uganet_send_id++, out_msg_index++, uagent_service_attr.dn, uagent_service_attr.to_console, mod, func, out); #endif if (msg_len > 0 && msg_len < UAGENT_INFO_PAYLOAD_SIZE) { UAGENT_DEBUG("[uA]upload payload %s", msg_pub); rc = pub_info(msg_len, msg_pub, (policy&send_policy_trans_guarantee) ? 1 : 0); } else { UAGENT_ERR("[uA]miss pub as payload over flow %d\n", msg_len); } uagent_release_mutex(); } msg_delay_pub_len = 0; memset(msg_delay_pub, 0, UAGENT_INFO_PAYLOAD_SIZE); } if (append_new) { if (msg_delay_pub_len == 0) { UAGENT_DEBUG("call %s create new alarm (%d)\n",__func__,len); /* 0->1 create alarm */ start_monitor_delay_out(); } UAGENT_DEBUG("call %s save len %d, old %d\n",__func__, len,msg_delay_pub_len); memcpy(&msg_delay_pub[msg_delay_pub_len], data, len); msg_delay_pub_len += len; rc = 0; } return rc; } int uagent_send(const ua_mod_t mod, const ua_func_t func, const unsigned short len, const void *data, const ua_send_policy_t policy) { int rc = -EINVAL; if(0==len || NULL !=data) { rc = -1; if (UAGENT_INITED_FINISH) { rc = -ENOMEM; if (len < UAGENT_INFO_PAYLOAD_SIZE) { if (uagent_get_mutex()) { if (POLICY_SET(policy,send_policy_delay) && !POLICY_SET(policy,send_policy_object)) { rc = delay_send(mod, func, len, data, policy); }else{ short msg_len = snprintf(msg_pub, sizeof(msg_pub), UAGENT_FORMAT_PRE, uganet_send_id++, out_msg_index++, uagent_service_attr.dn, uagent_service_attr.to_console, mod, func); if(msg_len>0){ short empty_room_for_data = 0; if (POLICY_SET(policy,send_policy_object)) { empty_room_for_data = UAGENT_INFO_PAYLOAD_SIZE-msg_len-strlen(UAGENT_FORMAT_OBJ_SUFFIX)-1; strncpy(&msg_pub[msg_len], data, len<empty_room_for_data?len:empty_room_for_data); msg_len += (len<empty_room_for_data?len:empty_room_for_data); strncpy(&msg_pub[msg_len], UAGENT_FORMAT_OBJ_SUFFIX, UAGENT_INFO_PAYLOAD_SIZE-msg_len-1); msg_len += strlen(UAGENT_FORMAT_OBJ_SUFFIX); if (msg_len < UAGENT_INFO_PAYLOAD_SIZE) { rc = pub_info(msg_len, msg_pub, POLICY_SET(policy,send_policy_trans_guarantee)); } else { UAGENT_ERR("[uA]miss pub as payload over flow %d\n", msg_len); } } else { msg_pub[msg_len++] = '"'; empty_room_for_data = UAGENT_INFO_PAYLOAD_SIZE-msg_len-strlen(UAGENT_FORMAT_STR_SUFFIX)-1; size_t actual_len = 0; #ifdef UAGENT_CONFIG_SUPPORT_BASE64 memset(msg_pub_base64, 0, UAGENT_INFO_PAYLOAD_BASE64_SIZE); if(0==mbedtls_base64_encode(msg_pub_base64, UAGENT_INFO_PAYLOAD_BASE64_SIZE, &actual_len, data, len)){ strncpy(&msg_pub[msg_len], (char *)msg_pub_base64, empty_room_for_data); } else { actual_len = len; strncpy(&msg_pub[msg_len], data, empty_room_for_data); } #else actual_len = len; strncpy(&msg_pub[msg_len], data, empty_room_for_data); #endif msg_len += (actual_len<empty_room_for_data?actual_len:empty_room_for_data); strncpy(&msg_pub[msg_len], UAGENT_FORMAT_STR_SUFFIX, UAGENT_INFO_PAYLOAD_SIZE-msg_len-1); msg_len += strlen(UAGENT_FORMAT_STR_SUFFIX); if (msg_len < UAGENT_INFO_PAYLOAD_SIZE) { rc = pub_info(msg_len, msg_pub, POLICY_SET(policy,send_policy_trans_guarantee)); } else { UAGENT_ERR("[uA]miss pub as payload over flow %d\n", msg_len); } } } } uagent_release_mutex(); } } }else{ UAGENT_ERR("[uA]uagent send may fail from 0x%x 0x%x as not inited", mod, func); } } return rc; } int uagent_ack(const service_agent_rlt_t rlt, const unsigned long id, const ua_mod_t mod, const ua_func_t func, const void *data) { int rc = -1; if (UAGENT_INITED_FINISH) { int msg_len = 0; char msg_pub_ack[256]; if (SERVICE_AGENT_OK == rlt) { msg_len = snprintf(msg_pub_ack, sizeof(msg_pub_ack), UAGENT_INFO_ACK_OK, uganet_send_id++, uagent_service_attr.dn, uagent_service_attr.to_console, mod, func, SERVICE_AGENT_OK, id); } else { msg_len = snprintf(msg_pub_ack, sizeof(msg_pub_ack), UAGENT_INFO_ACK_FAIL, uganet_send_id++, uagent_service_attr.dn, uagent_service_attr.to_console, mod, func, SERVICE_AGENT_FAIL, (NULL == data) ? "unknown reason" : (char*)data, id); } UAGENT_DEBUG("call %s ack %d mod 0x%x func 0x%x id %ld\n", __func__,rlt, mod, func,id); if (msg_len > 0 && msg_len < UAGENT_INFO_PAYLOAD_SIZE) { rc = pub_info(msg_len, msg_pub_ack, 0); } else { UAGENT_ERR("[uA]miss pub as payload over flow %d\n", msg_len); } } return rc; } static int pub_info(const unsigned short len, void *str, const bool trans_guarantee) { int rc = -EINVAL; if (len > 0 && NULL != str) { rc = uagent_ext_comm_publish(len, str, trans_guarantee); UAGENT_INFO("[uA]send(%d) %s rc %d\n", len, (char*)str, rc); } return rc; }
YifuLiu/AliOS-Things
components/uagent/src/uagent_send.c
C
apache-2.0
9,990
/* * Copyright (C) 2015-2019 Alibaba Group Holding Limited */ #include <string.h> #include "uagent.h" #include "uagent_inner_api.h" #include "aos/kernel.h" #include "aos/errno.h" #include "k_config.h" #include "cJSON.h" static aos_mutex_t uagent_mutex; void uagent_init_mutex(void) { aos_mutex_new(&uagent_mutex); } bool uagent_get_mutex(void) { return 0 == aos_mutex_lock(&uagent_mutex, AOS_WAIT_FOREVER); } void uagent_release_mutex(void) { aos_mutex_unlock(&uagent_mutex); } int add_list(mod_func_t *mod_func_tree, const ua_func_t func, char *func_name) { int rc = -1; if (NULL != mod_func_tree && NULL != func_name) { UAGENT_DEBUG("will add list mod %s func %d func name %s\n", mod_func_tree->mod_info.name, func, func_name); uagent_func_node_t *header = mod_func_tree->header; if (NULL == mod_func_tree->header) { mod_func_tree->header = (uagent_func_node_t*)aos_malloc(sizeof(uagent_func_node_t)); if (NULL != mod_func_tree->header) { mod_func_tree->header->next = NULL; mod_func_tree->header->func = func; memset(mod_func_tree->header->func_name, 0, sizeof(mod_func_tree->header->func_name)); strncpy(mod_func_tree->header->func_name, func_name, sizeof(mod_func_tree->header->func_name) - 1); mod_func_tree->mod_info.func_count = 1; rc = 0; } else { UAGENT_ERR("[uA]alloc memory of func %s for mod %s fail\n", func_name, mod_func_tree->mod_info.name); } } else { uagent_func_node_t *p = header; while (p != NULL) { if (p->func == func) { /* found it alredy in list, just update */ memset(header->func_name, 0, sizeof(header->func_name)); strncpy(header->func_name, func_name, sizeof(header->func_name) - 1); /* keep the count */ rc = 0; break; } if (p->next == NULL) { p->next = (uagent_func_node_t*)aos_malloc(sizeof(uagent_func_node_t)); if (NULL != p->next) { p->next->next = NULL; p->next->func = func; memset(p->next->func_name, 0, sizeof(p->next->func_name)); strncpy(p->next->func_name, func_name, sizeof(p->next->func_name) - 1); mod_func_tree->mod_info.func_count++; rc = 0; } else { UAGENT_ERR("[uA]alloc memory of func %s for mod %s fail\n", func_name, mod_func_tree->mod_info.name); } break; } else { p = p->next; } } } } return rc; } int del_list(mod_func_t *mod_func_tree, const ua_func_t func) { int rc = -1; if (NULL != mod_func_tree) { uagent_func_node_t *header = mod_func_tree->header; if (NULL != header) { uagent_func_node_t *p = header; if (p->func == func) {/* header matches, remove it */ mod_func_tree->header = p->next; aos_free(p); p = NULL; rc = 0; } else { uagent_func_node_t *before = header; p = before->next; while (p != NULL) { if (p->func == func) { before->next = p->next;/* rear of list, just remove this node */ aos_free(p); p = NULL; rc = 0; break; } else { before = p; p = before->next; } } } if (0 == rc) { if (mod_func_tree->mod_info.func_count > 0) { mod_func_tree->mod_info.func_count--; } } } } return rc; }
YifuLiu/AliOS-Things
components/uagent/src/uagent_utility.c
C
apache-2.0
4,120
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #include <stdint.h> #include <stdio.h> #include "wifi_camera.h" #include "ucamera_service.h" #include "ulog/ulog.h" #if AOS_COMP_CLI #include "aos/cli.h" #endif #define TAG "ucamera_example" #define LOG printf #define CAPTURED_IMAGE "/data/capture.jpg" static void ucamera_comp_example(int argc, char **argv) { int ret; frame_buffer_t *frame = NULL; if (argc < 3) LOG("wrong parameter number\n"); if (!strncmp(argv[1], "init", 4)) { /*init network*/ event_service_init(NULL); netmgr_service_init(NULL); LOG("ucamera comp init successfully!\n"); } else if (!strncmp(argv[1], "-t", 2)) { if (!strcmp(argv[2], "wifi")) { /*init ucamera service*/ ret = ucamera_service_init(WIFI_CAMERA_NAME); if (ret < 0) { LOGE(TAG, "ucamera service init fail\n"); return; } ret = ucamera_service_config(UCAMERA_CMD_SET_CONTROL_URL, (void *)WIFICAMERA_FRAME_SIZE_CONTROL_URL); if (ret < 0) { LOGE(TAG, "ucamera_service_config frame size failed"); return; } ret = ucamera_service_connect(WIFICAMERA_URL); if (ret < 0) { LOGE(TAG, "ucamera service start fail\n"); return; } /*get one camera frame*/ frame = ucamera_service_get_frame(); if (!frame) { LOGE(TAG, "ucamera get frame fail\n"); return; } else { LOG("ucamera get frame OK!\n"); } /*save frame to jpeg file*/ ret = ucamera_service_save_frame(frame, CAPTURED_IMAGE); if (ret < 0) { LOGE(TAG, "save image fail\n"); return; } else { LOG("save image to %s successfully!\n", CAPTURED_IMAGE); } ret = ucamera_service_disconnect(); if (ret < 0) { LOGE(TAG, "ucamera service stop fail\n"); return; } /*uninit ucamera service*/ ucamera_service_uninit(); } else { LOG("unknown camera device type!\n"); } } return; } #if AOS_COMP_CLI /* reg args: fun, cmd, description*/ ALIOS_CLI_CMD_REGISTER(ucamera_comp_example, ucamera, ucamera component base example) #endif
YifuLiu/AliOS-Things
components/ucamera/example/ucamera_example.c
C
apache-2.0
2,494
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _UART_CAMERA_H_ #define _UART_CAMERA_H_ #define UART_CAMERA_NAME "uart-camera" #define UART_CAMERA_FRAME_WIDTH 320 #define UART_CAMERA_FRAME_HEIGHT 240 #endif // _UART_CAMERA_H_
YifuLiu/AliOS-Things
components/ucamera/include/device/uart/uart_camera.h
C
apache-2.0
254
#ifndef _UART_FRAME_H #define _UART_FRAME_H #include <stdio.h> #include <stdint.h> #define DISABLE_USE_UART_QUEUE typedef enum { IDLE = 0x00, WAIT_FINISH, FINISH, } frame_state_n; /* * frame_state is volatile type */ extern volatile frame_state_n frame_state; void uart_frame_init(int32_t rx, int32_t tx, uint32_t baud); void uart_frame_send(uint8_t cmd, const uint8_t *frame, uint32_t len, bool wait_finish); void uart_update_pin(int32_t rx, int32_t tx); int32_t uart_frame_recv(uint8_t **data, uint32_t *len); int32_t uart_frame_uninit(); #endif
YifuLiu/AliOS-Things
components/ucamera/include/device/uart/uart_frame.h
C
apache-2.0
568
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited */ #ifndef _DECHUNK_H_ #define _DECHUNK_H_ #include <stdio.h> #define DCE_OK 0 #define DCE_ISRUNNING 1 #define DCE_FORMAT 2 #define DCE_ARGUMENT 3 #define DCE_MEM 4 #define DCE_LOCK 5 int dechunk_init(); int dechunk(void *input, size_t inlen); int dechunk_getbuff(void **buff, size_t *buf_size); int dechunk_free(); void *memstr(void *src, size_t src_len, char *sub); #endif // _DECHUNK_H_
YifuLiu/AliOS-Things
components/ucamera/include/device/wifi/dechunk.h
C
apache-2.0
519
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _WIFI_CAMERA_H_ #define _WIFI_CAMERA_H_ #define WIFI_CAMERA_NAME "wifi-camera" #define WIFI_CAMERA_FRAME_WIDTH 320 #define WIFI_CAMERA_FRAME_HEIGHT 240 #endif // _WIFI_CAMERA_H_
YifuLiu/AliOS-Things
components/ucamera/include/device/wifi/wifi_camera.h
C
apache-2.0
254
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _CAMERA_COMMON_H_ #define _CAMERA_COMMON_H_ #include <stdint.h> typedef struct _frame_buffer_t { uint8_t *buf; uint32_t len; uint16_t width; uint16_t height; uint32_t format; } frame_buffer_t; typedef enum { SIZE_160X120 = 1, SIZE_240X240 = 4, SIZE_320X240 = 5, SIZE_640X480 = 8, SIZE_800X600 = 9, } size_id_t; typedef struct _frame_size_t { uint16_t width; uint16_t height; size_id_t id; } frame_size_t; typedef enum { FRAME_FORMAT_RGB565, FRAME_FORMAT_JPEG, FRAME_FORMAT_BMP, FRAME_FORMAT_PNG, FRAME_FORMAT_YUV, FRAME_FORMAT_MAX } frame_format_t; typedef enum { // for wifi camera only UCAMERA_CMD_SET_URL, UCAMERA_CMD_SET_CONTROL_URL, // for uart camera only UCAMERA_CMD_SET_UART_PARAMS, UCAMERA_CMD_SET_UPLOAD_TIME, UCAMERA_CMD_SET_WIFI_SSID_PWD, UCAMERA_CMD_SET_LED_BRIGHTNESS, UCAMERA_CMD_SET_MODE, UCAMERA_CMD_GET_TOKEN, // common command UCAMERA_CMD_SET_FRAME_SIZE, UCAMERA_CMD_SET_MIRROR, UCAMERA_CMD_SET_FLIP, UCAMERA_CMD_SET_POSITION, UCAMERA_CMD_MAX } command_t; #endif // _CAMERA_COMMON_H_
YifuLiu/AliOS-Things
components/ucamera/include/ucamera_common.h
C
apache-2.0
1,223
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _CAMERA_DEVICE_H_ #define _CAMERA_DEVICE_H_ #include <stdint.h> #include <stdbool.h> #include "wifi_camera.h" #include "uart_camera.h" #include "ucamera_service.h" #include "ucamera_common.h" typedef enum { CAM_WIFI_STA_MODE, CAM_UART_MODE, CAM_TIMING_MODE } cam_mode_t; typedef enum { CAM_WIFI_TYPE, CAM_UART_TYPE, CAM_USB_TYPE, } cam_dev_type_t; typedef struct _wifi_cam_params_t { const char *url; const char *control_url; } wifi_cam_params_t; typedef struct _uart_cam_params_t { uint32_t bandrate; uint32_t rx; uint32_t tx; cam_mode_t mode; uint32_t led_brightness; uint32_t upload_time; char *wifi_ssid; char *wifi_pwd; } uart_cam_params_t; typedef union { uart_cam_params_t uart; wifi_cam_params_t wifi; } ucamera_dev_params_t; typedef struct _ucamera_device_t { /* * * */ /* The name of this camera device */ const char *name; bool is_dummy; char *stream_buf; int32_t stream_len; /*frame size*/ frame_size_t frame_size; cam_dev_type_t type; /*params*/ ucamera_dev_params_t params; command_t cmd; /*frame*/ frame_buffer_t frame; /*init camera*/ int32_t (*camera_init) (struct _ucamera_device_t *dev); /*uninit camera*/ void (*camera_uninit) (struct _ucamera_device_t *dev); /*connect to camera device*/ int32_t (*camera_connect) (struct _ucamera_device_t *dev); /*disconnect to camera device, this can be done after camera init*/ int32_t (*camera_disconnect) (struct _ucamera_device_t *dev); /*config camera device, this should be done after camera init, before connect*/ int32_t (*camera_config) (struct _ucamera_device_t *dev); /*get camera frame*/ frame_buffer_t *(*camera_get_frame) (struct _ucamera_device_t *dev); void (*camera_free) (struct _ucamera_device_t *dev); } ucamera_device_t; ucamera_device_t *ucamera_device_init(const char *dev_name); void ucamera_device_uninit(void); const char *ucamera_get_device_name(void); ucamera_device_t *ucamera_get_device(void); #endif // _CAMERA_DEVICE_H_
YifuLiu/AliOS-Things
components/ucamera/include/ucamera_device.h
C
apache-2.0
2,183
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _CAMERA_SERVICE_H_ #define _CAMERA_SERVICE_H_ #include <stdint.h> #include "ucamera_device.h" #include "ucamera_common.h" #ifdef __cplusplus extern "C" { #endif #define UCAMERA_PIX_FMT_YYUV 0 #define UCAMERA_PIX_FMT_AYUV32 1 #define UCAMERA_PIX_FMT_ARGB32 2 #define UCAMERA_PIX_FMT_BGRA32 3 #define UCAMERA_PIX_FMT_RGB24 4 #define UCAMERA_PIX_FMT_BGR24 5 #define UCAMERA_PIX_FMT_YUV420 6 #define UCAMERA_PIX_FMT_YUV420SP 7 #define UCAMERA_PIX_FMT_PNG 8 #define UCAMERA_PIX_FMT_JPEG 9 typedef struct _ucamera_context_t { const char *name; const char *desc; cam_dev_type_t type; int (*available) (void); ucamera_device_t *(*create) (int devindex); } ucamera_context_t; extern ucamera_context_t wifi_camera; extern ucamera_context_t uart_camera; /** @defgroup ucamera_aos_api ucamera * @{ */ /** * Init the ucamera module. * * @param[in] dev_name device name. * @param[in] dev_name device name. * * @return 0 on success, negative error on failure. */ int32_t ucamera_service_init(const char *dev_name); /** * Uninit the ucamera module. * * @return 0 on success, negative error on failure. */ int32_t ucamera_service_uninit(void); /** * Config frame parameters of ucamera service * * @return frame buffer content. */ int32_t ucamera_service_config(command_t cmd, void *params); /** * Start the ucamera service * * @return 0 on success, negative error on failure. */ int32_t ucamera_service_connect(const char *url); /** * Stop the ucamera service * * @return 0 on success, negative error on failure. */ int32_t ucamera_service_disconnect(void); /** * Get one frame of camera device. * @return frame buffer content. */ frame_buffer_t *ucamera_service_get_frame(void); /** * Init the ucamera module. * @param[in] frame frame buffer content. * @param[in] path path of saving image. * @return 0 on success, negative error on failure. */ int ucamera_service_save_frame(frame_buffer_t *frame, const char *path); /** * @} */ #ifdef __cplusplus } // extern "C" #endif #endif // _WIFI_CAMERA_H_
YifuLiu/AliOS-Things
components/ucamera/include/ucamera_service.h
C
apache-2.0
2,166
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #include <stdio.h> #include <string.h> #include "ulog/ulog.h" #include "aos/kernel.h" #include "ucamera_service.h" #include "freertos/FreeRTOS.h" #include "freertos/queue.h" #include "freertos/semphr.h" #include "stdatomic.h" #include "uart_frame.h" // #include "lvgl.h" // #include "lvgl_helpers.h" // #include "axp192.h" // #include "i2c_manager.h" #include "tft/tft.h" #define TAG "UART_CAMERA" #define HEAD_SIZE 2048 #define BODY_SZIE (1024 * 128 + 1) // #define USE_LVGL_DRAW_IMAGE // #define USE_TFT ucamera_context_t uart_camera; static QueueHandle_t jpeg_frame_queue = NULL; static QueueHandle_t command_queue = NULL; static atomic_uint_fast8_t capture_image; static atomic_int_least32_t x; static atomic_int_least32_t y; static atomic_int_least32_t cmd_want; static char token[33]; typedef enum { kWifiSta, kUart, kTiming } CamMode_t; typedef struct _JpegFrame_t { uint8_t *buf; uint32_t size; } JpegFrame_t; typedef struct _uart_ommand_t { uint8_t cmd; uint8_t *buf; uint32_t size; } uart_command_t; void set_capture_image(uint8_t show) { atomic_store(&capture_image, show); } uint8_t get_capture_image(void) { return (uint8_t)atomic_load(&capture_image); } #if defined(USE_LVGL_DRAW_IMAGE) || defined(USE_TFT) static xSemaphoreHandle cap_sem; #endif #define CANVAS_WIDTH 320 #define CANVAS_HEIGHT 240 #ifdef USE_LVGL_DRAW_IMAGE #define LV_TICK_PERIOD_MS 1 #define I2C_0 i2c_hal(0) SemaphoreHandle_t xGuiSemaphore; static void lv_tick_task(void *arg) { (void) arg; lv_tick_inc(LV_TICK_PERIOD_MS); } static void guiTask(void *pvParameter) { (void) pvParameter; // ESP_LOGE(TAG, "gui task entern"); xGuiSemaphore = xSemaphoreCreateMutex(); /* Create and start a periodic timer interrupt to call lv_tick_inc */ const esp_timer_create_args_t periodic_timer_args = { .callback = &lv_tick_task, .name = "periodic_gui" }; esp_timer_handle_t periodic_timer; ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &periodic_timer)); ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, LV_TICK_PERIOD_MS * 1000)); while (1) { /* Delay 1 tick (assumes FreeRTOS tick is 10ms */ vTaskDelay(pdMS_TO_TICKS(10)); /* Try to take the semaphore, call lvgl related function on success */ if (pdTRUE == xSemaphoreTake(xGuiSemaphore, portMAX_DELAY)) { lv_task_handler(); xSemaphoreGive(xGuiSemaphore); } } vTaskDelete(NULL); } static void start_display(void) { // ESP_LOGE(TAG, "start_display"); xTaskCreatePinnedToCore(guiTask, "gui", 4096 * 10, NULL, 1, NULL, 0); } static void driver_init(void) { axp192_init(I2C_0); axp192_ioctl(I2C_0, AXP192_GPIO0_SET_LEVEL, AXP192_HIGH); // M-Bus Power axp192_ioctl(I2C_0, AXP192_GPIO1_SET_LEVEL, AXP192_LOW); // Enable LED axp192_ioctl(I2C_0, AXP192_GPIO2_SET_LEVEL, AXP192_LOW); // Disable speaker axp192_ioctl(I2C_0, AXP192_LDO2_SET_VOLTAGE, 3300); // Set LDO2 LCD&TP voltage axp192_ioctl(I2C_0, AXP192_LDO2_ENABLE); // Enable LDO2 axp192_ioctl(I2C_0, AXP192_GPIO4_SET_LEVEL, AXP192_LOW); // LCD&TP Reset vTaskDelay(100 / portTICK_PERIOD_MS); axp192_ioctl(I2C_0, AXP192_GPIO4_SET_LEVEL, AXP192_HIGH); // LCD&TP Hold vTaskDelay(100 / portTICK_PERIOD_MS); lvgl_driver_init(); start_display(); } static void draw_image(uint8_t *buf, uint32_t len) { static int init = 0; static lv_obj_t *canvas = NULL; static int8_t *cbuf = NULL; if (!buf) { return NULL; } if (init == 0) { printf("LV_CANVAS_BUF_SIZE_TRUE_COLOR(CANVAS_WIDTH, CANVAS_HEIGHT): %d\n", LV_CANVAS_BUF_SIZE_TRUE_COLOR(CANVAS_WIDTH, CANVAS_HEIGHT)); cbuf = (int8_t *)malloc(LV_CANVAS_BUF_SIZE_TRUE_COLOR(CANVAS_WIDTH, CANVAS_HEIGHT)); canvas = lv_canvas_create(lv_scr_act()); lv_canvas_set_buffer(canvas, cbuf, CANVAS_WIDTH, CANVAS_HEIGHT, LV_IMG_CF_TRUE_COLOR); lv_obj_center(canvas); lv_canvas_fill_bg(canvas, lv_palette_lighten(LV_PALETTE_GREY, 3), LV_OPA_COVER); } lv_img_dsc_t img; img.data = buf; img.data_size = len; img.header.always_zero = 0; img.header.w = CANVAS_WIDTH; img.header.h = CANVAS_HEIGHT; img.header.cf = LV_IMG_CF_TRUE_COLOR; lv_draw_img_dsc_t img_dsc; lv_draw_img_dsc_init(&img_dsc); lv_canvas_draw_img(canvas, 0, 0, &img, &img_dsc); lv_draw_rect_dsc_t rect_dsc; lv_draw_rect_dsc_init(&rect_dsc); rect_dsc.radius = 0; rect_dsc.bg_opa = LV_OPA_0; // rect_dsc.bg_grad_dir = LV_GRAD_DIR_HOR; rect_dsc.bg_color = lv_palette_main(LV_PALETTE_NONE); // rect_dsc.bg_grad_color = lv_palette_main(LV_PALETTE_BLUE); rect_dsc.border_width = 2; // rect_dsc.border_opa = LV_OPA_90; rect_dsc.border_color = lv_palette_main(LV_PALETTE_RED); rect_dsc.shadow_width = 5; rect_dsc.shadow_ofs_x = 0; rect_dsc.shadow_ofs_y = 0; lv_canvas_draw_rect(canvas, 70, 60, 100, 70, &rect_dsc); lv_draw_label_dsc_t label_dsc; lv_draw_label_dsc_init(&label_dsc); label_dsc.color = lv_palette_main(LV_PALETTE_YELLOW); lv_canvas_draw_text(canvas, 40, 20, 100, &label_dsc, "Some text on text canvas"); init = 1; } static lv_disp_draw_buf_t disp_buf; static lv_disp_drv_t disp_drv; static void lvgl_display_init(void) { // lv_color_t *buf1 = heap_caps_malloc(DISP_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA); // printf("(DISP_BUF_SIZE*sizeof(lv_color_t): %d\n", DISP_BUF_SIZE*sizeof(lv_color_t)); // lv_color_t *buf1 = (lv_color_t *)malloc(DISP_BUF_SIZE*sizeof(lv_color_t)); lv_color_t *buf1 = (lv_color_t *)malloc(12800); assert(buf1 != NULL); // lv_color_t *buf2 = heap_caps_malloc(DISP_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA); // lv_color_t *buf2 = (lv_color_t *)malloc(DISP_BUF_SIZE*sizeof(lv_color_t)); lv_color_t *buf2 = (lv_color_t *)malloc(12800); assert(buf2 != NULL); uint32_t size_in_px = 6400; // DISP_BUF_SIZE; lv_disp_draw_buf_init(&disp_buf, buf1, buf2, size_in_px); lv_disp_drv_init(&disp_drv); disp_drv.hor_res = 320; disp_drv.ver_res = 240; disp_drv.flush_cb = disp_driver_flush; disp_drv.draw_buf = &disp_buf; lv_disp_drv_register(&disp_drv); } #endif #if defined(USE_LVGL_DRAW_IMAGE) || defined(USE_TFT) static void jpeg_capture_task(void *arg) { int32_t ret = 0; // frame_buffer_t frame; // frame.buf = NULL; // frame.len = 0; ucamera_device_t *dev = (ucamera_device_t *)arg; printf("jpeg_capture_task start\n"); while (1) { long long start_recv = aos_now_ms(); ret = xQueueReceive(jpeg_frame_queue, &dev->frame, portMAX_DELAY); if (ret == pdTRUE) { long long end_recv = aos_now_ms(); printf("xQueueReceive ok, excute time: %lld\n", end_recv - start_recv); long long prev = aos_now_ms(); #ifdef USE_LVGL_DRAW_IMAGE draw_image(dev->frame.buf, dev->frame.len); xSemaphoreGive(cap_sem); #endif #ifdef USE_TFT TFT_jpg_image(atomic_load(&x), atomic_load(&y), 0, NULL, dev->frame.buf, dev->frame.len); xSemaphoreGive(cap_sem); #endif long long cur = aos_now_ms(); printf("draw image done, excute time: %lld\n", (cur - prev)); free(dev->frame.buf); dev->frame.buf = NULL; } else { printf("xQueueReceive fail\n"); } } } #endif uart_command_t *send_cmd(uint8_t cmd_in, uint8_t *buff, uint32_t size, uint32_t wait_time) { if (wait_time == 0) { uart_frame_send(cmd_in, buff, size, true); return NULL; } uart_command_t *cmd = malloc(sizeof(uart_command_t)); // heap_caps_malloc(sizeof(uart_command_t), MALLOC_CAP_DEFAULT | MALLOC_CAP_8BIT); if (cmd == NULL) { return NULL; } #ifdef DISABLE_USE_UART_QUEUE atomic_store(&cmd_want, cmd_in); uart_frame_send(cmd_in, buff, size, true); #else atomic_store(&cmd_want, -1); while (xQueueReceive(command_queue, cmd, 0) == pdTRUE) { free(cmd->buf); } atomic_store(&cmd_want, cmd_in); uart_frame_send(cmd_in, buff, size, true); if (xQueueReceive(command_queue, cmd, wait_time) == pdTRUE) { return cmd; } #endif // heap_caps_free(cmd); free(cmd); return NULL; } void frame_recv_callback(int cmd, const uint8_t *buf, int len) { if (atomic_load(&cmd_want) == (cmd & 0x7f)) { uart_command_t recv; recv.buf = (uint8_t *)calloc(1, len); // heap_caps_calloc(len, sizeof(uint8_t), MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL); if (recv.buf == NULL) { return ; } recv.size = len; memcpy(recv.buf, buf, len); if (xQueueSend(command_queue, &recv, 0) != pdTRUE) { free(recv.buf); } } if (cmd == 0x00) { printf("receive frame from queue 0\n"); if (get_capture_image() != 0) { frame_buffer_t frame; printf("receive frame from queue 1\n"); frame.buf = (uint8_t *)calloc(1, len); // heap_caps_calloc(len, sizeof(uint8_t), MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL); if (frame.buf == NULL) { printf("allocate frame.buf fail\n"); return; } memcpy(frame.buf, buf, len); frame.len = len; if (xQueueSend(jpeg_frame_queue, &frame, 0) != pdTRUE) { printf("xQueueSend fail\n"); free(frame.buf); } } } } static void uart_camera_delete(ucamera_device_t *dev) { free(dev); } static bool uart_camera_device_available(void) { return true; } int32_t uart_camera_init(ucamera_device_t *dev) { if (jpeg_frame_queue == NULL) { jpeg_frame_queue = xQueueCreate(1, sizeof(frame_buffer_t)); command_queue = xQueueCreate(2, sizeof(uart_command_t)); atomic_store(&capture_image, 1); atomic_init(&x, 0); atomic_init(&y, 0); atomic_init(&cmd_want, -1); #ifdef USE_LVGL_DRAW_IMAGE lv_init(); driver_init(); lvgl_display_init(); #endif #if defined(USE_LVGL_DRAW_IMAGE) || defined(USE_TFT) cap_sem = xSemaphoreCreateBinary(); xSemaphoreGive(cap_sem); #endif #if defined(USE_LVGL_DRAW_IMAGE) || defined(USE_TFT) xTaskCreatePinnedToCore(jpeg_capture_task, "jpeg show task", 4 * 1024, (void *)dev, 1, NULL, 0); #endif } else { uart_update_pin(dev->params.uart.rx, dev->params.uart.tx); } return 0; } int32_t uart_camera_uninit(ucamera_device_t *dev) { set_capture_image(0); return 0; } int32_t uart_camera_connect(ucamera_device_t *dev) { return 0; } void uart_camera_disconnect(ucamera_device_t *dev) { } int32_t uart_camera_config(ucamera_device_t *dev) { uint32_t data = 0; const char *ssid = NULL; const char *pwd = NULL; uint16_t ssid_len = 0; uint16_t pwd_len = 0; uint8_t *out_buf = NULL; if (!dev) return -1; switch (dev->cmd) { case UCAMERA_CMD_SET_UART_PARAMS: if (jpeg_frame_queue != NULL) uart_frame_init(dev->params.uart.rx, dev->params.uart.tx, dev->params.uart.bandrate); break; case UCAMERA_CMD_SET_FRAME_SIZE: send_cmd(1, (uint8_t *)&dev->frame_size.id, 2, 0); break; case UCAMERA_CMD_SET_MODE: if (dev->params.uart.mode == CAM_UART_MODE) { data = 5; send_cmd(1, (uint8_t *)&data, 2, 0); data = CAM_UART_MODE; send_cmd(26, (uint8_t *)&data, 1, 0); } else if (dev->params.uart.mode == CAM_TIMING_MODE) { data = 9; send_cmd(1, (uint8_t *)&data, 2, 0); data = CAM_TIMING_MODE; send_cmd(26, (uint8_t *)&data, 1, 0); } break; case UCAMERA_CMD_SET_LED_BRIGHTNESS: data = dev->params.uart.led_brightness; if (data > 1024) { data = 1024; } send_cmd(40, (uint8_t *)&data, 2, 0); break; case UCAMERA_CMD_SET_WIFI_SSID_PWD: ssid = dev->params.uart.wifi_ssid; pwd = dev->params.uart.wifi_pwd; ssid_len = strlen(ssid) + 1; pwd_len = strlen(pwd) + 1; if ((ssid_len + pwd_len) > 98) { return -1; } out_buf = (uint8_t *)malloc(ssid_len + pwd_len + 2); out_buf[0] = ssid_len; out_buf[ssid_len] = '\0'; memcpy(out_buf + 1, ssid, ssid_len); memcpy(out_buf + ssid_len + 2, pwd, pwd_len); out_buf[ssid_len + pwd_len + 1] = '\0'; send_cmd(31, out_buf, ssid_len + pwd_len + 2, 0); free(out_buf); break; case UCAMERA_CMD_SET_UPLOAD_TIME: data = dev->params.uart.upload_time; if (data < 5) { data = 5; } if (data > 65536) { data = 65536; } send_cmd(35, (uint8_t *)&data, 2, 0); break; default: break; } // save config send_cmd(28, NULL, 0, 0); return 0; } frame_buffer_t *uart_camera_get_frame(ucamera_device_t *dev) { int32_t ret = 0; int32_t cmd; uint8_t *buf = NULL; uint32_t len; #if defined(USE_LVGL_DRAW_IMAGE) || defined(USE_TFT) set_capture_image(1); if (xSemaphoreTake(cap_sem, portMAX_DELAY) == pdTRUE) { if (dev->frame.buf != NULL && dev->frame.len != 0) return &dev->frame; else return NULL; } else { return NULL; } #else #ifdef DISABLE_USE_UART_QUEUE while (1) { ret = uart_frame_recv(&buf, &len); if (ret < 0) { goto end; } cmd = buf[7]; // get one jpeg frame if (cmd == 0x00) { dev->frame.buf = (uint8_t *)calloc(1, len); // heap_caps_calloc(len, sizeof(uint8_t), MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL); if (dev->frame.buf == NULL) { printf("allocate frame.buf fail\n"); return NULL; } memcpy(dev->frame.buf, &buf[8], len); dev->frame.len = len; dev->frame.width = dev->frame_size.width; dev->frame.height = dev->frame_size.height; dev->frame.format = FRAME_FORMAT_JPEG; free(buf); // printf("get jpeg frame success\n"); return &dev->frame; } else { if (buf) free(buf); continue; } } end: if (buf) { free(buf); } return NULL; #else set_capture_image(1); ret = xQueueReceive(jpeg_frame_queue, &dev->frame, portMAX_DELAY); if (ret == pdPASS) { dev->frame.width = dev->frame_size.width; dev->frame.height = dev->frame_size.height; dev->frame.format = FRAME_FORMAT_JPEG; printf("[uart_camera_get_frame]get frame success\n"); return &dev->frame; } return NULL; #endif #endif } static ucamera_device_t *uart_camera_device_create(int devindex) { ucamera_device_t *dev = NULL; /* Initialize all variables that we clean on shutdown */ dev = (ucamera_device_t *) calloc(1, sizeof(ucamera_device_t)); if (!dev) { LOGE(TAG, "malloc camera device fail\n"); return 0; } dev->is_dummy = false; dev->frame_size.width = UART_CAMERA_FRAME_WIDTH; dev->frame_size.height = UART_CAMERA_FRAME_HEIGHT; /* Set the function pointers */ dev->camera_init = uart_camera_init; dev->camera_uninit = uart_camera_uninit; dev->camera_connect = uart_camera_connect; dev->camera_disconnect = uart_camera_disconnect; dev->camera_config = uart_camera_config; dev->camera_get_frame = uart_camera_get_frame; dev->camera_free = uart_camera_delete; LOG("create camera device successfully\n"); return dev; } ucamera_context_t uart_camera = { UART_CAMERA_NAME, "UART Camera", CAM_UART_TYPE, uart_camera_device_available, uart_camera_device_create };
YifuLiu/AliOS-Things
components/ucamera/src/device/uart/esp32/uart_camera.c
C
apache-2.0
16,114
#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "driver/gpio.h" #include "driver/uart.h" #include "string.h" #include "esp_heap_caps.h" #include "uart_frame.h" #define UART_NUM UART_NUM_1 #define UART_QUEUE_LENGTH 10 #define TX_BUF_SIZE 0 #define FRAME_MAX_SIZE (16 * 1024) #define RX_BUF_SIZE 2 * 1024 #define PACK_FIRST_BYTE 0xAA #define PACK_SECOND_BYTE 0x55 volatile frame_state_n frame_state; #ifndef DISABLE_USE_UART_QUEUE static QueueHandle_t uart_queue = NULL; #endif static QueueHandle_t uart_buffer_queue = NULL; #ifndef DISABLE_USE_UART_QUEUE static void uart_frame_task(void *arg); #endif static void uart_frame_send_task(void *arg); typedef struct _UartFrame_t { bool free_buffer; uint8_t* buffer; uint32_t len; } UartFrame_t; uint32_t baud_rate = 1500000; uint16_t uart_tx_pin = 26; uint16_t uart_rx_pin = 36; void __attribute__((weak)) frame_post_callback(uint8_t cmd) { } void __attribute__((weak)) frame_recv_callback(int cmd, const uint8_t*buf, int len) { } static void uart_base_init() { uart_driver_delete(UART_NUM); const uart_config_t uart_config = { .baud_rate = baud_rate, .data_bits = UART_DATA_8_BITS, .parity = UART_PARITY_DISABLE, .stop_bits = UART_STOP_BITS_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE }; uart_param_config(UART_NUM, &uart_config); uart_set_pin(UART_NUM, uart_tx_pin, uart_rx_pin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); #ifdef DISABLE_USE_UART_QUEUE uart_driver_install(UART_NUM, RX_BUF_SIZE, TX_BUF_SIZE, UART_QUEUE_LENGTH, NULL, 0); #else uart_driver_install(UART_NUM, RX_BUF_SIZE, TX_BUF_SIZE, UART_QUEUE_LENGTH, &uart_queue, ESP_INTR_FLAG_LOWMED); #endif uart_set_rx_timeout(UART_NUM, 50); } void uart_frame_init(int32_t rx, int32_t tx, uint32_t baud) { baud_rate = baud; uart_rx_pin = rx; uart_tx_pin = tx; uart_buffer_queue = xQueueCreate(1, sizeof(UartFrame_t)); uart_base_init(); #ifndef DISABLE_USE_UART_QUEUE xTaskCreatePinnedToCore(uart_frame_task, "uart_queue_task", 4 * 1024, NULL, 3, NULL, 0); #endif xTaskCreatePinnedToCore(uart_frame_send_task, "uart_frame_send_task", 2 * 1024, NULL, 1, NULL, 0); } void uart_update_pin(int32_t rx, int32_t tx) { uart_set_pin(UART_NUM, tx, rx, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); } typedef enum { kWaitStart = 0x00, kRecvLenght, kLenghtCheck, kRecvCMD, kRecvData, kCrcCheck, kSuccess, } frame_state_t; static void uart_frame_send_task(void *arg) { UartFrame_t frame; for (;;) { xQueueReceive(uart_buffer_queue, &frame, portMAX_DELAY); uart_wait_tx_done(UART_NUM, portMAX_DELAY); uart_write_bytes(UART_NUM, (const char *)frame.buffer, frame.len); uart_wait_tx_done(UART_NUM, portMAX_DELAY); frame_post_callback(frame.buffer[7]); if (frame.free_buffer) { free(frame.buffer); } } vTaskDelete(NULL); } #ifdef DISABLE_USE_UART_QUEUE int32_t uart_frame_recv(uint8_t **data, uint32_t *len) { uint8_t *buf = calloc(1, FRAME_MAX_SIZE); //heap_caps_calloc(FRAME_MAX_SIZE, sizeof(uint8_t), MALLOC_CAP_DEFAULT | MALLOC_CAP_INTERNAL); uint8_t recv_buf[1024]; uint8_t *ptr = recv_buf; uint32_t packet_pos = 0; uint8_t packet_ahead[] = {PACK_FIRST_BYTE, PACK_SECOND_BYTE}; uint32_t frame_length = 0; uint8_t xor = 0x00; uint8_t cmd = 0x00; uint16_t size; buf[0] = PACK_FIRST_BYTE; buf[1] = PACK_SECOND_BYTE; frame_state_t frame_state = kWaitStart; int32_t ret = 0; for(;;) { memset(recv_buf, 0, 1024); size = 1024; ret = uart_read_bytes(UART_NUM, recv_buf, size, portMAX_DELAY); if (ret < 0) { printf("uart_read_bytes fail\n"); return -1; } ptr = recv_buf; while (size) { switch (frame_state) { case kWaitStart: buf[packet_pos] = *ptr; ptr += 1; size -= 1; if (buf[packet_pos] == packet_ahead[packet_pos]) { packet_pos += 1; if (packet_pos == 2) { frame_length = 0; frame_state = kRecvLenght; } } else { packet_pos = 0; } break; case kRecvLenght: buf[packet_pos] = *ptr; ptr += 1; size -= 1; packet_pos += 1; if (packet_pos == (2 + 4)) { xor = 0x000; frame_state = kLenghtCheck; } break; case kLenghtCheck: buf[packet_pos] = *ptr; ptr += 1; size -= 1; xor = 0x00 ^ buf[2] ^ buf[3] ^ buf[4] ^ buf[5]; if (xor == buf[packet_pos]) { packet_pos += 1; frame_length = (buf[2] << 24) | (buf[3] << 16) | (buf[4] << 8) | (buf[5] << 0); if (frame_length > FRAME_MAX_SIZE - 9) { packet_pos = 0; frame_state = kWaitStart; } else { frame_state = kRecvCMD; } } else { packet_pos = 0; frame_state = kWaitStart; } break; case kRecvCMD: buf[packet_pos] = *ptr; cmd = buf[packet_pos]; ptr += 1; size -= 1; packet_pos += 1; frame_state = kRecvData; break; case kRecvData: while(size > 0) { buf[packet_pos] = *ptr; ptr += 1; size -= 1; packet_pos += 1; if (packet_pos == (frame_length + 6)) { frame_state = kCrcCheck; break; } } break; case kCrcCheck: buf[packet_pos] = *ptr; ptr += 1; size -= 1; xor = 0x00; for (uint16_t i = 0; i < packet_pos; i++) { xor = buf[i] ^ xor; } if (xor != buf[packet_pos]) { packet_pos = 0; frame_state = kWaitStart; break; } case kSuccess: packet_pos = 0; frame_state = kWaitStart; *data = buf; *len = frame_length - 2; return 0; default: break; } } } return -1; } #else static void uart_frame_task(void *arg) { uart_event_t xEvent; // uint32_t buf_pos = 0; uint8_t *buf = calloc(1, FRAME_MAX_SIZE); //heap_caps_calloc(FRAME_MAX_SIZE, sizeof(uint8_t), MALLOC_CAP_DEFAULT | MALLOC_CAP_INTERNAL); uint8_t *recv_buf = (uint8_t *)malloc(1024 * sizeof(uint8_t)); uint8_t* ptr = recv_buf; uint32_t packet_pos = 0; uint8_t packet_ahead[] = {PACK_FIRST_BYTE, PACK_SECOND_BYTE}; uint32_t frame_length = 0; uint8_t xor = 0x00; uint8_t cmd = 0x00; uint16_t size; buf[0] = PACK_FIRST_BYTE; buf[1] = PACK_SECOND_BYTE; frame_state_t frame_state = kWaitStart; for(;;) { if (xQueueReceive(uart_queue, (void*)&xEvent, portMAX_DELAY) == pdTRUE) { switch(xEvent.type) { case UART_DATA: { uart_read_bytes(UART_NUM, recv_buf, xEvent.size, portMAX_DELAY); ptr = recv_buf; size = xEvent.size; while (size) { switch (frame_state) { case kWaitStart: buf[packet_pos] = *ptr; ptr += 1; size -= 1; if (buf[packet_pos] == packet_ahead[packet_pos]) { packet_pos += 1; if (packet_pos == 2) { frame_length = 0; frame_state = kRecvLenght; } } else { packet_pos = 0; } break; case kRecvLenght: buf[packet_pos] = *ptr; ptr += 1; size -= 1; packet_pos += 1; if (packet_pos == (2 + 4)) { xor = 0x000; frame_state = kLenghtCheck; } break; case kLenghtCheck: buf[packet_pos] = *ptr; ptr += 1; size -= 1; xor = 0x00 ^ buf[2] ^ buf[3] ^ buf[4] ^ buf[5]; if (xor == buf[packet_pos]) { packet_pos += 1; frame_length = (buf[2] << 24) | (buf[3] << 16) | (buf[4] << 8) | (buf[5] << 0); if (frame_length > FRAME_MAX_SIZE - 9) { packet_pos = 0; frame_state = kWaitStart; } else { frame_state = kRecvCMD; } } else { packet_pos = 0; frame_state = kWaitStart; } break; case kRecvCMD: buf[packet_pos] = *ptr; cmd = buf[packet_pos]; ptr += 1; size -= 1; packet_pos += 1; frame_state = kRecvData; break; case kRecvData: while(size > 0) { buf[packet_pos] = *ptr; ptr += 1; size -= 1; packet_pos += 1; if (packet_pos == (frame_length + 6)) { frame_state = kCrcCheck; break; } } break; case kCrcCheck: buf[packet_pos] = *ptr; ptr += 1; size -= 1; xor = 0x00; for (uint16_t i = 0; i < packet_pos; i++) { xor = buf[i] ^ xor; } if (xor != buf[packet_pos]) { packet_pos = 0; frame_state = kWaitStart; break; } case kSuccess: packet_pos = 0; frame_state = kWaitStart; frame_recv_callback(buf[7], &buf[8], frame_length - 2); break; default: break; } } break; } case UART_FIFO_OVF: { xQueueReset(uart_queue); break; } case UART_BUFFER_FULL: { uart_flush_input(UART_NUM); xQueueReset(uart_queue); break; } case UART_BREAK: { break; } case UART_PARITY_ERR: { break; } case UART_FRAME_ERR: { break; } default: { break; } } } } vTaskDelete(NULL); } #endif void uart_frame_send(uint8_t cmd, const uint8_t* frame, uint32_t len, bool wait_finish) { uint32_t out_len = 9 + len; uint8_t* out_buf = (uint8_t *)malloc(sizeof(uint8_t) * out_len); out_buf[0] = PACK_FIRST_BYTE; out_buf[1] = PACK_SECOND_BYTE; out_buf[2] = (out_len - 7) >> 24; out_buf[3] = (out_len - 7) >> 16; out_buf[4] = (out_len - 7) >> 8; out_buf[5] = (out_len - 7); out_buf[6] = 0x00 ^ out_buf[2] ^ out_buf[3] ^ out_buf[4] ^ out_buf[5]; out_buf[7] = cmd; memcpy(&out_buf[8], frame, len); int xor_resilt = 0x00; for (uint32_t i = 0; i < out_len - 1; i++) { xor_resilt = out_buf[i] ^ xor_resilt; } out_buf[out_len - 1] = xor_resilt; if (wait_finish) { while (uxQueueMessagesWaiting(uart_buffer_queue)) { vTaskDelay(pdMS_TO_TICKS(10)); } } UartFrame_t uart_frame; uart_frame.buffer = out_buf; uart_frame.len = out_len; uart_frame.free_buffer = true; xQueueSend(uart_buffer_queue, &uart_frame, portMAX_DELAY); }
YifuLiu/AliOS-Things
components/ucamera/src/device/uart/esp32/uart_frame.c
C
apache-2.0
14,433
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #include <stdio.h> #include <string.h> #include "ulog/ulog.h" #include "aos/kernel.h" #include "ucamera_service.h" #include "stdatomic.h" #include "uart_frame.h" #define TAG "UART_CAMERA" #define HEAD_SIZE 2048 #define BODY_SZIE (1024 * 128 + 1) // #define USE_LVGL_DRAW_IMAGE // #define USE_TFT typedef enum { kWifiSta, kUart, kTiming } CamMode_t; typedef struct _JpegFrame_t { uint8_t *buf; uint32_t size; } JpegFrame_t; typedef struct _uart_ommand_t { uint8_t cmd; uint8_t *buf; uint32_t size; } uart_command_t; int g_init_flag = 0; ucamera_context_t uart_camera; static atomic_uint_fast8_t capture_image; static atomic_int_least32_t x; static atomic_int_least32_t y; static atomic_int_least32_t cmd_want; static char token[33]; void set_capture_image(uint8_t show) { atomic_store(&capture_image, show); } uint8_t get_capture_image(void) { return (uint8_t)atomic_load(&capture_image); } #define CANVAS_WIDTH 320 #define CANVAS_HEIGHT 240 uart_command_t *send_cmd(uint8_t cmd_in, uint8_t *buff, uint32_t size, uint32_t wait_time) { if (wait_time == 0) { uart_frame_send(cmd_in, buff, size, true); return NULL; } uart_command_t *cmd = malloc(sizeof(uart_command_t)); // heap_caps_malloc(sizeof(uart_command_t), MALLOC_CAP_DEFAULT | MALLOC_CAP_8BIT); if (cmd == NULL) { return NULL; } atomic_store(&cmd_want, cmd_in); uart_frame_send(cmd_in, buff, size, true); free(cmd); return NULL; } static void uart_camera_delete(ucamera_device_t *dev) { free(dev); } static bool uart_camera_device_available(void) { return true; } int32_t uart_camera_init(ucamera_device_t *dev) { aos_status_t status = -1; if (g_init_flag == 0) { atomic_store(&capture_image, 1); atomic_init(&x, 0); atomic_init(&y, 0); atomic_init(&cmd_want, -1); g_init_flag = 1; } return 0; } int32_t uart_camera_uninit(ucamera_device_t *dev) { set_capture_image(0); uart_frame_uninit(); return 0; } int32_t uart_camera_connect(ucamera_device_t *dev) { return 0; } void uart_camera_disconnect(ucamera_device_t *dev) { } int32_t uart_camera_config(ucamera_device_t *dev) { uint32_t data = 0; const char *ssid = NULL; const char *pwd = NULL; uint16_t ssid_len = 0; uint16_t pwd_len = 0; uint8_t *out_buf = NULL; if (!dev) return -1; switch (dev->cmd) { case UCAMERA_CMD_SET_UART_PARAMS: uart_frame_init(dev->params.uart.rx, dev->params.uart.tx, dev->params.uart.bandrate); break; case UCAMERA_CMD_SET_FRAME_SIZE: send_cmd(1, (uint8_t *)&dev->frame_size.id, 2, 0); break; case UCAMERA_CMD_SET_MODE: if (dev->params.uart.mode == CAM_UART_MODE) { data = 5; send_cmd(1, (uint8_t *)&data, 2, 0); data = CAM_UART_MODE; send_cmd(26, (uint8_t *)&data, 1, 0); } else if (dev->params.uart.mode == CAM_TIMING_MODE) { data = 9; send_cmd(1, (uint8_t *)&data, 2, 0); data = CAM_TIMING_MODE; send_cmd(26, (uint8_t *)&data, 1, 0); } break; case UCAMERA_CMD_SET_LED_BRIGHTNESS: data = dev->params.uart.led_brightness; if (data > 1024) { data = 1024; } send_cmd(40, (uint8_t *)&data, 2, 0); break; case UCAMERA_CMD_SET_WIFI_SSID_PWD: ssid = dev->params.uart.wifi_ssid; pwd = dev->params.uart.wifi_pwd; ssid_len = strlen(ssid) + 1; pwd_len = strlen(pwd) + 1; if ((ssid_len + pwd_len) > 98) { return -1; } out_buf = (uint8_t *)malloc(ssid_len + pwd_len + 2); out_buf[0] = ssid_len; out_buf[ssid_len] = '\0'; memcpy(out_buf + 1, ssid, ssid_len); memcpy(out_buf + ssid_len + 2, pwd, pwd_len); out_buf[ssid_len + pwd_len + 1] = '\0'; send_cmd(31, out_buf, ssid_len + pwd_len + 2, 0); free(out_buf); break; case UCAMERA_CMD_SET_UPLOAD_TIME: data = dev->params.uart.upload_time; if (data < 5) { data = 5; } if (data > 65536) { data = 65536; } send_cmd(35, (uint8_t *)&data, 2, 0); break; default: break; } // save config send_cmd(28, NULL, 0, 0); return 0; } frame_buffer_t *uart_camera_get_frame(ucamera_device_t *dev) { int32_t ret = 0; int32_t cmd; uint8_t *buf = NULL; uint32_t len; while (1) { ret = uart_frame_recv(&buf, &len); if (ret < 0) { goto end; } cmd = buf[7]; // get one jpeg frame if (cmd == 0x00) { //printf("get one jpeg frame, len:%d\n", len); dev->frame.buf = (uint8_t *)calloc(1, len); if (dev->frame.buf == NULL) { printf("allocate frame.buf fail\n"); return NULL; } memcpy(dev->frame.buf, &buf[8], len); dev->frame.len = len; dev->frame.width = dev->frame_size.width; dev->frame.height = dev->frame_size.height; dev->frame.format = FRAME_FORMAT_JPEG; free(buf); //printf("get jpeg frame success\n"); return &dev->frame; } else { if (buf) free(buf); continue; } } end: if (buf) { free(buf); } return NULL; } static ucamera_device_t *uart_camera_device_create(int devindex) { ucamera_device_t *dev = NULL; /* Initialize all variables that we clean on shutdown */ dev = (ucamera_device_t *) calloc(1, sizeof(ucamera_device_t)); if (!dev) { LOGE(TAG, "malloc camera device fail\n"); return 0; } dev->is_dummy = false; dev->frame_size.width = UART_CAMERA_FRAME_WIDTH; dev->frame_size.height = UART_CAMERA_FRAME_HEIGHT; /* Set the function pointers */ dev->camera_init = uart_camera_init; dev->camera_uninit = uart_camera_uninit; dev->camera_connect = uart_camera_connect; dev->camera_disconnect = uart_camera_disconnect; dev->camera_config = uart_camera_config; dev->camera_get_frame = uart_camera_get_frame; dev->camera_free = uart_camera_delete; LOG("create camera device successfully\n"); return dev; } ucamera_context_t uart_camera = { UART_CAMERA_NAME, "UART Camera", CAM_UART_TYPE, uart_camera_device_available, uart_camera_device_create };
YifuLiu/AliOS-Things
components/ucamera/src/device/uart/haas/uart_camera.c
C
apache-2.0
6,636
#include <stdio.h> #include <aos/kernel.h> #include "aos_hal_uart.h" #include "string.h" #include "uart_frame.h" #define UART_NUM 1 #define UART_QUEUE_LENGTH 10 #define TX_BUF_SIZE 0 #define FRAME_MAX_SIZE (16 * 1024) #define RX_BUF_SIZE 4 * 1024 #define PACK_FIRST_BYTE 0xAA #define PACK_SECOND_BYTE 0x55 #define UART_TIMEOUT (0xFFFFFF) volatile frame_state_n frame_state; #ifndef DISABLE_USE_UART_QUEUE //static QueueHandle_t uart_queue = NULL; static aos_queue_t *uart_queue = NULL; #endif //static QueueHandle_t &uart_buffer_queue = NULL; /* queue resource */ #define MESSAGE_MAX_LENGTH 10 /* maximum message length */ uart_dev_t g_uart_device = { .port = 2, .config = { .baud_rate = 1500000, .data_width = DATA_WIDTH_8BIT, .parity = NO_PARITY, .stop_bits = STOP_BITS_1, .flow_control = FLOW_CONTROL_DISABLED, .mode = MODE_TX_RX }, .priv = NULL, .cb = NULL, .userdata = NULL }; static uint32_t g_frame_state = 0; static aos_task_t uart_frame_send_task_handle; static void uart_frame_send_task(void *arg); static void uart_base_uninit(void); typedef struct _UartFrame_t { bool free_buffer; uint8_t* buffer; uint32_t len; } UartFrame_t; /* Static memory for static creation */ static char queue_buffer[sizeof(UartFrame_t) * 2]; /* for the internal buffer of the queue */ static aos_queue_t uart_buffer_queue; void __attribute__((weak)) frame_post_callback(uint8_t cmd) { } void __attribute__((weak)) frame_recv_callback(int cmd, const uint8_t*buf, int len) { } static void uart_base_init(uint32_t baud) { int ret = -1; g_uart_device.config.baud_rate = baud; ret = aos_hal_uart_init(&g_uart_device); if (0 != ret) { printf("%s: aos_hal_uart_init failed ret = %d;\n", __func__, ret); } return; } void uart_frame_init(int32_t rx, int32_t tx, uint32_t baud) { aos_status_t status = -1; baud; rx; tx; if (g_frame_state) { printf("[%s]already initialized\n", __func__); return 0; } status = aos_queue_new(&uart_buffer_queue, (void *)queue_buffer, sizeof(queue_buffer), sizeof(queue_buffer)); if (status != 0) { printf("[%s]create queue error\n", __func__); return; } else { printf("[%s]create queue success\n", __func__); } uart_base_init(baud); status = aos_task_create(&uart_frame_send_task_handle, "uart_frame_send_task", uart_frame_send_task, NULL, NULL, 2 * 1024, 50, AOS_TASK_AUTORUN); if (status != 0) { printf("[%s]create %s error\n", __func__, "uart_frame_send_task"); uart_base_uninit(); aos_queue_free(&uart_buffer_queue); return; } g_frame_state = 1; } static void uart_base_uninit(void) { int ret = -1; g_frame_state = 0; ret = aos_hal_uart_finalize(&g_uart_device); if (0 != ret) { printf("%s: aos_hal_uart_finalize failed ret = %d;\n", __func__, ret); } return; } int32_t uart_frame_uninit() { aos_task_delete(&uart_frame_send_task_handle); uart_base_uninit(); aos_queue_free(&uart_buffer_queue); return 0; } typedef enum { kWaitStart = 0x00, kRecvLenght, kLenghtCheck, kRecvCMD, kRecvData, kCrcCheck, kSuccess, } frame_state_t; static void uart_frame_send_task(void *arg) { aos_status_t status; UartFrame_t frame; int rev_size = 0; int ret = 0; for (;;) { status = aos_queue_recv(&uart_buffer_queue, AOS_WAIT_FOREVER, (void *)&frame, &rev_size); if (status == 0) { /* show message data */ printf("[%s]%d recv message\r\n", __func__, rev_size); } else { printf("[%s]recv buf queue error\n", __func__); } ret = aos_hal_uart_send(&g_uart_device, frame.buffer, frame.len, AOS_WAIT_FOREVER); if (ret != 0) { printf("aos_hal_uart_send failed, ret:%d\n", ret); } frame_post_callback(frame.buffer[7]); if (frame.free_buffer) { free(frame.buffer); } if (!g_frame_state) break; } aos_task_exit(0); } int32_t uart_frame_recv(uint8_t **data, uint32_t *len) { uint8_t *buf = calloc(1, FRAME_MAX_SIZE); uint8_t *recv_buf = calloc(1, RX_BUF_SIZE); uint8_t *ptr = recv_buf; uint32_t packet_pos = 0; uint8_t packet_ahead[] = {PACK_FIRST_BYTE, PACK_SECOND_BYTE}; uint32_t frame_length = 0; uint8_t xor = 0x00; uint8_t cmd = 0x00; uint16_t size; buf[0] = PACK_FIRST_BYTE; buf[1] = PACK_SECOND_BYTE; frame_state_t frame_state = kWaitStart; int32_t ret = 0; if (!buf) return -1; if (!recv_buf) { free(buf); return -1; } for(;;) { memset(recv_buf, 0, RX_BUF_SIZE); size = 0; ret = aos_hal_uart_recv_II(&g_uart_device, recv_buf, RX_BUF_SIZE, &size, 40); if (ret != 0) { free(recv_buf); recv_buf = NULL; return -1; } ptr = recv_buf; while (size) { switch (frame_state) { case kWaitStart: buf[packet_pos] = *ptr; ptr += 1; size -= 1; if (buf[packet_pos] == packet_ahead[packet_pos]) { packet_pos += 1; if (packet_pos == 2) { frame_length = 0; frame_state = kRecvLenght; } } else { packet_pos = 0; } break; case kRecvLenght: buf[packet_pos] = *ptr; ptr += 1; size -= 1; packet_pos += 1; if (packet_pos == (2 + 4)) { xor = 0x000; frame_state = kLenghtCheck; } break; case kLenghtCheck: buf[packet_pos] = *ptr; ptr += 1; size -= 1; xor = 0x00 ^ buf[2] ^ buf[3] ^ buf[4] ^ buf[5]; if (xor == buf[packet_pos]) { packet_pos += 1; frame_length = (buf[2] << 24) | (buf[3] << 16) | (buf[4] << 8) | (buf[5] << 0); if (frame_length > FRAME_MAX_SIZE - 9) { packet_pos = 0; frame_state = kWaitStart; } else { frame_state = kRecvCMD; } } else { packet_pos = 0; frame_state = kWaitStart; } break; case kRecvCMD: buf[packet_pos] = *ptr; cmd = buf[packet_pos]; ptr += 1; size -= 1; packet_pos += 1; frame_state = kRecvData; break; case kRecvData: while(size > 0) { buf[packet_pos] = *ptr; ptr += 1; size -= 1; packet_pos += 1; if (packet_pos == (frame_length + 6)) { frame_state = kCrcCheck; break; } } break; case kCrcCheck: buf[packet_pos] = *ptr; ptr += 1; size -= 1; xor = 0x00; for (uint16_t i = 0; i < packet_pos; i++) { xor = buf[i] ^ xor; } if (xor != buf[packet_pos]) { packet_pos = 0; frame_state = kWaitStart; break; } case kSuccess: packet_pos = 0; frame_state = kWaitStart; *data = buf; *len = frame_length - 2; free(recv_buf); recv_buf = NULL; return 0; default: break; } } } free(recv_buf); recv_buf = NULL; return -1; } void uart_frame_send(uint8_t cmd, const uint8_t* frame, uint32_t len, bool wait_finish) { aos_status_t status = -1; uint32_t out_len = 9 + len; uint8_t* out_buf = (uint8_t *)malloc(sizeof(uint8_t) * out_len); out_buf[0] = PACK_FIRST_BYTE; out_buf[1] = PACK_SECOND_BYTE; out_buf[2] = (out_len - 7) >> 24; out_buf[3] = (out_len - 7) >> 16; out_buf[4] = (out_len - 7) >> 8; out_buf[5] = (out_len - 7); out_buf[6] = 0x00 ^ out_buf[2] ^ out_buf[3] ^ out_buf[4] ^ out_buf[5]; out_buf[7] = cmd; memcpy(&out_buf[8], frame, len); int xor_resilt = 0x00; for (uint32_t i = 0; i < out_len - 1; i++) { xor_resilt = out_buf[i] ^ xor_resilt; } out_buf[out_len - 1] = xor_resilt; if (wait_finish) { //while (uxQueueMessagesWaiting(&uart_buffer_queue)) { while (aos_queue_get_count(&uart_buffer_queue) > 0) { //vTaskDelay(pdMS_TO_TICKS(10)); aos_msleep(10); } } UartFrame_t uart_frame; uart_frame.buffer = out_buf; uart_frame.len = out_len; uart_frame.free_buffer = true; //xQueueSend(&uart_buffer_queue, &uart_frame, portMAX_DELAY); status = aos_queue_send(&uart_buffer_queue, (void *)&uart_frame, sizeof(uart_frame)); if (status != 0) { printf("[%s]send buf queue error, status:%d\n", __func__, status); } else printf("[%s]send buf queue success\n", __func__); }
YifuLiu/AliOS-Things
components/ucamera/src/device/uart/haas/uart_frame.c
C
apache-2.0
10,018
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited */ #include "dechunk.h" #include <string.h> #include <stdlib.h> #define CHUNK_INIT() \ do { \ g_is_chunkbegin = 0; \ g_chunk_len = 0; \ g_chunk_read = 0; \ } while (0) #define DC_MIN(x, y) ((x) > (y) ? (y) : (x)) static char *g_buff_out = NULL; static char *g_buff_pt = NULL; static size_t g_buff_outlen = 0; static size_t g_chunk_len = 0; static size_t g_chunk_read = 0; static int g_is_running = 0; static int g_is_first = 1; static int g_is_chunkbegin = 0; void *memstr(void *src, size_t src_len, char *sub) { if (NULL == src || NULL == sub || src_len < strlen(sub)) return NULL; char *p = src; char *q = sub; size_t indx = src_len; size_t sub_len = strlen(sub); while (indx > 0) { int i = 0; while (i < sub_len) { char cp = *(p + i); char cq = *(q + i); // case ignore if (cq >= 'A' && cq <= 'Z') cq |= 0x20; if (cp >= 'A' && cp <= 'Z') cp |= 0x20; if (cq != cp) break; i++; } if (i == sub_len) return p; p++; indx--; } return NULL; } int dechunk_init() { if (g_is_running) return DCE_ISRUNNING; g_buff_out = NULL; g_buff_pt = NULL; g_buff_outlen = 0; g_chunk_len = 0; g_chunk_read = 0; g_is_running = 1; g_is_first = 1; g_is_chunkbegin = 0; return DCE_OK; } int dechunk(void *input, size_t inlen) { if (!g_is_running) return DCE_LOCK; if (NULL == input || inlen == 0) return DCE_ARGUMENT; void *data_start = input; size_t data_len = inlen; if (g_is_first) { data_start = memstr(data_start, data_len, "\r\n\r\n"); if (NULL == data_start) return DCE_FORMAT; data_start += 4; data_len -= (data_start - input); g_is_first = 0; } if (!g_is_chunkbegin) { char *stmp = data_start; int itmp = 0; sscanf(stmp, "%x", &itmp); // exclude the terminate "\r\n" itmp = (itmp > 0 ? itmp - 2 : itmp); data_start = memstr(stmp, data_len, "\r\n"); data_start += 2; // strlen("\r\n") data_len -= (data_start - (void *)stmp); g_chunk_len = itmp; g_buff_outlen += g_chunk_len; g_is_chunkbegin = 1; g_chunk_read = 0; if (g_chunk_len > 0 && 0 != g_buff_outlen) { if (NULL == g_buff_out) { g_buff_out = (char *)malloc(g_buff_outlen); g_buff_pt = g_buff_out; } else { g_buff_out = realloc(g_buff_out, g_buff_outlen); } if (NULL == g_buff_out) return DCE_MEM; } } if (g_chunk_read < g_chunk_len) { size_t cpsize = DC_MIN(g_chunk_len - g_chunk_read, data_len); memcpy(g_buff_pt, data_start, cpsize); g_buff_pt += cpsize; g_chunk_read += cpsize; data_len -= (cpsize + 2); data_start += (cpsize + 2); if (g_chunk_read >= g_chunk_len) { CHUNK_INIT(); if (data_len > 0) return dechunk(data_start, data_len); } } else { CHUNK_INIT(); } return DCE_OK; } int dechunk_free() { free(g_buff_out); g_buff_out = NULL; g_buff_pt = NULL; g_buff_outlen = 0; g_chunk_len = 0; g_chunk_read = 0; g_is_running = 0; g_is_first = 1; g_is_chunkbegin = 0; return DCE_OK; } int dechunk_getbuff(void **buff, size_t *buf_size) { *buff = g_buff_out; *buf_size = g_buff_outlen; return DCE_OK; }
YifuLiu/AliOS-Things
components/ucamera/src/device/wifi/dechunk/dechunk.c
C
apache-2.0
3,916
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #include <stdio.h> #include <string.h> #include "ulog/ulog.h" #include "aos/kernel.h" #include "ucamera_service.h" #include <httpclient.h> #include "wifi_camera.h" // #include <aiconfig.h> /*Tested this program with esp32 eye*/ #define TAG "WIFI_CAMERA" #define HEAD_SIZE 2048 #define BODY_SZIE (1024 * 128 + 1) static httpclient_t wifi_camera_client = { 0 }; static httpclient_data_t wifi_camera_client_data = {0}; static void wifi_camera_delete(ucamera_device_t *dev) { free(dev); } static bool wifi_camera_device_available(void) { return true; } int32_t wifi_camera_init(ucamera_device_t *dev) { int32_t ret; char *customer_header = "Accept: */*\r\n"; ret = httpclient_prepare(&wifi_camera_client_data, HEAD_SIZE, BODY_SZIE); if (ret != HTTP_SUCCESS) return -1; wifi_camera_client.is_http = true; httpclient_set_custom_header(&wifi_camera_client, customer_header); LOG("wifi camera init done\n"); return ret; } int32_t wifi_camera_uninit(ucamera_device_t *dev) { int32_t ret; ret = httpclient_unprepare(&wifi_camera_client_data); return ret; } int32_t wifi_camera_connect(ucamera_device_t *dev) { int32_t ret; printf("dev->url: %s\n", dev->params.wifi.url); ret = httpclient_conn(&wifi_camera_client, (const char *)dev->params.wifi.url); if (HTTP_SUCCESS != ret) { LOGE(TAG, "http connect failed"); return -1; } LOG("connect to wifi camera successfully\n"); return ret; } void wifi_camera_disconnect(ucamera_device_t *dev) { if (!dev) return; httpclient_clse(&wifi_camera_client); LOG("disconnect to wifi camera successfully\n"); } int32_t wifi_camera_config(ucamera_device_t *dev) { int32_t ret; httpclient_t client = {0}; if (!dev->params.wifi.control_url) { LOGE(TAG, "ev->control_url is null"); return -1; } ret = httpclient_get(&wifi_camera_client, dev->params.wifi.control_url, &wifi_camera_client_data); if (HTTP_SUCCESS != ret) { LOGE(TAG, "wifi camera config failed"); return -1; } LOG("wifi_camera_config ok, url: %s", dev->params.wifi.control_url); return ret; } frame_buffer_t *wifi_camera_get_frame(ucamera_device_t *dev) { int ret; if (!dev) return NULL; httpclient_reset(&wifi_camera_client_data); ret = httpclient_send(&wifi_camera_client, (const char *)dev->params.wifi.url, HTTP_GET, &wifi_camera_client_data); if (HTTP_SUCCESS != ret) { LOGE(TAG, "http send request failed"); return NULL; } do { ret = httpclient_recv(&wifi_camera_client, &wifi_camera_client_data); if (ret < 0) { dev->stream_buf = NULL; dev->stream_len = 0; break; } dev->stream_buf = wifi_camera_client_data.response_buf; dev->stream_len = wifi_camera_client_data.response_content_len; } while (ret == HTTP_EAGAIN); /*malloc frame*/ dev->frame.buf = dev->stream_buf; dev->frame.len = dev->stream_len; dev->frame.width = WIFI_CAMERA_FRAME_WIDTH; dev->frame.height = WIFI_CAMERA_FRAME_HEIGHT; dev->frame.format = FRAME_FORMAT_JPEG; return &dev->frame; } static ucamera_device_t *wifi_camera_device_create(int devindex) { ucamera_device_t *device = NULL; /* Initialize all variables that we clean on shutdown */ device = (ucamera_device_t *) malloc(sizeof(ucamera_device_t)); if (!device) { LOGE(TAG, "malloc camera device fail\n"); return 0; } device->is_dummy = false; device->frame_size.width = WIFI_CAMERA_FRAME_WIDTH; device->frame_size.height = WIFI_CAMERA_FRAME_HEIGHT; /* Set the function pointers */ device->camera_init = wifi_camera_init; device->camera_uninit = wifi_camera_uninit; device->camera_connect = wifi_camera_connect; device->camera_disconnect = wifi_camera_disconnect; device->camera_config = wifi_camera_config; device->camera_get_frame = wifi_camera_get_frame; device->camera_free = wifi_camera_delete; LOG("create camera device successfully\n"); return device; } ucamera_context_t wifi_camera = { WIFI_CAMERA_NAME, "http camera stream over wifi", CAM_WIFI_TYPE, wifi_camera_device_available, wifi_camera_device_create };
YifuLiu/AliOS-Things
components/ucamera/src/device/wifi/wifi_camera.c
C
apache-2.0
4,380
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #include <stdio.h> #include <string.h> #include "ulog/ulog.h" #include "aos/kernel.h" #include "ucamera_service.h" #include "ucamera_device.h" #define TAG "UCAMERA_SERVICE" static ucamera_device_t *g_ucamera_dev = NULL; /* Available camera context */ static ucamera_context_t *camera_ctx[] = { #if CONFIG_WIFI_CAMERA_ENABLE &wifi_camera, #endif #if CONFIG_UART_CAMERA_ENABLE &uart_camera, #endif NULL }; /* * Initialize the ucamera device */ ucamera_device_t *ucamera_device_init(const char *dev_name) { ucamera_device_t *device; int32_t index; int32_t i; /*Reset camera service*/ if (g_ucamera_dev != NULL) ucamera_device_uninit(); /* Select the proper device driver */ index = 0; device = NULL; if (dev_name == NULL) return NULL; if (dev_name != NULL) { for (i = 0; camera_ctx[i]; ++i) { if (strncasecmp(camera_ctx[i]->name, dev_name, strlen(dev_name)) == 0) { if (camera_ctx[i]->available()) { device = camera_ctx[i]->create(index); break; } } } } else { for (i = 0; camera_ctx[i]; ++i) { if (camera_ctx[i]->available()) { device = camera_ctx[i]->create(index); if (device != NULL) break; } } } if (device == NULL) { if (dev_name) { LOGE(TAG, "%s not available", dev_name); return NULL; } LOGE(TAG, "No available device device"); return NULL; } g_ucamera_dev = device; g_ucamera_dev->name = camera_ctx[i]->name; g_ucamera_dev->type = camera_ctx[i]->type; /* Initialize the camera device */ if (g_ucamera_dev->camera_init(g_ucamera_dev) < 0) { ucamera_device_uninit(); return NULL; } return g_ucamera_dev; } /* * Uninitialize the ucamera device */ void ucamera_device_uninit(void) { int32_t i, j; if (!g_ucamera_dev) return; g_ucamera_dev->camera_uninit(g_ucamera_dev); g_ucamera_dev->camera_free(g_ucamera_dev); g_ucamera_dev = NULL; return; } const char *ucamera_get_device_name(void) { if (!g_ucamera_dev) return NULL; return g_ucamera_dev->name; } ucamera_device_t *ucamera_get_device(void) { return g_ucamera_dev; }
YifuLiu/AliOS-Things
components/ucamera/src/ucamera_device.c
C
apache-2.0
2,449
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #include <stdio.h> #include <string.h> #include "ulog/ulog.h" #include "aos/kernel.h" #include "ucamera_service.h" #include "wifi_camera.h" #define TAG "UCAMERA_SERVICE" /* * Initialize the ucamera service */ int32_t ucamera_service_init(const char *dev_name) { ucamera_device_t *dev = ucamera_device_init(dev_name); if (!dev) { LOGE(TAG, "ucamera service init fail\n"); return -1; } return 0; } /* * Uninitialize the ucamera service */ int32_t ucamera_service_uninit(void) { ucamera_device_t *dev = ucamera_get_device(); if (!dev) { LOGE(TAG, "ucamera get device name fail\n"); return -1; } ucamera_device_uninit(); return 0; } /* * Config the ucamera service */ int32_t ucamera_service_config(command_t cmd, void *params) { int32_t ret; ucamera_device_t *dev = ucamera_get_device(); if (!dev) { LOGE(TAG, "ucamera get device name fail\n"); return -1; } dev->cmd = cmd; if (dev->type == CAM_WIFI_TYPE) { switch (cmd) { case UCAMERA_CMD_SET_URL: dev->params.wifi.control_url = (const char *)params; break; case UCAMERA_CMD_SET_CONTROL_URL: case UCAMERA_CMD_SET_FRAME_SIZE: case UCAMERA_CMD_SET_MIRROR: case UCAMERA_CMD_SET_FLIP: dev->params.wifi.control_url = (const char *)params; break; default: break; } } else if (dev->type == CAM_UART_TYPE) { switch (cmd) { case UCAMERA_CMD_SET_UART_PARAMS: dev->params.uart.bandrate = ((uart_cam_params_t *)params)->bandrate; dev->params.uart.rx = ((uart_cam_params_t *)params)->rx; dev->params.uart.tx = ((uart_cam_params_t *)params)->tx; break; case UCAMERA_CMD_SET_MODE: dev->params.uart.mode = ((uart_cam_params_t *)params)->mode; break; case UCAMERA_CMD_SET_FRAME_SIZE: dev->frame_size.id = ((frame_size_t *)params)->id; if (dev->frame_size.id == SIZE_800X600) { dev->frame_size.width = 800; dev->frame_size.height = 600; } else if (dev->frame_size.id == SIZE_640X480) { dev->frame_size.width = 640; dev->frame_size.height = 480; } else if (dev->frame_size.id == SIZE_320X240) { dev->frame_size.width = 320; dev->frame_size.height = 240; } else if (dev->frame_size.id == SIZE_240X240) { dev->frame_size.width = 240; dev->frame_size.height = 240; } else if (dev->frame_size.id == SIZE_160X120) { dev->frame_size.width = 120; dev->frame_size.height = 120; } break; case UCAMERA_CMD_SET_LED_BRIGHTNESS: dev->params.uart.led_brightness = ((uart_cam_params_t *)params)->led_brightness; break; case UCAMERA_CMD_SET_WIFI_SSID_PWD: dev->params.uart.wifi_ssid = ((uart_cam_params_t *)params)->wifi_ssid; dev->params.uart.wifi_pwd = ((uart_cam_params_t *)params)->wifi_pwd; break; case UCAMERA_CMD_SET_UPLOAD_TIME: dev->params.uart.upload_time = ((uart_cam_params_t *)params)->upload_time; break; default: break; } } ret = dev->camera_config(dev); if (ret < 0) LOGE(TAG, "ucamera_config fail\n"); return ret; } /* * Start the ucamera service */ int32_t ucamera_service_connect(const char *url) { int32_t ret; ucamera_device_t *dev = ucamera_get_device(); if (!dev) { LOGE(TAG, "ucamera service start fail\n"); return -1; } dev->params.wifi.url = url; ret = dev->camera_connect(dev); if (ret < 0) LOGE(TAG, "ucamera device connect fail\n"); return ret; } /* * Stop the ucamera service */ int32_t ucamera_service_disconnect(void) { int32_t ret; ucamera_device_t *dev = ucamera_get_device(); if (!dev) { LOGE(TAG, "ucamera service stop fail\n"); return -1; } ret = dev->camera_disconnect(dev); if (ret < 0) LOGE(TAG, "ucamera device disconnect fail\n"); return ret; } /* * Get frame of camera device */ frame_buffer_t *ucamera_service_get_frame(void) { frame_buffer_t *frame = NULL; ucamera_device_t *dev = ucamera_get_device(); if (!dev) { LOGE(TAG, "ucamera get device name fail\n"); return NULL; } frame = dev->camera_get_frame(dev); return frame; } /* * Save frame of camera */ int ucamera_service_save_frame(frame_buffer_t *frame, const char *path) { FILE *file = NULL; file = fopen(path, "wb"); if (file == NULL) { LOGE(TAG, "opening output file fail\n"); return -1; } if (fwrite(frame->buf, frame->len, 1, file) < 1) { LOGE(TAG, "write buf fail\n"); fclose(file); return -1; } fclose(file); return 0; }
YifuLiu/AliOS-Things
components/ucamera/src/ucamera_service.c
C
apache-2.0
5,126
#!/usr/bin/env python3 import os import sys import getpass import shutil comp_path = sys.path[0] print("comp_path:") print(comp_path) # original folder org_image_path = comp_path + "/example/image" # new folder data_path = comp_path + "/../../hardware/chip/haas1000/prebuild/data/data" image_path = data_path + "/ucloud_ai_image" # delete prebuild/data resources if os.path.exists(image_path): print ('Delete /data/ucloud_ai_image firstly') shutil.rmtree(image_path) # copy resources shutil.copytree(org_image_path, image_path) # result print("run external script success")
YifuLiu/AliOS-Things
components/ucloud_ai/cp_resources.py
Python
apache-2.0
589
/* * Copyright (C) 2015-2021 Alibaba Group Holding Limited */ #include "ucloud_ai_common.h" #include "ulog/ulog.h" #if AOS_COMP_CLI #include "aos/cli.h" #endif #define TAG "uclud_ai_example" #define LOG printf static void ucloud_ai_comp_example(int argc, char **argv) { int model_index = -1; int ret = -1; char *image = NULL; if (argc < 2) { LOG("Please test with command: ucloud_ai_example -m [0~14]\n"); return; } if (!strncmp(argv[1], "init", 4)) { /*init network*/ event_service_init(NULL); netmgr_service_init(NULL); LOG("ucloud_ai comp init successfully!\n"); return; } else if (!strncmp(argv[1], "-m", 2)) { if (argv[2] < 0 && argv[2] > 14) { LOGE(TAG, "range of model value is 0 ~ 14, please try again\n"); return; } } else { LOG("unkown command\n"); return; } model_index = atoi(argv[2]); /*ucloud ai component init*/ ret = ucloud_ai_init(); if (ret < 0) { LOGE(TAG, "ucloud_ai_init failed, ret: %d\n", ret); return -1; } /*Config OSS Information*/ ucloud_ai_set_key_secret(OSS_ACCESS_KEY, OSS_ACCESS_SECRET); ucloud_ai_set_oss_endpoint(OSS_ENDPOINT); ucloud_ai_set_oss_bucket(OSS_BUCKET); switch (model_index) { #ifdef CONFIG_ALICLOUD_FACEBODY_ENABLE case UCLOUD_AI_MODEL_COMPARING_FACEBODY: LOG("Comparing facebody:\n"); ucloud_ai_facebody_comparing_face(FACE1_IMAGE, FACE2_IMAGE, NULL); break; case UCLOUD_AI_MODEL_GENERATE_HUMAN_ANIME_STYLE: LOG("Generate human anime style:\n"); ucloud_ai_facebody_generate_human_anime_style(ANIME_IMAGE, NULL); break; case UCLOUD_AI_MODEL_RECOGNIZE_EXPRESSION: LOG("Recognize expression:\n"); ucloud_ai_facebody_recognize_expression(EXPRESSION_IMAGE, NULL); break; #endif #ifdef CONFIG_ALICLOUD_OBJECTDET_ENABLE case UCLOUD_AI_MODEL_DETECT_OBJECT: LOG("Detect object:\n"); ucloud_ai_objectdet_detect_object(OBJECT_IMAGE, NULL); break; case UCLOUD_AI_MODEL_DETECT_MAIN_BODY: LOG("Detect main body:\n"); ucloud_ai_objectdet_detect_main_body(MAINBODY_IMAGE, NULL); break; #endif #ifdef CONFIG_ALICLOUD_IMAGESEG_ENABLE case UCLOUD_AI_MODEL_SEGMENT_COMMON_IMAGE: LOG("Segment common image:\n"); ucloud_ai_imageseg_segment_common_image(MAINBODY_IMAGE, NULL); break; case UCLOUD_AI_MODEL_SEGMENT_FACE: LOG("Segment face:\n"); ucloud_ai_imageseg_segment_face(FACE1_IMAGE, NULL); break; #endif #ifdef CONFIG_ALICLOUD_OCR_ENABLE case UCLOUD_AI_MODEL_RECOGNIZE_IDENTITY_CARD_FACE_SIDE: LOG("Recognize identity card face side:\n"); ucloud_ai_ocr_recognize_identity_card_face_side(CARD_FACE_IMAGE, NULL); break; case UCLOUD_AI_MODEL_RECOGNIZE_IDENTITY_CARD_BACK_SIDE: LOG("Recognize identity card back side:\n"); ucloud_ai_ocr_recognize_identity_card_back_side(CARD_BACK_IMAGE, NULL); break; case UCLOUD_AI_MODEL_RECOGNIZE_BANK_CARD: LOG("Recognize bank card:\n"); ucloud_ai_ocr_recognize_bank_card(BANK_CARD_IMAGE, NULL); break; case UCLOUD_AI_MODEL_RECOGNIZE_CHARACTER: LOG("Recognize character:\n"); ucloud_ai_ocr_recognize_character(CHARACTER_IMAGE, NULL); break; #endif #ifdef CONFIG_ALICLOUD_IMAGERECOG_ENABLE case UCLOUD_AI_MODEL_CLASSIFYING_RUBBISH: LOG("Classifying rubbish:\n"); ucloud_ai_imagerecog_classifying_rubbish(RUBBISH_IMAGE, NULL); break; case UCLOUD_AI_MODEL_DETECT_FRUITS: LOG("Detect fruits:\n"); ucloud_ai_imagerecog_detect_fruits(FRUITS_IMAGE, NULL); break; #endif #ifdef CONFIG_ALICLOUD_IMAGEENHAN_ENABLE case UCLOUD_AI_MODEL_ERASE_PERSON: LOG("Erase person:\n"); ucloud_ai_imageenhan_erase_person(PERSON_ORG_IMAGE, IMAGEENHAN_ERASE_PERSON_USERMASK_URL, NULL); break; case UCLOUD_AI_MODEL_EXTEND_IMAGE_STYLE: LOG("Extend image style:\n"); ucloud_ai_imageenhan_extend_image_style(STYLE_IMAGE, IMAGEENHAN_EXTEND_IMAGE_STYLE_URL, NULL); break; #endif default: break; } ret = ucloud_ai_uninit(); if (ret < 0) { LOGE(TAG, "ucloud_ai_uninit failed, ret: %d\n", ret); return -1; } return; } #if AOS_COMP_CLI /* reg args: fun, cmd, description*/ ALIOS_CLI_CMD_REGISTER(ucloud_ai_comp_example, ucloud_ai, ucloud_ai component base example) #endif
YifuLiu/AliOS-Things
components/ucloud_ai/example/ucloud_ai_example.c
C
apache-2.0
4,830
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _CHATBOT_H_ #define _CHATBOT_H_ #include "model/internal.h" #ifdef __cplusplus extern "C" { #endif char *chatbot(char *pInstanceId, char *pSessionId, char *text); #ifdef __cplusplus } #endif #endif // _CHATBOT_H_
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/chatbot.h
C
apache-2.0
290
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _COMMON_H_ #define _COMMON_H_ #include <stdint.h> #include "model/facebody.h" #include "model/imageenhan.h" #include "model/imagerecog.h" #include "model/imageseg.h" #include "model/objectdet.h" #include "model/ocr.h" #include "model/internal.h" #ifdef __cplusplus extern "C" { #endif typedef union _AIModelResultStruct { FacebodyResultStruct facebody; ImageSegResultStruct imageseg; ImageEnhanResultStruct imageenhan; ImageRecogResultStruct imagerecog; ObjectDetResultStruct objectdet; OcrResultStruct ocr; } AIModelResultStruct; int getResponseBodyByUrl(const char *url, const char **buffer); void setAccesskeyAndSecret(char *key, char *secret); char *getTokenId(const char *domain, const char *region); char *computeContentMD5(const char *data, size_t size); char *generateUuid(); char *urlEncode(const char *src); char *urlDecode(const char *src); #ifdef __cplusplus } #endif #endif // _COMMON_H_
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/common.h
C
apache-2.0
1,004
/* * Copyright (C) 2015-2018 Alibaba Group Holding Limited */ #ifndef _FACEBODY_H_ #define _FACEBODY_H_ #include "internal.h" #ifdef __cplusplus extern "C" { #endif typedef struct _ComparingFaceStruct { float confidence; RectStruct location; } ComparingFaceStruct; typedef struct _RecognizeExpressionStruct { char *expression; float probability; RectStruct location; } RecognizeExpressionStruct; typedef struct _GenerateHumanAnimeStyleStruct { char *url; char *image; int imageLen; } GenerateHumanAnimeStyleStruct; typedef struct _DetectPedestrianStruct { char *type; float score; RectStruct box; } DetectPedestrianStruct; typedef union _FacebodyResultStruct { ComparingFaceStruct face; RecognizeExpressionStruct expression; GenerateHumanAnimeStyleStruct anime; DetectPedestrianStruct pedestrian; } FacebodyResultStruct; int compareFace(char *urlA, char *urlB, AIModelCBFunc cb); int recognizeExpression(char *url, AIModelCBFunc cb); int generateHumanAnimeStyle(char *url, AIModelCBFunc cb); int detectPedestrian(char *url, AIModelCBFunc cb); #ifdef __cplusplus } #endif #endif
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/facebody.h
C
apache-2.0
1,149
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _IMAGEENHAN_H_ #define _IMAGEENHAN_H_ #include "model/internal.h" #ifdef __cplusplus extern "C" { #endif typedef struct _ErasePersonStruct { char *url; char *image; int imageLen; } ErasePersonStruct; typedef struct _ExtendImageStyleStruct { char *majorUrl; char *majorImage; char *outImageUrl; char *outImage; int majorImageLen; int outImageLen; } ExtendImageStyleStruct; typedef union _ImageEnhanResultStruct { ErasePersonStruct person; ExtendImageStyleStruct style; } ImageEnhanResultStruct; int erasePerson(char *imageUrl, char *userMaskUrl, AIModelCBFunc cb); int extendImageStyle(char *majorUrl, char *styleUrl, AIModelCBFunc cb); #ifdef __cplusplus } #endif #endif
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/imageenhan.h
C
apache-2.0
794
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _IMAGERECOG_H_ #define _IMAGERECOG_H_ #include "internal.h" #ifdef __cplusplus extern "C" { #endif typedef struct _ClassifyingRubbishStruct { char *rubbish; char *category; float categoryScore; float rubbishScore; } ClassifyingRubbishStruct; typedef struct _DetectFruitsStruct { char *name; float score; RectStruct box; } DetectFruitsStruct; typedef union _ImageRecogResultStruct { ClassifyingRubbishStruct rubbish; DetectFruitsStruct fruits; } ImageRecogResultStruct; int classifyingRubbish(char *url, AIModelCBFunc cb); int detectFruits(char *url, AIModelCBFunc cb); #ifdef __cplusplus } #endif #endif
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/imagerecog.h
C
apache-2.0
720
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _IMAGESEG_H_ #define _IMAGESEG_H_ #include "internal.h" #ifdef __cplusplus extern "C" { #endif typedef struct _SegmentCommonStruct { char *url; char *image; int imageLen; } SegmentCommonStruct; typedef struct _SegmentFaceStruct { char *url; char *image; int imageLen; RectStruct location; } SegmentFaceStruct; typedef union _ImageSegResultStruct { SegmentCommonStruct common; SegmentFaceStruct face; } ImageSegResultStruct; int segmentCommonImage(char *url, AIModelCBFunc cb); int segmentFace(char *url, AIModelCBFunc cb); #ifdef __cplusplus } #endif #endif
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/imageseg.h
C
apache-2.0
673
/* * Copyright (C) 2021-2023 Alibaba Group Holding Limited */ #ifndef _INTERNAL_H_ #define _INTERNAL_H_ #define CLOUD_AI_REGION_ID "cn-shanghai" #define CLOUD_AI_FACEBODY_ENDPOINT "facebody.cn-shanghai.aliyuncs.com" #define CLOUD_AI_OBJECTDET_ENDPOINT "objectdet.cn-shanghai.aliyuncs.com" #define CLOUD_AI_IMAGESEG_ENDPOINT "imageseg.cn-shanghai.aliyuncs.com" #define CLOUD_AI_IMAGERECOG_ENDPOINT "imagerecog.cn-shanghai.aliyuncs.com" #define CLOUD_AI_IMAGEENHAN_ENDPOINT "imageenhan.cn-shanghai.aliyuncs.com" #define CLOUD_AI_OCR_ENDPOINT "ocr.cn-shanghai.aliyuncs.com" #define CLOUD_AI_CHATBOT_ENDPOINT "chatbot.cn-shanghai.aliyuncs.com" #define OSS_ENDPOINT "oss-cn-shanghai.aliyuncs.com" #ifdef __cplusplus extern "C" { #endif typedef struct _RectStruct { float x; float y; float w; float h; } RectStruct; typedef int (*AIModelCBFunc)(void *result); const char *getAccessKey(void); const char *getAccessSecret(void); #ifdef __cplusplus } #endif #endif // _INTERNAL_H_
YifuLiu/AliOS-Things
components/ucloud_ai/include/model/internal.h
C
apache-2.0
995