DPS pin为什么需要挂电容

最新推荐文章于 2023-10-09 20:16:53 发布
原创 最新推荐文章于 2023-10-09 20:16:53 发布 · 1.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
本文为博主原创文章，未经博主允许不得转载。

本文探讨了DPSpin PCB设计中电容的选择原则及其对稳定性的影响。介绍了钽电容和陶瓷电容的不同作用，并讨论了如何通过合理配置电容网络(capnetwork)来确保DPSpin系统的稳定性和精度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

首相大家要知道不同的电容有不同的用途，同时现实中的电容和理想电容不一样，当频率很高的时候，由于ESL的作用，电容表现为电感。

在设计DPS pin的PCB时，一般选用以下两类电容
tantalum capacitor : maintain the stability of the DPS
ceramic capacitors : to manage the very high dI/dt of load current

如果DPS pin的高速的话(不太确定?)，要牵扯到Power Distribution Network (PDN) 设计，简单来说就是给DPS pin的外围加一对cap，来是的DPS pin的输出在比较短的时间内稳定。

DPS内部应该是一个DAC(不太确定?)，将用户设定的电压转换成对应的电压输出。DPS有一个crossover频率。
为了保证所供应的电压是稳定的，所以都有四线连接，两条force，两条ground，形成一个loopback回路；
为了保证loopback回路的稳定所以会在DUT board上加上相应的cap network
但是cap network的选择是一个学问？
solition 1：所选电容的谐振频率要小于DPS的 crossover频率
solution 2: 所选电容的的ESR(等效串联电阻)足够大，使得相位的最大偏移点位于DPS的不重要的频率区域
note：将DPS连接到DUT board上，需要force sense和cap network，会导致线损，尽管很小，但是有些时候需要考虑到
note2：在设计DUB board的时候，有时会预留( spare pads )来为以后继续调优cap network来使用
note3：在设计DUB board的PCB的时候，线距要足够宽，etc
note4: 所加的cap会影响精度
note6: 如果想使用LTspice来模拟对应的DPS pin的话，需要ATE提供商提供相应的model文件，否则的话不行

