lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: Remove tracked build artifacts

Browse Source
This commit is contained in:
lmx
2025-11-28 16:24:27 +08:00
parent 892ed9267b
commit 818e8c3778
2356 changed files with 0 additions and 587882 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
apps/common/device/gSensor/EPMotion.h
View File

@ -1,257 +0,0 @@
/*******************************************************************************/
/**
******************************************************************************
* @file EPMotion.h
* @author ycwang@miramems.com
* @version V2.0
* @date 2019-01-31
* @brief
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, MiraMEMS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
*/
/*******************************************************************************/
#ifndef __EPMOTION_h
#define __EPMOTION_h
/*******************************************************************************
Includes
********************************************************************************/
#include "mira_std.h"
/*******************************************************************************
Macro definitions - Algorithm Build Options
********************************************************************************/
#define D_TAP_ENABLE 1
#define M_TAP_ENABLE 1
#define STEP_ENABLE 1
/*******************************************************************************
Typedef definitions
********************************************************************************/
enum {
DEBUG_ERR = 1,
DEBUG_MSG = 1 << 1,
DEBUG_DATA = 1 << 2,
DEBUG_RAW = 1 << 3,
};
typedef enum {
PIN_NONE,
PIN_ONE,
PIN_TWO
} tPIN_NUM;
typedef enum {
PIN_LEVEL_NONE,
PIN_LEVEL_LOW,
PIN_LEVEL_HIGH
} tPIN_LEVEL;
typedef enum {
NO_LATCHED,
LATCHED_250MS,
LATCHED_500MS,
LATCHED_1S,
LATCHED_2S,
LATCHED_4S,
LATCHED_8S,
LATCHED_1MS = 10,
LATCHED_2MS,
LATCHED_25MS,
LATCHED_50MS,
LATCHED_100MS,
LATCHED
} tLATCH_MODE;
typedef enum {
TEVENT_NONE,
TEVENT_TAP_NOTIFY,
} EPMotion_EVENT;
typedef enum {
NONE_T,
D_TAP_T,
M_TAP_T,
STEP_T,
} tAlgorithm;
typedef enum {
DISABLE_T,
ENABLE_T
} tSwitchCmd;
struct tInt_Pin_Config {
tPIN_NUM num;
tPIN_LEVEL level;
};
struct tREG_Func {
s8_m(*read)(u8_m addr, u8_m *data_m, u8_m len);
s8_m(*write)(u8_m addr, u8_m data_m);
};
struct tDEBUG_Func {
s32_m(*myprintf)(const char *fmt, ...);
};
struct EPMotion_op_s {
struct tInt_Pin_Config pin;
s8_m(*mir3da_event_handle)(EPMotion_EVENT event, u8_m data_m);
struct tREG_Func reg;
struct tDEBUG_Func debug;
};
/*******************************************************************************
Global variables and functions
********************************************************************************/
/*******************************************************************************
* Function Name: EPMotion_Init
* Description : This function initializes the EPMotion.
* Arguments : EPMotion_op_s *ops
* Return Value : 0: OK; -1: Type Error; -2: OP Error; -3: Chip Error
********************************************************************************/
s8_m EPMotion_Init(struct EPMotion_op_s *ops);
/*******************************************************************************
* Function Name: EPMotion_Tap_Set_Parma
* Description : This function sets tap parmas.
* Arguments :
* threshold - set interrupt threshold 0~31 ,(threshold*125)mg
* default is 21(2625mg)
* latch_mode - set interrupt latched mode ,(tLATCH_MODE)
* default is NO_LATCHED
* duration - set interrupt duration 0~7(50~700)ms,
* default is 0(50ms)
* Return Value : None
********************************************************************************/
void EPMotion_Tap_Set_Parma(u8_m threshold, tLATCH_MODE latch_mode, u8_m duration);
#if D_TAP_ENABLE
/*******************************************************************************
* Function Name: EPMotion_Tap_Set_Filter
* Description : This function sets filter.
* Arguments :
* level - set level of checking data 1~3 ,default is 1
* ths - set the value of filter ,(ths*1)mg
* Return Value : None
********************************************************************************/
void EPMotion_D_Tap_Set_Filter(u8_m level, u16_m ths);
#endif
#if M_TAP_ENABLE
/*******************************************************************************
* Function Name: EPMotion_M_Tap_Set_Dur
* Description : This function sets M tap duration.
* Arguments :
* m_dur_int - set interrupt duration 20~70,(m_dur_int*10)ms,
* default is 50(500ms)
* m_dur_event - set m tap event duration 20~6000,(m_dur_event*10)ms,
* default is 100(1000ms)
*EPMotion_M_Tap_Set_Dur第一个参数是设置两次敲击间隔的最大时间 第二参数是连续多次敲击总的有效时间
* Return Value : None
********************************************************************************/
void EPMotion_M_Tap_Set_Dur(u8_m m_dur_int, u16_m m_dur_event);
#endif
/*******************************************************************************
* Function Name: EPMotion_Reset_Tap_INT
* Description : This function reset tap INT.
* Arguments : None
* Return Value : None
********************************************************************************/
void EPMotion_Reset_Tap_INT(void);
/*******************************************************************************
* Function Name: EPMotion_Resume_Tap_INT
* Description : This function resume tap INT.
* Arguments : None
* Return Value : None
********************************************************************************/
void EPMotion_Resume_Tap_INT(void);
#if STEP_ENABLE
/*******************************************************************************
* Function Name: EPMotion_Reset_Step
* Description : This function reset step counter.
* Arguments : None
* Return Value : None
********************************************************************************/
void EPMotion_Reset_Step(void);
/*******************************************************************************
* Function Name: EPMotion_Get_Step
* Description : This function gets the step.
* Arguments : None
* Return Value : step
********************************************************************************/
u16_m EPMotion_Get_Step(void);
#endif
/*******************************************************************************
* Function Name: EPMotion_Control
* Description : This function initializes the xMotion.
* Arguments : name - select which algorithm to control
cmd - enable/disable
* Return Value : 0->Success, -1->Init Fail£¬-2£¬No Supported
********************************************************************************/
s8_m EPMotion_Control(tAlgorithm name, tSwitchCmd cmd);
/*******************************************************************************
* Function Name: EPMotion_Process_Data
* Description : This function runs the EPMotion Algorithm.
* Arguments : None
* Return Value : None
********************************************************************************/
void EPMotion_Process_Data(s8_m int_active);
/*******************************************************************************
* Function Name: EPMotion_Chip_Read_XYZ
* Description : This function reads the chip xyz.
* Arguments : x, y, z - acc data
* Return Value : 0: OK; -1: Error
********************************************************************************/
s8_m EPMotion_Chip_Read_XYZ(s16_m *x, s16_m *y, s16_m *z);
/*******************************************************************************
* Function Name: EPMotion_Get_Version
* Description : This function gets EPMotion version.
* Arguments : ver - EPMotion version Num
* Return Value : None
********************************************************************************/
void EPMotion_Get_Version(u8_m *ver);
/*******************************************************************************
* Function Name: EPMotion_Chip_Power_On
* Description : This function enables the chip.
* Arguments : None
* Return Value : 0: OK; -1: Error
********************************************************************************/
s8_m EPMotion_Chip_Power_On(void);
/*******************************************************************************
* Function Name: EPMotion_Chip_Power_Off
* Description : This function disables on the chip.
* Arguments : None
* Return Value : 0: OK; -1: Error
********************************************************************************/
s8_m EPMotion_Chip_Power_Off(void);
/*******************************************************************************
* Function Name: EPMotion_Set_Debug_level
* Description : This function sets the debug log level
* Arguments : Log level
* Return Value : None
********************************************************************************/
void EPMotion_Set_Debug_level(u8_m level);
#endif

371
apps/common/device/gSensor/SC7A20.c
View File

