wxsmart
/
controller-pcba
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

DEV

This commit is contained in:
qiuxin 2025-05-19 19:29:08 +08:00
parent 2a1233826c
commit 69b41c5f5f
7 changed files with 362 additions and 504 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
Core/Src/freertos.c
View File

@ -93,6 +93,7 @@ void start_gpio_di_do_task(void const *argument);
void start_ec11_task(void const *argument); void start_ec11_task(void const *argument);
void start_ad7124_test_task(void const *argument); void start_ad7124_test_task(void const *argument);
void ad7124_multi_channel_init(uint8_t sample_rate); void ad7124_multi_channel_init(uint8_t sample_rate);
void start_adc_task(void const *argument);
extern void MX_LWIP_Init(void); extern void MX_LWIP_Init(void);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */ void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */
@ -152,6 +153,8 @@ void MX_FREERTOS_Init(void)
/* definition and creation of dac_task */ /* definition and creation of dac_task */
// osThreadDef(dac_task, start_dac_task, osPriorityNormal, 0, 512); // osThreadDef(dac_task, start_dac_task, osPriorityNormal, 0, 512);
// dac_taskHandle = osThreadCreate(osThread(dac_task), NULL); // dac_taskHandle = osThreadCreate(osThread(dac_task), NULL);
osThreadDef(adc_task, start_adc_task, osPriorityBelowNormal, 0, 128);
adc_taskHandle = osThreadCreate(osThread(adc_task), NULL);
/* definition and creation of adc_task */ /* definition and creation of adc_task */
// osThreadDef(adc_task, start_adc_task, osPriorityBelowNormal, 0, 128); // osThreadDef(adc_task, start_adc_task, osPriorityBelowNormal, 0, 128);
@ -166,8 +169,8 @@ void MX_FREERTOS_Init(void)
// ec11_taskHandle = osThreadCreate(osThread(ec11_task), NULL); // ec11_taskHandle = osThreadCreate(osThread(ec11_task), NULL);
/* definition and creation of ad7124_test_task */ /* definition and creation of ad7124_test_task */
osThreadDef(ad7124_test_task, start_ad7124_test_task, osPriorityNormal, 0, 512); // osThreadDef(ad7124_test_task, start_ad7124_test_task, osPriorityNormal, 0, 512);
ad7124_test_taskHandle = osThreadCreate(osThread(ad7124_test_task), NULL); // ad7124_test_taskHandle = osThreadCreate(osThread(ad7124_test_task), NULL);
/* USER CODE BEGIN RTOS_THREADS */ /* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */ /* add threads, ... */
@ -305,15 +308,15 @@ void start_adc_task(void const *argument)
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
osThreadSuspend(dac_taskHandle); // 暂停DAC任务，防止ADC采集时产生干????????,因为ADC和DAC采用的是同一路SPI，但是时序不???????? //osThreadSuspend(dac_taskHandle); // 暂停DAC任务，防止ADC采集时产生干????????,因为ADC和DAC采用的是同一路SPI，但是时序不????????
uint8_t ch = 0; uint8_t ch = 0;
for (ch = STOP_NC_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++) for (ch = AI_IN0_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++)
{ {
ad7124_get_analog(ch); ad7124_get_analog(ch);
} }
communication_reset_hart(); //communication_reset_hart();
osThreadResume(dac_taskHandle); //osThreadResume(dac_taskHandle);
vTaskDelay(10); vTaskDelay(100);
} }
/* USER CODE END start_adc_task */ /* USER CODE END start_adc_task */
} }
@ -377,128 +380,146 @@ volatile uint16_t g_config_0 = 0; // 用于观察配置寄存器0
volatile uint32_t g_filter_0 = 0; // 用于观察滤波器配置 volatile uint32_t g_filter_0 = 0; // 用于观察滤波器配置
extern int32_t g_ad7124_id; extern int32_t g_ad7124_id;
void start_ad7124_test_task(const void *argument) // void start_ad7124_test_task(const void *argument)
{ // {
vTaskDelay(1000); // vTaskDelay(1000);
// 初始化AD7124 // // 初始化AD7124
ad7124_setup(); // ad7124_setup();
vTaskDelay(100); // vTaskDelay(100);
while(1) // while(1)
{ // {
// 遍历所有启用的通道 // // 遍历所有启用的通道
for(uint8_t ch = STOP_NC_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++) // for(uint8_t ch = STOP_NC_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++)
{ // {
// 1. 将ADC设置为掉电模式 // // 1. 将ADC设置为掉电模式
ad7124_regs[AD7124_ADC_CONTROL].value = 0x0600; // Power-down mode // ad7124_regs[AD7124_ADC_CONTROL].value = 0x0600; // Power-down mode
ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]); // ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
vTaskDelay(1); // vTaskDelay(1);
// 2. 配置当前通道 // // 2. 配置当前通道
ad7124_regs[AD7124_CHANNEL_0].value = ad7124_channel_regs[ch].value; // ad7124_regs[AD7124_CHANNEL_0].value = ad7124_channel_regs[ch].value;
ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]); // ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
// 3. 读取并保存通道配置状态 // // 3. 读取并保存通道配置状态
ad7124_read_register(&ad7124_regs[AD7124_CHANNEL_0]); // ad7124_read_register(&ad7124_regs[AD7124_CHANNEL_0]);
g_channel_config = ad7124_regs[AD7124_CHANNEL_0].value; // g_channel_config = ad7124_regs[AD7124_CHANNEL_0].value;
// 4. 设置为单次转换模式并启动转换 // // 4. 设置为单次转换模式并启动转换
ad7124_regs[AD7124_ADC_CONTROL].value = 0x0684; // Single conversion mode // ad7124_regs[AD7124_ADC_CONTROL].value = 0x0684; // Single conversion mode
ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]); // ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
// 5. 立即读取状态寄存器确认转换开始 // // 5. 立即读取状态寄存器确认转换开始
ad7124_read_register(&ad7124_regs[AD7124_STATUS]); // ad7124_read_register(&ad7124_regs[AD7124_STATUS]);
g_channel_status = ad7124_regs[AD7124_STATUS].value; // g_channel_status = ad7124_regs[AD7124_STATUS].value;
// 6. 等待转换完成 // // 6. 等待转换完成
uint16_t timeout = 1000; // uint16_t timeout = 1000;
while(timeout--) { // while(timeout--) {
int32_t ret = ad7124_read_register(&ad7124_regs[AD7124_STATUS]); // int32_t ret = ad7124_read_register(&ad7124_regs[AD7124_STATUS]);
if(ret >= 0) { // if(ret >= 0) {
g_channel_status = ad7124_regs[AD7124_STATUS].value; // g_channel_status = ad7124_regs[AD7124_STATUS].value;
if(!(g_channel_status & AD7124_STATUS_REG_RDY)) { // if(!(g_channel_status & AD7124_STATUS_REG_RDY)) {
// 转换完成，立即读取数据 // // 转换完成，立即读取数据
g_adc_data = ad7124_read_data(); // g_adc_data = ad7124_read_data();
break; // break;
} // }
} // }
vTaskDelay(1); // vTaskDelay(1);
} // }
// 7. 读取错误寄存器检查是否有错误 // // 7. 读取错误寄存器检查是否有错误
ad7124_read_register(&ad7124_regs[AD7124_ERROR]); // ad7124_read_register(&ad7124_regs[AD7124_ERROR]);
g_adc_error = ad7124_regs[AD7124_ERROR].value; // g_adc_error = ad7124_regs[AD7124_ERROR].value;
// 8. 保存最终的控制寄存器状态 // // 8. 保存最终的控制寄存器状态
ad7124_read_register(&ad7124_regs[AD7124_ADC_CONTROL]); // ad7124_read_register(&ad7124_regs[AD7124_ADC_CONTROL]);
g_adc_control = ad7124_regs[AD7124_ADC_CONTROL].value; // g_adc_control = ad7124_regs[AD7124_ADC_CONTROL].value;
// 9. 如果发生错误，重置ADC // // 9. 如果发生错误，重置ADC
if(g_adc_error != 0) { // if(g_adc_error != 0) {
ad7124_reset(); // ad7124_reset();
vTaskDelay(100); // vTaskDelay(100);
ad7124_setup(); // ad7124_setup();
vTaskDelay(10); // vTaskDelay(10);
} // }
// 10. 如果超时或出错，增加延时方便调试 // // 10. 如果超时或出错，增加延时方便调试
if(timeout == 0 || g_adc_error != 0) { // if(timeout == 0 || g_adc_error != 0) {
vTaskDelay(100); // vTaskDelay(100);
} // }
} // }
vTaskDelay(pdMS_TO_TICKS(10)); // vTaskDelay(pdMS_TO_TICKS(10));
} // }
} // }
/** /**
* @brief Initialize AD7124 with multiple channels * @brief Initialize AD7124 with multiple channels
* @param sample_rate: Sample rate selection (2Hz to 1kHz) * @param sample_rate: Sample rate selection (2Hz to 1kHz)
* @retval None * @retval None
*/ */
void ad7124_multi_channel_init(uint8_t sample_rate) // void ad7124_multi_channel_init(uint8_t sample_rate)
{ // {
// Reset AD7124 // // Reset AD7124
ad7124_reset(); // ad7124_reset();
vTaskDelay(pdMS_TO_TICKS(100)); // 复位后延时 // vTaskDelay(pdMS_TO_TICKS(100)); // 复位后延时
// 配置ADC控制寄存器 // // 配置ADC控制寄存器
ad7124_regs[AD7124_ADC_CONTROL].value = // ad7124_regs[AD7124_ADC_CONTROL].value =
AD7124_ADC_CTRL_REG_DATA_STATUS | // Enable status register // AD7124_ADC_CTRL_REG_DATA_STATUS | // Enable status register
AD7124_ADC_CTRL_REG_CS_EN | // Enable chip select // AD7124_ADC_CTRL_REG_CS_EN | // Enable chip select
AD7124_ADC_CTRL_REG_REF_EN | // Enable internal reference // AD7124_ADC_CTRL_REG_REF_EN | // Enable internal reference
AD7124_ADC_CTRL_REG_POWER_MODE(3); // Full power mode // AD7124_ADC_CTRL_REG_POWER_MODE(3); // Full power mode
ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]); // ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
// 配置Setup 0 // // 配置Setup 0
ad7124_regs[AD7124_CONFIG_0].value = // ad7124_regs[AD7124_CONFIG_0].value =
AD7124_CFG_REG_BIPOLAR | // Bipolar mode // AD7124_CFG_REG_BIPOLAR | // Bipolar mode
AD7124_CFG_REG_BURNOUT(0) | // Burnout current source off // AD7124_CFG_REG_BURNOUT(0) | // Burnout current source off
AD7124_CFG_REG_REF_BUFP | // Reference buffer positive enabled // AD7124_CFG_REG_REF_BUFP | // Reference buffer positive enabled
AD7124_CFG_REG_REF_BUFM | // Reference buffer negative enabled // AD7124_CFG_REG_REF_BUFM | // Reference buffer negative enabled
AD7124_CFG_REG_AIN_BUFP | // Enable positive input buffer // AD7124_CFG_REG_AIN_BUFP | // Enable positive input buffer
AD7124_CFG_REG_AINN_BUFM | // Enable negative input buffer // AD7124_CFG_REG_AINN_BUFM | // Enable negative input buffer
AD7124_CFG_REG_REF_SEL(2) | // Use internal reference // AD7124_CFG_REG_REF_SEL(2) | // Use internal reference
AD7124_CFG_REG_PGA(0); // Gain = 1 // AD7124_CFG_REG_PGA(0); // Gain = 1
ad7124_write_register(&ad7124_regs[AD7124_CONFIG_0]); // ad7124_write_register(&ad7124_regs[AD7124_CONFIG_0]);
// 初始禁用所有通道 // // 初始禁用所有通道
for(uint8_t ch = 0; ch < AD7124_CHANNEL_EN_MAX; ch++) { // for(uint8_t ch = 0; ch < AD7124_CHANNEL_EN_MAX; ch++) {
ad7124_regs[AD7124_CHANNEL_0 + ch].value = 0; // ad7124_regs[AD7124_CHANNEL_0 + ch].value = 0;
ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0 + ch]); // ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0 + ch]);
} // }
// 配置滤波器 // // 配置滤波器
ad7124_regs[AD7124_FILTER_0].value = // ad7124_regs[AD7124_FILTER_0].value =
AD7124_FILT_REG_FILTER(0) | // SINC4 filter // AD7124_FILT_REG_FILTER(0) | // SINC4 filter
AD7124_FILT_REG_REJ60 | // Enable 60Hz rejection // AD7124_FILT_REG_REJ60 | // Enable 60Hz rejection
AD7124_FILT_REG_POST_FILTER(3) | // Post filter enabled // AD7124_FILT_REG_POST_FILTER(3) | // Post filter enabled
AD7124_FILT_REG_FS(1); // Output data rate // AD7124_FILT_REG_FS(1); // Output data rate
ad7124_write_register(&ad7124_regs[AD7124_FILTER_0]); // ad7124_write_register(&ad7124_regs[AD7124_FILTER_0]);
} // }
/* Private application code --------------------------------------------------*/ /* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */ /* USER CODE BEGIN Application */
// void start_adc_task(void const *argument)
// {
// /* USER CODE BEGIN start_adc_task */
// ad7124_setup();
// /* Infinite loop */
// for (;;)
// {
// osThreadSuspend(dac_taskHandle); // 暂停DAC任务，防止ADC采集时产生干<E7949F>????????,因为ADC和DAC采用的是同一路SPI，但是时序不<E5BA8F>????????
// uint8_t ch = 0;
// for (ch = STOP_NC_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++)
// {
// ad7124_get_analog(ch);
// }
// communication_reset_hart();
// osThreadResume(dac_taskHandle);
// vTaskDelay(10);
// }
// /* USER CODE END start_adc_task */
// }
/* USER CODE END Application */ /* USER CODE END Application */