【电子通识】为什么IC需要自己的去耦电容？
一点硬件
10-20 2050
IC经常每一个电源网络的PIN脚都需要接上一个去耦电容。原因主要是什么？
基于STM32L4XX、HAL库的DPS368XTSA1压力传感器驱动程序设计
zhusl6688的博客
05-14 64
一、简介：DPS368XTSA1 是博世 (Bosch) 公司生产的一款高精度数字气压传感器，专为移动设备、可穿戴设备和物联网应用设计。该传感器能够精确测量大气压力并计算海拔高度，具有超低功耗、高精度和快速响应的特点。二、硬件接口：I2C 接口连接：SPI 接口连接：推荐外部电路：三、头文件：#ifndef __DPS368_H #define __DPS368_H#include "stm32l4xx_hal.h" #include <stdint.h> #include <stdbool.h>/* 传感
电源附近接电容
Cloris0307的博客
07-26 1059
具体操作遵循着小电容前（近），大电容后（相对远）的原则来摆放！在电源附近，一般会在VCC和GND里面接入两个电容。
芯片测试基础
2202_75467525的博客
10-09 1614
对与晶圆（wafer）上每一个独立电路单元（Die）进行检测，也是区分是否为良品的第一道测试也成为“Wafer Sort”、CP测试。·封装完成后的测试，确保满足原有的要求，称为“Final Test”、FT测试、成品测试。·保证PASS中的产品中没有不合格的，保证Package Test的正确性。·器件的工作范围·经过老化后，测试芯片是否出现参数偏移·跟为严格的温度、老化等测试·保证购买芯片的合格·测试经过封装之后，是否完整和过程的正确性，一般同FT测试一起完成。
DpsConnectivity
u011382906的博客
05-08 2138
DpsConnectivity
ATE测试板：V93000 LB 板上MS-DPS 电源上为什么会加两电容？
weixin_44246045的博客
01-06 1111
在查看 V93000-LB 板原理图时，常常会看到在 MS-DPS 电源“P”与地“G”间会设计两个电容，一个容量小的电容和一个容量大的电容，这两个电容容量为多大，它们在测试中起什么作用？ 如上图所示，这是MS-DPS 电源，在电源VDD 端与地 GND 端设计了两个电容，一个容量为 10uA 电容，一个容量为0.1uA 电容，VDD 端与 DPS1-P-01连接，GND 端与 DPS1-G-01 连接。这两个电阻究竟有什么作用？ 我们知道电容有以下作用： 1）大电容（10uF-100uF）滤低频
大疆c板例程bmi088里面为什么debug中数据不更新
03-08
例如，陀螺仪量程为2000dps时，灵敏度为16.384 LSB/(dps)，转换公式为： $$ \text{角速度} = \frac{\text{原始数据}}{16.384} \, \text{dps} $$ 若符号位未处理，可能导致数据异常。 #### 6. **使用调试工具验证*...
Altium Designer - 常用元件3D模型封装库（STEP模型）-电路方案
04-19
3710HR DISPLAY, 4-LED、REDLED、SMG_4、SMG_4_1、SW3dPS-dsp-012、SW3dPS-jm12864a、SW3dPS-LCD module 16 X 2 backlight、SW3dPS-Lumex_LCM-X02002DXX_2x20LCD_withBackLight、SW3dPS-optrex_dmc16207_2linex16...
发现yaw的值在一定时间后会被锁死（oled屏幕上数字不发生改变），查找原因，查找原因修正 empty.c #include <math.h> // 添加数学库用于fabs函数 #include "board.h" #include "my_key.h" #include "my_time.h" #include "ti_msp_dl_config.h" #include "oled.h" void BUZZY_OFF(void) { DL_GPIO_setPins(BUZZY_PORT, BUZZY_PIN_PIN); } void BUZZY_ON(void) { DL_GPIO_clearPins(BUZZY_PORT, BUZZY_PIN_PIN); } void refresh_oled(void); void key(void); void go_straight(int dis); void go_arc_ccd(hsu_time_t); void go_brc_ccd(hsu_time_t); void turn_in_place(float angle); void sound_light_alert(void); void show_task_now(void); u8 Car_Mode = Diff_Car; int Motor_Left, Motor_Right; // 电机PWM变量 应是Motor的 u8 PID_Send; // 延时和调参相关变量 float RC_Velocity = 200, RC_Turn_Velocity, Move_X, Move_Y, Move_Z, PS2_ON_Flag; // 遥控控制的速度 float Velocity_Left, Velocity_Right; // 车轮速度(mm/s) u16 test_num, show_cnt; float Voltage = 0; extern float Yaw; // 声明外部YAW角度变量 int64_t left_encoder = 0, right_encoder = 0; void SysTick_Handler(void) { hsu_time_systick_handler(); } typedef enum { BEGIN, T1, T2, T3, T4 } TaskState; typedef enum { STOP, GO_STRAIGHT, GO_CCD, TURN_IN_PLACE, WAIT_ALERT } DoingWhat; typedef struct __TASK_NAMESPACE { uint8_t is; uint8_t is_running; uint8_t finish; uint8_t sub_finish; uint8_t running_state; // 0: 停止, 1: 运行中 TaskState state; DoingWhat doing_what; float target; float vx; float vz; // 用于复杂任务 uint8_t sub_task_stage; // 子任务阶段 uint8_t lap_count; // 圈数计数 int64_t start_encoder; // 起始编码器值 uint32_t alert_start_time; // 声光提示开始时间 float start_yaw; // 起始YAW角度 float target_yaw_diff; // 目标YAW角度差 hsu_time_t ccd_end_time; } TaskNamespace; void reset_task_namespace(TaskNamespace *t) { t->is_running = 0; t->finish = 0; t->sub_finish = 0; t->state = BEGIN; t->doing_what = STOP; t->vx = 0; t->vz = 0; t->sub_task_stage = 0; t->lap_count = 0; t->start_encoder = left_encoder; t->alert_start_time = 0; t->start_yaw = 0; t->target_yaw_diff = 0; t->running_state = 0; // 明确重置运行状态为0 t->ccd_end_time = 0; t->is = 0; } void next_state(TaskNamespace *t) { TaskState last_state = t->state; reset_task_namespace(t); if (last_state < T4) { t->state = last_state + 1; } } TaskNamespace task_namespace; void show_task_now(void) { //OLED_ShowString(0, 0, "Task Now:"); switch (task_namespace.state) { case BEGIN: OLED_ShowString(1, 10,"0"); break; case T1: OLED_ShowString(1, 10,"1"); break; case T2: OLED_ShowString(1, 10,"2"); break; case T3: OLED_ShowString(1, 10,"3"); break; case T4: OLED_ShowString(1, 10,"4"); break; default: break; } } void main_task(void); int main(void) { // 系统初始化 SYSCFG_DL_init(); // 初始化系统配置 hsu_time_init(); // 时间 // 清除所有外设的中断挂起状态 NVIC_ClearPendingIRQ(ENCODERA_INT_IRQN); // 编码器A中断 NVIC_ClearPendingIRQ(ENCODERB_INT_IRQN); // 编码器B中断 NVIC_ClearPendingIRQ(UART_0_INST_INT_IRQN); // UART0串口中断 // 使能各外设的中断 NVIC_EnableIRQ(ENCODERA_INT_IRQN); // 开启编码器A中断 NVIC_EnableIRQ(ENCODERB_INT_IRQN); // 开启编码器B中断 NVIC_EnableIRQ(UART_0_INST_INT_IRQN); // 开启UART0中断 reset_task_namespace(&task_namespace); task_namespace.state = BEGIN; // 明确设置初始状态 // 定时器和ADC相关中断配置 NVIC_ClearPendingIRQ(TIMER_0_INST_INT_IRQN); // 清除定时器0中断挂起 NVIC_EnableIRQ(TIMER_0_INST_INT_IRQN); // 开启定时器0中断 NVIC_EnableIRQ(ADC12_VOLTAGE_INST_INT_IRQN); NVIC_EnableIRQ(ADC12_CCD_INST_INT_IRQN); OLED_Init(); // 初始化OLED显示屏 OLED_ShowString(1, 1, "Task Now:"); OLED_ShowString(2, 1, "state:"); OLED_ShowString(3, 1, "yaw:"); MPU6050_initialize(); DMP_Init(); BUZZY_ON(); // 主循环 // printf("Test delay 500us\n"); // hsu_time_delay_us(500); // printf("Test delay 500us end\n"); uint8_t main_task_timer = hsu_time_timer_create(10, true, main_task); hsu_time_timer_start(main_task_timer); uint8_t refresh_oled_timer = hsu_time_timer_create(5, true, refresh_oled); hsu_time_timer_start(refresh_oled_timer); uint8_t key_timer = hsu_time_timer_create(2, true, key); hsu_time_timer_start(key_timer); while (1) { hsu_time_timer_process(); RD_TSL(); // 读取CCD数据 Find_CCD_Median(); // 计算CCD数据中值 Read_DMP(); show_task_now(); char yaw_str[10]; // 存储格式化后的字符串 snprintf(yaw_str, sizeof(yaw_str), "%.1f", Yaw); // 格式化为带一位小数的字符串 OLED_ShowString(3, 6, yaw_str); // 在指定位置显示YAW值 //DL_GPIO_togglePins(LED_PORT, LED_led_PIN); // printf("L=%lld R=%lld YAW=%.1f\n", left_encoder, right_encoder, Yaw); } } void task_no(void); void task_1(void); void task_2(void); void task_3(void); void task_4(void); void main_task(void) { if (!(task_namespace.is)) return; printf("main task\n"); switch (task_namespace.state) { case BEGIN: task_no(); break; case T1: task_1(); break; case T2: task_2(); break; case T3: task_3(); break; case T4: task_4(); break; default: break; } switch (task_namespace.doing_what) { case STOP: Get_Target_Encoder(0, 0); break; case GO_STRAIGHT: if ((left_encoder * 1.f) < task_namespace.target) { Get_Target_Encoder(0.3, 0); // 提高速度到300mm/s } else { Get_Target_Encoder(0, 0); task_namespace.doing_what = STOP; task_namespace.finish = 1; } break; case GO_CCD: if (task_namespace.ccd_end_time < hsu_time_get_ms()) { Get_Target_Encoder(0, 0); task_namespace.doing_what = STOP; task_namespace.finish = 1; } else { CCD_Mode(); } break; case TURN_IN_PLACE: // 原地转向控制 if (task_namespace.target_yaw_diff != 0) { float current_yaw_diff = Yaw - task_namespace.start_yaw; // 处理角度跨越±180度的情况 if (current_yaw_diff > 180) { current_yaw_diff -= 360; } else if (current_yaw_diff < -180) { current_yaw_diff += 360; } printf("Turn: Start=%.1f Current=%.1f Diff=%.1f Target=%.1f\n", task_namespace.start_yaw, Yaw, current_yaw_diff, task_namespace.target_yaw_diff); // 检查是否达到目标角度 if ((task_namespace.target_yaw_diff > 0 && current_yaw_diff >= task_namespace.target_yaw_diff) || (task_namespace.target_yaw_diff < 0 && current_yaw_diff <= task_namespace.target_yaw_diff)) { Get_Target_Encoder(0, 0); // 停止转向 task_namespace.doing_what = STOP; task_namespace.finish = 1; } else { // 继续转向 float turn_speed = (task_namespace.target_yaw_diff > 0) ? 0.1 : -0.1; Get_Target_Encoder(0, turn_speed); } } break; case WAIT_ALERT: Get_Target_Encoder(0, 0); // 停车 if (hsu_time_get_ms() - task_namespace.alert_start_time > 1000) { // 声光提示1秒 task_namespace.doing_what = STOP; task_namespace.finish = 1; } break; default: break; } } void task_no(void) { return; } // 任务1：A点到B点直线行驶 void task_1(void) { if (!task_namespace.is_running) { task_namespace.is_running = 1; task_namespace.sub_task_stage = 0; task_namespace.finish = 1; return; } if (task_namespace.finish) { switch (task_namespace.sub_task_stage) { case 0: // 开始第一阶段：A到B go_straight(300); break; case 1: // A到B完成，开始B到C DL_GPIO_togglePins(LED_PORT, LED_led_PIN); break; case 2: //任务结束 reset_task_namespace(&task_namespace); task_namespace.running_state = 0; // 重置为停止状态 break; } task_namespace.finish = 0; task_namespace.sub_task_stage++; } return; } // 任务2：A->B->C->D->A循环 void task_2(void) { if (!task_namespace.is_running) { task_namespace.is_running = 1; task_namespace.sub_task_stage = 0; task_namespace.finish = 1; return; } if (task_namespace.finish) { switch (task_namespace.sub_task_stage) { case 0: // 开始第一阶段：A到B go_straight(3300); break; case 1: //DL_GPIO_togglePins(LED_PORT, LED_led_PIN); go_straight(2000); break; case 2: // B到C弧线完成，开始C到D直线 sound_light_alert(); //turn_in_place(-17.0f); go_straight(2980); break; case 3: // C到D完成，开始D到A弧线 sound_light_alert(); go_arc_ccd(3530); break; case 4: // D到A弧线完成，任务结束 sound_light_alert(); reset_task_namespace(&task_namespace); break; } task_namespace.finish = 0; task_namespace.sub_task_stage++; } return; } // 任务3：A->C->B->D->A循环 void task_3(void) { if (!task_namespace.is_running) { task_namespace.is_running = 1; task_namespace.sub_task_stage = 0; task_namespace.finish = 1; return; } if (task_namespace.finish) { switch (task_namespace.sub_task_stage) { case 0: turn_in_place(-31.0f); break; case 1: go_straight(4060); break; case 2: turn_in_place(30.0f); break; case 3: // 开始C到B弧线 sound_light_alert(); //go_straight(40); go_brc_ccd(3550); break; case 4: turn_in_place(36.0f); break; case 5: sound_light_alert(); go_straight(3985); break; case 6: turn_in_place(-40.0f); break; case 7: // 开始C到B弧线 sound_light_alert(); go_arc_ccd(3600); break; case 8: // D到A弧线完成，任务结束 sound_light_alert(); reset_task_namespace(&task_namespace); break; } task_namespace.finish = 0; task_namespace.sub_task_stage++; } return; } // 任务4：重复任务3路径4圈 void task_4(void) { if (!task_namespace.is_running) { task_namespace.is_running = 1; task_namespace.sub_task_stage = 0; task_namespace.finish = 1; return; } if (task_namespace.finish) { switch (task_namespace.sub_task_stage) { case 0: turn_in_place(-30.0f); break; case 1: go_straight(4045); break; case 2: turn_in_place(29.0f); break; case 3: // 开始C到B弧线 sound_light_alert(); //go_straight(40); go_brc_ccd(5000); break; case 4: turn_in_place(34.0f); break; case 5: sound_light_alert(); go_straight(4035); break; case 6: turn_in_place(-33.0f); break; case 7: // 开始C到B弧线 sound_light_alert(); go_arc_ccd(5000); break; case 8: // D到A弧线完成，任务结束 sound_light_alert(); reset_task_namespace(&task_namespace); break; } task_namespace.finish = 0; task_namespace.sub_task_stage++; } } void TIMER_0_INST_IRQHandler(void) { if (DL_TimerA_getPendingInterrupt(TIMER_0_INST)) { if (DL_TIMER_IIDX_ZERO) { Get_Velocity_From_Encoder(Get_Encoder_countA, Get_Encoder_countB); Get_Encoder_countA = Get_Encoder_countB = 0; MotorA.Motor_Pwm = Incremental_PI_Left(MotorA.Current_Encoder, MotorA.Target_Encoder); MotorB.Motor_Pwm = Incremental_PI_Right(MotorB.Current_Encoder, MotorB.Target_Encoder); if (!Flag_Stop) { Set_PWM(-MotorA.Motor_Pwm, -MotorB.Motor_Pwm); } else { Set_PWM(0, 0); } } } } uint32_t gpio_interrup1, gpio_interrup2; int64_t B1, B2, B3, B4; int64_t A1, A2, A3, A4; void GROUP1_IRQHandler(void) { // 获取中断信号 gpio_interrup1 = DL_GPIO_getEnabledInterruptStatus(ENCODERA_PORT, ENCODERA_E1A_PIN | ENCODERA_E1B_PIN); gpio_interrup2 = DL_GPIO_getEnabledInterruptStatus(ENCODERB_PORT, ENCODERB_E2A_PIN | ENCODERB_E2B_PIN); // encoderB if ((gpio_interrup1 & ENCODERA_E1A_PIN) == ENCODERA_E1A_PIN) { if (!DL_GPIO_readPins(ENCODERA_PORT, ENCODERA_E1B_PIN)) { right_encoder--; Get_Encoder_countB--; } else { right_encoder++; Get_Encoder_countB++; } } else if ((gpio_interrup1 & ENCODERA_E1B_PIN) == ENCODERA_E1B_PIN) { if (!DL_GPIO_readPins(ENCODERA_PORT, ENCODERA_E1A_PIN)) { right_encoder++; Get_Encoder_countB++; } else { right_encoder--; Get_Encoder_countB--; } } // encoderA if ((gpio_interrup2 & ENCODERB_E2A_PIN) == ENCODERB_E2A_PIN) { if (!DL_GPIO_readPins(ENCODERB_PORT, ENCODERB_E2B_PIN)) { left_encoder++; Get_Encoder_countA--; } else { left_encoder--; Get_Encoder_countA++; } } else if ((gpio_interrup2 & ENCODERB_E2B_PIN) == ENCODERB_E2B_PIN) { if (!DL_GPIO_readPins(ENCODERB_PORT, ENCODERB_E2A_PIN)) { left_encoder--; Get_Encoder_countA++; } else { left_encoder++; Get_Encoder_countA--; } } DL_GPIO_clearInterruptStatus(ENCODERA_PORT, ENCODERA_E1A_PIN | ENCODERA_E1B_PIN); DL_GPIO_clearInterruptStatus(ENCODERB_PORT, ENCODERB_E2A_PIN | ENCODERB_E2B_PIN); } // 直线行驶函数 void go_straight(int dis) { task_namespace.doing_what = GO_STRAIGHT; task_namespace.target = left_encoder + dis; task_namespace.finish = 0; } // 原地转向函数 void turn_in_place(float angle) { task_namespace.doing_what = TURN_IN_PLACE; task_namespace.start_yaw = Yaw; task_namespace.target_yaw_diff = angle; // 正值右转，负值左转 task_namespace.finish = 0; } // CCD巡线函数（需要外部条件结束） void go_ccd_line(void) { task_namespace.doing_what = GO_CCD; task_namespace.start_encoder = left_encoder; task_namespace.finish = 0; // 设置一个安全的最大距离，防止无限巡线 // 可以根据实际场地调整这个值 static uint32_t ccd_end_time = 0; if (ccd_end_time == 0) { ccd_end_time = hsu_time_get_ms(); } // 如果巡线时间超过10秒或距离超过2000mm，强制结束 if (hsu_time_get_ms() - ccd_end_time > 10000 || (left_encoder * 1.f - task_namespace.start_encoder) > 2000) { task_namespace.finish = 1; ccd_end_time = 0; } } // 弧线CCD巡线函数 void go_arc_ccd(hsu_time_t time) { task_namespace.doing_what = GO_CCD; task_namespace.start_encoder = left_encoder; task_namespace.ccd_end_time = hsu_time_get_ms() + time; } void go_brc_ccd(hsu_time_t time) { task_namespace.doing_what = GO_CCD; task_namespace.start_encoder = right_encoder; task_namespace.ccd_end_time = hsu_time_get_ms() + time; } // 声光提示函数 void sound_light_alert(void) { DL_GPIO_togglePins(LED_PORT, LED_led_PIN); DL_GPIO_setPins(BUZZY_PORT, BUZZY_PIN_PIN); uint32_t start_time = hsu_time_get_ms(); while (hsu_time_get_ms() - start_time < 1000) { // 空循环等待1秒 } //hsu_time_delay_ms(200); DL_GPIO_togglePins(LED_PORT, LED_led_PIN); DL_GPIO_clearPins(BUZZY_PORT, BUZZY_PIN_PIN); } // callback void refresh_oled(void) { show_task_now(); OLED_ShowString(2, 1, "state:"); if (task_namespace.running_state) { OLED_ShowString(2, 7, "1"); // 运行中 } else { OLED_ShowString(2, 7, "0"); // 停止 } } uint32_t key_get_tick_ms(void) { return hsu_time_get_ms(); } void key(void) { key_event_t event = key_scan(); //uint8_t key_value = key_read_pin(); // 获取按键状态 //S1 switch (event) { case KEY_EVENT_SINGLE_CLICK: next_state(&task_namespace); break; case KEY_EVENT_DOUBLE_CLICK: task_namespace.is = 1; task_namespace.running_state = 1; task_namespace.is_running = 0; // 重置任务运行标志 break; } } MPU6050.c #include "MPU6050.h" #include <stdio.h> #include "inv_mpu.h" // #include "IOI2C.h" // #include "usart.h" #define PRINT_ACCEL (0x01) #define PRINT_GYRO (0x02) #define PRINT_QUAT (0x04) #define ACCEL_ON (0x01) #define GYRO_ON (0x02) #define MOTION (0) #define NO_MOTION (1) #define DEFAULT_MPU_HZ (200) #define FLASH_SIZE (512) #define FLASH_MEM_START ((void *)0x1800) #define q30 1073741824.0f short gyro[3], accel[3], sensors; float Roll, Pitch, Yaw; float q0 = 1.0f, q1 = 0.0f, q2 = 0.0f, q3 = 0.0f; static signed char gyro_orientation[9] = {-1, 0, 0, 0, -1, 0, 0, 0, 1}; Imu_t mpu6050 = {0}; Imu_t RegOri_mpu6050 = {0}; // iic转接 #include "bsp_siic.h" static pIICInterface_t siic = &User_sIICDev; uint8_t IICwriteBits(uint8_t addr, uint8_t reg, uint8_t bitStart, uint8_t length, uint8_t data) { uint8_t b; if (siic->read_reg(addr << 1, reg, &b, 1, 200) == IIC_OK) { uint8_t mask = (0xFF << (bitStart + 1)) | (0xFF >> ((8 - bitStart) + length - 1)); data <<= (8 - length); data >>= (7 - bitStart); b &= mask; b |= data; return siic->write_reg(addr << 1, reg, &b, 1, 200); } return 1; } uint8_t IICwriteBit(uint8_t dev, uint8_t reg, uint8_t bitNum, uint8_t data) { uint8_t b; siic->read_reg(dev << 1, reg, &b, 1, 200); b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum)); return siic->write_reg(dev << 1, reg, &b, 1, 200); } uint8_t IICreadBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t *data) { return siic->read_reg(dev << 1, reg, data, length, 200); } int i2cRead(uint8_t addr, uint8_t reg, uint8_t len, uint8_t *buf) { return siic->read_reg(addr << 1, reg, buf, len, 200); } unsigned char I2C_ReadOneByte(unsigned char I2C_Addr, unsigned char addr) { uint8_t b = 0; siic->read_reg(I2C_Addr << 1, addr, &b, 1, 200); return b; } static unsigned short inv_row_2_scale(const signed char *row) { unsigned short b; if (row[0] > 0) b = 0; else if (row[0] < 0) b = 4; else if (row[1] > 0) b = 1; else if (row[1] < 0) b = 5; else if (row[2] > 0) b = 2; else if (row[2] < 0) b = 6; else b = 7; // error return b; } static unsigned short inv_orientation_matrix_to_scalar(const signed char *mtx) { unsigned short scalar; scalar = inv_row_2_scale(mtx); scalar |= inv_row_2_scale(mtx + 3) << 3; scalar |= inv_row_2_scale(mtx + 6) << 6; return scalar; } static void run_self_test(void) { int result; long gyro[3], accel[3]; result = mpu_run_self_test(gyro, accel); if (result == 0x7) { /* Test passed. We can trust the gyro data here, so let's push it down * to the DMP. */ float sens; unsigned short accel_sens; mpu_get_gyro_sens(&sens); gyro[0] = (long)(gyro[0] * sens); gyro[1] = (long)(gyro[1] * sens); gyro[2] = (long)(gyro[2] * sens); dmp_set_gyro_bias(gyro); mpu_get_accel_sens(&accel_sens); accel[0] *= accel_sens; accel[1] *= accel_sens; accel[2] *= accel_sens; dmp_set_accel_bias(accel); // printf("setting bias succesfully ......\r\n"); } } uint8_t buffer[14]; int16_t MPU6050_FIFO[6][11]; int16_t Gx_offset = 0, Gy_offset = 0, Gz_offset = 0; /************************************************************************** Function: The new ADC data is updated to FIFO array for filtering Input : ax，ay，az：x，y, z-axis acceleration data；gx，gy，gz：x. Y, z-axis angular acceleration data Output : none 函数功能：将新的ADC数据更新到 FIFO数组，进行滤波处理 入口参数：ax，ay，az：x，y，z轴加速度数据；gx，gy，gz：x，y，z轴角加速度数据 返回 值：无 **************************************************************************/ void MPU6050_newValues(int16_t ax, int16_t ay, int16_t az, int16_t gx, int16_t gy, int16_t gz) { unsigned char i; int32_t sum = 0; for (i = 1; i < 10; i++) { // FIFO 操作 MPU6050_FIFO[0][i - 1] = MPU6050_FIFO[0][i]; MPU6050_FIFO[1][i - 1] = MPU6050_FIFO[1][i]; MPU6050_FIFO[2][i - 1] = MPU6050_FIFO[2][i]; MPU6050_FIFO[3][i - 1] = MPU6050_FIFO[3][i]; MPU6050_FIFO[4][i - 1] = MPU6050_FIFO[4][i]; MPU6050_FIFO[5][i - 1] = MPU6050_FIFO[5][i]; } MPU6050_FIFO[0][9] = ax; // 将新的数据放置到 数据的最后面 MPU6050_FIFO[1][9] = ay; MPU6050_FIFO[2][9] = az; MPU6050_FIFO[3][9] = gx; MPU6050_FIFO[4][9] = gy; MPU6050_FIFO[5][9] = gz; sum = 0; for (i = 0; i < 10; i++) { // 求当前数组的合，再取平均值 sum += MPU6050_FIFO[0][i]; } MPU6050_FIFO[0][10] = sum / 10; sum = 0; for (i = 0; i < 10; i++) { sum += MPU6050_FIFO[1][i]; } MPU6050_FIFO[1][10] = sum / 10; sum = 0; for (i = 0; i < 10; i++) { sum += MPU6050_FIFO[2][i]; } MPU6050_FIFO[2][10] = sum / 10; sum = 0; for (i = 0; i < 10; i++) { sum += MPU6050_FIFO[3][i]; } MPU6050_FIFO[3][10] = sum / 10; sum = 0; for (i = 0; i < 10; i++) { sum += MPU6050_FIFO[4][i]; } MPU6050_FIFO[4][10] = sum / 10; sum = 0; for (i = 0; i < 10; i++) { sum += MPU6050_FIFO[5][i]; } MPU6050_FIFO[5][10] = sum / 10; } /************************************************************************** Function: Setting the clock source of mpu6050 Input : source：Clock source number Output : none 函数功能：设置 MPU6050 的时钟源 入口参数：source：时钟源编号 返回 值：无 * CLK_SEL | Clock Source * --------+-------------------------------------- * 0 | Internal oscillator * 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 **************************************************************************/ void MPU6050_setClockSource(uint8_t source) { IICwriteBits(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CLKSEL_BIT, MPU6050_PWR1_CLKSEL_LENGTH, source); } /** Set full-scale gyroscope range. * @param range New full-scale gyroscope range value * @see getFullScaleRange() * @see MPU6050_GYRO_FS_250 * @see MPU6050_RA_GYRO_CONFIG * @see MPU6050_GCONFIG_FS_SEL_BIT * @see MPU6050_GCONFIG_FS_SEL_LENGTH */ void MPU6050_setFullScaleGyroRange(uint8_t range) { IICwriteBits(devAddr, MPU6050_RA_GYRO_CONFIG, MPU6050_GCONFIG_FS_SEL_BIT, MPU6050_GCONFIG_FS_SEL_LENGTH, range); } /************************************************************************** Function: Setting the maximum range of mpu6050 accelerometer Input : range：Acceleration maximum range number Output : none 函数功能：设置 MPU6050 加速度计的最大量程 入口参数：range：加速度最大量程编号 返回 值：无 **************************************************************************/ // #define MPU6050_ACCEL_FS_2 0x00 //===最大量程+-2G // #define MPU6050_ACCEL_FS_4 0x01 //===最大量程+-4G // #define MPU6050_ACCEL_FS_8 0x02 //===最大量程+-8G // #define MPU6050_ACCEL_FS_16 0x03 //===最大量程+-16G void MPU6050_setFullScaleAccelRange(uint8_t range) { IICwriteBits(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_AFS_SEL_BIT, MPU6050_ACONFIG_AFS_SEL_LENGTH, range); } /************************************************************************** Function: Set mpu6050 to sleep mode or not Input : enable：1，sleep；0，work； Output : none 函数功能：设置 MPU6050 是否进入睡眠模式 入口参数：enable：1，睡觉；0，工作； 返回 值：无 **************************************************************************/ void MPU6050_setSleepEnabled(uint8_t enabled) { IICwriteBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_SLEEP_BIT, enabled); } /************************************************************************** Function: Read identity Input : none Output : 0x68 函数功能：读取 MPU6050 WHO_AM_I 标识 入口参数：无 返回 值：0x68 **************************************************************************/ uint8_t MPU6050_getDeviceID(void) { IICreadBytes(devAddr, MPU6050_RA_WHO_AM_I, 1, buffer); return buffer[0]; } /************************************************************************** Function: Check whether mpu6050 is connected Input : none Output : 1：Connected；0：Not connected 函数功能：检测MPU6050 是否已经连接 入口参数：无 返回 值：1：已连接；0：未连接 **************************************************************************/ uint8_t MPU6050_testConnection(void) { if (MPU6050_getDeviceID() == 0x68) // 0b01101000; return 1; else return 0; } /************************************************************************** Function: Setting whether mpu6050 is the host of aux I2C cable Input : enable：1，yes；0;not Output : none 函数功能：设置 MPU6050 是否为AUX I2C线的主机 入口参数：enable：1，是；0：否 返回 值：无 **************************************************************************/ void MPU6050_setI2CMasterModeEnabled(uint8_t enabled) { IICwriteBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_I2C_MST_EN_BIT, enabled); } /************************************************************************** Function: Setting whether mpu6050 is the host of aux I2C cable Input : enable：1，yes；0;not Output : none 函数功能：设置 MPU6050 是否为AUX I2C线的主机 入口参数：enable：1，是；0：否 返回 值：无 **************************************************************************/ void MPU6050_setI2CBypassEnabled(uint8_t enabled) { IICwriteBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_I2C_BYPASS_EN_BIT, enabled); } /************************************************************************** Function: initialization Mpu6050 to enter the available state Input : none Output : none 函数功能：初始化 MPU6050 以进入可用状态 入口参数：无 返回 值：无 **************************************************************************/ void MPU6050_initialize(void) { // 未识别陀螺仪,复位 if (MPU6050_getDeviceID() != 0x68) DL_SYSCTL_resetDevice(DL_SYSCTL_RESET_POR); MPU6050_setClockSource(MPU6050_CLOCK_PLL_YGYRO); // 设置时钟 MPU6050_setFullScaleGyroRange(MPU6050_GYRO_FS_2000); // 陀螺仪量程设置 MPU6050_setFullScaleAccelRange(MPU6050_ACCEL_FS_2); // 加速度度最大量程 +-2G MPU6050_setSleepEnabled(0); // 进入工作状态 MPU6050_setI2CMasterModeEnabled(0); // 不让MPU6050 控制AUXI2C MPU6050_setI2CBypassEnabled(0); // 主控制器的I2C与 MPU6050的AUXI2C 直通关闭 } /************************************************************************** Function: Initialization of DMP in mpu6050 Input : none Output : none 函数功能：MPU6050内置DMP的初始化 入口参数：无 返回 值：无 **************************************************************************/ void DMP_Init(void) { uint8_t resetflag = 0; uint8_t temp[1] = {0}; i2cRead(0x68, 0x75, 1, temp); printf("mpu_set_sensor complete ......\r\n"); if (temp[0] != 0x68) DL_SYSCTL_resetDevice(DL_SYSCTL_RESET_POR); if (!mpu_init()) { if (!mpu_set_sensors(INV_XYZ_GYRO | INV_XYZ_ACCEL)) printf("mpu_set_sensor complete ......\r\n"); else resetflag = 1; if (!mpu_configure_fifo(INV_XYZ_GYRO | INV_XYZ_ACCEL)) printf("mpu_configure_fifo complete ......\r\n"); else resetflag = 1; if (!mpu_set_sample_rate(DEFAULT_MPU_HZ)) printf("mpu_set_sample_rate complete ......\r\n"); else resetflag = 1; if (!dmp_load_motion_driver_firmware()) printf("dmp_load_motion_driver_firmware complete ......\r\n"); else resetflag = 1; if (!dmp_set_orientation(inv_orientation_matrix_to_scalar(gyro_orientation))) printf("dmp_set_orientation complete ......\r\n"); else resetflag = 1; if (!dmp_enable_feature(DMP_FEATURE_6X_LP_QUAT | DMP_FEATURE_TAP | DMP_FEATURE_ANDROID_ORIENT | DMP_FEATURE_SEND_RAW_ACCEL | DMP_FEATURE_SEND_CAL_GYRO | DMP_FEATURE_GYRO_CAL)) printf("dmp_enable_feature complete ......\r\n"); else resetflag = 1; if (!dmp_set_fifo_rate(DEFAULT_MPU_HZ)) printf("dmp_set_fifo_rate complete ......\r\n"); else resetflag = 1; run_self_test(); if (!mpu_set_dmp_state(1)) printf("mpu_set_dmp_state complete ......\r\n"); } else { DL_SYSCTL_resetDevice(DL_SYSCTL_RESET_POR); } if (resetflag) { mpu6050_i2c_sda_unlock(); DL_SYSCTL_resetDevice(DL_SYSCTL_RESET_POR); } } /************************************************************************** Function: Read the attitude information of DMP in mpu6050 Input : none Output : none 函数功能：读取MPU6050内置DMP的姿态信息 入口参数：无 返回 值：无 **************************************************************************/ void Read_DMP(void) { unsigned long sensor_timestamp; unsigned char more; long quat[4]; dmp_read_fifo(gyro, accel, quat, &sensor_timestamp, &sensors, &more); // 读取DMP数据 if (sensors & INV_WXYZ_QUAT) { q0 = quat[0] / q30; q1 = quat[1] / q30; q2 = quat[2] / q30; q3 = quat[3] / q30; // 四元数 Roll = asin(-2 * q1 * q3 + 2 * q0 * q2) * 57.3; // 计算出横滚角 Pitch = atan2(2 * q2 * q3 + 2 * q0 * q1, -2 * q1 * q1 - 2 * q2 * q2 + 1) * 57.3; // 计算出俯仰角 Yaw = atan2(2 * (q1 * q2 + q0 * q3), q0 * q0 + q1 * q1 - q2 * q2 - q3 * q3) * 57.3; // 计算出偏航角 } } /************************************************************************** Function: Read mpu6050 built-in temperature sensor data Input : none Output : Centigrade temperature 函数功能：读取MPU6050内置温度传感器数据 入口参数：无 返回 值：摄氏温度 **************************************************************************/ int Read_Temperature(void) { float Temp; Temp = (I2C_ReadOneByte(devAddr, MPU6050_RA_TEMP_OUT_H) << 8) + I2C_ReadOneByte(devAddr, MPU6050_RA_TEMP_OUT_L); if (Temp > 32768) Temp -= 65536; // 数据类型转换 Temp = (36.53 + Temp / 340) * 10; // 温度放大十倍存放 return (int)Temp; } //------------------End of File----------------------------
最新发布
07-22
- 剧烈运动导致陀螺仪量程溢出（±2000dps默认值），传感器进入错误状态（引用[4]）。 5. **硬件问题** - 电源波动（如电机干扰）使MPU6050工作异常（引用[4]）。 --- ### 解决方案 #### 1. 优化I²C通信...
#include <zephyr/kernel.h> #include <zephyr/device.h> #include <zephyr/devicetree.h> #include <zephyr/drivers/i2c.h> #include <zephyr/logging/log.h> #include <stdio.h> #include <math.h> #include "GVL.h" #include "data_preprocess.h" #define LOG_MODULE_NAME LSM6DSOWTR_thread LOG_MODULE_REGISTER(LOG_MODULE_NAME); // LSM6DSOWTR 寄存器定义 #define LSM6DSOWTR_REG_WHO_AM_I 0x0F #define LSM6DSOWTR_REG_CTRL1_XL 0x10 #define LSM6DSOWTR_REG_CTRL2_G 0x11 #define LSM6DSOWTR_REG_CTRL3_C 0x12 #define LSM6DSOWTR_REG_OUTX_L_G 0x22 #define LSM6DSOWTR_REG_OUTX_H_G 0x23 #define LSM6DSOWTR_REG_OUTY_L_G 0x24 #define LSM6DSOWTR_REG_OUTY_H_G 0x25 #define LSM6DSOWTR_REG_OUTZ_L_G 0x26 #define LSM6DSOWTR_REG_OUTZ_H_G 0x27 #define LSM6DSOWTR_REG_OUTX_L_XL 0x28 #define LSM6DSOWTR_REG_OUTX_H_XL 0x29 #define LSM6DSOWTR_REG_OUTY_L_XL 0x2A #define LSM6DSOWTR_REG_OUTY_H_XL 0x2B #define LSM6DSOWTR_REG_OUTZ_L_XL 0x2C #define LSM6DSOWTR_REG_OUTZ_H_XL 0x2D // 配置参数 #define LSM6DSOWTR_WHO_AM_I_VAL 0x6C #define LSM6DSOWTR_ODR_XL_104HZ 0x40 // 加速度计 104Hz #define LSM6DSOWTR_FS_XL_2G 0x00 // ±2g 量程 #define LSM6DSOWTR_ODR_G_104HZ 0x40 // 陀螺仪 104Hz #define LSM6DSOWTR_FS_G_245DPS 0x00 // ±245dps 量程 #define LSM6DSOWTR_REG_STATUS_REG 0x1E #define ACCEL_SENSITIVITY_2G 0.000061f #define GYRO_SENSITIVITY_245DPS 0.00875f // 8.75 mdps/LSB // 压力传感器LPS28DFW 寄存器定义 #define LPS28DFW_WHO_AM_I 0x0F #define LPS28DFW_CTRL_REG1 0x10 #define LPS28DFW_CTRL_REG2 0x11 #define LPS28DFW_PRESS_OUT_XL 0x28 // 压力输出 XL (LSB) #define LPS28DFW_PRESS_OUT_L 0x29 // 压力输出 L #define LPS28DFW_PRESS_OUT_H 0x2A // 压力输出 H (MSB) #define LPS28DFW_TEMP_OUT_L 0x2B // 温度输出 L (LSB) #define LPS28DFW_TEMP_OUT_H 0x2C // 温度输出 H (MSB) // 配置参数 #define LPS28DFW_WHO_AM_I_VAL 0xB4 #define LPS28DFW_ODR_50HZ 0x50 // 50Hz 输出速率 #define SAMPLE_INTERVAL_MS 100 //MS5837压力传感器 #define MS5837_CMD_RESET 0x1E #define MS5837_CMD_CONVERT_D1_OSR1024 0x44 #define MS5837_CMD_CONVERT_D2_OSR1024 0x54 #define MS5837_CMD_ADC_READ 0x00 #define MS5837_PROM_READ_BASE 0xA0 struct ms5837_calib { uint16_t factory; // PROM word 0 (厂商数据) uint16_t c1; // 压力灵敏度 uint16_t c2; // 压力偏移 uint16_t c3; // 温度系数-压力灵敏度 uint16_t c4; // 温度系数-压力偏移 uint16_t c5; // 参考温度 uint16_t c6; // 温度系数 uint16_t crc; // CRC校验 }; // 等待数据就绪 static bool wait_for_data_ready(const struct i2c_dt_spec *dev_spec) { uint8_t status; int retries = 10; while (retries-- > 0) { if (i2c_reg_read_byte_dt(dev_spec, LSM6DSOWTR_REG_STATUS_REG, &status) == 0) { // 检查加速度计和陀螺仪数据就绪位 (bit0 & bit1) if ((status & 0x03) == 0x03) return true; } k_msleep(1); } return false; } int init_MS5837(const struct i2c_dt_spec *dev_spec, struct ms5837_calib *calib) { int ret; uint8_t reset_cmd = MS5837_CMD_RESET; const int max_retries = 3; int retry_count = 0; LOG_INF("Initializing MS5837..."); // 带重试的复位命令 do { ret = i2c_write_dt(dev_spec, &reset_cmd, 1); if (ret == 0) break; LOG_WRN("Reset command failed (attempt %d): %d", retry_count + 1, ret); k_msleep(5); } while (++retry_count < max_retries); if (ret != 0) { LOG_ERR("Reset command failed after %d attempts: %d", max_retries, ret); return ret; } k_msleep(5); // 确保复位完成 LOG_INF("Reading calibration data..."); for (int i = 0; i < 7; i++) { uint8_t prom_addr = MS5837_PROM_READ_BASE + (i * 2); uint8_t data[2]; ret = i2c_write_read_dt(dev_spec, &prom_addr, 1, data, sizeof(data)); if (ret != 0) { LOG_ERR("PROM read at 0x%02x failed: %d", prom_addr, ret); return ret; } // 大端序转换 uint16_t value = (data[0] << 8) | data[1]; // 修复: 正确赋值到结构体 switch(i) { case 0: calib->factory = value; break; case 1: calib->c1 = value; break; case 2: calib->c2 = value; break; case 3: calib->c3 = value; break; case 4: calib->c4 = value; break; case 5: calib->c5 = value; break; case 6: calib->c6 = value; break; } } LOG_INF("Calibration data read successfully"); return 0; } // 读取传感器数据并计算 int read_MS5837(const struct i2c_dt_spec *dev_spec, const struct ms5837_calib *calib, double *pressure, double *temperature) { int ret; uint8_t cmd; uint8_t adc_data[3]; uint32_t D1 = 0, D2 = 0; // 启动压力转换 cmd = MS5837_CMD_CONVERT_D1_OSR1024; ret = i2c_write_dt(dev_spec, &cmd, 1); if (ret != 0) { LOG_ERR("Pressure conversion start failed: %d", ret); return ret; } k_msleep(3); // OSR1024需要2.28ms转换时间 // 启动温度转换 cmd = MS5837_CMD_CONVERT_D2_OSR1024; ret = i2c_write_dt(dev_spec, &cmd, 1); if (ret != 0) { LOG_ERR("Temp conversion start failed: %d", ret); return ret; } k_msleep(3); // OSR1024需要2.28ms转换时间 // 读取压力ADC值 cmd = MS5837_CMD_ADC_READ; ret = i2c_write_read_dt(dev_spec, &cmd, 1, adc_data, sizeof(adc_data)); if (ret != 0) { LOG_ERR("Pressure ADC read failed: %d", ret); return ret; } D1 = ((uint32_t)adc_data[0] << 16) | ((uint32_t)adc_data[1] << 8) | adc_data[2]; // 读取温度ADC值 cmd = MS5837_CMD_ADC_READ; ret = i2c_write_read_dt(dev_spec, &cmd, 1, adc_data, sizeof(adc_data)); if (ret != 0) { LOG_ERR("Temp ADC read failed: %d", ret); return ret; } D2 = ((uint32_t)adc_data[0] << 16) | ((uint32_t)adc_data[1] << 8) | adc_data[2]; // 启动压力转换 cmd = MS5837_CMD_CONVERT_D1_OSR1024; ret = i2c_write_dt(dev_spec, &cmd, 1); if (ret != 0) { LOG_ERR("Pressure conversion start failed: %d", ret); return ret; } k_msleep(3); // OSR1024需要2.28ms转换时间 // 读取压力ADC值 cmd = MS5837_CMD_ADC_READ; ret = i2c_write_read_dt(dev_spec, &cmd, 1, adc_data, sizeof(adc_data)); if (ret != 0) { LOG_ERR("Pressure ADC read failed: %d", ret); return ret; } D1 = ((uint32_t)adc_data[0] << 16) | ((uint32_t)adc_data[1] << 8) | adc_data[2]; // 打印原始ADC值用于调试 LOG_DBG("Raw ADC: D1=%u, D2=%u", D1, D2); // 计算温度 int32_t dT = D2 - ((uint32_t)calib->c5 << 8); int32_t TEMP = 2000 + (((int64_t)dT * calib->c6) >> 23); // 计算压力 int64_t OFF = ((int64_t)calib->c2 << 17) + (((int64_t)calib->c4 * dT) >> 6); int64_t SENS = ((int64_t)calib->c1 << 16) + (((int64_t)calib->c3 * dT) >> 7); // 二阶温度补偿 int64_t T2 = 0, OFF2 = 0, SENS2 = 0; if (TEMP < 2000) { T2 = ((int64_t)dT * dT) >> 31; OFF2 = 61 * (TEMP - 2000) * (TEMP - 2000) / 16; SENS2 = 29 * (TEMP - 2000) * (TEMP - 2000) / 16; if (TEMP < -1500) { OFF2 += 17 * (TEMP + 1500) * (TEMP + 1500); SENS2 += 9 * (TEMP + 1500) * (TEMP + 1500); } } // 应用补偿 TEMP -= T2; OFF -= OFF2; SENS -= SENS2; // 最终压力计算 int32_t P = (((D1 * SENS) >> 21) - OFF) >> 15; // 转换为实际单位 *temperature = TEMP / 100.0; // 转换为摄氏度 *pressure = P / 100.0; // 转换为毫巴(mbar) return 0; } // // 初始化压力传感器 // static int init_LPS28DFW(const struct i2c_dt_spec *dev_spec) // { // int retries = 0; // const int max_retries = 5; // uint8_t whoami; // int ret; // LOG_DBG("Starting LPS28DFW initialization..."); // // 尝试读取 WHO_AM_I 寄存器 // while (retries < max_retries) { // ret = i2c_reg_read_byte_dt(dev_spec, LPS28DFW_WHO_AM_I, &whoami); // if (ret == 0) { // break; // 读取成功 // } // LOG_WRN("WHO_AM_I read attempt %d failed: %d", retries + 1, ret); // retries++; // k_sleep(K_MSEC(20)); // 短暂延时后重试 // } // if (ret != 0) { // LOG_ERR("Failed to read WHO_AM_I after %d attempts: %d", max_retries, ret); // return ret; // } // if (whoami != LPS28DFW_WHO_AM_I_VAL) { // LOG_ERR("Unexpected WHO_AM_I: 0x%02x (expected 0x%02x)", // whoami, LPS28DFW_WHO_AM_I_VAL); // return -ENODEV; // } // LOG_INF("LPS28DFW detected (WHO_AM_I=0x%02x)", whoami); // retries = 0; // uint8_t reg_value = 0; // // 尝试配置 CTRL_REG1 // while (retries < max_retries) { // // 写入配置 // ret = i2c_reg_write_byte_dt(dev_spec, LPS28DFW_CTRL_REG1, LPS28DFW_ODR_50HZ); // if (ret != 0) { // LOG_WRN("CTRL_REG1 write attempt %d failed: %d", retries + 1, ret); // retries++; // k_sleep(K_MSEC(20)); // 短暂延时后重试 // continue; // } // // 验证写入 // k_sleep(K_MSEC(5)); // 短暂延时确保寄存器稳定 // ret = i2c_reg_read_byte_dt(dev_spec, LPS28DFW_CTRL_REG1, &reg_value); // if (ret == 0 && reg_value == LPS28DFW_ODR_50HZ) { // break; // 验证成功 // } // LOG_WRN("CTRL_REG1 verification failed (wrote 0x%02x, read 0x%02x)", // LPS28DFW_ODR_50HZ, reg_value); // retries++; // k_sleep(K_MSEC(20)); // } // if (retries >= max_retries) { // LOG_ERR("Failed to configure CTRL_REG1 after %d attempts", max_retries); // return -EIO; // } // LOG_INF("LPS28DFW initialized successfully (CTRL_REG1=0x%02x)", reg_value); // return 0; // } // // 读取压力数据 // static double read_pressure(const struct i2c_dt_spec *dev_spec) // { // uint8_t press_data[3]; // int ret; // ret = i2c_burst_read_dt(dev_spec, LPS28DFW_PRESS_OUT_XL, press_data, sizeof(press_data)); // if (ret != 0) { // LOG_ERR("Pressure read failed: %d", ret); // return 0.0; // } // LOG_INF("press_data[0]=%d , press_data[1]=%d , press_data[2]=%d", // press_data[0], press_data[1], press_data[2]); // int32_t raw_pressure = (int32_t)press_data[0] | // ((int32_t)press_data[1] << 8) | // ((int32_t)press_data[2] << 16); // if (raw_pressure & 0x00800000) { // raw_pressure |= 0xFF000000; // } // double pressure_hPa = (double)raw_pressure / 2048.0; // return pressure_hPa / 10.0; // } // // 读取温度数据 // static double read_temperature(const struct i2c_dt_spec *dev_spec) // { // uint8_t temp_data[2]; // int ret; // // 读取温度寄存器 (L, H) // ret = i2c_burst_read_dt(dev_spec, LPS28DFW_TEMP_OUT_L, temp_data, sizeof(temp_data)); // if (ret != 0) { // LOG_ERR("Temperature read failed: %d", ret); // return 0.0; // } // // 组合16位温度值 (小端格式: L, H) // int16_t raw_temp = (int16_t)((uint16_t)temp_data[0] | ((uint16_t)temp_data[1] << 8)); // // 转换为摄氏度 (100 LSB/°C) // return (double)raw_temp / 100.0; // } // 初始化 LSM6DS0 传感器 static int init_lsm6dsowtr(const struct i2c_dt_spec *dev_spec) { uint8_t whoami; int ret; LOG_INF("Initializing LSM6DSOWTR sensor..."); // 读取 WHO_AM_I 寄存器 ret = i2c_reg_read_byte_dt(dev_spec, LSM6DSOWTR_REG_WHO_AM_I, &whoami); if (ret != 0) { LOG_ERR("Failed to read WHO_AM_I: %d", ret); return ret; } if (whoami != LSM6DSOWTR_WHO_AM_I_VAL) { LOG_ERR("Unexpected WHO_AM_I: 0x%02X (expected 0x%02X)", whoami, LSM6DSOWTR_WHO_AM_I_VAL); return -ENODEV; } LOG_INF("LSM6DSOWTR detected (WHO_AM_I=0x%02X)", whoami); // 配置加速度计 uint8_t ctrl1_xl = LSM6DSOWTR_ODR_XL_104HZ | LSM6DSOWTR_FS_XL_2G; ret = i2c_reg_write_byte_dt(dev_spec, LSM6DSOWTR_REG_CTRL1_XL, ctrl1_xl); if (ret != 0) { LOG_ERR("Failed to write CTRL1_XL: %d", ret); return ret; } // 配置陀螺仪 uint8_t ctrl2_g = LSM6DSOWTR_ODR_G_104HZ | LSM6DSOWTR_FS_G_245DPS; ret = i2c_reg_write_byte_dt(dev_spec, LSM6DSOWTR_REG_CTRL2_G, ctrl2_g); if (ret != 0) { LOG_ERR("Failed to write CTRL2_G: %d", ret); return ret; } uint8_t reg_val; ret = i2c_reg_read_byte_dt(dev_spec, LSM6DSOWTR_REG_CTRL1_XL, &reg_val); if (ret != 0 || reg_val != ctrl1_xl) { LOG_ERR("CTRL1_XL verification failed: wrote 0x%02X, read 0x%02X", ctrl1_xl, reg_val); return -EIO; } ret = i2c_reg_read_byte_dt(dev_spec, LSM6DSOWTR_REG_CTRL2_G, &reg_val); if (ret != 0 || reg_val != ctrl2_g) { LOG_ERR("CTRL2_G verification failed: wrote 0x%02X, read 0x%02X", ctrl2_g, reg_val); return -EIO; } // 配置控制寄存器3 ret = i2c_reg_write_byte_dt(dev_spec, LSM6DSOWTR_REG_CTRL3_C, 0x04); // BDU=1 (块数据更新) if (ret != 0) { LOG_ERR("Failed to write CTRL3_C: %d", ret); return ret; } LOG_INF("LSM6DSOWTR initialized successfully"); return 0; } // 读取加速度计数据 static void read_accelerometer(const struct i2c_dt_spec *dev_spec, double *x, double *y, double *z) { if (!wait_for_data_ready(dev_spec)) { LOG_WRN("Accel data not ready"); *x = *y = *z = NAN; return; } uint8_t data[6]; int ret = i2c_burst_read_dt(dev_spec, LSM6DSOWTR_REG_OUTX_L_XL, data, sizeof(data)); if (ret != 0) { LOG_ERR("Accelerometer read failed: %d", ret); *x = *y = *z = NAN; return; } // 组合16位数据（小端格式） int16_t raw_x = (int16_t)((data[1] << 8) | data[0]); int16_t raw_y = (int16_t)((data[3] << 8) | data[2]); int16_t raw_z = (int16_t)((data[5] << 8) | data[4]); // 转换为 g (重力加速度) - ±2g 量程，灵敏度 0.061 mg/LSB *x = raw_x * ACCEL_SENSITIVITY_2G; *y = raw_y * ACCEL_SENSITIVITY_2G; *z = raw_z * ACCEL_SENSITIVITY_2G; } // 读取陀螺仪数据 static void read_gyroscope(const struct i2c_dt_spec *dev_spec, double *x, double *y, double *z) { if (!wait_for_data_ready(dev_spec)) { LOG_WRN("Gyro data not ready"); *x = *y = *z = NAN; return; } uint8_t data[6]; int ret = i2c_burst_read_dt(dev_spec, LSM6DSOWTR_REG_OUTX_L_G, data, sizeof(data)); if (ret != 0) { LOG_ERR("Gyroscope read failed: %d", ret); *x = *y = *z = NAN; return; } // 组合16位数据（小端格式） int16_t raw_x = (int16_t)((data[1] << 8) | data[0]); int16_t raw_y = (int16_t)((data[3] << 8) | data[2]); int16_t raw_z = (int16_t)((data[5] << 8) | data[4]); // 转换为 dps (度/秒) - ±245dps 量程，灵敏度 8.75 mdps/LSB *x = raw_x * GYRO_SENSITIVITY_245DPS; *y = raw_y * GYRO_SENSITIVITY_245DPS; *z = raw_z * GYRO_SENSITIVITY_245DPS; } // 将浮点值转换为定点表示（用于存储） static int32_t sensor_value_to_int(double value, int scale_factor) { return (int32_t)(value * scale_factor); } // 主传感器线程 void lsm6dsowtr_thread(void) { LOG_INF("LSM6DSOWTR sensor thread started"); // 获取六轴传感器设备规范 static const struct i2c_dt_spec lsm6dsowtr_dev = I2C_DT_SPEC_GET(DT_NODELABEL(lsm6dsowtr)); if (!device_is_ready(lsm6dsowtr_dev.bus)) { LOG_ERR("I2C bus not ready: %s", lsm6dsowtr_dev.bus->name); return; } // 获取压力传感器设备规范 static const struct i2c_dt_spec pressure_dev = I2C_DT_SPEC_GET(DT_NODELABEL(mysensor)); if (!device_is_ready(pressure_dev.bus)) { LOG_ERR("I2C bus %s is not ready!", pressure_dev.bus->name); return; } // 初始化传感器 int init_result; // // 初始化压力传感器 // init_result = init_LPS28DFW(&pressure_dev); // if (init_result != 0) { // LOG_ERR("Pressure sensor initialization failed: %d", init_result); // } else { // LOG_INF("Pressure sensor initialized successfully"); // } struct ms5837_calib calib_data; int ms5837_init_ret = init_MS5837(&pressure_dev, &calib_data); if (ms5837_init_ret != 0) { LOG_ERR("MS5837 initialization failed: %d", ms5837_init_ret); // 非致命错误，继续运行其他传感器 } else { LOG_INF("MS5837 initialized successfully"); } // // 初始化六轴传感器 // int lsm_init_ret = init_lsm6dsowtr(&lsm6dsowtr_dev); // if (lsm_init_ret != 0) { // LOG_ERR("LSM6DSOWTR initialization failed: %d", lsm_init_ret); // // 如果主要传感器失败，考虑退出线程 // return; // } // 初始化传感器 if (init_MS5837(&pressure_dev, &calib_data) != 0) { LOG_ERR("MS5837 initialization failed"); } // 初始化六轴传感器 init_result = init_lsm6dsowtr(&lsm6dsowtr_dev); if (init_result != 0) { LOG_ERR("LSM6DSOWTR initialization failed: %d", init_result); } else { LOG_INF("LSM6DSOWTR initialized successfully"); } LOG_INF("Starting sensor data collection..."); // 主循环变量 int64_t last_sample_time = k_uptime_get(); int64_t last_batch_time = last_sample_time; while (1) { // 读取传感器数据 // double press, temp; // if (ms5837_init_ret == 0) { double press, temp; if (read_MS5837(&pressure_dev, &calib_data, &press, &temp) == 0) { LOG_INF("Pressure: %.2f mbar, Temperature: %.2f C", press, temp); } else { LOG_WRN("MS5837 read error"); } // } // double press = read_pressure(&pressure_dev); // double temp = read_temperature(&pressure_dev); // int press_int = (int)press; // int press_frac = (int)((press - press_int) * 1000); // int temp_int = (int)temp; // int temp_frac = (int)((temp - temp_int) * 100); // 打印整数格式的值 // printk("Pressure: %d.%03d kPa, Temperature: %d.%02d C\n", // press_int, press_frac, temp_int, temp_frac); double accel_x, accel_y, accel_z; double gyro_x, gyro_y, gyro_z; read_accelerometer(&lsm6dsowtr_dev, &accel_x, &accel_y, &accel_z); read_gyroscope(&lsm6dsowtr_dev, &gyro_x, &gyro_y, &gyro_z); //float magnitude = calculate_acceleration_magnitude(accel_x, accel_y, accel_z); LOG_INF("Accel: X=%.3f g, Y=%.3f g, Z=%.3f g", accel_x, accel_y, accel_z); LOG_INF("Gyro: X=%.2f dps, Y=%.2f dps, Z=%.2f dps", gyro_x, gyro_y, gyro_z); // 获取当前时间戳 int64_t current_time = k_uptime_get(); // 准备数据点 sensor_data_point_t data_point = { .timestamp = current_time, .pressure = sensor_value_to_int(press, 1000), // kPa * 1000 = milli-kPa .temp = sensor_value_to_int(temp, 100), // °C * 100 = centi-°C .acc_x = sensor_value_to_int(accel_x, 1000), // g * 1000 = milli-g .acc_y = sensor_value_to_int(accel_y, 1000), .acc_z = sensor_value_to_int(accel_z, 1000), .gyro_x = sensor_value_to_int(gyro_x, 1000), // dps * 1000 = milli-dps .gyro_y = sensor_value_to_int(gyro_y, 1000), .gyro_z = sensor_value_to_int(gyro_z, 1000) }; // data_point = filter_sensor_data(&data_point); // 安全地添加到批量缓冲区 k_mutex_lock(&data_mutex, K_FOREVER); // 检查当前批次缓冲区是否有效 if (sensor_batch.count == 0) { // 新批次，记录起始时间戳 sensor_batch.start_timestamp = current_time; } // 添加数据点到批次 if (sensor_batch.count < BATCH_SIZE) { sensor_batch.data[sensor_batch.count] = data_point; sensor_batch.count++; // 检查批次是否已满 if (sensor_batch.count >= BATCH_SIZE) { // 批次已满，标记为就绪 sensor_batch.ready = true; LOG_DBG("Batch filled (%d points)", BATCH_SIZE); } } else { LOG_WRN("Batch buffer full, discarding data point"); } // 检查是否超时（即使批次未满） if ((current_time - sensor_batch.start_timestamp) >= (MAX_BATCH_TIMEOUT * 1000)) { if (sensor_batch.count > 0) { sensor_batch.ready = true; LOG_DBG("Batch timeout with %d points", sensor_batch.count); } } // 如果批次就绪，通知BLE线程 if (sensor_batch.ready) { k_sem_give(&batch_ready_sem); LOG_DBG("Notified BLE thread of data ready"); } k_mutex_unlock(&data_mutex); // 计算下一个采样点的时间 int64_t elapsed = k_uptime_get() - last_sample_time; int32_t sleep_time = SAMPLE_INTERVAL_MS - elapsed; if (sleep_time > 0) { k_msleep(sleep_time); } else { LOG_WRN("Sampling behind schedule by %d ms", -sleep_time); } last_sample_time = k_uptime_get(); } } // 定义传感器线程 K_THREAD_DEFINE(lsm6dsowtr_thread_id, 4096, lsm6dsowtr_thread, NULL, NULL, NULL, 7, 0, 0);ret = i2c_write_dt(dev_spec, &reset_cmd, 1);仍然返回-5
07-03
2.MS5837传感器复位命令发送后，为什么需要等待至少2.8ms才能进行后续操作？3.如何通过逻辑分析仪判断I2C通信中的NACK错误？4.当I2C设备地址冲突时，Zephyr驱动会表现出什么错误现象？ 5.在设备树中配置I2C总线时钟...
电源技术中的MAX9959:25V电压范围、800mA器件电源（DPS）
11-03
MAX9959为自动测试设备(ATE)或其它仪器提供器件电源(DPS)。小尺寸、高集成度及灵活性使MAX9959成为需要多器件电源应用的理想、经济的选择。 　　MAX9959具有多个输入控制电压，支持输出电压的独立设置，可设置电压或电流的最大和最小值(最小正极性或最大负极性)。当负载电流处于两个设置门限之间时，MAX9959是电压源；达到设置电流门限后，将平稳地转换成精密的电流源。输出具有两个独立的可调电压嵌位电路，限制处于外部电平之间的负极性和正极性输出电压。 　　MAX9959能够提供25V电压和高达±800mA的电流。DPS支持外部缓冲，以源出或吸收较大电流。可将多个MAX9959并
ATE API：DPS_TASK概述
weixin_44246045的博客
01-17 437
上一节介绍了ATE测试程序的基本结构，知道run（）是执行测试的内容，在模板中这部分内容就是需要根据测试任务来实现的代码。 编写数字电路测试程序时，最常见的是基于电源（DPS）、数字通道（PPUM）和功能（function）的测试，在编写这几种类型测试程序时，会用到SmarTest的专用API，本节将介绍基于电源DPS的测试API:DPS_TASK。 DPS_TASK在DC测试中应用十分广泛，只要涉及到对电源引脚的测试，几乎都会用到这个API。编写测试程序时，基于DPS_TASK创建对象，利用它的成员函
芯片电源引脚为什么要加一个100nF电容
热门推荐
谢谢关注“小鱼教你模数电”,各平台同号
11-06 1万+
那么就有那么一个频率f=f0，使得Z=ESR，这时电容就相当于一个纯电阻，整个电容这时阻抗最小，这个频率f0我们称为电容的谐振频率，当信号频率小于f0时电容呈现容性，电容等效于一个电阻和电容的串联，当信号频率大于f0时电容呈现感性，表现为。也就是信号的频率应当小于电容的谐振频率。因为我们常用的数字芯片其信号频率基本都在10MHZ以下，所以电源上的干扰或者其自身产生的干扰信号也大概在这个范围，所以我们的常用的经验值一般用100nF的电容，如果器件信号频率比较高我们可以选择容值小点的电容。
DPS学习-GPIO
zyghero的专栏
10-15 2431
1、GPIO介绍 在F2812中系统提供了许多通用的I/O引脚，这些引脚绝大多数是多功能复用的引脚，即既可以作为数字I/O口，也可以作为特殊功能口（如SCI、SPI、CAN等）。可以根据设计需要，通过GPIO MUX（复用开关）寄存器来选择配置工作方式。如果引脚工作在通用数字量I/O模式，可以通过方向控制寄存器（GPxDIR）来控制通用I/O的方向，还可以通过量化寄存器（GPxQUAL）对输入信
ATE DPS参数：ATE DPS电压、电流控制参数
weixin_44246045的博客
01-15 1046
V93000 ATE电源引脚在Level Equation设置时会使用到两项最重要的参数：电压控制参数和电流控制参数。这两个参数是必须设定项，它们有什么含义，它们能用来干什么，怎样来使用？本文将进行介绍。 1、电压控制参数 在Level Equation设置中，电压参数是非常重要的参数，通过电压参数可以实现电压大小的设定，或电压force范围的设定。DPS引脚电压参数有两个：vout和 vout_frc_rng。 1）vout：DPS电源及MS-DPS电源中均会使用到，vout表示对电源输出电压值的设
ATE DPS参数：ATE DPS的“offcurr”
weixin_44246045的博客
01-13 422
V93000 ATE电源引脚在Level Equation设置时会遇到一个参数：offcurr，这是一个必须设定的参数，这个参数是什么含义，它有哪些状态，怎样来使用？本文将进行介绍。 1、什么是offcurr？ offcurr是英文off current state的缩写，指“断开电流状态”。这里的断开是对dps电源而言，这个参数设置的作用是：断开电源后电流状态的设定。 2、offcurr有哪些状态？ offcurr的状态设置有5种：act、min、open、act_min和act_open。各状态
ATE DPS参数：ATE DPS上电、断电缓急程度控制参数
weixin_44246045的博客
01-14 593
V93000 ATE电源引脚在Level Equation设置时有时会用下面这一组参数： vout_rise_t_ms_per_volt vout_fall_t_ms_per_volt vout_rise_settling_t_ms vout_fall_settling_t_ms 这组参数不是必须设定的内容，那这一组参数是什么含义，有什么作用，怎么使用？下面将进行介绍。 1、这一组参数是什么？ 这四个参数是DPS电源上升下降斜率及setting时间的控制参数，含义如下： 1）vout_ris
参数测量基础——工程师基础知识
集成光电子
08-18 2430
原创：是德科技 “我经常讲当你了解所谈论的某件事情时，你就能够进行测量和用数字表述 ......" "而当你不能测量和用数字表述时，你的知识是不完整和不及格的; 这只是初步和片面的了解，无论是否可能，您都应力求攀上科学的更高一层。" — 威廉·汤姆孙 (开尔文勋爵) 重要的五个个测量术语： 准确度、可重复性、分辨率，屏蔽和保护。 其中准确度和可重复性是相互独立的。 对于生产测试来说，可重复性通常比绝对准确度更为重要。 最重要的是分辨率，这个是上述两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值