@ -1,371 +0,0 @@
#include "gSensor/SC7A20.h"
#include "gSensor/gSensor_manage.h"
#include "app_config.h"
#include "gSensor/SC7A20.h"
#include "math.h"
#if TCFG_SC7A20_EN
u8 volatile sl_click_timer_en = 0;
#define INT_IO IO_PORTC_02
#define SL_Sensor_Algo_Release_Enable 1
u8 Click_time = 0X00;
u8 Click_add_flag = 0X00;
u32 SL_MEMS_i2cRead(u8 addr, u8 reg, u8 len, u8 *buf)
{
return _gravity_sensor_get_ndata(addr, reg, buf, len);
}
u8 SL_MEMS_i2cWrite(u8 addr, u8 reg, u8 data)
{
gravity_sensor_command(addr, reg, data);
return 0;
}
char SC7A20_Check()
{
u8 reg_value = 0;
SL_MEMS_i2cRead(SC7A20_R_ADDR, SC7A20_WHO_AM_I, 1, &reg_value);
if (reg_value == 0x11) {
return 0x01;
} else {
return 0x00;
}
}
u8 SC7A20_Config(void)
{
u8 Check_Flag = 0;
u8 write_num = 0, i = 0;
u8 ODR = 0x6f; //400HZ/6f 200HZ
u8 HP = 0x0c; //开启高通滤波
u8 click_int = 0x04;//0x82 //将Click中断映射到INT1 OVERRUN
u8 range = 0x90; //4g量程
u8 fifo_en = 0x40; //使能fifo
u8 fifo_mode = 0x9c; //0x9d //Stream模式，0-29(WTM30个)
u8 click_mode = 0x15; //单击3轴触发
Check_Flag = SC7A20_Check();
if (Check_Flag == 1) {
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG1, ODR);
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG2, HP);
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG3, click_int);// click int1
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG4, range);
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG5, fifo_en);
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_FIFO_CTRL_REG, fifo_mode);
/*
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CLICK_CFG, click_mode);//单Z轴
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CLICK_THS, SC7A20_CLICK_TH);//62.6mg(4g)*10
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_TIME_LIMIT, SC7A20_CLICK_WINDOWS);
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_TIME_LATENCY, SC7A20_CLICK_LATENCY);
*/
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG6, SC7A20_INT_LEVEL);
printf("check ok\n");
return 0;
} else {
printf("check fail\n");
return -1;
}
}
u8 SC7A20_disable(void)
{
u8 Check_Flag = SC7A20_Check();
if (Check_Flag == 1) {
u8 ODR = 0x00;
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG1, ODR);
printf("check ok\n");
return 0;
} else {
printf("check fail\n");
return -1;
}
}
#if SL_Sensor_Algo_Release_Enable==0
extern signed short SL_DEBUG_DATA[10][128];
extern u8 SL_DEBUG_DATA_LEN;
#endif
u8 sl_pp_num = 0;
u8 SL_Get_CLICK_PP_CNT(u8 fun_flag)
{
if (fun_flag == 0) {
sl_pp_num = 0;
}
return sl_pp_num;
}
unsigned int SL_Click_Sqrt(unsigned int sqrt_data)
{
unsigned int SL_SQRT_LOW, SL_SQRT_UP, SL_SQRT_MID;
u8 sl_sqrt_num = 0;
SL_SQRT_LOW = 0;
SL_SQRT_UP = sqrt_data;
SL_SQRT_MID = (SL_SQRT_UP + SL_SQRT_LOW) / 2;
while (sl_sqrt_num < 200) {
if (SL_SQRT_MID * SL_SQRT_MID > sqrt_data) {
SL_SQRT_UP = SL_SQRT_MID;
} else {
SL_SQRT_LOW = SL_SQRT_MID;
}
if (SL_SQRT_UP - SL_SQRT_LOW == 1) {
if (SL_SQRT_UP * SL_SQRT_UP - sqrt_data > sqrt_data - SL_SQRT_LOW * SL_SQRT_LOW) {
return SL_SQRT_LOW;
} else {
return SL_SQRT_UP;
}
}
SL_SQRT_MID = (SL_SQRT_UP + SL_SQRT_LOW) / 2;
sl_sqrt_num++;
}
return 0;
}
char SC7A20_Click_Read(int TH1, int TH2)
{
u8 i = 0, j = 0, k = 0;
u8 click_num = 0;
u8 fifo_len;
unsigned int sc7a20_data = 0;
unsigned int fifo_data_xyz[32];
u8 click_result = 0x00;
unsigned int click_sum = 0;
u8 data1[6];
signed char data[6];
g_printf("INT_HAPPEN!\r\n");
SL_MEMS_i2cRead(SC7A20_R_ADDR, SC7A20_SRC_REG, 1, &fifo_len);
if ((fifo_len & 0x40) == 0x40) {
fifo_len = 32;
} else {
fifo_len = fifo_len & 0x1f;
}
for (i = 0; i < fifo_len; i++) {
SL_MEMS_i2cRead(SC7A20_R_ADDR, 0xA8, 6, &data1[0]);
data[1] = (signed char)data1[1];
data[3] = (signed char)data1[3];
data[5] = (signed char)data1[5];
sc7a20_data = (data[1]) * (data[1]) + (data[3]) * (data[3]) + (data[5]) * (data[5]);
sc7a20_data = SL_Click_Sqrt(sc7a20_data);
fifo_data_xyz[i] = sc7a20_data;
#if SL_Sensor_Algo_Release_Enable==0
SL_DEBUG_DATA[0][i] = data[1];
SL_DEBUG_DATA[1][i] = data[3];
SL_DEBUG_DATA[2][i] = data[5];
SL_DEBUG_DATA[3][i] = fifo_data_xyz[i];
SL_DEBUG_DATA_LEN = fifo_len;
#endif
}
k = 0;
for (i = 1; i < fifo_len - 1; i++) {
if ((fifo_data_xyz[i + 1] > TH1) && (fifo_data_xyz[i - 1] < 30)) {
g_printf("in_th\r\n");
if (click_num == 0) {
click_sum = 0; //first peak
for (j = 0; j < i - 1; j++) {
if (fifo_data_xyz[j] > fifo_data_xyz[j + 1]) {
click_sum += fifo_data_xyz[j] - fifo_data_xyz[j + 1];
} else {
click_sum += fifo_data_xyz[j + 1] - fifo_data_xyz[j];
}
}
#if SL_Sensor_Algo_Release_Enable==0
g_printf("click_sum:%d!\r\n", click_sum);
#endif
if (click_sum > TH2) {
sl_pp_num++;
break;
}
k = i;
} else {
k = i; //sencond peak
}
}
if (k != 0) {
if (fifo_data_xyz[i - 1] - fifo_data_xyz[i + 1] > TH1 - 10) {
if (i - k < 5) {
click_num = 1;
break;
}
}
}
}
if (click_num == 1) {
click_result = 1;
} else {
click_result = 0;
}
return click_result;
}
//GPIO?????,??INT2
//Service function in Int Function
//u8 sl_click_timer_en =0;
u8 sl_click_status = 0;
unsigned short click_timer_cnt = 0;
unsigned short click_timer_total_cnt = 0;
u8 click_click_final_cnt = 0;
char SC7A20_Click_Alog(void)
{
u8 click_status = 0;
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG3, 0x00);
click_status = SC7A20_Click_Read(SC7A20_TH1, SC7A20_TH2); //40,50
g_printf("click_status = 0x%x\n", click_status);
if (click_status == 1) {
if (sl_click_timer_en == 0) {
//set click timer flag
sl_click_timer_en = 1;
//clear click timer cnt value
click_timer_cnt = 0;
click_timer_total_cnt = 0;
click_click_final_cnt = 0;
}
sl_click_status = 1;
}
SL_MEMS_i2cWrite(SC7A20_W_ADDR, SC7A20_CTRL_REG3, 0x82);
return click_status;
}
//This fuction is execute in 50ms timer when the timer is opened
char SC7A20_click_status(void)
{
u8 click_e_cnt = 0;
if (sl_click_timer_en == 1) {
click_timer_cnt++;
if ((click_timer_cnt < click_pp_num) && (sl_click_status == 1)) {
g_printf("status:%d\r\n", sl_click_status);
g_printf("fin_num:%d\r\n", click_click_final_cnt);
sl_click_status = 0;
click_timer_total_cnt = click_timer_total_cnt + click_timer_cnt;
click_timer_cnt = 0;
click_click_final_cnt++;
}
click_e_cnt = SL_Get_CLICK_PP_CNT(1);
if ((((click_timer_cnt >= click_pp_num) || (click_timer_total_cnt >= click_max_num)) && (click_e_cnt < 1)) ||
((click_timer_cnt >= click_pp_num) && (click_e_cnt > 0)))
// if((click_timer_cnt>=click_pp_num)||(click_timer_total_cnt>=click_max_num))
{
//clear click timer flag
sl_click_timer_en = 0;
//clear click timer cnt value
click_timer_cnt = 0;
click_timer_total_cnt = 0;
g_printf("fin_num:%d\r\n", click_click_final_cnt);
if (click_e_cnt > 0) {
click_e_cnt = SL_Get_CLICK_PP_CNT(0);
return 0;
} else {
return click_click_final_cnt;
}
}
}
return 0;
}
void SC7A20_int_io_detect(u8 int_io_status)
{
static u8 int_io_status_old;
/* u8 int_io_status = 0; */
/* int_io_status = gpio_read(INT_IO); */
if ((int_io_status) && (int_io_status_old == 0)) {
log_e("sc7a20_int_io_detect\n");
SC7A20_Click_Alog();
} else {
}
int_io_status_old = int_io_status;
}
void SC7A20_read_data(axis_info_t *sl_accel)
{
u8 data[6];
u8 fifo_len = 0;
SL_MEMS_i2cRead(SC7A20_R_ADDR, SC7A20_SRC_REG, 1, &fifo_len);
if ((fifo_len & 0x40) == 0x40) {
fifo_len = 32;
} else {
fifo_len = fifo_len & 0x1f;
}
for (u8 i = 0; i < fifo_len; i++) {
SL_MEMS_i2cRead(SC7A20_R_ADDR, 0xA8, 6, data);
sl_accel[i].x = (short)((data[1] << 8) | data[0]);
// sl_accel[i].x = sl_accel[i].x >> 4;
sl_accel[i].y = (short)((data[3] << 8) | data[2]);
// sl_accel[i].y = sl_accel[i].y >> 4;
sl_accel[i].z = (short)((data[5] << 8) | data[4]);
// sl_accel[i].z = sl_accel[i].z >> 4;
// printf("group:%2d,sl_accel_x:%5d, sl_accel_y:%5d, sl_accel_z:%5d\n", i, sl_accel[i].x, sl_accel[i].y, sl_accel[i].z);
}
}
void SC7A20_ctl(u8 cmd, void *arg)
{
char res;
switch (cmd) {
case GSENSOR_DISABLE:
res = SC7A20_disable();
memcpy(arg, &res, 1);
break;
case GSENSOR_RESET_INT:
res = SC7A20_Config();
memcpy(arg, &res, 1);
break;
case GSENSOR_RESUME_INT:
break;
case GSENSOR_INT_DET:
SC7A20_int_io_detect(*(u8 *)arg);
break;
case READ_GSENSOR_DATA:
SC7A20_read_data((axis_info_t *)arg);
break;
case SEARCH_SENSOR:
res = SC7A20_Check();
memcpy(arg, &res, 1);
break;
default:
break;
}
}
static u8 sc7a20_idle_query(void)
{
return !sl_click_timer_en;
}
REGISTER_GRAVITY_SENSOR(gSensor) = {
.logo = "sc7a20",
.gravity_sensor_init = SC7A20_Config,
.gravity_sensor_check = SC7A20_click_status,
.gravity_sensor_ctl = SC7A20_ctl,
};
REGISTER_LP_TARGET(sc7a20_lp_target) = {
.name = "sc7a20",
.is_idle = sc7a20_idle_query,
};
#endif

116
apps/common/device/gSensor/SC7A20.h
View File

@ -1,116 +0,0 @@
/*
Copyright (c) 2019 Silan MEMS. All Rights Reserved.
*/
#ifndef SC7A20_H
#define SC7A20_H
/********添加IIC头文件******************/
//#include "i2c.h"
/***************************************/
/***使用驱动前请根据实际接线情况配置（7bit）IIC地址******/
/**SC7A20的SDO 脚接地： 0x18****************/
/**SC7A20的SDO 脚接电源： 0x19****************/
#define SC7A20_W_ADDR (0x19U << 1 | 0x0)
#define SC7A20_R_ADDR (0x19U << 1 | 0x1)
/*******************************************************/
#define SC7A20_CLICK_TH 0x38 //Click触发阈值,如果单次敲击无法触发中断，请将下面这个参数适当调小,如果单次敲击太过灵敏，请将下面这个参数适当调大
#define SC7A20_CLICK_WINDOWS 0x05 //Click有效窗口
#define SC7A20_CLICK_LATENCY 0x10 //Click中断持续时间,odr = 0x10时， 时间 = 16 * 2.5ms
#define SC7A20_INT_LEVEL 0x02 //0x02为中断时低电平，0x0为高电平
//如果中断能够触发，但是无法识别为单击，请调小如下函数中的参数 TH1
//如果单击能够触发，摇晃都会触发多击，请调小如下函数中的参数 TH2
//如果单击能够触发，多击功能比较难实现，请调大如下函数中的参数 TH2
#define SC7A20_TH1 40
#define SC7A20_TH2 50
#define click_pp_num (unsigned short)10*25 //10对应0.5s(不需要管后面的*25)
#define click_max_num (unsigned short)60*25 // 60对应3s
/*************驱动初始化函数**************/
unsigned char SC7A20_Config(void);
/**SC7A20_Config 函数中， ODR 默认0x7f 400HZ/6f 200HZ ************/
/**SC7A20_Config 函数中， HP 默认0xOC 开启高通滤波 ************/
/**SC7A20_Config 函数中， click_int 默认0x80 将Click中断映射到INT1************/
/**SC7A20_Config 函数中， range 默认0x90 4g量程************/
/**SC7A20_Config 函数中， fifo_en 默认0x40 使能fifo************/
/**SC7A20_Config 函数中， fifo_mode 默认0x80 Stream模式************/
/**SC7A20_Config 函数中， click_mode 默认0x15 单击3轴触发************/
/**SC7A20_Config 函数中， click_th 默认0x38 Click触发阈值************/
/**SC7A20_Config 函数中， click_window 默认0x05 Click有效窗口************/
/**SC7A20_Config 函数中， click_latency 默认0x10 Click中断持续时间************/
/*************返回数据情况如下*****************/
/**return : 1 IIC通讯正常IC在线***************/
/**return : 0; IIC通讯异常或IC不在线***************/
/*************单击状态检测**************/
char SC7A20_Click_Read(int TH1, int TH2);
/*************TH1 调节单击灵敏度，默认9000*****************/
/*************TH2 默认6000*****************/
/*************TH3 默认7000*****************/
/*************返回数据情况如下*****************/
/**return : 1 单次敲击有效***************/
/**return : 0; 单次敲击无效***************/
/*************外部中断调用Click敲击函数**************/
char SC7A20_Click_Alog(void);
/*************返回数据情况如下*****************/
/**return : 1 单次敲击有效***************/
/**return : 0; 单次敲击无效***************/
/*************定时器中断调用Click状态函数**************/
char SC7A20_click_status(void);
/*************返回数据情况如下*****************/
/**return : N N次敲击有效***************/
/**reg map***************/
#define SC7A20_OUT_TEMP_L 0x0C
#define SC7A20_OUT_TEMP_H 0x0D
#define SC7A20_WHO_AM_I 0x0F
#define SC7A20_USER_CAL_START 0x13
#define SC7A20_USER_CAL_END 0x1A
#define SC7A20_NVM_WR 0x1E
#define SC7A20_TEMP_CFG 0x1F
#define SC7A20_CTRL_REG1 0x20
#define SC7A20_CTRL_REG2 0x21
#define SC7A20_CTRL_REG3 0x22
#define SC7A20_CTRL_REG4 0x23
#define SC7A20_CTRL_REG5 0x24
#define SC7A20_CTRL_REG6 0x25
#define SC7A20_REFERENCE 0x26
#define SC7A20_STATUS_REG 0x27
#define SC7A20_OUT_X_L 0x28
#define SC7A20_OUT_X_H 0x29
#define SC7A20_OUT_Y_L 0x2A
#define SC7A20_OUT_Y_H 0x2B
#define SC7A20_OUT_Z_L 0x2C
#define SC7A20_OUT_Z_H 0x2D
#define SC7A20_FIFO_CTRL_REG 0x2E
#define SC7A20_SRC_REG 0x2F
#define SC7A20_INT1_CFG 0x30
#define SC7A20_INT1_SOURCE 0x31
#define SC7A20_INT1_THS 0x32
#define SC7A20_INT1_DURATION 0x33
#define SC7A20_INT2_CFG 0x34
#define SC7A20_INT2_SOURCE 0x35
#define SC7A20_INT2_THS 0x36
#define SC7A20_INT2_DURATION 0x37
#define SC7A20_CLICK_CFG 0x38
#define SC7A20_CLICK_SRC 0x39
#define SC7A20_CLICK_THS 0x3A
#define SC7A20_TIME_LIMIT 0x3B
#define SC7A20_TIME_LATENCY 0x3C
#define SC7A20_TIME_WINDOW 0x3D
#define SC7A20_ACT_THS 0x3E
#define SC7A20_ACT_DURATION 0x3F
#endif // SC7A20_H

141
apps/common/device/gSensor/STK8321.c
View File