64
MDK-ARM/controller_pcba.uvoptx
View File

@ -152,9 +152,9 @@
<Bp> <Bp>
<Number>0</Number> <Number>0</Number>
<Type>0</Type> <Type>0</Type>
<LineNumber>147</LineNumber> <LineNumber>401</LineNumber>
<EnabledFlag>1</EnabledFlag> <EnabledFlag>1</EnabledFlag>
<Address>134243296</Address> <Address>134243228</Address>
<ByteObject>0</ByteObject> <ByteObject>0</ByteObject>
<HtxType>0</HtxType> <HtxType>0</HtxType>
<ManyObjects>0</ManyObjects> <ManyObjects>0</ManyObjects>
@ -163,55 +163,7 @@
<BreakIfRCount>1</BreakIfRCount> <BreakIfRCount>1</BreakIfRCount>
<Filename>..\User\driver\ad7124.c</Filename> <Filename>..\User\driver\ad7124.c</Filename>
<ExecCommand></ExecCommand> <ExecCommand></ExecCommand>
<Expression>\\semi_finished_product_testing\../User/driver/ad7124.c\147</Expression> <Expression>\\semi_finished_product_testing\../User/driver/ad7124.c\401</Expression>
</Bp>
<Bp>
<Number>1</Number>
<Type>0</Type>
<LineNumber>439</LineNumber>
<EnabledFlag>1</EnabledFlag>
<Address>134271122</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>../Core/Src/freertos.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\semi_finished_product_testing\../Core/Src/freertos.c\439</Expression>
</Bp>
<Bp>
<Number>2</Number>
<Type>0</Type>
<LineNumber>422</LineNumber>
<EnabledFlag>1</EnabledFlag>
<Address>134271054</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>../Core/Src/freertos.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\semi_finished_product_testing\../Core/Src/freertos.c\422</Expression>
</Bp>
<Bp>
<Number>3</Number>
<Type>0</Type>
<LineNumber>419</LineNumber>
<EnabledFlag>1</EnabledFlag>
<Address>134271036</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>../Core/Src/freertos.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\semi_finished_product_testing\../Core/Src/freertos.c\419</Expression>
</Bp> </Bp>
</Breakpoint> </Breakpoint>
<WatchWindow1> <WatchWindow1>
@ -310,6 +262,16 @@
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>g_adc_control</ItemText> <ItemText>g_adc_control</ItemText>
</Ww> </Ww>
<Ww>
<count>19</count>
<WinNumber>1</WinNumber>
<ItemText>ad7124_analog[channel_nr]</ItemText>
</Ww>
<Ww>
<count>20</count>
<WinNumber>1</WinNumber>
<ItemText>read_data,0x10</ItemText>
</Ww>
</WatchWindow1> </WatchWindow1>
<Tracepoint> <Tracepoint>
<THDelay>0</THDelay> <THDelay>0</THDelay>