@ -1,141 +0,0 @@
#include "gSensor/STK8321.h"
#include "gSensor/gSensor_manage.h"
#include "app_config.h"
#if TCFG_STK8321_EN
static u8 stk8321_timeout_start = 0;
u8 STK8321_Read(u8 addr)
{
u8 data = 0;
_gravity_sensor_get_ndata(I2C_ADDR_STK8321_R, addr, &data, 1);
return data;
}
void STK8321_Write(u8 addr, u8 data)
{
//g_sensor_write(G_SlaveAddr,addr,data);
gravity_sensor_command(I2C_ADDR_STK8321_W, addr, data);
}
u8 STK8321_init(void)
{
u8 k = 0, init_cnt = 10;
u8 chip_id = 0;
printf("\n###############>> [ init STK8321 start] <<################\n");
do {
chip_id = STK8321_Read(0x00);
printf("\n STK8321 ID = [%x]\n", chip_id);
init_cnt--;
} while ((chip_id != 0x86) && (init_cnt));
STK8321_Write(0x14, 0xB6); //software reset
delay(1000);
if (chip_id != 0x86) {
return -1;
}
STK8321_Write(0x14, 0xB6); //software reset
delay(100);
// mode settings
STK8321_Write(0x11, 0x00); //active mode
STK8321_Write(0x0F, 0x08); //range = +-8g
STK8321_Write(0x10, 0x0D); //BW = 250Hz or ODR = 500Hz
STK8321_Write(0x34, 0x04); //Enable I2C WatchDog
// INT mode
STK8321_Write(0x20, 0x00); //INT1 and INT2 active high
STK8321_Write(0x21, 0x8F); //latched & clear
// slope settings
STK8321_Write(0x16, 0x04); // enable slope on Z-axis
STK8321_Write(0x19, 0x01); // map sig-motion to INT 1
STK8321_Write(0x27, 0x01); // The actual number of samples SLP_DUR[1:0]+1
STK8321_Write(0x28, 0x25); // SLP_THD[7:0]*15.64_mg
STK8321_Write(0x2A, 0x06); //Enable significant and any-motion interrupt
STK8321_Write(0x29, 0x05); //skip_time 1LSB=20ms
STK8321_Write(0x2B, 0x0A); //proof_time 1LSB=20ms
printf("\n###############>> [ init STK8321 end ] <<################\n");
return 0;
}
static char STK8321_check_event()
{
static u16 timeout_cnt = 125; //需要等250ms
u8 click_cnt = 0;
if (stk8321_timeout_start) {
if (timeout_cnt) {
timeout_cnt --;
} else {
u8 RegReadValue = 0;
g_printf("stk8321_timeout");
RegReadValue = STK8321_Read(0x09);
if ((RegReadValue & 0x04) == 0x00) {
g_printf("Double Tap");
click_cnt = 2;
} else if ((RegReadValue & 0x04) == 0x04) {
g_printf("Triple Tap");
click_cnt = 3;
} else {
g_printf("NO Tap");
click_cnt = 0;
}
STK8321_Write(0x2A, 0x02);
STK8321_Write(0x21, 0x8F);
stk8321_timeout_start = 0;
timeout_cnt = 125;
}
}
return click_cnt;
}
void STK8321_int_io_detect(u8 int_io_status)
{
static u8 int_io_status_old;
if (!stk8321_timeout_start) {
if (!(int_io_status) && (int_io_status_old == 1)) {
g_printf("STK8321_int_io_detect\n");
stk8321_timeout_start = 1;
STK8321_Write(0x2A, 0x04);
STK8321_Write(0x21, 0x8F);
}
int_io_status_old = int_io_status;
}
}
void STK8321_ctl(u8 cmd, void *arg)
{
switch (cmd) {
case GSENSOR_RESET_INT:
break;
case GSENSOR_RESUME_INT:
break;
case GSENSOR_INT_DET:
STK8321_int_io_detect(*(u8 *)arg);
break;
default:
break;
}
}
static u8 STK8321_idle_query(void)
{
return !stk8321_timeout_start;
}
REGISTER_GRAVITY_SENSOR(gSensor) = {
.logo = "STK8321",
.gravity_sensor_init = STK8321_init,
.gravity_sensor_check = STK8321_check_event,
.gravity_sensor_ctl = STK8321_ctl,
};
REGISTER_LP_TARGET(da230_lp_target) = {
.name = "STK8321",
.is_idle = STK8321_idle_query,
};
#endif

11
apps/common/device/gSensor/STK8321.h
View File

@ -1,11 +0,0 @@
#ifndef __STK8321_H__
#define __STK8321_H__
#include "typedef.h"
#define STK8321_ID 0x30
#define I2C_ADDR_STK8321_W (STK8321_ID | 0x0)
#define I2C_ADDR_STK8321_R (STK8321_ID | 0x1)
#endif

393
apps/common/device/gSensor/da230.c
View File

@ -1,393 +0,0 @@
#include "gSensor/EPMotion.h"
#include "gSensor/da230.h"
#include "gSensor/gSensor_manage.h"
#include "app_config.h"
#if TCFG_DA230_EN
#define LOG_TAG "[DA230]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
static u8 da230_init_ok = 0;
static u8 tap_data = 0;
static u8 tap_start = 0;
static u8 event_ocur = 0;
static u8 da230_is_idle = 1;
void da230_set_idle_flag(u8 flag)
{
da230_is_idle = flag;
}
u32 da230_register_read(u8 addr, u8 *data)
{
_gravity_sensor_get_ndata(I2C_ADDR_DA230_R, addr, data, 1);
return 0;
}
s8_m da230_register_write(u8_m addr, u8_m data)
{
gravity_sensor_command(I2C_ADDR_DA230_W, addr, data);
return 0;
}
s8_m da230_read_nbyte_data(u8_m addr, u8_m *data, u8_m len)
{
_gravity_sensor_get_ndata(I2C_ADDR_DA230_R, addr, data, len);
return 0;
}
s8_m da230_register_mask_write(unsigned char addr, unsigned char mask, unsigned char data)
{
int res = 0;
unsigned char tmp_data;
/* iic_readn(I2C_ADDR_DA230_R, addr, &tmp_data, 1); */
da230_read_nbyte_data(addr, &tmp_data, 1);
tmp_data &= ~mask;
tmp_data |= data & mask;
/* iic_write(I2C_ADDR_DA230_W, addr, &tmp_data, 1); */
da230_register_write(addr, tmp_data);
return 1;
}
s8_m handleEvent(EPMotion_EVENT event, u8 data)
{
event_ocur = 0;
tap_start = 0;
da230_set_idle_flag(1);
log_info("da230_set_idle_flag:1");
switch (event) {
case TEVENT_TAP_NOTIFY: {
tap_data = data;
printf("*******DATA:%d \n", data);
}
break;
default:
break;
}
return 0;
}
u32 da230_register_write_bit(u8 addr, u8 start, u8 len, u8 data)
{
u32 res = 0;
u8 tmp_data;
res = da230_register_read(addr, &tmp_data);
if (res) {
return res;
}
SFR(tmp_data, start, len, data);
res = da230_register_write(addr, tmp_data);
return res;
}
u32 da230_close_i2c_pullup(void)
{
u32 res = 0;
res |= da230_register_write(0x7f, 0x83);
res |= da230_register_write(0x7f, 0x69);
res |= da230_register_write(0x7f, 0xBD);
/**********将0x8f bit1写0，去掉da230内部i2c弱上拉*********/
res |= da230_register_write_bit(0x8f, 1, 1, 0);
return res;
}
#if 0
u32 da230_read_block_data(u8 base_addr, u8 count, u8 *data)
{
u32 i = 0;
for (i = 0; i < count; i++) {
if (da230_register_read(base_addr + i, (data + i))) {
return -1;
}
}
return count;
}
u32 da230_register_read_continuously(u8 addr, u8 count, u8 *data)
{
u32 res = 0;
res = (count == da230_read_block_data(addr, count, data)) ? 0 : 1;
return res;
}
u32 da230_open_step_counter(void)
{
u32 res = 0;
res |= da230_register_write(NSA_REG_STEP_CONGIF1, 0x01);
res |= da230_register_write(NSA_REG_STEP_CONGIF2, 0x62);
res |= da230_register_write(NSA_REG_STEP_CONGIF3, 0x46);
res |= da230_register_write(NSA_REG_STEP_CONGIF4, 0x32);
res |= da230_register_write(NSA_REG_STEP_FILTER, 0xa2);
return res;
}
u16 da230_get_step(void)
{
u8 tmp_data[4] = {0};
u16 f_step = 0;
if (da230_register_read_continuously(NSA_REG_STEPS_MSB, 4, tmp_data) == 0) {
if (0x40 == tmp_data[2] && 0x07 == tmp_data[3]) {
f_step = ((tmp_data[0] << 8 | tmp_data[1])) / 2;
}
}
return (f_step);
}
u32 da230_close_step_counter(void)
{
u32 res = 0;
res = da230_register_write(NSA_REG_STEP_FILTER, 0x22);
return res;
}
u32 da230_register_write_bit(u8 addr, u8 start, u8 len, u8 data)
{
u32 res = 0;
u8 tmp_data;
res = da230_register_read(addr, &tmp_data);
if (res) {
return res;
}
SFR(tmp_data, start, len, data);
res = da230_register_write(addr, tmp_data);
return res;
}
u32 da230_open_i2c_pullup(void)
{
u32 res = 0;
res |= da230_register_write(0x7f, 0x83);
res |= da230_register_write(0x7f, 0x69);
res |= da230_register_write(0x7f, 0xBD);
/**********将0x8f bit1写1，开启da230内部i2c弱上拉*********/
res |= da230_register_write_bit(0x8f, 1, 1, 1);
return res;
}
#endif
struct EPMotion_op_s ops_handle = {
{PIN_ONE, PIN_LEVEL_LOW},
handleEvent,
{da230_read_nbyte_data, da230_register_write},
printf
};
u8 da230_init(void)
{
u8 data = 0;
JL_PORTB->DIR &= ~BIT(2);
JL_PORTB->DIE |= BIT(2);
JL_PORTB->OUT |= BIT(2);
da230_register_read(NSA_REG_WHO_AM_I, &data);
if (data != 0x13) {
log_e("da230 init err1!!!!!!!\n");
return -1;
}
if (EPMotion_Init(&ops_handle)) {
log_e("da230 init err2!!!!!!!\n");
return -1;
}
EPMotion_Set_Debug_level(DEBUG_ERR);
EPMotion_Tap_Set_Parma(0x0d, LATCHED_100MS, 0x00); //0x05~0x1f
//EPMotion_D_Tap_Set_Filter(1, 130);
EPMotion_M_Tap_Set_Dur(70, 500);
// EPMotion_M_Tap_Set_Dur(60,150);
da230_register_mask_write(0x10, 0xe0, 0xc0);
EPMotion_Control(M_TAP_T, ENABLE_T);
// EPMotion_Tap_Set_Parma(0x08,LATCHED_25MS,0x00); //0x05~0x1f
//close i2c pullup
da230_close_i2c_pullup();
da230_register_mask_write(0x8f, 0x02, 0x00);
da230_init_ok = 1;
log_info("da230 init success!!!\n");
return 0;
}
u32 da230_set_enable(u8 enable)
{
u32 res = 0;
if (da230_init_ok) {
if (enable) {
EPMotion_Chip_Power_On();
} else {
EPMotion_Chip_Power_Off();
}
}
return res;
}
void da230_read_XYZ(short *x, short *y, short *z)
{
if (da230_init_ok) {
EPMotion_Chip_Read_XYZ(x, y, z);
}
}
#if 0
u16 da230_open_interrupt(u16 num)
{
u16 res = 0;
res = da230_register_write(NSA_REG_INTERRUPT_SETTINGS1, 0x87);
res = da230_register_write(NSA_REG_ACTIVE_THRESHOLD, 0x05);
switch (num) {
case 0:
res = da230_register_write(NSA_REG_INTERRUPT_MAPPING1, 0x04);
break;
case 1:
res = da230_register_write(NSA_REG_INTERRUPT_MAPPING3, 0x04);
break;
}
return res;
}
#endif
void da230_check_tap_int(void)
{
static int count = 0;
if (tap_start) {
if (event_ocur == 1) {
count = 0;
}
if ((count % 5) == 0) {
//printf("====process event %d\r\n",event_ocur);
// gpio_direction_output(IO_PORT_DM, 1);
EPMotion_Process_Data(event_ocur);
// gpio_direction_output(IO_PORT_DM, 0);
}
count++;
if (count >= 300000) {
count = 0;
}
}
}
void da230_low_energy_mode(void)
{
da230_register_write(0x11, 0x04);
}
void da230_int_io_detect(u8 int_io_status)
{
static u8 int_io_status_old = 0;
/* u8 int_io_status = 0; */
if (da230_init_ok) {
/* int_io_status = gpio_read(INT_IO); */
if ((int_io_status) && (int_io_status_old == 0)) {
log_e("da230_int_io_detect\n");
if (tap_start == 0) {
tap_start = 1;
da230_set_idle_flag(0);
log_info("da230_set_idle_flag:0");
}
event_ocur = 1;
putchar('A');
} else {
event_ocur = 0;
}
int_io_status_old = int_io_status;
da230_check_tap_int();
}
}
static char da230_check_event()
{
u8 tmp_tap_data = 0;
tmp_tap_data = tap_data;
if (tap_data) {
tap_data = 0;
printf("tmp_tap_data = %d\n", tmp_tap_data);
}
return tmp_tap_data;
/* return EPMotion_Process_Data(); */
}
void da230_ctl(u8 cmd, void *arg)
{
switch (cmd) {
case GSENSOR_RESET_INT:
EPMotion_Reset_Tap_INT();
break;
case GSENSOR_RESUME_INT:
EPMotion_Resume_Tap_INT();
break;
case GSENSOR_INT_DET:
da230_int_io_detect(*(u8 *)arg);
break;
default:
break;
}
}
static u8 da230_idle_query(void)
{
return da230_is_idle;
}
REGISTER_GRAVITY_SENSOR(gSensor) = {
.logo = "da230",
.gravity_sensor_init = da230_init,
.gravity_sensor_check = da230_check_event,
.gravity_sensor_ctl = da230_ctl,
};
REGISTER_LP_TARGET(da230_lp_target) = {
.name = "da230",
.is_idle = da230_idle_query,
};
#endif

25
apps/common/device/gSensor/da230.h
View File

@ -1,25 +0,0 @@
#ifndef __da230_h
#define __da230_h
#include "typedef.h"
#include "mira_std.h"
#define LATCHED_MODE LATCHED_1S //interrupt latched mode
#define INTERRUPT_THRESHOLD 15 //interrupt threshold 0~31 ,(threshold*125)mg
#define INTERRUPT_DURATION 5 //interrupt duration 0~7 ,(50~700)ms 0:50ms 1:100ms 2:150ms 3:200ms 4:250ms 5:375ms 6:500ms 7:700ms
#define TAP_SAMPLE_LEVEL 1 //采样次数 = 25-TAP_SAMPLE_LEVEL*5
#define TAP_FILTER 30 //噪声大小，大于TAP_FILTER认为是噪声
#define I2C_ADDR_DA230_W 0x4e
#define I2C_ADDR_DA230_R 0x4f
extern u32 da230_register_read(u8 addr, u8 *data);
extern s8_m da230_register_write(u8_m addr, u8_m data);
extern u32 da230_register_write_bit(u8 addr, u8 start, u8 len, u8 data);
// extern u8 da230_int_event_detect(void);
#endif

488
apps/common/device/gSensor/gSensor_manage.c
View File

@ -1,488 +0,0 @@
#include "gSensor/gSensor_manage.h"
#include "device/device.h"
#include "app_config.h"
#include "debug.h"
#include "key_event_deal.h"
#include "btstack/avctp_user.h"
#include "app_main.h"
#include "tone_player.h"
#include "user_cfg.h"
#include "system/os/os_api.h"
#include "asm/power/power_wakeup.h"
/* #include "audio_config.h" */
/* #include "app_power_manage.h" */
/* #include "system/timer.h" */
/* #include "event.h" */
#if TCFG_USER_TWS_ENABLE
#include "bt_tws.h"
#endif
#define ENABLE_XLOG 1
#ifdef xlog
#undef xlog
#endif
#if ENABLE_XLOG
#define xlog(format, ...) printf("[XT:%s] " format, __func__, ##__VA_ARGS__)
#else
#define xlog(format, ...) ((void)0)
#endif
spinlock_t iic_lock;
#define LOG_TAG "[GSENSOR]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define xlog_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
static const struct gsensor_platform_data *platform_data;
G_SENSOR_INTERFACE *gSensor_hdl = NULL;
G_SENSOR_INFO __gSensor_info = {.iic_delay = 10};
#define gSensor_info (&__gSensor_info)
static cbuffer_t *data_w_cbuf;
//static short read_buf[256];
extern int gsensorlen;
extern OS_MUTEX SENSOR_IIC_MUTEX;
// extern spinlock_t sensor_iic;
extern u8 sensor_iic_init_status;
#define BUF_SIZE gsensorlen*3
static short *data_buf;
u8 read_write_status = 0;
#if TCFG_GSENOR_USER_IIC_TYPE
#define iic_init(iic) hw_iic_init(iic)
#define iic_uninit(iic) hw_iic_uninit(iic)
#define iic_start(iic) hw_iic_start(iic)
#define iic_stop(iic) hw_iic_stop(iic)
#define iic_tx_byte(iic, byte) hw_iic_tx_byte(iic, byte)
#define iic_rx_byte(iic, ack) hw_iic_rx_byte(iic, ack)
#define iic_read_buf(iic, buf, len) hw_iic_read_buf(iic, buf, len)
#define iic_write_buf(iic, buf, len) hw_iic_write_buf(iic, buf, len)
#define iic_suspend(iic) hw_iic_suspend(iic)
#define iic_resume(iic) hw_iic_resume(iic)
#else
#define iic_init(iic) soft_iic_init(iic)
#define iic_uninit(iic) soft_iic_uninit(iic)
#define iic_start(iic) soft_iic_start(iic)
#define iic_stop(iic) soft_iic_stop(iic)
#define iic_tx_byte(iic, byte) soft_iic_tx_byte(iic, byte)
#define iic_rx_byte(iic, ack) soft_iic_rx_byte(iic, ack)
#define iic_read_buf(iic, buf, len) soft_iic_read_buf(iic, buf, len)
#define iic_write_buf(iic, buf, len) soft_iic_write_buf(iic, buf, len)
#define iic_suspend(iic) soft_iic_suspend(iic)
#define iic_resume(iic) soft_iic_resume(iic)
#endif
void gSensor_event_to_user(u8 event)
{
struct sys_event e;
e.type = SYS_KEY_EVENT;
e.u.key.event = event;
e.u.key.value = 0;
sys_event_notify(&e);
}
void gSensor_int_io_detect(void *priv)
{
u8 int_io_status = 0;
u8 det_result = 0;
int_io_status = gpio_read(platform_data->gSensor_int_io);
//xlog("status %d\n",int_io_status);
gSensor_hdl->gravity_sensor_ctl(GSENSOR_INT_DET, &int_io_status);
if (gSensor_hdl->gravity_sensor_check == NULL) {
return;
}
det_result = gSensor_hdl->gravity_sensor_check();
if (det_result == 1) {
xlog("GSENSOR_EVENT_CLICK\n");
gSensor_event_to_user(KEY_EVENT_CLICK);
} else if (det_result == 2) {
xlog("GSENSOR_EVENT_DOUBLE_CLICK\n");
gSensor_event_to_user(KEY_EVENT_DOUBLE_CLICK);
} else if (det_result == 3) {
xlog("GSENSOR_EVENT_THREE_CLICK\n");
gSensor_event_to_user(KEY_EVENT_TRIPLE_CLICK);
}
}
int gSensor_read_data(u8 *buf, u8 buflen)
{
if (buflen < 32) {
return 0;
}
axis_info_t accel_data[32];
if (!gpio_read(platform_data->gSensor_int_io)) {
gSensor_hdl->gravity_sensor_ctl(READ_GSENSOR_DATA, accel_data);
}
memcpy(buf, accel_data, sizeof(accel_data));
return sizeof(accel_data) / sizeof(axis_info_t);
}
//输出三轴数组和数据长度
//
int get_gSensor_data(short *buf)
{
// xlog("%s",__func__);
axis_info_t accel_data[32];
if (!gpio_read(platform_data->gSensor_int_io)) {
gSensor_hdl->gravity_sensor_ctl(READ_GSENSOR_DATA, accel_data);
for (int i = 0; i < 29; i++) {
buf[i * 2] = accel_data[i].x;
buf[i * 2 + 1] = accel_data[i].y;
buf[i * 2 + 2] = accel_data[i].z;
// xlog("cnt:%1d x:%5d y:%5d z:%5d\n", i, accel_data[i].x, accel_data[i].y, accel_data[i].z);
}
return sizeof(accel_data) / sizeof(axis_info_t);
}
return 0;
}
int read_gsensor_buf(short *buf)
{
read_gsensor_nbuf(buf, 1200);
return 1200;
}
static u8 wr_lock;
int read_gsensor_nbuf(short *buf, short datalen)
{
// xlog("%s",__func__);
if (data_w_cbuf == NULL) {
return 0;
}
if (gSensor_info->init_flag == 1) {
// if (read_write_status == 0) {
// read_write_status = 1;
// return 0;
// }
if (data_w_cbuf->data_len >= datalen) {
cbuf_read(data_w_cbuf, buf, datalen);
cbuf_clear(data_w_cbuf);
return datalen;
} else {
return 0;
}
} else {
xlog("%s NOT ONLINE ", __func__);
return 0;
}
}
void write_gsensor_data_handle(void)
{
axis_info_t accel_data[32];
if (data_w_cbuf == NULL) {
return ;
}
if (gSensor_info->init_flag == 1) {
// if (read_write_status == 0) {
// xlog("%s ",__func__);
// return;
// }
if (!gpio_read(platform_data->gSensor_int_io)) {
gSensor_hdl->gravity_sensor_ctl(READ_GSENSOR_DATA, accel_data);
/*for(int i=0;i<29;i++){
xlog("cnt:%1d x:%5d y:%5d z:%5d\n", i, accel_data[i].x, accel_data[i].y, accel_data[i].z);
}*/
u8 wlen;
wlen = cbuf_write(data_w_cbuf, accel_data, 2 * 3 * 29);
/* for(int i=0;i<29;i++){ */
/* xlog("sour x=%06d y=%06d z=%06d",accel_data[i].x,accel_data[i].y,accel_data[i].z); */
/* } */
if (wlen == 0) {
xlog("data_w_cbuf_full");
}
}
} else {
// xlog("%s ",__func__);
return ;
}
}
// 临时的设备扫描诊断函数
void i2c_scanner_probe(u8* device_addr, u8* found_number)
{
printf("Starting I2C bus scan...\n");
int devices_found = 0;
// I2C地址范围是 0x08 到 0x77
for (uint8_t addr_7bit = 0x00; addr_7bit < 0x7F; addr_7bit++)
{
// 构建8位的写地址
uint8_t write_addr_8bit = (addr_7bit << 1);
iic_start(gSensor_info->iic_hdl);
// 尝试发送写地址，并检查返回值
// iic_tx_byte 返回 1 表示收到了 ACK
if (iic_tx_byte(gSensor_info->iic_hdl, write_addr_8bit))
{
device_addr[devices_found] = addr_7bit;
printf("=====================================================================\n");
printf("I2C device found at 7-bit address: 0x%02X\n", addr_7bit);
printf("I2C device found at 8-bit address: 0x%02X\n", write_addr_8bit);
printf("=====================================================================\n");
devices_found++;
}
iic_stop(gSensor_info->iic_hdl);
delay(gSensor_info->iic_delay); // 短暂延时
}
*found_number = devices_found;
if (devices_found == 0) {
printf("Scan finished. No I2C devices found.\n");
} else {
printf("Scan finished. Found %d device(s).\n", devices_found);
}
}
char w_log_buffer_1[100];
char w_log_buffer_2[100];
char w_log_buffer_3[100];
char w_log_buffer_4[100];
char w_log_buffer_5[100];
u8 gravity_sensor_command(u8 w_chip_id, u8 register_address, u8 function_command)
{
// spin_lock(&sensor_iic);
/* os_mutex_pend(&SENSOR_IIC_MUTEX,0); */
u8 ret = 1;
// xlog("iic_start\n");
iic_start(gSensor_info->iic_hdl);
// xlog("iic_tx_byte id\n");
if (0 == iic_tx_byte(gSensor_info->iic_hdl, w_chip_id)) {
ret = 0;
xlog("\n gsen iic wr err 0\n");
strcpy(&w_log_buffer_1, "gsen iic wr err 0\n");
goto __gcend;
}
// xlog("iic delay\n");
delay(gSensor_info->iic_delay);
// xlog("iic_tx_byte: address\n");
if (0 == iic_tx_byte(gSensor_info->iic_hdl, register_address)) {
ret = 0;
xlog("\n gsen iic wr err 1\n");
strcpy(&w_log_buffer_2, "gsen iic wr err 1\n");
goto __gcend;
}
delay(gSensor_info->iic_delay);
// xlog("iic_tx_byte: command\n");
if (0 == iic_tx_byte(gSensor_info->iic_hdl, function_command)) {
ret = 0;
xlog("\n gsen iic wr err 2\n");
strcpy(&w_log_buffer_3, "gsen iic wr err 3\n");
goto __gcend;
}
strcpy(&w_log_buffer_4, "gsen iic wr sucess\n");
// xlog("\n gsen iic wr sucess\n");
__gcend:
iic_stop(gSensor_info->iic_hdl);
// spin_unlock(&sensor_iic);
/* os_mutex_post(&SENSOR_IIC_MUTEX); */
return ret;
}
char sen_log_buffer_1[100];
char sen_log_buffer_2[100];
char sen_log_buffer_3[100];
char sen_log_buffer_4[100];
char sen_log_buffer_5[100];
u8 _gravity_sensor_get_ndata(u8 r_chip_id, u8 register_address, u8 *buf, u8 data_len)
{
// xlog("%s",__func__);
// spin_lock(&sensor_iic);
/* os_mutex_pend(&SENSOR_IIC_MUTEX,0); */
u8 read_len = 0;
iic_start(gSensor_info->iic_hdl);
if (0 == iic_tx_byte(gSensor_info->iic_hdl, r_chip_id - 1)) {
xlog("I2C NACK on writing ADDR: 0x%X\n", r_chip_id - 1);
read_len = 0;
strcpy(&sen_log_buffer_1, "gsen iic rd err 0\n");
goto __gdend;
}
delay(gSensor_info->iic_delay);
if (0 == iic_tx_byte(gSensor_info->iic_hdl, register_address)) {
xlog("I2C NACK on register ADDR: 0x%X\n", register_address);
// xlog("\n gsen iic rd err 1\n");
read_len = 0;
strcpy(&sen_log_buffer_2, "gsen iic rd err 1\n");
goto __gdend;
}
iic_start(gSensor_info->iic_hdl);
if (0 == iic_tx_byte(gSensor_info->iic_hdl, r_chip_id)) {
xlog("\n gsen iic rd err 2\n");
read_len = 0;
strcpy(&sen_log_buffer_3, "gsen iic rd err 2\n" );
goto __gdend;
}
delay(gSensor_info->iic_delay);
for (; data_len > 1; data_len--) {
*buf++ = iic_rx_byte(gSensor_info->iic_hdl, 1);
read_len ++;
}
*buf = iic_rx_byte(gSensor_info->iic_hdl, 0);
read_len ++;
strcpy(&sen_log_buffer_4, "gsen iic rd success\n");
// xlog("\n gsen iic rd success\n");
__gdend:
iic_stop(gSensor_info->iic_hdl);
delay(gSensor_info->iic_delay);
// spin_unlock(&sensor_iic);
/* os_mutex_post(&SENSOR_IIC_MUTEX); */
// strcpy(&sen_log_buffer_5, "gsen iic rd err\n");
return read_len;
}
void gsensor_io_ctl(u8 cmd, void *arg)
{
gSensor_hdl->gravity_sensor_ctl(cmd, arg);
}
//u8 gravity_sen_dev_cur; /*当前挂载的Gravity sensor*/
int gravity_sensor_init(void *_data)
{
if (sensor_iic_init_status == 0) {
// spin_lock_init(&sensor_iic);
sensor_iic_init_status = 1;
}
gSensor_info->init_flag = 0;
int retval = 0;
platform_data = (const struct gsensor_platform_data *)_data;
gSensor_info->iic_hdl = platform_data->iic;
retval = iic_init(gSensor_info->iic_hdl);
xlog("\n gravity_sensor_init\n");
if (retval < 0) {
xlog("\n open iic for gsensor err\n");
return retval;
} else {
xlog("\n iic open succ\n");
}
retval = -EINVAL;
list_for_each_gsensor(gSensor_hdl) {
if (!memcmp(gSensor_hdl->logo, platform_data->gSensor_name, strlen(platform_data->gSensor_name))) {
retval = 0;
break;
}
}
if (retval < 0) {
xlog(">>>gSensor_hdl logo err\n");
return retval;
}
if (gSensor_hdl->gravity_sensor_init()) {
xlog(">>>>gSensor_Int ERROR\n");
} else {
xlog(">>>>gSensor_Int SUCC\n");
gSensor_info->init_flag = 1;
if (platform_data->gSensor_int_io != -1) {
gpio_set_pull_up(platform_data->gSensor_int_io, 1);
gpio_set_pull_down(platform_data->gSensor_int_io, 0);
gpio_set_direction(platform_data->gSensor_int_io, 1);
gpio_set_die(platform_data->gSensor_int_io, 1);
data_buf = zalloc(BUF_SIZE);
if (data_buf == NULL) {
xlog("gsensor_cbuf_error!");
return 0;
}
data_w_cbuf = zalloc(sizeof(cbuffer_t));
if (data_w_cbuf == NULL) {
return 0;
}
cbuf_init(data_w_cbuf, data_buf, BUF_SIZE);
/* port_edge_wkup_set_callback(write_gsensor_data_handle); */
/* 已改为使用port_edge_wkup_set_callback_by_index,使用时需要重新实现 */
xlog("cbuf_init");
// spin_lock_init(&iic_lock);
// sys_s_hi_timer_add(NULL, gSensor_int_io_detect, 10); //10ms
// sys_s_hi_timer_add(NULL, gSensor_read_data, 2000); //2s
}
}
return 0;
}
int gsensor_disable(void)
{
if (data_w_cbuf == NULL) {
return -1;
} else {
if (gSensor_info->init_flag == 1) {
int valid = 0;
gSensor_hdl->gravity_sensor_ctl(GSENSOR_DISABLE, &valid);
if (valid == 0) {
free(data_w_cbuf);
data_w_cbuf = NULL;
return 0;
}
}
}
return -1;
}
int gsensor_enable(void)
{
//查找设备
int valid = 0;
gSensor_hdl->gravity_sensor_ctl(SEARCH_SENSOR, &valid);
if (valid == 0) {
return -1;
}
//工作空间
data_buf = zalloc(BUF_SIZE);
if (data_buf == NULL) {
xlog("gsensor_cbuf_error!");
return -1;
}
data_w_cbuf = zalloc(sizeof(cbuffer_t));
if (data_w_cbuf == NULL) {
return -1;
}
cbuf_init(data_w_cbuf, data_buf, BUF_SIZE);
xlog("cbuf_init");
//设置参数
valid = 0;
gSensor_hdl->gravity_sensor_ctl(GSENSOR_RESET_INT, &valid);
if (valid == -1) {
return -1;
}
xlog("gsensor_reset_succeed\n");
return 0;
}