57
MDK-ARM/semi-finished_product_testing/semi-finished_product_testing.build_log.htm
View File

@ -1,57 +0,0 @@
<html>
<body>
<pre>
<h1>µVision Build Log</h1>
<h2>Tool Versions:</h2>
IDE-Version: ¦ÌVision V5.36.0.0
Copyright (C) 2021 ARM Ltd and ARM Germany GmbH. All rights reserved.
License Information: 1 admin, 1, LIC=UJWP0-B9JWK-458T5-GZZVK-L22WW-E2L2W
Tool Versions:
Toolchain: MDK-ARM Plus Version: 5.36.0.0
Toolchain Path: C:\Keil_v5\ARM\ARMCC\Bin
C Compiler: Armcc.exe V5.06 update 7 (build 960)
Assembler: Armasm.exe V5.06 update 7 (build 960)
Linker/Locator: ArmLink.exe V5.06 update 7 (build 960)
Library Manager: ArmAr.exe V5.06 update 7 (build 960)
Hex Converter: FromElf.exe V5.06 update 7 (build 960)
CPU DLL: SARMCM3.DLL V5.36.0.0
Dialog DLL: DCM.DLL V1.17.3.0
Target DLL: STLink\ST-LINKIII-KEIL_SWO.dll V3.0.9.0
Dialog DLL: TCM.DLL V1.53.0.0
<h2>Project:</h2>
C:\Users\qiuxin.JS250402\Desktop\PCBA\controller_pcba_rtos\MDK-ARM\controller_pcba.uvprojx
Project File Date: 05/14/2025
<h2>Output:</h2>
*** Using Compiler 'V5.06 update 7 (build 960)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'
Build target 'controller_pcba'
"semi-finished_product_testing\semi-finished_product_testing.axf" - 0 Error(s), 0 Warning(s).
<h2>Software Packages used:</h2>
Package Vendor: ARM
http://www.keil.com/pack/ARM.CMSIS.5.8.0.pack
ARM.CMSIS.5.8.0
CMSIS (Common Microcontroller Software Interface Standard)
* Component: CORE Version: 5.5.0
Package Vendor: Keil
http://www.keil.com/pack/Keil.STM32F4xx_DFP.2.14.0.pack
Keil.STM32F4xx_DFP.2.14.0
STMicroelectronics STM32F4 Series Device Support, Drivers and Examples
<h2>Collection of Component include folders:</h2>
.\RTE\_controller_pcba
C:\Users\qiuxin.JS250402\AppData\Local\Arm\Packs\ARM\CMSIS\5.8.0\CMSIS\Core\Include
C:\Users\qiuxin.JS250402\AppData\Local\Arm\Packs\Keil\STM32F4xx_DFP\2.14.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include
<h2>Collection of Component Files used:</h2>
* Component: ARM::CMSIS:CORE:5.5.0
Include file: CMSIS\Core\Include\tz_context.h
Build Time Elapsed: 00:00:01
</pre>
</body>
</html>

5
User/application/src/tcpserverc.c
View File