88
apps/common/device/gSensor/gSensor_manage.h
View File

@ -1,88 +0,0 @@
#ifndef _GSENSOR_MANAGE_H
#define _GSENSOR_MANAGE_H
#include "printf.h"
#include "cpu.h"
//#include "iic.h"
#include "asm/iic_hw.h"
#include "asm/iic_soft.h"
#include "timer.h"
#include "app_config.h"
#include "event.h"
#include "system/includes.h"
#define ACCEL_OF_GRAVITY 10
#define ACCEL_DATA_GAIN 10
enum {
GSENSOR_DISABLE = 0,
GSENSOR_RESET_INT,
GSENSOR_RESUME_INT,
GSENSOR_INT_DET,
READ_GSENSOR_DATA,
GET_ACCEL_DATA,
SEARCH_SENSOR,
};
typedef struct {
short x;
short y;
short z;
} axis_info_t;
typedef struct {
u8 logo[20];
u8(*gravity_sensor_init)(void);
char (*gravity_sensor_check)(void);
void (*gravity_sensor_ctl)(u8 cmd, void *arg);
} G_SENSOR_INTERFACE;
struct gsensor_platform_data {
u8 iic;
char gSensor_name[20];
u32 gSensor_int_io;
};
typedef struct {
u8 iic_hdl;
u8 iic_delay; //这个延时并非影响iic的时钟频率，而是2Byte数据之间的延时
u8 ctl_flag;
int init_flag;
int check_cnt;
int check_timer_hdl;
} G_SENSOR_INFO;
int gravity_sensor_init(void *_data);
int gsensor_enable(void);
int gsensor_disable(void);
u8 gravity_sensor_command(u8 w_chip_id, u8 register_address, u8 function_command);
u8 _gravity_sensor_get_ndata(u8 r_chip_id, u8 register_address, u8 *buf, u8 data_len);
int get_gSensor_data(short *buf);
int gSensor_read_data(u8 *buf, u8 buflen);
int read_gsensor_buf(short *buf);
int read_gsensor_nbuf(short *buf, short datalen);
extern G_SENSOR_INTERFACE gsensor_dev_begin[];
extern G_SENSOR_INTERFACE gsensor_dev_end[];
#define REGISTER_GRAVITY_SENSOR(gSensor) \
static G_SENSOR_INTERFACE gSensor SEC_USED(.gsensor_dev)
#define list_for_each_gsensor(c) \
for (c=gsensor_dev_begin; c<gsensor_dev_end; c++)
#define GSENSOR_PLATFORM_DATA_BEGIN(data) \
static const struct gsensor_platform_data data = {
#define GSENSOR_PLATFORM_DATA_END() \
};
/*
enum {
GSENSOR_EVENT_CLICK = 0,
GSENSOR_EVENT_DOUBLE_CLICK,
GSENSOR_EVENT_THREE_CLICK,
};
#define DEVICE_EVENT_GSENSOR (('G' << 24) | ('S' << 16) | ('R' << 8) | '\0')
*/
#endif

99
apps/common/device/gSensor/mira_std.h
View File

@ -1,99 +0,0 @@
/*******************************************************************************/
/**
******************************************************************************
* @file mira_std.h
* @author ycwang@miramems.com
* @version V1.0
* @date 26-Nov-2014
* @brief
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, MiraMEMS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>&copy; COPYRIGHT 2014 MiraMEMS</center></h2>
*/
/*******************************************************************************/
#ifndef __mira_std_h
#define __mira_std_h
/*******************************************************************************
Macro definitions - Register define for Gsensor asic
********************************************************************************/
#define NSA_REG_SPI_I2C 0x00
#define NSA_REG_WHO_AM_I 0x01
#define NSA_REG_ACC_X_LSB 0x02
#define NSA_REG_ACC_X_MSB 0x03
#define NSA_REG_ACC_Y_LSB 0x04
#define NSA_REG_ACC_Y_MSB 0x05
#define NSA_REG_ACC_Z_LSB 0x06
#define NSA_REG_ACC_Z_MSB 0x07
#define NSA_REG_MOTION_FLAG 0x09
#define NSA_REG_G_RANGE 0x0f
#define NSA_REG_ODR_AXIS_DISABLE 0x10
#define NSA_REG_POWERMODE_BW 0x11
#define NSA_REG_SWAP_POLARITY 0x12
#define NSA_REG_FIFO_CTRL 0x14
#define NSA_REG_INTERRUPT_SETTINGS0 0x15
#define NSA_REG_INTERRUPT_SETTINGS1 0x16
#define NSA_REG_INTERRUPT_SETTINGS2 0x17
#define NSA_REG_INTERRUPT_MAPPING1 0x19
#define NSA_REG_INTERRUPT_MAPPING2 0x1a
#define NSA_REG_INTERRUPT_MAPPING3 0x1b
#define NSA_REG_INT_PIN_CONFIG 0x20
#define NSA_REG_INT_LATCH 0x21
#define NSA_REG_ACTIVE_DURATION 0x27
#define NSA_REG_ACTIVE_THRESHOLD 0x28
#define NSA_REG_TAP_DURATION 0x2A
#define NSA_REG_TAP_THRESHOLD 0x2B
#define NSA_REG_ENGINEERING_MODE 0x7f
#define NSA_REG_SENS_COMP 0x8c
#define NSA_REG_MEMS_OPTION 0x8f
#define NSA_REG_CHIP_INFO 0xc0
/*******************************************************************************
Typedef definitions
********************************************************************************/
#define ARM_BIT_8 0
#if ARM_BIT_8
//如下数据类型是在8位机上定义的，在其它平台（比如32位）可能存在差别，需要根据实际情况修改 。
typedef unsigned char u8_m; /* 无符号8位整型变量*/
typedef signed char s8_m; /* 有符号8位整型变量*/
typedef unsigned int u16_m; /* 无符号16位整型变量*/
typedef signed int s16_m; /* 有符号16位整型变量*/
typedef unsigned long u32_m; /* 无符号32位整型变量*/
typedef signed long s32_m; /* 有符号32位整型变量*/
typedef float fp32_m; /* 单精度浮点数（32位长度）*/
typedef double fp64_m; /* 双精度浮点数（64位长度）*/
#else
//如下数据类型是在32位机上定义的，在其它平台（比如8位）可能存在差别，需要根据实际情况修改 。
typedef unsigned char u8_m; /* 无符号8位整型变量*/
typedef signed char s8_m; /* 有符号8位整型变量*/
typedef unsigned short u16_m; /* 无符号16位整型变量*/
typedef signed short s16_m; /* 有符号16位整型变量*/
typedef unsigned int u32_m; /* 无符号32位整型变量*/
typedef signed int s32_m; /* 有符号32位整型变量*/
typedef float fp32_m; /* 单精度浮点数（32位长度）*/
typedef double fp64_m; /* 双精度浮点数（64位长度）*/
#endif
typedef struct AccData_tag {
s16_m ax; //加速度计原始数据结构体 数据格式 0 0 1024
s16_m ay;
s16_m az;
} AccData;
#define mir3da_abs(x) (((x) > 0) ? (x) : (-(x)))
s32_m mir3da_sqrt(s32_m val);
void mir3da_memset(void *dest, u8_m count);
void *mir3da_memcpy(void *dest, void *source, u8_m count);
#endif

134
apps/common/device/gSensor/mpu6050.c
View File

@ -1,134 +0,0 @@
#include "gSensor/mpu6050.h"
#include "gSensor/gSensor_manage.h"
#include "app_config.h"
#include "imuSensor_manage.h"
#if TCFG_MPU6050_EN
int gsensorlen = 32;
OS_MUTEX SENSOR_IIC_MUTEX;
spinlock_t sensor_iic;
u8 sensor_iic_init_status = 0;
#define ACCEL_ONLY_LOW_POWER 0
u8 mpu6050_register_read(u8 addr, u8 *data)
{
_gravity_sensor_get_ndata(I2C_ADDR_MPU6050_R, addr, data, 1);
return 0;
}
u8 mpu6050_register_write(u8 addr, u8 data)
{
gravity_sensor_command(I2C_ADDR_MPU6050_W, addr, data);
return 0;
}
u8 mpu6050_read_nbyte_data(u8 addr, u8 *data, u8 len)
{
return _gravity_sensor_get_ndata(I2C_ADDR_MPU6050_R, addr, data, len);
}
u8 mpu6050_get_xyz_data(u8 addr, void *xyz_data)
{
u8 buf[6], read_len;
axis_info_t *data = (axis_info_t *)xyz_data;
read_len = mpu6050_read_nbyte_data(addr, buf, 6);
if (read_len == 6) {
data->x = ((u16)buf[0] << 8) | buf[1];
data->y = ((u16)buf[2] << 8) | buf[3];
data->z = ((u16)buf[4] << 8) | buf[5];
data->x = 2 * ACCEL_OF_GRAVITY * ACCEL_DATA_GAIN * data->x / 32768;
data->y = 2 * ACCEL_OF_GRAVITY * ACCEL_DATA_GAIN * data->y / 32768;
data->z = 2 * ACCEL_OF_GRAVITY * ACCEL_DATA_GAIN * data->z / 32768;
}
return read_len;
}
extern void step_cal_init();
extern int step_cal();
u8 mpu6050_init()
{
u8 res = 0;
u8 data;
res = mpu6050_register_read(MPU6050_RA_WHO_AM_I, &data); //读ID
if (data == MPU_ADDR) {
g_printf("read MPU6050 ID suss");
} else {
g_printf("read MPU6050 ID err");
return -1;
}
data = 0x80;
mpu6050_register_write(MPU6050_RA_PWR_MGMT_1, data); //复位
os_time_dly(10);
data = 0x00;
data |= BIT(3); //关闭温度传感器
#if ACCEL_ONLY_LOW_POWER
data |= BIT(5); //设置accel-only低功耗模式
#endif
mpu6050_register_write(MPU6050_RA_PWR_MGMT_1, data); //退出休眠
data = 0x00;
data |= (BIT(0) | BIT(1) | BIT(2)); //关闭陀螺仪
#if ACCEL_ONLY_LOW_POWER
data |= (3 << 6); //accel-only低功耗模式下，唤醒频率为40Hz
#endif
/*mpu6050_register_write(MPU6050_RA_PWR_MGMT_2, data);*/
data = ACCEL_RANGE_2G << 3;
mpu6050_register_write(MPU6050_RA_ACCEL_CONFIG, data); //加速度计量程
#if (!ACCEL_ONLY_LOW_POWER)
data = 0x06;
mpu6050_register_write(MPU6050_RA_CONFIG, data); //设置陀螺仪输出速率
data = MPU6050_GYRO_OUT_RATE / MPU6050_SAMPLE_RATE - 1;
mpu6050_register_write(MPU6050_RA_SMPLRT_DIV, data); //设置采样率, 采样率=陀螺仪输出速率/(1+SMPLRT_DIV)
data = 0x00;
mpu6050_register_write(MPU6050_RA_INT_ENABLE, data); //关闭中断
data = 0x00;
mpu6050_register_write(MPU6050_RA_USER_CTRL, data); //关闭主机IIC
#endif
/*step_cal_init();*/
/*sys_timer_add(NULL, step_cal, 50);*/
return 0;
}
void mpu6050_ctl(u8 cmd, void *arg)
{
switch (cmd) {
case GET_ACCEL_DATA:
case IMU_GET_ACCEL_DATA:
mpu6050_get_xyz_data(MPU6050_RA_ACCEL_XOUT_H, arg);
break;
case IMU_GET_GYRO_DATA:
mpu6050_get_xyz_data(MPU6050_RA_GYRO_XOUT_H, arg);
break;
case READ_GSENSOR_DATA:
break;
}
}
REGISTER_GRAVITY_SENSOR(gSensor) = {
.logo = "mpu6050",
.gravity_sensor_init = mpu6050_init,
.gravity_sensor_check = NULL,
.gravity_sensor_ctl = mpu6050_ctl,
};
//未合到imu: init:gravity_sensor_init(&motion_sensor_data);
REGISTER_IMU_SENSOR(mpu6050_sensor) = {
.logo = "mpu6050",
.imu_sensor_init = mpu6050_init,
.imu_sensor_check = NULL,
.imu_sensor_ctl = mpu6050_ctl,
};
#endif //TCFG_MPU6050_EN

16
apps/common/device/gSensor/mpu6050.h
View File

@ -1,16 +0,0 @@
#ifndef __MPU6050_H_
#define __MPU6050_H_
#include "mpu6050_reg.h"
#define MPU6050_GYRO_OUT_RATE 1000 //1K或8K
#define MPU6050_SAMPLE_RATE 125
enum {
ACCEL_RANGE_2G,
ACCEL_RANGE_4G,
ACCEL_RANGE_8G,
ACCEL_RANGE_16G,
};
#endif

598
apps/common/device/gSensor/mpu6050_reg.h
View File