@ -413,8 +413,7 @@ uint16_t handle_type_87(const uint8_t *body, uint16_t body_len, uint8_t *tx)
{ {
uint16_t total_len = 2 + 2 + 2 + 2 + 1 + 74 + 2; // 帧头+帧长+源+目标+类型+74字节输出读取+校验 uint16_t total_len = 2 + 2 + 2 + 2 + 1 + 74 + 2; // 帧头+帧长+源+目标+类型+74字节输出读取+校验
// 1. 读取ID寄存器 // 1. 读取ID寄存器
ad7124_read_register(&ad7124_regs[AD7124_ID]);
uint8_t id = (uint8_t)(ad7124_regs[AD7124_ID].value & 0xFF);
// 帧头 // 帧头
tx[0] = head_00; tx[0] = head_00;
tx[1] = head_01; tx[1] = head_01;
@ -433,7 +432,7 @@ uint16_t total_len = 2 + 2 + 2 + 2 + 1 + 74 + 2; // 帧头+帧长+源+目标+类
// 报文类型 // 报文类型
tx[8] = reply_type; tx[8] = reply_type;
tx[9] = id;
// 7字节使能状态（直接复制 body 到 tx[9]~tx[15]） // 7字节使能状态（直接复制 body 到 tx[9]~tx[15]）
//memcpy(&tx[9], body, 74); // 确保 body 是74字节 //memcpy(&tx[9], body, 74); // 确保 body 是74字节

246
User/driver/ad7124.c
View File

@ -1,19 +1,13 @@
#include "ad7124.h" #include "ad7124.h"
#include "user_spi.h"
#include "usart.h"
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
/* Error codes */ /* Error codes */
#define INVALID_VAL -1 /* Invalid argument */ #define INVALID_VAL -1 /* Invalid argument */
#define COMM_ERR -2 /* Communication error on receive */ #define COMM_ERR -2 /* Communication error on receive */
#define AD7124_TIMEOUT -3 /* A timeout has occured */ #define AD7124_TIMEOUT -3 /* A timeout has occured */
int32_t FINESH_ID;
int32_t g_ad7124_id;
// 配置ad7124寄存器的值，根据实际项目需求配置 // 配置ad7124寄存器的值，根据实际项目需求配置
ad7124_st_reg_t ad7124_regs[AD7124_REG_NO] = { static ad7124_st_reg_t ad7124_regs[AD7124_REG_NO] = {
{AD7124_STATUS, 0x00, AD7124_SIZE_1, AD7124_R}, /* AD7124_Status */ {AD7124_STATUS, 0x00, AD7124_SIZE_1, AD7124_R}, /* AD7124_Status */
{AD7124_ADC_CONTROL, 0x0680, AD7124_SIZE_2, AD7124_RW}, /* AD7124_ADC_Control - Enable reference, chip select, and data status */ {AD7124_ADC_CONTROL, 0x0280, AD7124_SIZE_2, AD7124_RW}, /* AD7124_ADC_Control */
{AD7124_DATA, 0x000000, AD7124_SIZE_3, AD7124_R}, /* AD7124_Data */ {AD7124_DATA, 0x000000, AD7124_SIZE_3, AD7124_R}, /* AD7124_Data */
{AD7124_IOCON1, 0x000000, AD7124_SIZE_3, AD7124_RW}, /* AD7124_IOCon1 */ {AD7124_IOCON1, 0x000000, AD7124_SIZE_3, AD7124_RW}, /* AD7124_IOCon1 */
{AD7124_IOCON2, 0x0000, AD7124_SIZE_2, AD7124_RW}, /* AD7124_IOCon2 */ {AD7124_IOCON2, 0x0000, AD7124_SIZE_2, AD7124_RW}, /* AD7124_IOCon2 */
@ -37,14 +31,14 @@ ad7124_st_reg_t ad7124_regs[AD7124_REG_NO] = {
{AD7124_CHANNEL_13, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */ {AD7124_CHANNEL_13, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */
{AD7124_CHANNEL_14, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */ {AD7124_CHANNEL_14, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */
{AD7124_CHANNEL_15, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_15 */ {AD7124_CHANNEL_15, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_15 */
{AD7124_CONFIG_0, 0x0DE0, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_0 - Enable buffers and internal reference */ {AD7124_CONFIG_0, 0x00E0, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_0 - 单极性模式 */
{AD7124_CONFIG_1, 0x0040, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_1 */ {AD7124_CONFIG_1, 0x0040, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_1 */
{AD7124_CONFIG_2, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_2 */ {AD7124_CONFIG_2, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_2 - 单极性模式 */
{AD7124_CONFIG_3, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_3 */ {AD7124_CONFIG_3, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_3 - 单极性模式 */
{AD7124_CONFIG_4, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_4 */ {AD7124_CONFIG_4, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_4 - 单极性模式 */
{AD7124_CONFIG_5, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_5 */ {AD7124_CONFIG_5, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_5 - 单极性模式 */
{AD7124_CONFIG_6, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_6 */ {AD7124_CONFIG_6, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_6 - 单极性模式 */
{AD7124_CONFIG_7, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_7 */ {AD7124_CONFIG_7, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_7 - 单极性模式 */
{AD7124_FILTER_0, 0x060020, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Filter_0 */ {AD7124_FILTER_0, 0x060020, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Filter_0 */
{AD7124_FILTER_1, 0x060180, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Filter_1 */ {AD7124_FILTER_1, 0x060180, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Filter_1 */
{AD7124_FILTER_2, 0x060180, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Filter_2 */ {AD7124_FILTER_2, 0x060180, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Filter_2 */
@ -71,7 +65,7 @@ ad7124_st_reg_t ad7124_regs[AD7124_REG_NO] = {
{AD7124_GAIN_7, 0x500000, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Gain_7 */ {AD7124_GAIN_7, 0x500000, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Gain_7 */
}; };
ad7124_st_reg_t ad7124_channel_regs[AD7124_CHANNEL_EN_MAX] = { static ad7124_st_reg_t ad7124_channel_regs[AD7124_CHANNEL_EN_MAX] = {
{AD7124_CHANNEL_0, 0x8051, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_0 */ {AD7124_CHANNEL_0, 0x8051, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_0 */
{AD7124_CHANNEL_1, 0x8071, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_1 */ {AD7124_CHANNEL_1, 0x8071, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_1 */
{AD7124_CHANNEL_2, 0x8091, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_2 */ {AD7124_CHANNEL_2, 0x8091, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_2 */
@ -82,6 +76,12 @@ ad7124_st_reg_t ad7124_channel_regs[AD7124_CHANNEL_EN_MAX] = {
{AD7124_CHANNEL_7, 0x8131, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_7 */ {AD7124_CHANNEL_7, 0x8131, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_7 */
{AD7124_CHANNEL_8, 0x8151, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_8 */ {AD7124_CHANNEL_8, 0x8151, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_8 */
{AD7124_CHANNEL_9, 0x8171, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_9 */ {AD7124_CHANNEL_9, 0x8171, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_9 */
{AD7124_CHANNEL_10, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_10 */
{AD7124_CHANNEL_11, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_11 */
{AD7124_CHANNEL_12, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_12 */
{AD7124_CHANNEL_13, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */
{AD7124_CHANNEL_14, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */
{AD7124_CHANNEL_15, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_15 */
}; };
ad7124_analog_t ad7124_analog[AD7124_CHANNEL_EN_MAX] = {NULL}; // AD通道采样结构体数组，用于存放AD通道采样数据 ad7124_analog_t ad7124_analog[AD7124_CHANNEL_EN_MAX] = {NULL}; // AD通道采样结构体数组，用于存放AD通道采样数据
@ -98,54 +98,45 @@ int32_t ad7124_no_check_read_register(ad7124_st_reg_t *p_reg)
{ {
int32_t ret = 0; int32_t ret = 0;
uint8_t buffer[8] = {0, 0, 0, 0, 0, 0, 0, 0}; uint8_t buffer[8] = {0, 0, 0, 0, 0, 0, 0, 0};
uint8_t i = 0;
uint8_t add_status_length = 0; uint8_t add_status_length = 0;
uint8_t i = 0; // 添加变量声明
// 构建命令字 /* Build the Command word */
buffer[0] = AD7124_COMM_REG_RD | AD7124_COMM_REG_RA(p_reg->addr); buffer[0] = AD7124_COMM_REG_WEN | AD7124_COMM_REG_RD |
AD7124_COMM_REG_RA(p_reg->addr);
// 打印调试信息
// char uart_buf[100];
// sprintf(uart_buf, "Reading register 0x%02X, command: 0x%02X\r\n", p_reg->addr, buffer[0]);
// HAL_UART_Transmit(&huart1, (uint8_t*)uart_buf, strlen(uart_buf), 100);
/*
* If this is an AD7124_DATA register read, and the DATA_STATUS bit is set
* in ADC_CONTROL, need to read 4, not 3 bytes for DATA with STATUS
*/
if ((p_reg->addr == AD7124_DATA) && if ((p_reg->addr == AD7124_DATA) &&
(ad7124_regs[AD7124_ADC_CONTROL].value & AD7124_ADC_CTRL_REG_DATA_STATUS)) (ad7124_regs[AD7124_ADC_CONTROL].value & AD7124_ADC_CTRL_REG_DATA_STATUS))
{ {
add_status_length = 1; add_status_length = 1; // 此处是根据寄存器配置而决定,根据AD7124_ADC_CONTROL第10位决定
} }
// 从设备读取数据 /* Read data from the device */
ret = ad7124_read_write_spi(buffer, p_reg->size + 1 + add_status_length); ret = ad7124_read_write_spi(buffer, p_reg->size + 1 + add_status_length);
if (ret < 0) if (ret < 0)
return ret; return ret;
// 解析数据（buffer[1]开始为有效数据） /*
// if (p_reg->size == 1) { * if reading Data with 4 bytes, need to copy the status byte to the STATUS
// p_reg->value = buffer[1]; * register struct value member
// } else if (p_reg->size == 2) { */
// p_reg->value = ((uint16_t)buffer[1] << 8) | buffer[2];
// } else if (p_reg->size == 3) {
// p_reg->value = ((uint32_t)buffer[1] << 16) | ((uint32_t)buffer[2] << 8) | buffer[3];
// } else {
// p_reg->value = 0;
// }
p_reg->value = 0;
for (i = 1; i < p_reg->size + 1; i++)
{
p_reg->value <<= 8;
p_reg->value += buffer[i];
}
if (add_status_length) if (add_status_length)
{ {
ad7124_regs[AD7124_STATUS].value = buffer[p_reg->size + 1]; ad7124_regs[AD7124_STATUS].value = buffer[p_reg->size + 1];
} }
// 仅用于调试：如果是ID寄存器，赋值到全局变量 /* Build the result */
if (p_reg->addr == AD7124_ID) { p_reg->value = 0;
g_ad7124_id = p_reg->value; for (i = 1; i < p_reg->size + 1; i++)
{
p_reg->value <<= 8;
p_reg->value += buffer[i];
} }
return ret; return ret;
} }
@ -178,7 +169,7 @@ int32_t ad7124_no_check_write_register(ad7124_st_reg_t *reg)
/* Write data to the device */ /* Write data to the device */
ret = ad7124_read_write_spi(wr_buf, reg->size + 1); ret = ad7124_read_write_spi(wr_buf, reg->size + 1);
FINESH_ID = ret;
return ret; return ret;
} }
@ -197,17 +188,13 @@ int32_t ad7124_read_register(ad7124_st_reg_t *p_reg)
{ {
int32_t ret; int32_t ret;
// 检查寄存器地址是否不是错误地址，并且检查ERROR寄存器的SPI_IGNORE_ERR位是否被设置
if (p_reg->addr != AD7124_ERROR && (ad7124_regs[AD7124_ERROR_EN].value & AD7124_ERREN_REG_SPI_IGNORE_ERR_EN)) if (p_reg->addr != AD7124_ERROR && (ad7124_regs[AD7124_ERROR_EN].value & AD7124_ERREN_REG_SPI_IGNORE_ERR_EN))
{ {
// 读寄存器之前检查ERROR寄存器的SPI_IGNORE_ERR位 ret = ad7124_wait_for_spi_ready(AD7124_RDY); // 读寄存器之前检查ERROR寄存器的SPI_IGNORE_ERR位
ret = ad7124_wait_for_spi_ready(AD7124_RDY);
// 如果等待SPI就绪失败，则返回错误码
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
// 不检查ERROR寄存器的SPI_IGNORE_ERR位，直接读取寄存器
ret = ad7124_no_check_read_register(p_reg); ret = ad7124_no_check_read_register(p_reg);
return ret; return ret;
@ -352,7 +339,7 @@ int32_t ad7124_read_data(void)
{ {
int32_t read_data; int32_t read_data;
/* Read the value of the Status Register */ /* Read the value of the Status Register */
ad7124_read_register(&ad7124_regs[AD7124_DATA]);//读取数据寄存器 ad7124_read_register(&ad7124_regs[AD7124_DATA]);
/* Get the read result */ /* Get the read result */
read_data = ad7124_regs[AD7124_DATA].value; read_data = ad7124_regs[AD7124_DATA].value;
@ -402,32 +389,22 @@ int32_t ad7124_read_data(void)
void ad7124_get_analog(uint8_t channel_nr) void ad7124_get_analog(uint8_t channel_nr)
{ {
int32_t read_data; int32_t read_data;
// 设置AD7124寄存器，选择指定通道
// for (i = STOP_NC_ADC; i < AD7124_CHANNEL_EN_MAX; i++) // for (i = STOP_NC_ADC; i < AD7124_CHANNEL_EN_MAX; i++)
// { // {
ad7124_regs[AD7124_CHANNEL_0].value = ad7124_channel_regs[channel_nr].value; // 保存当前通道的配置
ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]); ad7124_regs[AD7124_CHANNEL_0 + channel_nr].value = ad7124_channel_regs[channel_nr].value;
ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0 + channel_nr]);
// 等待转换完成 while (ad7124_wait_for_conv_ready(AD7124_RDY)); // 等待转换完成
while (ad7124_wait_for_conv_ready(AD7124_RDY))
; // 等待转换完成
// 存储读取的模拟数据
ad7124_analog[channel_nr].channel = channel_nr; ad7124_analog[channel_nr].channel = channel_nr;
read_data = ad7124_read_data(); read_data = ad7124_read_data();
ad7124_analog[channel_nr].data = read_data; ad7124_analog[channel_nr].data = read_data;
ad7124_analog[channel_nr].voltage = (float)(read_data * VREF / GAIN / AD_CODE); // AD7124单极性计算公式：Code = (0xFFFFFF × AIN × Gain)/VREF
//ad7124_analog[channel_nr].current = (float)(ad7124_analog[channel_nr].voltage / AD7124_RES * 1000); // 乘1000是为了将单位转换为mA
// 计算电压值 // 关闭当前使用的通道
// AD7124单极性计算公式：Code = (0xFFFFFF × AIN × Gain)/VREF ad7124_regs[AD7124_CHANNEL_0 + channel_nr].value = 0;
ad7124_analog[channel_nr].voltage = (float)(read_data * VREF / GAIN / AD_CODE); ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0 + channel_nr]);
// 计算电流值，乘1000是为了将单位转换为mA
ad7124_analog[channel_nr].current = (float)(ad7124_analog[channel_nr].voltage / AD7124_RES * 1000);
// 恢复通道0寄存器为默认值
ad7124_regs[AD7124_CHANNEL_0].value = 0;
ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
// } // }
} }
/** /**
@ -441,85 +418,45 @@ int32_t ad7124_setup(void)
{ {
int32_t ret; int32_t ret;
uint8_t reg_nr; uint8_t reg_nr;
// board_spi_init(AD7124); // 初始化SPI,因为DAC161的SPI要和AD7124共用，并且时序不一样，所以要先初始化SPI接口。
// Initialize SPI /* Reset the device interface.*/
board_spi_init(AD7124);
HAL_Delay(10); // Wait for SPI to stabilize
// Reset device
ret = ad7124_reset(); ret = ad7124_reset();
if (ret < 0) if (ret < 0)
return ret; return ret;
HAL_Delay(10);
ad7124_read_register(&ad7124_regs[AD7124_ID]);//查看AD7124的ID寄存器，确认是否连接正确
// Wait after reset // 关闭所有通道
HAL_Delay(100); for (reg_nr = AD7124_CHANNEL_0; reg_nr <= AD7124_CHANNEL_15; reg_nr++)
{
// Wait for power-on ad7124_regs[reg_nr].value = 0; // 将通道寄存器值设为0，关闭通道
ret = ad7124_wait_to_power_on(AD7124_RDY);
if (ret < 0)
return ret;
// Read and verify ID register
ret = ad7124_read_register(&ad7124_regs[AD7124_ID]);
if (ret < 0)
return ret;
if ((ad7124_regs[AD7124_ID].value & 0xF0) != 0x40) {
return COMM_ERR; // Invalid ID
}
// Initialize registers in sequence
// First ADC Control register - Set to standby mode initially
ad7124_regs[AD7124_ADC_CONTROL].value =
AD7124_ADC_CTRL_REG_POWER_MODE(3) | // Full power mode
AD7124_ADC_CTRL_REG_CS_EN | // Enable chip select
AD7124_ADC_CTRL_REG_DATA_STATUS | // Enable status register
AD7124_ADC_CTRL_REG_REF_EN | // Enable reference
AD7124_ADC_CTRL_REG_MODE(0); // Continuous conversion mode initially
ret = ad7124_write_register(&ad7124_regs[AD7124_ADC_CONTROL]);
if (ret < 0)
return ret;
// Then Configuration registers
ad7124_regs[AD7124_CONFIG_0].value =
AD7124_CFG_REG_BIPOLAR | // Bipolar mode
AD7124_CFG_REG_REF_BUFP | // Reference buffer positive enabled
AD7124_CFG_REG_REF_BUFM | // Reference buffer negative enabled
AD7124_CFG_REG_AIN_BUFP | // Enable positive input buffer
AD7124_CFG_REG_AINN_BUFM | // Enable negative input buffer
AD7124_CFG_REG_REF_SEL(2) | // Use internal reference
AD7124_CFG_REG_PGA(0); // Gain = 1
ret = ad7124_write_register(&ad7124_regs[AD7124_CONFIG_0]);
if (ret < 0)
return ret;
// Then Filter registers - Set for 50Hz rejection
ad7124_regs[AD7124_FILTER_0].value =
AD7124_FILT_REG_FILTER(0) | // SINC4 filter
AD7124_FILT_REG_REJ60 | // Enable 60Hz rejection
AD7124_FILT_REG_POST_FILTER(3) | // Post filter enabled
AD7124_FILT_REG_FS(1); // Output data rate
ret = ad7124_write_register(&ad7124_regs[AD7124_FILTER_0]);
if (ret < 0)
return ret;
// Initialize all channels to disabled state
for(reg_nr = AD7124_CHANNEL_0; reg_nr <= AD7124_CHANNEL_15; reg_nr++) {
ad7124_regs[reg_nr].value = 0x0000; // Disable channel
ret = ad7124_write_register(&ad7124_regs[reg_nr]); ret = ad7124_write_register(&ad7124_regs[reg_nr]);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
// Verify ADC Control register // 设置配置寄存器为单极性模式
ret = ad7124_read_register(&ad7124_regs[AD7124_ADC_CONTROL]); ad7124_regs[AD7124_CONFIG_0].value = 0x00E0; // 清除bit 11，设置为单极性模式
if (ret < 0) ad7124_regs[AD7124_CONFIG_2].value = 0x0060; // 清除bit 11，设置为单极性模式
return ret; ad7124_regs[AD7124_CONFIG_3].value = 0x0060; // 清除bit 11，设置为单极性模式
ad7124_regs[AD7124_CONFIG_4].value = 0x0060; // 清除bit 11，设置为单极性模式
ad7124_regs[AD7124_CONFIG_5].value = 0x0060; // 清除bit 11，设置为单极性模式
ad7124_regs[AD7124_CONFIG_6].value = 0x0060; // 清除bit 11，设置为单极性模式
ad7124_regs[AD7124_CONFIG_7].value = 0x0060; // 清除bit 11，设置为单极性模式
return 0; /* Initialize registers AD7124_ADC_Control through AD7124_Filter_7. */
for (reg_nr = AD7124_STATUS; reg_nr < AD7124_OFFSET_0; reg_nr++) // 对ad7124的可写寄存器进行配置，不包括只读寄存器
{
if (ad7124_regs[reg_nr].rw == AD7124_RW)// 只写寄存器才进行写入操作
{
ret = ad7124_write_register(&ad7124_regs[reg_nr]);// 先写入寄存器值
ret = ad7124_read_register(&ad7124_regs[reg_nr]); // 读取寄存器值
if (ret < 0)
break;
}
}
HAL_GPIO_WritePin(AD7124_SYNC_GPIO_Port, AD7124_SYNC_Pin, GPIO_PIN_SET); // AD7124同步信号一直高电平状态
return ret;
} }
/** /**
@ -535,30 +472,9 @@ int32_t ad7124_setup(void)
int32_t ad7124_read_write_spi(uint8_t *buff, uint8_t length) int32_t ad7124_read_write_spi(uint8_t *buff, uint8_t length)
{ {
int32_t ret; int32_t ret;
board_spi_init(AD7124); // 初始化SPI,因为DAC161的SPI要和AD7124共用，并且时序不一样，所以要先初始化SPI接口。
// 确保CS信号在传输前是高的
board_spi_cs_off(AD7124);
HAL_Delay(1); // 添加短暂延时
// 确保SPI配置正确
board_spi_init(AD7124);
// 拉低CS开始传输
board_spi_cs_on(AD7124); board_spi_cs_on(AD7124);
HAL_Delay(1); // 添加短暂延时 ret = spi_transmit_receive(&hspi1, buff, length);
// 执行SPI传输
ret = spi_transmit_receive(&hspi2, buff, length);
// 等待最后一个字节传输完成
HAL_Delay(1);
// 拉高CS结束传输
board_spi_cs_off(AD7124); board_spi_cs_off(AD7124);
HAL_Delay(1); // 确保CS保持高电平足够长时间
return ret; return ret;
} }
// 修改SPI初始化函数

257
User/driver/ad7124.h
View File

@ -6,28 +6,14 @@
/******************************************************************************/ /******************************************************************************/
#include "main.h" #include "main.h"
#include "user_spi.h" #include "user_spi.h"
/******************************************************************************/ /******************************************************************************/
/******************* Register map and register definitions ********************/ /******************* Register map and register definitions ********************/
/******************************************************************************/ /******************************************************************************/
// 常量定义
#define AD7124_CRC8_POLYNOMIAL_REPRESENTATION 0x07 /* x8 + x2 + x + 1 */
#define AD7124_DISABLE_CRC 0
#define AD7124_USE_CRC 1
#define AD7124_RDY 10000
#define AD7124_RES 100
#define VREF 2.5f
#define GAIN 1
#define AD_CODE 0XFFFFFF
//#define AD7124_4 0x00
#define AD7124_8 0x01
/* Communication Register bits */ /* Communication Register bits */
#define AD7124_COMM_REG_WEN (0 << 7) #define AD7124_COMM_REG_WEN (0 << 7)
#define AD7124_COMM_REG_WR (0 << 6) #define AD7124_COMM_REG_WR (0 << 6)
#define AD7124_COMM_REG_RD (1 << 6) //0x40 #define AD7124_COMM_REG_RD (1 << 6)
#define AD7124_COMM_REG_RA(x) ((x) & 0x3F) #define AD7124_COMM_REG_RA(x) ((x) & 0x3F)
/* Status Register bits */ /* Status Register bits */
@ -151,7 +137,6 @@
/* Configuration Registers 0-7 bits */ /* Configuration Registers 0-7 bits */
#define AD7124_CFG_REG_BIPOLAR (1 << 11) #define AD7124_CFG_REG_BIPOLAR (1 << 11)
#define AD7124_CFG_REG_UNIPOLAR (0 << 11) // 单极性
#define AD7124_CFG_REG_BURNOUT(x) (((x) & 0x3) << 9) #define AD7124_CFG_REG_BURNOUT(x) (((x) & 0x3) << 9)
#define AD7124_CFG_REG_REF_BUFP (1 << 8) #define AD7124_CFG_REG_REF_BUFP (1 << 8)
#define AD7124_CFG_REG_REF_BUFM (1 << 7) #define AD7124_CFG_REG_REF_BUFM (1 << 7)
@ -174,127 +159,159 @@
/*! AD7124 registers list*/ /*! AD7124 registers list*/
typedef enum typedef enum
{ {
AD7124_STATUS = 0X00,//状态寄存器 AD7124_STATUS = 0X00, // 只读的状态寄存器，读取芯片状态
AD7124_ADC_CONTROL,//ADC控制寄存器 AD7124_ADC_CONTROL, // 控制寄存器，设置采样速率等
AD7124_DATA,//数据寄存器 AD7124_DATA, // 数据寄存器，读取采样数据
AD7124_IOCON1,//IO控制寄存器1 AD7124_IOCON1, // 设置激励电流等参数，用作RTD测试时可用
AD7124_IOCON2,//IO控制寄存器2 AD7124_IOCON2, // 使能偏置电压
AD7124_ID,//ID寄存器 AD7124_ID, // ID寄存器，部分芯片的ID和手册上有所区别，可用此寄存器测试SPI通讯
AD7124_ERROR,//错误寄存器 AD7124_ERROR, // 错误寄存器，读取错误信息，读写寄存器之前先读下该寄存器，检测芯片状态是否支持读写
AD7124_ERROR_EN,//错误使能寄存器 AD7124_ERROR_EN, // 通过使能该寄存器的相应位来使能或者禁用诊断功能
AD7124_MCLK_COUNT,//MCLK计数寄存器 AD7124_MCLK_COUNT, // 监控主时钟频率
AD7124_CHANNEL_0,//通道0 AD7124_CHANNEL_0, // 设置AD采样通道和所需要的配置，其中的Setup位决定了采用哪种Config、Filter、Offset、Gain寄存器的配置；共有八种配置
AD7124_CHANNEL_1,//通道1 AD7124_CHANNEL_1, // 通道寄存器的顺序并不是从AI0引脚读到最后一个引脚，而是通过自己的设置来决定顺序
AD7124_CHANNEL_2,//通道2 AD7124_CHANNEL_2,
AD7124_CHANNEL_3,//通道3 AD7124_CHANNEL_3,
AD7124_CHANNEL_4,//通道4 AD7124_CHANNEL_4,
AD7124_CHANNEL_5,//通道5 AD7124_CHANNEL_5,
AD7124_CHANNEL_6,//通道6 AD7124_CHANNEL_6,
AD7124_CHANNEL_7,//通道7 AD7124_CHANNEL_7,
AD7124_CHANNEL_8,//通道8 AD7124_CHANNEL_8,
AD7124_CHANNEL_9,//通道9 AD7124_CHANNEL_9,
AD7124_CHANNEL_10,//通道10 AD7124_CHANNEL_10,
AD7124_CHANNEL_11,//通道11 AD7124_CHANNEL_11,
AD7124_CHANNEL_12,//通道12 AD7124_CHANNEL_12,
AD7124_CHANNEL_13,//通道13 AD7124_CHANNEL_13,
AD7124_CHANNEL_14,//通道14 AD7124_CHANNEL_14,
AD7124_CHANNEL_15,//通道15 AD7124_CHANNEL_15,
AD7124_CONFIG_0,//配置寄存器0 AD7124_CONFIG_0, // 配置极性，增益，基准选择等参数
AD7124_CONFIG_1,//配置寄存器1 AD7124_CONFIG_1,
AD7124_CONFIG_2,//配置寄存器2 AD7124_CONFIG_2,
AD7124_CONFIG_3,//配置寄存器3 AD7124_CONFIG_3,
AD7124_CONFIG_4,//配置寄存器4 AD7124_CONFIG_4,
AD7124_CONFIG_5,//配置寄存器5 AD7124_CONFIG_5,
AD7124_CONFIG_6,//配置寄存器6 AD7124_CONFIG_6,
AD7124_CONFIG_7,//配置寄存器7 AD7124_CONFIG_7,
AD7124_FILTER_0,//滤波寄存器0 AD7124_FILTER_0,
AD7124_FILTER_1,//滤波寄存器1 AD7124_FILTER_1, // 配置滤波器
AD7124_FILTER_2,//滤波寄存器2 AD7124_FILTER_2,
AD7124_FILTER_3,//滤波寄存器3 AD7124_FILTER_3,
AD7124_FILTER_4,//滤波寄存器4 AD7124_FILTER_4,
AD7124_FILTER_5,//滤波寄存器5 AD7124_FILTER_5,
AD7124_FILTER_6,//滤波寄存器6 AD7124_FILTER_6,
AD7124_FILTER_7,//滤波寄存器7 AD7124_FILTER_7,
AD7124_OFFSET_0,//偏移寄存器0 AD7124_OFFSET_0,
AD7124_OFFSET_1,//偏移寄存器1 AD7124_OFFSET_1,
AD7124_OFFSET_2,//偏移寄存器2 AD7124_OFFSET_2,
AD7124_OFFSET_3,//偏移寄存器3 AD7124_OFFSET_3,
AD7124_OFFSET_4,//偏移寄存器4 AD7124_OFFSET_4,
AD7124_OFFSET_5,//偏移寄存器5 AD7124_OFFSET_5,
AD7124_OFFSET_6,//偏移寄存器6 AD7124_OFFSET_6,
AD7124_OFFSET_7,//偏移寄存器7 AD7124_OFFSET_7,
AD7124_GAIN_0,//增益寄存器0 AD7124_GAIN_0,
AD7124_GAIN_1,//增益寄存器1 AD7124_GAIN_1,
AD7124_GAIN_2,//增益寄存器2 AD7124_GAIN_2,
AD7124_GAIN_3,//增益寄存器3 AD7124_GAIN_3,
AD7124_GAIN_4,//增益寄存器4 AD7124_GAIN_4,
AD7124_GAIN_5,//增益寄存器5 AD7124_GAIN_5,
AD7124_GAIN_6,//增益寄存器6 AD7124_GAIN_6,
AD7124_GAIN_7,//增益寄存器7 AD7124_GAIN_7,
AD7124_REG_NO//寄存器数量 AD7124_REG_NO
} ad7124_registers_addr_e; } ad7124_registers_addr_e; // 寄存器地址
typedef enum typedef enum
{ {
AD7124_SIZE_1 = 1, AD7124_SIZE_1 = 1,
AD7124_SIZE_2 = 2, AD7124_SIZE_2 = 2,
AD7124_SIZE_3 = 3, AD7124_SIZE_3 = 3,
} ad7124_registers_size_e; } ad7124_registers_size_e; // 寄存器字节大小
typedef enum typedef enum
{ {
AD7124_RW = 1,//读写 AD7124_RW = 1,
AD7124_R = 2,//读 AD7124_R = 2,
AD7124_W = 3,//写 AD7124_W = 3,
} ad7124_registers_rw_e; } ad7124_registers_rw_e; // 寄存器读写操作
typedef struct typedef struct
{ {
int addr; int addr; // 寄存器地址，ad7124_registers_e
int value; int value; // 寄存器值
int size; int size; // 寄存器字节大小
int rw; int rw; // 寄存器可执行的操作，ad7124_registers_rw_e
} ad7124_st_reg_t; } ad7124_st_reg_t; // AD7124寄存器结构体
typedef enum typedef enum
{ {
STOP_NC_ADC = 0,
STOP_NO_ADC, AI_IN0_ADC = 0, // AD7124_CHANNEL_EN_0
AI_IN1_ADC, AI_IN1_ADC, // AD7124_CHANNEL_EN_1
AI_IN2_ADC, AI_IN2_ADC, // AD7124_CHANNEL_EN_2
P1_DI2_ADC, AI_IN3_ADC, // AD7124_CHANNEL_EN_3
P1_DI1_ADC, AI_IN4_ADC, // AD7124_CHANNEL_EN_4
P1_AI_ADC, AI_IN5_ADC, // AD7124_CHANNEL_EN_5
P2_DI2_ADC, AI_IN6_ADC, // AD7124_CHANNEL_EN_6
P2_DI1_ADC, AI_IN7_ADC, // AD7124_CHANNEL_EN_7
P2_AI_ADC, AI_IN8_ADC, // AD7124_CHANNEL_EN_8
AI_IN9_ADC, // AD7124_CHANNEL_EN_9
AI_IN10_ADC, // AD7124_CHANNEL_EN_10
AI_IN11_ADC, // AD7124_CHANNEL_EN_11
AI_IN12_ADC, // AD7124_CHANNEL_EN_12
AI_IN13_ADC, // AD7124_CHANNEL_EN_13
AI_IN14_ADC, // AD7124_CHANNEL_EN_14
AI_IN15_ADC, // AD7124_CHANNEL_EN_15
AD7124_CHANNEL_EN_MAX, AD7124_CHANNEL_EN_MAX,
} ad7124_channel_e; } ad7124_channel_e; // 该项目所使用的通道
typedef struct typedef struct
{ {
uint8_t channel; uint8_t channel;
int32_t data; int32_t data; // 采样数据
float voltage; float voltage; // 电压值
float current; float current; // 电流值
} ad7124_analog_t; } ad7124_analog_t; // 采样数据结构体
// 声明外部变量 #define AD7124_CRC8_POLYNOMIAL_REPRESENTATION 0x07 /* x8 + x2 + x + 1 */
extern ad7124_st_reg_t ad7124_regs[AD7124_REG_NO]; #define AD7124_DISABLE_CRC 0 // 默认关闭校验
extern ad7124_st_reg_t ad7124_channel_regs[AD7124_CHANNEL_EN_MAX]; #define AD7124_USE_CRC 1
extern int32_t g_ad7124_id;
// 函数声明
int32_t ad7124_read_register(ad7124_st_reg_t *p_reg);//读取寄存器
int32_t ad7124_write_register(ad7124_st_reg_t *reg);//写入寄存器
int32_t ad7124_no_check_read_register(ad7124_st_reg_t *p_reg);//不检查读取寄存器
int32_t ad7124_no_check_write_register(ad7124_st_reg_t *reg);//不检查写入寄存器
int32_t ad7124_reset(void);//复位
int32_t ad7124_wait_for_spi_ready(uint32_t timeout);//等待SPI准备好
int32_t ad7124_wait_to_power_on(uint32_t timeout);//等待电源开启
int32_t ad7124_wait_for_conv_ready(uint32_t timeout);//等待转换准备好
int32_t ad7124_read_data(void);//读取数据
void ad7124_get_analog(uint8_t channel_nr);//获取模拟量
int32_t ad7124_setup(void);//设置
int32_t ad7124_read_write_spi(uint8_t *buff, uint8_t length);//读写SPI
#endif /* __AD7124_H */ #define AD7124_RDY 10000 // 等待时间
#define AD7124_RES 100 // 采样基准电阻
#define VREF 2.5f // 基准电压
#define GAIN 1 // 增益，该值和配置寄存器有关
//#define AD_CODE 0XFFFFFF // 24位ADC
#define AD_CODE 0X7FFFFF // 23位ADC
/*! Reads the value of the specified register. */
int32_t ad7124_read_register(ad7124_st_reg_t *p_reg); // 读寄存器
/*! Writes the value of the specified register. */
int32_t ad7124_write_register(ad7124_st_reg_t *reg); // 写寄存器
/*! Reads the value of the specified register without a device state check. */
int32_t ad7124_no_check_read_register(ad7124_st_reg_t *p_reg);
/*! Writes the value of the specified register without a device state check. */
int32_t ad7124_no_check_write_register(ad7124_st_reg_t *reg);
/*! Resets the device. */
int32_t ad7124_reset(void); // 复位ad7124芯片
/*! Waits until the device can accept read and write user actions. */
int32_t ad7124_wait_for_spi_ready(uint32_t timeout); // 读取ad7124芯片状态，直到可以执行读写操作
/*! Waits until the device finishes the power-on reset operation. */
int32_t ad7124_wait_to_power_on(uint32_t timeout);
/*! Waits until a new conversion result is available. */
int32_t ad7124_wait_for_conv_ready(uint32_t timeout); // 等待转换完成
/*! Reads the conversion result from the device. */
int32_t ad7124_read_data(void);
void ad7124_get_analog(uint8_t channel_nr);
/*! Initializes the AD7124. */
int32_t ad7124_setup(void);
int32_t ad7124_read_write_spi(uint8_t *buff, uint8_t length);
#endif /* __AD7124_H__ */

2
User/system/user_spi.c
View File

@ -31,7 +31,7 @@ void ad7124_spi_init(void)
hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH; // CPOL = 1 hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH; // CPOL = 1
hspi2.Init.CLKPhase = SPI_PHASE_2EDGE; // CPHA = 1 hspi2.Init.CLKPhase = SPI_PHASE_2EDGE; // CPHA = 1
hspi2.Init.NSS = SPI_NSS_SOFT; hspi2.Init.NSS = SPI_NSS_SOFT;
hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; // 降低速度以确保稳定性 hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; // 降低速度以确保稳定性
hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB; hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi2.Init.TIMode = SPI_TIMODE_DISABLE; hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;