@ -1,598 +0,0 @@
#ifndef __MPU6050_REG_H_
#define __MPU6050_REG_H_
#define MPU_ACK_WAIT_TIME 200 //us
#define MPU6050_AD0_LOW
#ifdef MPU6050_AD0_LOW
#define MPU_ADDR 0x68 //设备ID
#else
#define MPU_ADDR 0x69 //设备ID
#endif
#define I2C_ADDR_MPU6050_W (MPU_ADDR<<1|0) // AD0为低的时候设备的写地址
#define I2C_ADDR_MPU6050_R (MPU_ADDR<<1|1) // AD0为高的时候设备的写地址
//技术文档未公布的寄存器 主要用于官方DMP操作
#define MPU6050_RA_XG_OFFS_TC 0x00 //[bit7] PWR_MODE, [6:1] XG_OFFS_TC, [bit 0] OTP_BNK_VLD
#define MPU6050_RA_YG_OFFS_TC 0x01 //[7] PWR_MODE, [6:1] YG_OFFS_TC, [0] OTP_BNK_VLD
//bit7的定义,当设置为1,辅助I2C总线高电平是VDD。当设置为0,辅助I2C总线高电平是VLOGIC
#define MPU6050_RA_ZG_OFFS_TC 0x02 //[7] PWR_MODE, [6:1] ZG_OFFS_TC, [0] OTP_BNK_VLD
#define MPU6050_RA_X_FINE_GAIN 0x03 //[7:0] X_FINE_GAIN
#define MPU6050_RA_Y_FINE_GAIN 0x04 //[7:0] Y_FINE_GAIN
#define MPU6050_RA_Z_FINE_GAIN 0x05 //[7:0] Z_FINE_GAIN
#define MPU6050_RA_XA_OFFS_H 0x06 //[15:0] XA_OFFS 两个寄存器合在一起
#define MPU6050_RA_XA_OFFS_L_TC 0x07
#define MPU6050_RA_YA_OFFS_H 0x08 //[15:0] YA_OFFS 两个寄存器合在一起
#define MPU6050_RA_YA_OFFS_L_TC 0x09
#define MPU6050_RA_ZA_OFFS_H 0x0A //[15:0] ZA_OFFS 两个寄存器合在一起
#define MPU6050_RA_ZA_OFFS_L_TC 0x0B
#define MPU6050_RA_XG_OFFS_USRH 0x13 //[15:0] XG_OFFS_USR 两个寄存器合在一起
#define MPU6050_RA_XG_OFFS_USRL 0x14
#define MPU6050_RA_YG_OFFS_USRH 0x15 //[15:0] YG_OFFS_USR 两个寄存器合在一起
#define MPU6050_RA_YG_OFFS_USRL 0x16
#define MPU6050_RA_ZG_OFFS_USRH 0x17 //[15:0] ZG_OFFS_USR 两个寄存器合在一起
#define MPU6050_RA_ZG_OFFS_USRL 0x18
/*陀螺仪的采样频率*/
/*传感器的寄存器输出,FIFO输出,DMP采样、运动检测、
*零运动检测和自由落体检测都是基于采样率。
*通过SMPLRT_DIV把陀螺仪输出率分频即可得到采样率
*采样率=陀螺仪输出率/ (1 + SMPLRT_DIV)
*禁用DLPF的情况下(DLPF_CFG = 0或7) ，陀螺仪输出率= 8 khz
*在启用DLPF(见寄存器26)时，陀螺仪输出率= 1 khz
*加速度传感器输出率是1 khz。这意味着,采样率大于1 khz时,
*同一个加速度传感器的样品可能会多次输入到FIFO、DMP和传感器寄存器*/
#define MPU6050_RA_SMPLRT_DIV 0x19 //[0-7] 陀螺仪输出分频采样率
/*配置外部引脚采样和DLPF数字低通滤波器*/
#define MPU6050_RA_CONFIG 0x1A
//bit5-bit3 一个连接到FSYNC端口的外部信号可以通过配置EXT_SYNC_SET来采样
// 也就是说,这里设置之后,FSYNC的电平0或1进入最终数据寄存器,具体如下
// 0 不使用 1 FSYNC电平进入所有数据寄存器 2 FSYNC电平进入GYRO_XOUT_L 3 FSYNC电平进入GYRO_YOUT_L
// 4 FSYNC电平进入GYRO_ZOUT_L 5 FSYNC电平进入ACCEL_XOUT_L 6 FSYNC电平进入ACCEL_YOUT_L
// 7 FSYNC电平进入SYNC_ACCEL_ZOUT_L
//bit2-bit0 数字低通滤波器 用于滤除高频干扰 高于这个频率的干扰被滤除掉
/*对应关系如下
* * | 加速度传感器 | 陀螺仪
* * DLPF_CFG | 带宽 | 延迟 | 带宽 | 延迟 | 采样率
* -------------+--------+-------+--------+------+-------------
* 0 | 260Hz | 0ms | 256Hz | 0.98ms | 8kHz
* 1 | 184Hz | 2.0ms | 188Hz | 1.9ms | 1kHz
* 2 | 94Hz | 3.0ms | 98Hz | 2.8ms | 1kHz
* 3 | 44Hz | 4.9ms | 42Hz | 4.8ms | 1kHz
* 4 | 21Hz | 8.5ms | 20Hz | 8.3ms | 1kHz
* 5 | 10Hz | 13.8ms | 10Hz | 13.4ms | 1kHz
* 6 | 5Hz | 19.0ms | 5Hz | 18.6ms | 1kHz
* 7 | Reserved | Reserved | Reserved
* */
/*陀螺仪的配置,主要是配置陀螺仪的量程与自检(通过相应的位7 6 5 开启自检)*/
#define MPU6050_RA_GYRO_CONFIG 0x1B
//bit4-bit3 量程设置如下
// 0 = +/- 250 度/秒
// 1 = +/- 500 度/秒
// 2 = +/- 1000 度/秒
// 3 = +/- 2000 度/秒*/
/*加速度计的配置,主要是配置加速度计的量程与自检(通过相应的位7 6 5 开启自检)
*另外,还能配置系统的高通滤波器*/
#define MPU6050_RA_ACCEL_CONFIG 0x1C
//bit7 启动X自检 加速度计的自检
//bit6 启动Y自检
//bit5 启动Z自检
//bit4-bit3 加速度传感器的量程配置
// 0 = +/- 2g
// 1 = +/- 4g
// 2 = +/- 8g
// 3 = +/- 16g*/
//bit0到bit2 加速度传感器的高通滤波器
/*DHPF是在路径中连接于运动探测器(自由落体,运动阈值,零运动)的一个滤波器模块。
*高通滤波器的输出值不在数据寄存器中
*高通滤波器有三种模式：
*重置:在一个样本中将滤波器输出值设为零。这有效的禁用了高通滤波器。这种模式可以快速切换滤波器的设置模式。
*开启:高通滤波器能通过高于截止频率的信号
*持续:触发后,过滤器持续当前采样。过滤器输出值是输入样本和持续样本之间的差异
*设置值如下所示
* ACCEL_HPF | 高通滤波模式| 截止频率
* ----------+-------------+------------------
* 0 | Reset | None
* 1 | On | 5Hz
* 2 | On | 2.5Hz
* 3 | On | 1.25Hz
* 4 | On | 0.63Hz
* 7 | Hold | None
*/
#define MPU6050_RA_FF_THR 0x1D
/*自由落体加速度的阈值
*这个寄存器为自由落体的阈值检测进行配置。
*FF_THR的单位是1LSB = 2mg。当加速度传感器测量而得的三个轴的绝对值
*都小于检测阈值时，就可以测得自由落体值。这种情况下，(加速度计每次检测到就+1以下,所以还要依靠加速度采样率)
*自由落体时间计数器计数一次 (寄存器30)。当自由落体时间计数器达到
*FF_DUR中规定的时间时，自由落体被中断(或发生自由落体中断)
**/
#define MPU6050_RA_FF_DUR 0x1E
/*
*自由落体加速度的时间阈值
* 这个寄存器为自由落体时间阈值计数器进行配置。
* 时间计数频率为1 khz,因此FF_DUR的单位是 1 LSB = 1毫秒。
* 当加速度器测量而得的绝对值都小于检测阈值时，
* 自由落体时间计数器计数一次。当自由落体时间计数器
* 达到该寄存器的规定时间时，自由落体被中断。
* (或发生自由落体中断)
* */
#define MPU6050_RA_MOT_THR 0x1F
/*
*运动检测的加速度阈值
*这个寄存器为运动中断的阈值检测进行配置。
*MOT_THR的单位是 1LSB = 2mg。
*当加速度器测量而得的绝对值都超过该运动检测的阈值时，
*即可测得该运动。这一情况下，运动时间检测计数器计数一次。
*当运动检测计数器达到MOT_DUR的规定时间时，运动检测被中断。
* 运动中断表明了被检测的运动MOT_DETECT_STATUS (Register 97)的轴和极性。
*/
#define MPU6050_RA_MOT_DUR 0x20
/*
*运动检测时间的阈值。
*这个寄存器为运动中断的阈值检测进行配置。
*时间计数器计数频率为1 kHz ，因此MOT_THR的单位是 1LSB = 1ms。
*当加速度器测量而得的绝对值都超过该运动检测的阈值时(Register 31)，
*运动检测时间计数器计数一次。当运动检测计数器达到该寄存器规定的时间时，
*运动检测被中断。
**/
#define MPU6050_RA_ZRMOT_THR 0x21
/*
*零运动检测加速度阈值。
* 这个寄存器为零运动中断检测进行配置。
* ZRMOT_THR的单位是1LSB = 2mg。
* 当加速度器测量而得的三个轴的绝对值都小于检测阈值时，
* 就可以测得零运动。这种情况下，零运动时间计数器计数一次 (寄存器34)。
* 当自零运动时间计数器达到ZRMOT_DUR (Register 34)中规定的时间时，零运动被中断。
* 与自由落体或运动检测不同的是，当零运动首次检测到以及当零运动检测不到时，零运动检测都被中断。
* 当零运动被检测到时,其状态将在MOT_DETECT_STATUS寄存器(寄存器97) 中显示出来。
* 当运动状态变为零运动状态被检测到时,状态位设置为1。当零运动状态变为运动状态被检测到时,
* 状态位设置为0。
**/
#define MPU6050_RA_ZRMOT_DUR 0x22
/*
*零运动检测的时间阈值
* 这个寄存器为零运动中断检测进行时间计数器的配置。
* 时间计数器的计数频率为16 Hz,因此ZRMOT_DUR的单位是1 LSB = 64 ms。
* 当加速度器测量而得的绝对值都小于检测器的阈值(Register 33)时，
* 运动检测时间计数器计数一次。当零运动检测计数器达到该寄存器规定的时间时，
* 零运动检测被中断。
**/
/*
*设备的各种FIFO使能,包括温度 加速度 陀螺仪 从机
*将相关的数据写入FIFO缓冲中
**/
#define MPU6050_RA_FIFO_EN 0x23
//bit7 温度fifo使能
//bit6 陀螺仪Xfifo使能
//bit5 陀螺仪Yfifo使能
//bit4 陀螺仪Zfifo使能
//bit3 加速度传感器fifo使能
//bit2 外部从设备2fifo使能
//bit1 外部从设备1fifo使能
//bit0 外部从设备0fifo使能
#define MPU6050_RA_I2C_MST_CTRL 0x24
//配置单主机或者多主机下的IIC总线
//bit7 监视从设备总线,看总线是否可用 MULT_MST_EN设置为1时,MPU-60X0的总线仲裁检测逻辑被打开
//bit6 延迟数据就绪中断,直达从设备数据也进入主机再触发 相当于数据同步等待
//bit5 当设置为1时,与Slave3 相连的外部传感器数据(寄存器73 到寄存器 96)写入FIFO缓冲中,每次都写入
//bit4 主机读取一个从机到下一个从机读取之间的动作 为0 读取之间有一个restart,为1 下一次读取前会有一个重启,然后
// 一直读取直到切换写入或者切换设备
//bit3-bit0 配置MPU作为IIC主机时的时钟,基于MPU内部8M的分频
/* I2C_MST_CLK | I2C 主时钟速度 | 8MHz 时钟分频器
* ------------+------------------------+-------------------
* 0 | 348kHz | 23
* 1 | 333kHz | 24
* 2 | 320kHz | 25
* 3 | 308kHz | 26
* 4 | 296kHz | 27
* 5 | 286kHz | 28
* 6 | 276kHz | 29
* 7 | 267kHz | 30
* 8 | 258kHz | 31
* 9 | 500kHz | 16
* 10 | 471kHz | 17
* 11 | 444kHz | 18
* 12 | 421kHz | 19
* 13 | 400kHz | 20
* 14 | 381kHz | 21
* 15 | 364kHz | 22
* */
/**************************MPU链接IIC从设备控制寄存器,没使用从机连接的基本不用考虑这些************************************/
/*指定slave (0-3)的I2C地址
* 注意Bit 7 (MSB)控制了读/写模式。如果设置了Bit 7,那么这是一个读取操作,
* 如果将其清除,那么这是一个编写操作。其余位(6-0)是slave设备的7-bit设备地址。
* 在读取模式中,读取结果是存储于最低可用的EXT_SENS_DATA寄存器中。
* MPU-6050支持全5个slave，但Slave 4有其特殊功能(getSlave4* 和setSlave4*)。
* 如寄存器25中所述，I2C数据转换通过采样率体现。用户负责确保I2C数据转换能够
* 在一个采样率周期内完成。
* I2C slave数据传输速率可根据采样率来减小。
* 减小的传输速率是由I2C_MST_DLY(寄存器52)所决定的。
* slave数据传输速率是否根据采样率来减小是由I2C_MST_DELAY_CTRL (寄存器103)所决定的。
* slave的处理指令是固定的。Slave的处理顺序是Slave 1, Slave 2, Slave 3 和 Slave 4。
* 如果某一个Slave被禁用了，那么它会被自动忽略。
* 每个slave可按采样率或降低的采样率来读取。在有些slave以采样率读取有些以减小
* 的采样率读取的情况下，slave的读取顺序依旧不变。然而，
* 如果一些slave的读取速率不能在特定循环中进行读取，那么它们会被自动忽略
* 更多降低的读取速率相关信息,请参阅寄存器52。
* Slave是否按采样率或降低的采样率来读取由寄存器103得Delay Enable位来决定
**/
//从机0设置相关
#define MPU6050_RA_I2C_SLV0_ADDR 0x25
//bit7 当前IIC 从设备0的操作,1为读取 0写入
//bit6-bit0 从机设备的地址
/* 要读取或者要写入的设备内部的寄存器地址,不管读取还是写入*/
#define MPU6050_RA_I2C_SLV0_REG 0x26
/*iic从机系统配置寄存器*/
#define MPU6050_RA_I2C_SLV0_CTRL 0x27
//bit7 启动或者禁止这个设备的IIC数据传送过程
//bit6 当设置为1时,字节交换启用。当启用字节交换时,词对的高低字节即可交换
//bit5 当 I2C_SLV0_REG_DIS 置 1，只能进行读取或者写入数据。当该位清 0，可以再读取
// 或写入数据之前写入一个寄存器地址。当指定从机设备内部的寄存器地址进行发送或接收
// 数据时，该位必须等于 0
//bit4 指定从寄存器收到的字符对的分组顺序。当该位清 0，寄存器地址
// 0和 1, 2 和 3 的字节是分别成对（甚至，奇数寄存器地址 ） ，作为一个字符对。当该位置 1，
// 寄存器地址 1 和 2， 3 和 4 的字节是分别成对的，作为一个字符对
//bit3-bit0 指定从机 0 发送字符的长度。由Slave 0转换而来和转换至Slave 0的字节数,(IIC一次传输的长度)
// 该位清 0，I2C_SLV0_EN 位自动置 0.
/*IIC SLAVE1配置寄存器,与0相同*/
#define MPU6050_RA_I2C_SLV1_ADDR 0x28
#define MPU6050_RA_I2C_SLV1_REG 0x29
#define MPU6050_RA_I2C_SLV1_CTRL 0x2A
/*IIC SLAVE2配置寄存器,与0相同*/
#define MPU6050_RA_I2C_SLV2_ADDR 0x2B
#define MPU6050_RA_I2C_SLV2_REG 0x2C
#define MPU6050_RA_I2C_SLV2_CTRL 0x2D
/*IIC SLAVE3配置寄存器,与0相同*/
#define MPU6050_RA_I2C_SLV3_ADDR 0x2E
#define MPU6050_RA_I2C_SLV3_REG 0x2F
#define MPU6050_RA_I2C_SLV3_CTRL 0x30
/*slave4的I2C地址 IIC4与前几个的寄存器定义有所不同*/
#define MPU6050_RA_I2C_SLV4_ADDR 0x31 //与IIC SLAVE1类似
#define MPU6050_RA_I2C_SLV4_REG 0x32 /*slave4的当前内部寄存器*/
#define MPU6050_RA_I2C_SLV4_DO 0x33
/*写于slave4的新字节这一寄存器可储存写于slave4的数据。
* 如果I2C_SLV4_RW设置为1（设置为读取模式），那么该寄存器无法执行操作*/
#define MPU6050_RA_I2C_SLV4_CTRL 0x34
//当设置为1时，此位启用了slave4的转换操作。当设置为0时，则禁用该操作
#define MPU6050_I2C_SLV4_EN_BIT 7
//当设置为1时，此位启用了slave4事务完成的中断信号的生成。
// 当清除为0时，则禁用了该信号的生成。这一中断状态可在寄存器54中看到。
#define MPU6050_I2C_SLV4_INT_EN_BIT 6
//当设置为1时,只进行数据的读或写操作。当设置为0时,
// 在读写数据之前将编写一个寄存器地址。当指定寄存器地址在slave设备中时
// ，这应该等于0，而在该寄存器中会进行数据处理。
#define MPU6050_I2C_SLV4_REG_DIS_BIT 5
//采样率延迟,这为根据采样率减小的I2C slaves传输速率进行了配置。
// 当一个slave的传输速率是根据采样率而降低的,那么该slave是以每1 / (1 + I2C_MST_DLY) 个样本进行传输。
// 这一基本的采样率也是由SMPLRT_DIV (寄存器 25)和DLPF_CFG (寄存器26)所决定的的。
// slave传输速率是否根据采样率来减小是由I2C_MST_DELAY_CTRL (寄存器103)所决定的
#define MPU6050_I2C_SLV4_MST_DLY_BIT 4 //[4:0]
#define MPU6050_I2C_SLV4_MST_DLY_LENGTH 5
/*slave4中可读取的最后可用字节*/
#define MPU6050_RA_I2C_SLV4_DI 0x35
/*
* IIC辅助从机系统中断状态
**/
#define MPU6050_RA_I2C_MST_STATUS 0x36
//bit7 此位反映了一个与MPU-60X0相连的外部设备的FSYNC中断状态。
// 当设置为1且在INT_PIN_CFG(寄存器55)中断言FSYNC_INT_EN时，中断产生。
//bit6 当slave4事务完成时，设备会自动设置为1 如果定义了INT_ENABLE中的I2C_MST_INT_EN则产生中断
//bit5 I2C主机失去辅助I2C总线（一个错误状态）的仲裁，此位自动设置为1.如果断言了INT_ENABLE寄存器
// （寄存器56）中的I2C_MST_INT_EN位，则中断产生
//bit4 slave4的NACK状态
//bit3 slave3的NACK状态
//bit2 slave2的NACK状态
//bit1 slave1的NACK状态
//bit0 slave0的NACK状态
/*中断引脚配置寄存器*/
#define MPU6050_RA_INT_PIN_CFG 0x37
//bit7 中断的逻辑电平模式,高电平时，设置为0；低电平时，设置为1
//bit6 中断驱动模式,推拉模式设置为0，开漏模式设置为1.
//bit5 中断锁存模式.50us-pulse模式设置为0，latch-until-int-cleared模式设置为1
//bit4 中断锁存清除模式 status-read-only状态设置为0，any-register-read状态设置为1.
//bit3 FSYNC中断逻辑电平模式 0=active-high, 1=active-low
//bit2 FSYNC端口中断启用设置设置为0时禁用，设置为1时启用
//bit1 I2C支路启用状态,此位等于1且I2C_MST_EN (寄存器 106 位[5])等于0时,主机应用程序处理器能够直接访问MPU-60X0的辅助I2C总线
// 否则无论如何都不能直接访问
//bit0 当此位为1时，CLKOUT端口可以输出参考时钟。当此位为0时，输出禁用
/*部分中断使能*/
#define MPU6050_RA_INT_ENABLE 0x38
//bit7 自由落体中断使能
//bit6 运动检测中断使能
//bit5 零运动检测中断使能
//bit4 FIFO溢出中断使能
//bit3 IIC主机所有中断源使能
//bit0 数据就绪中断使能
/*DMP中断使能*/
#define MPU6050_RA_DMP_INT_STATUS 0x39
//不知道这些位的具体作用是什么,官方语焉不详,但是的确存在
#define MPU6050_DMPINT_4_BIT 4
#define MPU6050_DMPINT_3_BIT 3
#define MPU6050_DMPINT_2_BIT 2
#define MPU6050_DMPINT_1_BIT 1
#define MPU6050_DMPINT_0_BIT 0
/*DMP中断配置*/
#define MPU6050_RA_INT_STATUS 0x3A
//DMP中断位之一使能
#define MPU6050_INTERRUPT_PLL_RDY_INT_BIT 2
//DMP中断位之二使能
#define MPU6050_INTERRUPT_DMP_INT_BIT 1
/*加速度X输出*/
#define MPU6050_RA_ACCEL_XOUT_H 0x3B
#define MPU6050_RA_ACCEL_XOUT_L 0x3C
/*加速度Y输出*/
#define MPU6050_RA_ACCEL_YOUT_H 0x3D
#define MPU6050_RA_ACCEL_YOUT_L 0x3E
/*加速度Z输出*/
#define MPU6050_RA_ACCEL_ZOUT_H 0x3F
#define MPU6050_RA_ACCEL_ZOUT_L 0x40
/*温度值输出*/
#define MPU6050_RA_TEMP_OUT_H 0x41
#define MPU6050_RA_TEMP_OUT_L 0x42
/*陀螺仪X输出*/
#define MPU6050_RA_GYRO_XOUT_H 0x43
#define MPU6050_RA_GYRO_XOUT_L 0x44
/*陀螺仪Y输出*/
#define MPU6050_RA_GYRO_YOUT_H 0x45
#define MPU6050_RA_GYRO_YOUT_L 0x46
/*陀螺仪Z输出*/
#define MPU6050_RA_GYRO_ZOUT_H 0x47
#define MPU6050_RA_GYRO_ZOUT_L 0x48
/*从IIC从机上获取到的数据*/
#define MPU6050_RA_EXT_SENS_DATA_00 0x49
#define MPU6050_RA_EXT_SENS_DATA_01 0x4A
#define MPU6050_RA_EXT_SENS_DATA_02 0x4B
#define MPU6050_RA_EXT_SENS_DATA_03 0x4C
#define MPU6050_RA_EXT_SENS_DATA_04 0x4D
#define MPU6050_RA_EXT_SENS_DATA_05 0x4E
#define MPU6050_RA_EXT_SENS_DATA_06 0x4F
#define MPU6050_RA_EXT_SENS_DATA_07 0x50
#define MPU6050_RA_EXT_SENS_DATA_08 0x51
#define MPU6050_RA_EXT_SENS_DATA_09 0x52
#define MPU6050_RA_EXT_SENS_DATA_10 0x53
#define MPU6050_RA_EXT_SENS_DATA_11 0x54
#define MPU6050_RA_EXT_SENS_DATA_12 0x55
#define MPU6050_RA_EXT_SENS_DATA_13 0x56
#define MPU6050_RA_EXT_SENS_DATA_14 0x57
#define MPU6050_RA_EXT_SENS_DATA_15 0x58
#define MPU6050_RA_EXT_SENS_DATA_16 0x59
#define MPU6050_RA_EXT_SENS_DATA_17 0x5A
#define MPU6050_RA_EXT_SENS_DATA_18 0x5B
#define MPU6050_RA_EXT_SENS_DATA_19 0x5C
#define MPU6050_RA_EXT_SENS_DATA_20 0x5D
#define MPU6050_RA_EXT_SENS_DATA_21 0x5E
#define MPU6050_RA_EXT_SENS_DATA_22 0x5F
#define MPU6050_RA_EXT_SENS_DATA_23 0x60
//运动检测的状态
#define MPU6050_RA_MOT_DETECT_STATUS 0x61
//bit7 x轴反向运动检测中断状态
//bit6 x轴正向运动检测中断状态
//bit5 Y轴反向运动检测中断状态
//bit4 Y轴正向运动检测中断状态
//bit3 Z轴反向运动检测中断状态
//bit2 Z轴正向运动检测中断状态
//bit1
//bit0 零运动检测中断状态
//
/*写入到IIC从机中的数据,指定的slv数据输出容器*/
#define MPU6050_RA_I2C_SLV0_DO 0x63
#define MPU6050_RA_I2C_SLV1_DO 0x64
#define MPU6050_RA_I2C_SLV2_DO 0x65
#define MPU6050_RA_I2C_SLV3_DO 0x66
/*外部影子寄存器的配置,这个寄存器用于指定外部传感器数据影子的时间
*当启用了某一特定的slave，其传输速率就会减小。
*当一个slave的传输速率是根据采样率而降低的,那么该slave是以
*每1 / (1 + I2C_MST_DLY) 个样本进行传输。
* 1 / (1 + I2C_MST_DLY) Samples
* 这一基本的采样率也是由SMPLRT_DIV (寄存器 25)和DLPF_CFG (寄存器26)所决定的的。*/
#define MPU6050_RA_I2C_MST_DELAY_CTRL 0x67
//DELAY_ES_SHADOW设置为1,跟随外部传感器数据影子将会延迟到所有的数据接收完毕。
#define MPU6050_DELAYCTRL_DELAY_ES_SHADOW_BIT 7
//slv4-0的配置
#define MPU6050_DELAYCTRL_I2C_SLV4_DLY_EN_BIT 4
#define MPU6050_DELAYCTRL_I2C_SLV3_DLY_EN_BIT 3
#define MPU6050_DELAYCTRL_I2C_SLV2_DLY_EN_BIT 2
#define MPU6050_DELAYCTRL_I2C_SLV1_DLY_EN_BIT 1
#define MPU6050_DELAYCTRL_I2C_SLV0_DLY_EN_BIT 0
/*用于陀螺仪，加速度计，温度传感器的模拟和数字信号通道的复位。
复位会还原模数转换信号通道和清除他们的上电配置*/
#define MPU6050_RA_SIGNAL_PATH_RESET 0x68
//bit2 重置陀螺仪的信号路径
//bit1 重置加速度传感器的信号路径
//bit0 重置温度传感器的信号路径
/*获取加速度传感器启动延迟 还有滤波器的一些配置
* 加速度传感器数据路径为传感器寄存器、运动检测、
* 零运动检测和自由落体检测模块提供样本。在检测模块开始操作之前，
* 包含过滤器的信号路径必须用新样本来启用。
* 默认的4毫秒唤醒延迟时间可以加长3毫秒以上。在ACCEL_ON_DELAY中规定
* 这个延迟以1 LSB = 1 毫秒为单位。除非InvenSense另行指示，
* 用户可以选择任何大于零的值。*/
#define MPU6050_RA_MOT_DETECT_CTRL 0x69
//具体的有效控制位
//bit5-bit4 [5:4]1-4ms 延时时间1-4ms选择
//bit3-bit2 自由落体检测计数器的减量配置。
// 当指定数量的样本的加速度测量都满足其各自的阈值条件时，
// 检测结果存储于自由落体检测模块中。当满足阈值条件时，
// 相应的检测计数器递增1。用户可通过FF_COUNT配置不满足阈值条件来减量。
// 减量率可根据下表进行设置：
/* FF_COUNT | 计数器减量
* ---------+------------------
* 0 | 重置
* 1 | 1
* 2 | 2
* 3 | 4
* 当FF_COUNT配置为0(复位)时,任何不合格的样品都将计数器重置为0*/
//bit1-bit0 运动检测计数器的减量配置。
// 当指定数量的样本的加速度测量都满足其各自的阈值条件时，
// 检测结果存储于运动检测模块中。当满足阈值条件时，相应的检测计数器递增1。
// 用户可通过MOT_COUNT配置不满足阈值条件来减量。减量率可根据下表进行设置：
// MOT_COUNT | 计数器减量
/* ----------+------------------
* 0 | 重置
* 1 | 1
* 2 | 2
* 3 | 4
* 当MOT_COUNT配置为0(复位)时,任何不合格的样品都将计数器重置为0*/
/*这个寄存器允许用户使能或使能 FIFO 缓冲区，
*I2C 主机模式和主要 I2C 接口。FIFO 缓冲
区，I2C 主机，传感器信号通道和传感器寄存器也可以使用这个寄存器复位*/
#define MPU6050_RA_USER_CTRL 0x6A
//bit7 DMP禁止
//bit6 当此位设置为0,FIFO缓冲是禁用的
//bit5 当这个模式被启用,MPU-60X0即成为辅助I2C总线上的外部传感器slave设备的I2C主机
// 当此位被清除为0时,辅助I2C总线线路(AUX_DA and AUX_CL)理论上是由I2C总线
// (SDA和SCL)驱动的。这是启用旁路模式的一个前提
//bit4 I2C转换至SPI模式(只允许MPU-6000)
//bit3 重置DMP模式,官方文档未说明的寄存器
//bit2 重置FIFO当设置为1时，此位将重置FIFO缓冲区，此时FIFO_EN等于0。触发重置后，此位将自动清为0
//bit1 重置I2C主机当设置为1时，此位将重置I2C主机，此时I2C_MST_EN等于0。触发重置后，此位将自动清为0
//bit0 重置所有传感器寄存器和信号路径 如果只重置信号路径（不重置传感器寄存器），请使用寄存器104
/*允许用户配置电源模式和时钟源。还提供了复位整个设备和禁用温度传感器的位*/
#define MPU6050_RA_PWR_MGMT_1 0x6B
//bit7 触发一个设备的完整重置。 触发重置后，一个~ 50 毫秒的小延迟是合理的
//bit6 寄存器的SLEEP位设置使设备处于非常低功率的休眠模式。
//bit5 唤醒周期启用状态当此位设为1且SLEEP禁用时.在休眠模式和唤醒模式间循环，以此从活跃的传感器中获取数据样本
//bit3 温度传感器启用状态控制内部温度传感器的使用
//bit2-bit0 设定时钟源设置,一个频率为8 mhz的内部振荡器,基于陀螺仪的时钟或外部信息源都可以被选为MPU-60X0的时钟源
/* CLK_SEL | 时钟源
* --------+--------------------------------------
* 0 | 内部振荡器
* 1 | PLL with X Gyro reference
* 2 | PLL with Y Gyro reference
* 3 | PLL with Z Gyro reference
* 4 | PLL with external 32.768kHz reference
* 5 | PLL with external 19.2MHz reference
* 6 | Reserved
* 7 | Stops the clock and keeps the timing generator in reset
* */
/*这个寄存器允许用户配置加速度计在低功耗模式下唤起的频率。也允许用户让加速度计和
陀螺仪的个别轴进入待机模式。*/
#define MPU6050_RA_PWR_MGMT_2 0x6C
//bit7-bit6 Accel-Only低电量模式下的唤醒频率
/* 通过把Power Management 1寄存器（寄存器107）中的PWRSEL设为1，
* MPU-60X0可以处于Accerlerometer Only的低电量模式。在这种模式下,
设备将关闭除了原I2C接口以外的所有设备，只留下accelerometer以固定时间
间隔醒来进行测量。唤醒频率可用LP_WAKE_CTRL进行配置，如下表所示：
* LP_WAKE_CTRL | 　唤醒频率
* -------------+------------------
* 0 | 1.25 Hz
* 1 | 5 Hz
* 2 | 20 Hz
* 3 | 40 Hz
* */
//bit5 备用的x轴加速度传感器启用状态,也就是进入待机模式
//bit4 备用的Y轴加速度传感器启用状态
//bit3 备用的Z轴加速度传感器启用状态
//bit2 备用的x轴陀螺仪启用状态
//bit1 备用的Y轴陀螺仪启用状态
//bit0 备用的Z轴陀螺仪启用状态
/*设定DMP模式下的bank*/
#define MPU6050_RA_BANK_SEL 0x6D
//DMP内存配置
#define MPU6050_BANKSEL_PRFTCH_EN_BIT 6
#define MPU6050_BANKSEL_CFG_USER_BANK_BIT 5
#define MPU6050_BANKSEL_MEM_SEL_BIT 4
#define MPU6050_BANKSEL_MEM_SEL_LENGTH 5
//dmp内存地址设置
#define MPU6050_DMP_MEMORY_BANKS 8
#define MPU6050_DMP_MEMORY_BANK_SIZE 256
#define MPU6050_DMP_MEMORY_CHUNK_SIZE 16
/*设定DMP模式下的起始地址*/
#define MPU6050_RA_MEM_START_ADDR 0x6E
/*一个字节的dmp数据缓存*/
#define MPU6050_RA_MEM_R_W 0x6F
/*DMP配置寄存器1*/
#define MPU6050_RA_DMP_CFG_1 0x70
/*DMP配置寄存器2*/
#define MPU6050_RA_DMP_CFG_2 0x71
/*当前FIFO缓冲区大小
* 这个值表明了存储于FIFO缓冲区的字节数。
* 而这个数字也是能从FIFO缓冲区读取的字节数，
* 它与存储在FIFO(寄存器35和36)中的传感器数据组所提供的可用样本数成正比。
* 两个寄存器一起构成一个16位数据*/
#define MPU6050_RA_FIFO_COUNTH 0x72
#define MPU6050_RA_FIFO_COUNTL 0x73
/*这个寄存器用于从FIFO缓冲区中读取和编写数据。数据在寄存器编号(从低到高)的指
*令下编写入数据写入FIFO。如果所有的FIFO启用标志(见下文)都被启用了且
*所有外部传感器数据寄存器(寄存器73至寄存器96)都与一个slave设备相连
*,那么寄存器59到寄存器96的内容都将在采样率的指令下编写。
* 当传感器数据寄存器（寄存器59到寄存器96）的相关FIFO启用标志在FIFO_EN 寄存
* 器35)中都设为1时，它们的内容将被写入FIFO缓冲区。在I2C_MST_CTRL (寄存器 36)
* 中能找到一个与I2C Slave 3相连的额外的传感器数据寄存器标志。
* 如果FIFO缓冲区溢出,状态位FIFO_OFLOW_INT自动设置为1。
* 此位位于INT_STATUS (寄存器58)中。当FIFO缓冲区溢出时,最早的数据将会丢失
* 而新数据将被写入FIFO。如果FIFO缓冲区为空, 读取将返回原来从FIFO中读取的
* 最后一个字节，直到有可用的新数据。用户应检查FIFO_COUNT,以确保不在FIFO缓冲为空时读取。*/
#define MPU6050_RA_FIFO_R_W 0x74
/*寄存器是用来验证设备的身份的 默认值是0X34*/
#define MPU6050_RA_WHO_AM_I 0x75
//bit6-bit1 设备身份验证 0x34 最高位和最低位都剔除掉
#endif