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

AD7124开发完成，16通道都可采集数据并发送到上位机。

This commit is contained in:
qiuxin 2025-05-21 20:32:02 +08:00
parent 69b41c5f5f
commit 250abb4bda
15 changed files with 411 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Core/Inc/spi.h
View File

@ -33,12 +33,14 @@ extern "C" {
/* USER CODE END Includes */ /* USER CODE END Includes */
extern SPI_HandleTypeDef hspi1; extern SPI_HandleTypeDef hspi1;
extern SPI_HandleTypeDef hspi2;
/* USER CODE BEGIN Private defines */ /* USER CODE BEGIN Private defines */
/* USER CODE END Private defines */ /* USER CODE END Private defines */
void MX_SPI1_Init(void); void MX_SPI1_Init(void);
void MX_SPI2_Init(void);
/* USER CODE BEGIN Prototypes */ /* USER CODE BEGIN Prototypes */

36
Core/Src/freertos.c
View File

@ -94,6 +94,7 @@ 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); void start_adc_task(void const *argument);
void test_cs_pin(void);
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) */
@ -296,8 +297,8 @@ void start_dac_task(void const *argument)
/* USER CODE BEGIN Header_start_adc_task */ /* USER CODE BEGIN Header_start_adc_task */
/** /**
* @brief Function implementing the adc_task thread. * @brief ADC任务函数实现
* @param argument: Not used * @param argument: 未使用
* @retval None * @retval None
*/ */
/* USER CODE END Header_start_adc_task */ /* USER CODE END Header_start_adc_task */
@ -308,15 +309,14 @@ void start_adc_task(void const *argument)
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
//osThreadSuspend(dac_taskHandle); // 暂停DAC任务，防止ADC采集时产生干????????,因为ADC和DAC采用的是同一路SPI，但是时序不????????
uint8_t ch = 0; uint8_t ch = 0;
for (ch = AI_IN0_ADC; ch < AD7124_CHANNEL_EN_MAX; ch++) for (ch = AD7124_AIN0; ch < AD7124_CHANNEL_EN_MAX; ch++)
{ {
ad7124_get_analog(ch); ad7124_get_analog(ch);
} }
//communication_reset_hart();
//osThreadResume(dac_taskHandle); vTaskDelay(10);
vTaskDelay(100);
} }
/* USER CODE END start_adc_task */ /* USER CODE END start_adc_task */
} }
@ -523,3 +523,25 @@ extern int32_t g_ad7124_id;
// /* USER CODE END start_adc_task */ // /* USER CODE END start_adc_task */
// } // }
/* USER CODE END Application */ /* USER CODE END Application */
/**
* @brief 测试CS引脚的功能
*
* 这个函数将不断地尝试拉低和拉高CS引脚，并读取其状态。
* 它主要用于测试硬件连接和引脚操作的正确性。
*
* @return 无返回值
*/
void test_cs_pin(void)
{
while (1) {
ad7124_cs_on(); // 尝试拉低
GPIO_PinState state = HAL_GPIO_ReadPin(SPI2_CS_GPIO_Port, SPI2_CS_Pin);
// 打印或观察state值，应该是GPIO_PIN_RESET
HAL_Delay(100);
ad7124_cs_off(); // 尝试拉高
state = HAL_GPIO_ReadPin(SPI2_CS_GPIO_Port, SPI2_CS_Pin);
// 打印或观察state值，应该是GPIO_PIN_SET
HAL_Delay(100);
}
}

7
Core/Src/gpio.c
View File

@ -149,6 +149,13 @@ void MX_GPIO_Init(void)
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(SPI2_CS_GPIO_Port, &GPIO_InitStruct); HAL_GPIO_Init(SPI2_CS_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET); // 初始状态不选中 HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET); // 初始状态不选中
// CS (PD11) - 配置为输出
GPIO_InitStruct.Pin = SPI2_CS_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(SPI2_CS2_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_WritePin(SPI2_CS2_GPIO_Port, SPI2_CS2_Pin, GPIO_PIN_SET); // 初始状态不选中
/*Configure GPIO pins : PCPin PCPin */ /*Configure GPIO pins : PCPin PCPin */
GPIO_InitStruct.Pin = DI_CH1_Pin|DI_CH2_Pin; GPIO_InitStruct.Pin = DI_CH1_Pin|DI_CH2_Pin;

2
Core/Src/main.c
View File

@ -137,7 +137,7 @@ int main(void)
MX_USART1_UART_Init(); MX_USART1_UART_Init();
MX_TIM8_Init(); MX_TIM8_Init();
/* USER CODE BEGIN 2 */ /* USER CODE BEGIN 2 */
ad7124_spi_init(); //初始化AD7124芯片的SPI2通讯口 //board_spi_init(AD7124); // Initialize SPI2 for AD7124 using the unified initialization function
/*DMA INIT*/ /*DMA INIT*/
// start // start
HAL_UARTEx_ReceiveToIdle_DMA(&huart4, lcd_uart4.rx_data_temp, ARRAY_LEN(lcd_uart4.rx_data_temp)); HAL_UARTEx_ReceiveToIdle_DMA(&huart4, lcd_uart4.rx_data_temp, ARRAY_LEN(lcd_uart4.rx_data_temp));

92
MDK-ARM/controller_pcba.uvoptx
View File

@ -148,24 +148,7 @@
<Name>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0STM32F4xx_1024 -FS08000000 -FL0100000 -FP0($$Device:STM32F407VGTx$CMSIS\Flash\STM32F4xx_1024.FLM))</Name> <Name>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0STM32F4xx_1024 -FS08000000 -FL0100000 -FP0($$Device:STM32F407VGTx$CMSIS\Flash\STM32F4xx_1024.FLM))</Name>
</SetRegEntry> </SetRegEntry>
</TargetDriverDllRegistry> </TargetDriverDllRegistry>
<Breakpoint> <Breakpoint/>
<Bp>
<Number>0</Number>
<Type>0</Type>
<LineNumber>401</LineNumber>
<EnabledFlag>1</EnabledFlag>
<Address>134243228</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>..\User\driver\ad7124.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\semi_finished_product_testing\../User/driver/ad7124.c\401</Expression>
</Bp>
</Breakpoint>
<WatchWindow1> <WatchWindow1>
<Ww> <Ww>
<count>0</count> <count>0</count>
@ -190,22 +173,22 @@
<Ww> <Ww>
<count>4</count> <count>4</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>wr_buf[0]</ItemText> <ItemText>FINESH_ID</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>5</count> <count>5</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>FINESH_ID</ItemText> <ItemText>ret</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>6</count> <count>6</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>ret</ItemText> <ItemText>g_channel_config</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>7</count> <count>7</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>g_adc_data</ItemText> <ItemText>ad7124_regs[5].value</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>8</count> <count>8</count>
@ -215,62 +198,27 @@
<Ww> <Ww>
<count>9</count> <count>9</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>g_channel_config</ItemText> <ItemText>g_adc_data</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>10</count> <count>10</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>g_channel_status</ItemText> <ItemText>g_adc_state</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>11</count> <count>11</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>g_config_0</ItemText> <ItemText>g_adc_control</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>12</count> <count>12</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>g_filter_0</ItemText> <ItemText>wr_buf[8]</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>13</count> <count>13</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>ad7124_regs[5].value</ItemText> <ItemText>ad7124_analog[channel_nr].voltage</ItemText>
</Ww>
<Ww>
<count>14</count>
<WinNumber>1</WinNumber>
<ItemText>g_ad7124_id</ItemText>
</Ww>
<Ww>
<count>15</count>
<WinNumber>1</WinNumber>
<ItemText>g_adc_error</ItemText>
</Ww>
<Ww>
<count>16</count>
<WinNumber>1</WinNumber>
<ItemText>g_adc_data</ItemText>
</Ww>
<Ww>
<count>17</count>
<WinNumber>1</WinNumber>
<ItemText>g_adc_state</ItemText>
</Ww>
<Ww>
<count>18</count>
<WinNumber>1</WinNumber>
<ItemText>g_adc_control</ItemText>
</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> </Ww>
</WatchWindow1> </WatchWindow1>
<Tracepoint> <Tracepoint>
@ -347,7 +295,7 @@
<Group> <Group>
<GroupName>Application/User/Core</GroupName> <GroupName>Application/User/Core</GroupName>
<tvExp>0</tvExp> <tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel> <cbSel>0</cbSel>
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>
@ -2039,6 +1987,18 @@
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>
<bShared>0</bShared> <bShared>0</bShared>
</File> </File>
<File>
<GroupNumber>12</GroupNumber>
<FileNumber>136</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\User\driver\delay.c</PathWithFileName>
<FilenameWithoutPath>delay.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group> </Group>
<Group> <Group>
@ -2049,7 +2009,7 @@
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>
<File> <File>
<GroupNumber>13</GroupNumber> <GroupNumber>13</GroupNumber>
<FileNumber>136</FileNumber> <FileNumber>137</FileNumber>
<FileType>1</FileType> <FileType>1</FileType>
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
@ -2061,7 +2021,7 @@
</File> </File>
<File> <File>
<GroupNumber>13</GroupNumber> <GroupNumber>13</GroupNumber>
<FileNumber>137</FileNumber> <FileNumber>138</FileNumber>
<FileType>1</FileType> <FileType>1</FileType>
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
@ -2073,7 +2033,7 @@
</File> </File>
<File> <File>
<GroupNumber>13</GroupNumber> <GroupNumber>13</GroupNumber>
<FileNumber>138</FileNumber> <FileNumber>139</FileNumber>
<FileType>1</FileType> <FileType>1</FileType>
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>

5
MDK-ARM/controller_pcba.uvprojx
View File

@ -1113,6 +1113,11 @@
<FileType>1</FileType> <FileType>1</FileType>
<FilePath>..\User\driver\uart_lcd.c</FilePath> <FilePath>..\User\driver\uart_lcd.c</FilePath>
</File> </File>
<File>
<FileName>delay.c</FileName>
<FileType>1</FileType>
<FilePath>..\User\driver\delay.c</FilePath>
</File>
</Files> </Files>
</Group> </Group>
<Group> <Group>

2
User/application/src/communication_protocol.c
View File

@ -39,7 +39,7 @@ void communication_get_ai(communication_ai_t *ai_data, uint8_t *tx_data, const u
{ {
float32_u analog_data; float32_u analog_data;
uint8_t tx_data_len = COM_AI_DATA_SIZE; uint8_t tx_data_len = COM_AI_DATA_SIZE;
analog_data.f = S2B_FLOAT32(ad7124_analog[ai_data->channel].current); analog_data.f = S2B_FLOAT32(ad7124_analog[ai_data->channel].voltage);
tx_data[0] = FRAME_HEAD; // 帧头 tx_data[0] = FRAME_HEAD; // 帧头
tx_data[1] = COM_OK; // 状态 tx_data[1] = COM_OK; // 状态
tx_data[2] = rx_data[2]; // 设备号 tx_data[2] = rx_data[2]; // 设备号

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

@ -433,9 +433,21 @@ uint16_t total_len = 2 + 2 + 2 + 2 + 1 + 74 + 2; // 帧头+帧长+源+目标+类
// 报文类型 // 报文类型
tx[8] = reply_type; tx[8] = reply_type;
// 7字节使能状态（直接复制 body 到 tx[9]~tx[15]） tx[9] = 0x00; //io通道0-15
//memcpy(&tx[9], body, 74); // 确保 body 是74字节 tx[10] = 0x00; //io通道0-15
// 填充AD7124原始数据到tx[11]~tx[75]，每通道4字节，MSB格式
extern ad7124_analog_t ad7124_analog[AD7124_CHANNEL_EN_MAX];
for (int ch = 0; ch < AD7124_CHANNEL_EN_MAX; ++ch) {
int32_t data = ad7124_analog[ch].data;
tx[11 + ch * 4 + 0] = (data >> 24) & 0xFF;
tx[11 + ch * 4 + 1] = (data >> 16) & 0xFF;
tx[11 + ch * 4 + 2] = (data >> 8) & 0xFF;
tx[11 + ch * 4 + 3] = (data) & 0xFF;
}
// 其余tx[73]~tx[82]可按需要填充（如比例阀等），此处保持原样或补零
for (int i = 11 + AD7124_CHANNEL_EN_MAX * 4; i < 83; ++i) {
tx[i] = 0;
}
// 校验和 // 校验和
uint16_t checksum = 0; uint16_t checksum = 0;
for (int i = 4; i < 84; ++i) // 4~83（源地址+目标地址+类型+74字节） for (int i = 4; i < 84; ++i) // 4~83（源地址+目标地址+类型+74字节）

167
User/driver/ad7124.c
View File

@ -4,7 +4,8 @@
#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 */
// 配置ad7124寄存器的值，根据实际项目需求配置 // 配置ad7124寄存器的值，根据实际项目的电路图进行配置，
//比如单极性测量电压，AINM需要接AVSS，参见AD7124手册P87,AINP=0,AINM=17,需要配置{AD7124_CHANNEL_0, 0x0011, AD7124_SIZE_2, AD7124_RW},
static 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, 0x0280, AD7124_SIZE_2, AD7124_RW}, /* AD7124_ADC_Control */ {AD7124_ADC_CONTROL, 0x0280, AD7124_SIZE_2, AD7124_RW}, /* AD7124_ADC_Control */
@ -15,30 +16,30 @@ static ad7124_st_reg_t ad7124_regs[AD7124_REG_NO] = {
{AD7124_ERROR, 0x000000, AD7124_SIZE_3, AD7124_R}, /* AD7124_Error */ {AD7124_ERROR, 0x000000, AD7124_SIZE_3, AD7124_R}, /* AD7124_Error */
{AD7124_ERROR_EN, 0x000040, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Error_En */ {AD7124_ERROR_EN, 0x000040, AD7124_SIZE_3, AD7124_RW}, /* AD7124_Error_En */
{AD7124_MCLK_COUNT, 0x00, AD7124_SIZE_1, AD7124_R}, /* AD7124_Mclk_Count */ {AD7124_MCLK_COUNT, 0x00, AD7124_SIZE_1, AD7124_R}, /* AD7124_Mclk_Count */
{AD7124_CHANNEL_0, 0x0051, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_0 */ {AD7124_CHANNEL_0, 0x0011, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_0 */
{AD7124_CHANNEL_1, 0x0071, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_1 */ {AD7124_CHANNEL_1, 0x0031, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_1 */
{AD7124_CHANNEL_2, 0x0091, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_2 */ {AD7124_CHANNEL_2, 0x0051, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_2 */
{AD7124_CHANNEL_3, 0x00B1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_3 */ {AD7124_CHANNEL_3, 0x0071, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_3 */
{AD7124_CHANNEL_4, 0x00D1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_4 */ {AD7124_CHANNEL_4, 0x0091, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_4 */
{AD7124_CHANNEL_5, 0x00F1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_5 */ {AD7124_CHANNEL_5, 0x00B1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_5 */
{AD7124_CHANNEL_6, 0x0111, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_6 */ {AD7124_CHANNEL_6, 0x00D1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_6 */
{AD7124_CHANNEL_7, 0x0131, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_7 */ {AD7124_CHANNEL_7, 0x00F1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_7 */
{AD7124_CHANNEL_8, 0x0151, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_8 */ {AD7124_CHANNEL_8, 0x0111, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_8 */
{AD7124_CHANNEL_9, 0x0171, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_9 */ {AD7124_CHANNEL_9, 0x0131, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_9 */
{AD7124_CHANNEL_10, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_10 */ {AD7124_CHANNEL_10, 0x0151, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_10 */
{AD7124_CHANNEL_11, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_11 */ {AD7124_CHANNEL_11, 0x0171, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_11 */
{AD7124_CHANNEL_12, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_12 */ {AD7124_CHANNEL_12, 0x0191, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_12 */
{AD7124_CHANNEL_13, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */ {AD7124_CHANNEL_13, 0x01B1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */
{AD7124_CHANNEL_14, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */ {AD7124_CHANNEL_14, 0x01D1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */
{AD7124_CHANNEL_15, 0x0001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_15 */ {AD7124_CHANNEL_15, 0x01F1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_15 */
{AD7124_CONFIG_0, 0x00E0, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_0 - 单极性模式 */ {AD7124_CONFIG_0, 0x01E0, 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, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_2 - 单极性模式 */ {AD7124_CONFIG_2, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_2 */
{AD7124_CONFIG_3, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_3 - 单极性模式 */ {AD7124_CONFIG_3, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_3 */
{AD7124_CONFIG_4, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_4 - 单极性模式 */ {AD7124_CONFIG_4, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_4 */
{AD7124_CONFIG_5, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_5 - 单极性模式 */ {AD7124_CONFIG_5, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_5 */
{AD7124_CONFIG_6, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_6 - 单极性模式 */ {AD7124_CONFIG_6, 0x0860, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_6 */
{AD7124_CONFIG_7, 0x0060, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Config_7 - 单极性模式 */ {AD7124_CONFIG_7, 0x0860, 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 */
@ -66,24 +67,25 @@ static ad7124_st_reg_t ad7124_regs[AD7124_REG_NO] = {
}; };
static 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, 0x8011, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_0 */
{AD7124_CHANNEL_1, 0x8071, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_1 */ {AD7124_CHANNEL_1, 0x8031, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_1 */
{AD7124_CHANNEL_2, 0x8091, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_2 */ {AD7124_CHANNEL_2, 0x8051, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_2 */
{AD7124_CHANNEL_3, 0x80B1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_3 */ {AD7124_CHANNEL_3, 0x8071, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_3 */
{AD7124_CHANNEL_4, 0x80D1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_4 */ {AD7124_CHANNEL_4, 0x8091, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_4 */
{AD7124_CHANNEL_5, 0x80F1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_5 */ {AD7124_CHANNEL_5, 0x80B1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_5 */
{AD7124_CHANNEL_6, 0x8111, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_6 */ {AD7124_CHANNEL_6, 0x80D1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_6 */
{AD7124_CHANNEL_7, 0x8131, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_7 */ {AD7124_CHANNEL_7, 0x80F1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_7 */
{AD7124_CHANNEL_8, 0x8151, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_8 */ {AD7124_CHANNEL_8, 0x8111, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_8 */
{AD7124_CHANNEL_9, 0x8171, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_9 */ {AD7124_CHANNEL_9, 0x8131, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_9 */
{AD7124_CHANNEL_10, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_10 */ {AD7124_CHANNEL_10, 0x8151, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_10 */
{AD7124_CHANNEL_11, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_11 */ {AD7124_CHANNEL_11, 0x8171, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_11 */
{AD7124_CHANNEL_12, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_12 */ {AD7124_CHANNEL_12, 0x8191, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_12 */
{AD7124_CHANNEL_13, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */ {AD7124_CHANNEL_13, 0x81B1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_13 */
{AD7124_CHANNEL_14, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */ {AD7124_CHANNEL_14, 0x81D1, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_14 */
{AD7124_CHANNEL_15, 0x8001, AD7124_SIZE_2, AD7124_RW}, /* AD7124_Channel_15 */ {AD7124_CHANNEL_15, 0x81F1, 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通道采样数据
/** /**
* @brief 无校验读取AD7124寄存器 * @brief 无校验读取AD7124寄存器
@ -345,66 +347,25 @@ int32_t ad7124_read_data(void)
return read_data; return read_data;
} }
/**
* @brief 从AD7124获取模拟信号数据
*
* 该函数通过SPI接口从AD7124芯片获取模拟信号数据，并将数据保存到ad7124_analog中。
*
* @details
* - 遍历所有模拟通道，对每个通道执行以下操作：
* - 等待AD7124完成转换。
* - 读取转换后的数据。
* - 计算电压值（单极性计算公式）。
* - 计算电流值（基于电压值和电阻值），有的通道没有电流值可以忽略。
*
* @note
* - 转换完成后，通过公式计算电压和电流值，并将结果保存到全局数组ad7124_analog中。
* - 电压计算公式：Code = (0xFFFFFF × AIN × Gain)/VREF，其中VREF为参考电压，GAIN为增益，AD_CODE为AD代码。
* - 电流计算公式：电流 = 电压 / 电阻 * 1000，其中电阻值为AD7124_RES，单位转换为mA。
*/
// void ad7124_get_analog(void)
// {
// int32_t read_data;
// uint8_t i;
// uint8_t channel;
// // for (i = STOP_NC_ADC; i < AD7124_CHANNEL_EN_MAX; i++)
// // {
// // ad7124_regs[AD7124_CHANNEL_0].value = ad7124_channel_regs[i].value;
// // ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
// // ad7124_read_register(&ad7124_regs[AD7124_STATUS]);
// while (ad7124_wait_for_conv_ready(AD7124_RDY))
// ; // 等待转换完成
// channel = ad7124_regs[AD7124_STATUS].value;
// ad7124_analog[channel].channel = channel;
// read_data = ad7124_read_data();
// ad7124_analog[channel].data = read_data;
// ad7124_analog[channel].voltage = (float)(read_data * VREF / GAIN / AD_CODE); // AD7124单极性计算公式：Code = (0xFFFFFF × AIN × Gain)/VREF
// ad7124_analog[channel].current = (float)(ad7124_analog[channel].voltage / AD7124_RES * 1000); // 乘1000是为了将单位转换为mA
// // ad7124_regs[AD7124_CHANNEL_0].value = 0;
// // ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
// // }
// }
void ad7124_get_analog(uint8_t channel_nr) void ad7124_get_analog(uint8_t channel_nr)
{ {
int32_t read_data; int32_t read_data;
// 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_regs[AD7124_CHANNEL_0 + channel_nr].value = ad7124_channel_regs[channel_nr].value; ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
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].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_analog[channel_nr].current = (float)(ad7124_analog[channel_nr].voltage / AD7124_RES * 1000); // 乘1000是为了将单位转换为mA
// 关闭当前使用的通道 ad7124_regs[AD7124_CHANNEL_0].value = 0;
ad7124_regs[AD7124_CHANNEL_0 + channel_nr].value = 0; ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0]);
ad7124_write_register(&ad7124_regs[AD7124_CHANNEL_0 + channel_nr]);
// } // }
} }
/** /**
@ -424,38 +385,20 @@ int32_t ad7124_setup(void)
if (ret < 0) if (ret < 0)
return ret; return ret;
HAL_Delay(10); HAL_Delay(10);
ad7124_read_register(&ad7124_regs[AD7124_ID]);//查看AD7124的ID寄存器，确认是否连接正确 ad7124_read_register(&ad7124_regs[AD7124_ID]);
// 关闭所有通道
for (reg_nr = AD7124_CHANNEL_0; reg_nr <= AD7124_CHANNEL_15; reg_nr++)
{
ad7124_regs[reg_nr].value = 0; // 将通道寄存器值设为0，关闭通道
ret = ad7124_write_register(&ad7124_regs[reg_nr]);
if (ret < 0)
return ret;
}
// 设置配置寄存器为单极性模式
ad7124_regs[AD7124_CONFIG_0].value = 0x00E0; // 清除bit 11，设置为单极性模式
ad7124_regs[AD7124_CONFIG_2].value = 0x0060; // 清除bit 11，设置为单极性模式
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，设置为单极性模式
/* Initialize registers AD7124_ADC_Control through AD7124_Filter_7. */ /* Initialize registers AD7124_ADC_Control through AD7124_Filter_7. */
for (reg_nr = AD7124_STATUS; reg_nr < AD7124_OFFSET_0; reg_nr++) // 对ad7124的可写寄存器进行配置，不包括只读寄存器 for (reg_nr = AD7124_STATUS; reg_nr < AD7124_OFFSET_0; reg_nr++) //循环写入寄存器，从AD7124_STATUS到AD7124_OFFSET_0
{ {
if (ad7124_regs[reg_nr].rw == AD7124_RW)// 只写寄存器才进行写入操作 // ret = ad7124_read_register(&ad7124_regs[reg_nr]);
if (ad7124_regs[reg_nr].rw == AD7124_RW)
{ {
ret = ad7124_write_register(&ad7124_regs[reg_nr]);// 先写入寄存器值 ret = ad7124_write_register(&ad7124_regs[reg_nr]);//对AD7124的寄存器进行配置，包括ADC控制寄存器、滤波器配置等。
ret = ad7124_read_register(&ad7124_regs[reg_nr]); // 读取寄存器值 ret = ad7124_read_register(&ad7124_regs[reg_nr]);
if (ret < 0) if (ret < 0)
break; break;
} }
} }
HAL_GPIO_WritePin(AD7124_SYNC_GPIO_Port, AD7124_SYNC_Pin, GPIO_PIN_SET); // AD7124同步信号一直高电平状态 HAL_GPIO_WritePin(AD7124_SYNC_GPIO_Port, AD7124_SYNC_Pin, GPIO_PIN_SET); // AD7124同步信号使能
return ret; return ret;
} }

36
User/driver/ad7124.h
View File

@ -242,23 +242,23 @@ typedef struct
typedef enum typedef enum
{ {
AD7124_AIN0 = 0, // AD7124_CHANNEL_EN_0
AD7124_AIN1, // AD7124_CHANNEL_EN_1
AD7124_AIN2, // AD7124_CHANNEL_EN_2
AD7124_AIN3, // AD7124_CHANNEL_EN_3
AD7124_AIN4, // AD7124_CHANNEL_EN_4
AD7124_AIN5, // AD7124_CHANNEL_EN_5
AD7124_AIN6, // AD7124_CHANNEL_EN_6
AD7124_AIN7, // AD7124_CHANNEL_EN_7
AD7124_AIN8, // AD7124_CHANNEL_EN_8
AD7124_AIN9, // AD7124_CHANNEL_EN_9
AD7124_AIN10, // AD7124_CHANNEL_EN_10
AD7124_AIN11, // AD7124_CHANNEL_EN_11
AD7124_AIN12, // AD7124_CHANNEL_EN_12
AD7124_AIN13, // AD7124_CHANNEL_EN_13
AD7124_AIN14, // AD7124_CHANNEL_EN_14
AD7124_AIN15, // AD7124_CHANNEL_EN_15
AI_IN0_ADC = 0, // AD7124_CHANNEL_EN_0
AI_IN1_ADC, // AD7124_CHANNEL_EN_1
AI_IN2_ADC, // AD7124_CHANNEL_EN_2
AI_IN3_ADC, // AD7124_CHANNEL_EN_3
AI_IN4_ADC, // AD7124_CHANNEL_EN_4
AI_IN5_ADC, // AD7124_CHANNEL_EN_5
AI_IN6_ADC, // AD7124_CHANNEL_EN_6
AI_IN7_ADC, // AD7124_CHANNEL_EN_7
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; // 该项目所使用的通道
@ -279,8 +279,8 @@ typedef struct
#define AD7124_RES 100 // 采样基准电阻 #define AD7124_RES 100 // 采样基准电阻
#define VREF 2.5f // 基准电压 #define VREF 2.5f // 基准电压
#define GAIN 1 // 增益，该值和配置寄存器有关 #define GAIN 1 // 增益，该值和配置寄存器有关
//#define AD_CODE 0XFFFFFF // 24位ADC #define AD_CODE 0XFFFFFF // 24位ADC
#define AD_CODE 0X7FFFFF // 23位ADC //#define AD_CODE 0x7FFFFF // 23位ADC
/*! Reads the value of the specified register. */ /*! Reads the value of the specified register. */
int32_t ad7124_read_register(ad7124_st_reg_t *p_reg); // 读寄存器 int32_t ad7124_read_register(ad7124_st_reg_t *p_reg); // 读寄存器

43
User/driver/delay.c Normal file
View File

@ -0,0 +1,43 @@
#include "delay.h"
static uint32_t fac_us = 0; // us延时倍乘数
static uint32_t fac_ms = 0; // ms延时倍乘数
// 初始化延迟函数
void delay_init(void)
{
// 配置SysTick为外部时钟源(HCLK/8)
SysTick->CTRL &= ~SysTick_CTRL_CLKSOURCE_Msk; // 选择外部时钟源 HCLK/8
fac_us = SystemCoreClock / 8000000; // 为系统时钟的1/8
fac_ms = (uint32_t)fac_us * 1000; // 代表每个ms需要的systick时钟数
}
// 延时nus微秒
void delay_us(uint32_t nus)
{
uint32_t temp;
SysTick->LOAD = nus * fac_us; // 时间加载
SysTick->VAL = 0x00; // 清空计数器
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk; // 开始倒数
do
{
temp = SysTick->CTRL;
} while ((temp & 0x01) && !(temp & (1 << 16))); // 等待时间到达
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; // 关闭计数器
SysTick->VAL = 0X00; // 清空计数器
}
// 延时nms毫秒
void delay_ms(uint16_t nms)
{
uint32_t temp;
SysTick->LOAD = (uint32_t)nms * fac_ms; // 时间加载(SysTick->LOAD为24bit)
SysTick->VAL = 0x00; // 清空计数器
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk; // 开始倒数
do
{
temp = SysTick->CTRL;
} while ((temp & 0x01) && !(temp & (1 << 16))); // 等待时间到达
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; // 关闭计数器
SysTick->VAL = 0X00; // 清空计数器
}

12
User/driver/delay.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef __DELAY_H
#define __DELAY_H
#include "stm32f4xx_hal.h"
#include "core_cm4.h"
#include "system_stm32f4xx.h"
void delay_init(void);
void delay_us(uint32_t nus);
void delay_ms(uint16_t nms);
#endif /* __DELAY_H */

13
User/driver/error.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef __ERROR_H
#define __ERROR_H
/**
* @brief 错误码定义
*/
#define SUCCESS 0 /* 操作成功 */
#define FAILURE -1 /* 操作失败 */
#define INVALID_VAL -2 /* 无效参数 */
#define COMM_ERR -3 /* 通信错误 */
#define TIMEOUT -4 /* 超时错误 */
#endif /* __ERROR_H */

24
User/driver/platform_support.h Normal file
View File

@ -0,0 +1,24 @@
#ifndef __PLATFORM_SUPPORT_H
#define __PLATFORM_SUPPORT_H
/* 包含文件 */
#include <stdint.h>
#include "stm32f4xx_hal.h"
/* 定义 */
#define SUCCESS 0
#define FAILURE -1
/* 函数声明 */
/**
* @brief 毫秒延时函数
* @param ms - 延时时间，单位：毫秒
* @return 无
*/
static inline void mdelay(uint32_t ms)
{
HAL_Delay(ms);
}
#endif /* __PLATFORM_SUPPORT_H */

148
User/system/user_spi.c
View File

@ -1,29 +1,103 @@
#include "user_spi.h" #include "user_spi.h"
#include "stm32f4xx_hal.h"
#include "main.h"
#include <stdint.h>
#include <string.h>
#include <stdint.h>
#include <string.h>
/* SPI2 Handle */ #include "spi.h"
SPI_HandleTypeDef hspi2;
// 移除对platform_support.h的依赖
// 直接在此处定义需要的常量和函数
#define SUCCESS 0
#define FAILURE -1
// 声明mdelay函数
static inline void mdelay(uint32_t ms)
{
HAL_Delay(ms);
}
/******************************************************************************/
/***************************** #defines ***************************************/
/******************************************************************************/
#define SPI_BUFFER_SIZE 255 #define SPI_BUFFER_SIZE 255
/******************************************************************************/
/************************ Variable Declarations *******************************/
/******************************************************************************/
static uint8_t spi_rx_buffer[SPI_BUFFER_SIZE] = {0}; static uint8_t spi_rx_buffer[SPI_BUFFER_SIZE] = {0};
/******************************************************************************/
/************************ Functions Definitions *******************************/
/******************************************************************************/
#define SPI_BUFFER_SIZE 255
// SPI handle declaration
SPI_HandleTypeDef hspi2;
// Define return values
#define SUCCESS 0
#define FAILURE -1
int32_t spi_transmit_receive(SPI_HandleTypeDef *hspi, uint8_t *data_write, uint8_t bytes_number) int32_t spi_transmit_receive(SPI_HandleTypeDef *hspi, uint8_t *data_write, uint8_t bytes_number)
{ {
// 使用 HAL_SPI_TransmitReceive 函数进行 SPI 通信 // 使用 HAL_SPI_TransmitReceive 函数进行 SPI 通信
if (HAL_SPI_TransmitReceive(&hspi2, data_write, (uint8_t *)spi_rx_buffer, bytes_number, 1000) != HAL_OK) if (HAL_SPI_TransmitReceive(&hspi2, data_write, (uint8_t *)spi_rx_buffer, bytes_number, 1000) != HAL_OK)
{ {
// 如果通信失败，返回 FAIL // 如果通信失败，返回 FAILURE
return FAIL; return FAILURE;
} }
/* 将 SPI 接收缓冲区复制到提供的数据缓冲区，以便返回给调用者 */ /* 将 SPI 接收缓冲区复制到提供的数据缓冲区，以便返回给调用者 */
memcpy(data_write, spi_rx_buffer, bytes_number); memcpy(data_write, spi_rx_buffer, bytes_number);
// 返回 TRUE 表示通信成功 // 返回 SUCCESS 表示通信成功
return TRUE; return SUCCESS;
} }
void ad7124_spi_init(void) void ad7124_spi_init(void)
{ {
/* Enable SPI2 clock */ GPIO_InitTypeDef GPIO_InitStruct = {0};
__HAL_RCC_SPI2_CLK_ENABLE();
// Enable GPIO and SPI clocks
__HAL_RCC_SPI2_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE(); // For MISO and MOSI
__HAL_RCC_GPIOB_CLK_ENABLE(); // For SCK
__HAL_RCC_GPIOD_CLK_ENABLE(); // For CS
// Configure SPI2 pins
// MISO (PC2) and MOSI (PC3)
GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2; // SPI2 alternate function
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
// SCK (PB10)
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2; // SPI2 alternate function
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
// CS (PD10) - Configure as output
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP; // Add pull-up to ensure high when not driven
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
// Ensure CS is high before SPI initialization
// Configure SPI2 with the working configuration
hspi2.Instance = SPI2; hspi2.Instance = SPI2;
hspi2.Init.Mode = SPI_MODE_MASTER; hspi2.Init.Mode = SPI_MODE_MASTER;
hspi2.Init.Direction = SPI_DIRECTION_2LINES; hspi2.Init.Direction = SPI_DIRECTION_2LINES;
@ -31,20 +105,22 @@ 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_256; // 降低速度以确保稳定性 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;
hspi2.Init.CRCPolynomial = 10; hspi2.Init.CRCPolynomial = 10;
// 确保CS初始为高电平
HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(SPI2_CS2_GPIO_Port, SPI2_CS2_Pin, GPIO_PIN_SET);
if (HAL_SPI_Init(&hspi2) != HAL_OK) if (HAL_SPI_Init(&hspi2) != HAL_OK)
{ {
Error_Handler(); Error_Handler();
} }
// Double check CS is high after initialization
HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET);//关闭AD7124_CS1
HAL_GPIO_WritePin(SPI2_CS2_GPIO_Port, SPI2_CS2_Pin, GPIO_PIN_SET);//关闭AD7124_CS2
HAL_GPIO_WritePin(AD7124_SYNC_GPIO_Port, AD7124_SYNC_Pin, GPIO_PIN_SET);//关闭AD7124_SYNC
HAL_Delay(1);
} }
void dac161s997_spi_init(void) void dac161s997_spi_init(void)
@ -72,16 +148,18 @@ void dac161s997_spi_init(void)
void ad7124_cs_on(void) void ad7124_cs_on(void)
{ {
// 激活AD7124 (CS低电平有效) HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_RESET); // 拉低使能AD7124_CS1
HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_RESET); //HAL_GPIO_WritePin(SPI2_CS2_GPIO_Port, SPI2_CS2_Pin, GPIO_PIN_SET); // 拉高关闭AD7124_CS2
HAL_Delay(1);//延时1ms
} }
void ad7124_cs_off(void) void ad7124_cs_off(void)
{ {
// 禁用AD7124 (CS高电平) HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET); // 拉高关闭AD7124_CS1
HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET); //HAL_GPIO_WritePin(SPI2_CS2_GPIO_Port, SPI2_CS2_Pin, GPIO_PIN_RESET); // 拉低使能AD7124_CS2
HAL_Delay(1);
} }
void dac161s997_cs_on(chip_type_e dac_num) void dac161s997_cs_on(chip_type_e dac_num)
{ {
switch (dac_num) switch (dac_num)
@ -120,29 +198,25 @@ void dac161s997_cs_off(uint8_t dac_num)
} }
void board_spi_init(chip_type_e chip_type) void board_spi_init(chip_type_e chip_type)
{ {
switch (chip_type) switch(chip_type) {
{
case AD7124: case AD7124:
ad7124_spi_init(); ad7124_spi_init();
break; break;
case DAC161S997_1: case DAC161S997_1:
dac161s997_spi_init();
break;
case DAC161S997_2: case DAC161S997_2:
dac161s997_spi_init(); dac161s997_spi_init();
break; break;
default: default:
dac161s997_spi_init();
break; break;
} }
} }
void board_spi_cs_on(chip_type_e chip_type) void board_spi_cs_on(chip_type_e chip_type)
{ {
switch (chip_type) switch(chip_type) {
{
case AD7124: case AD7124:
ad7124_cs_on(); HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_RESET); // AD7124_CS1打开
HAL_Delay(1);
break; break;
case DAC161S997_1: case DAC161S997_1:
dac161s997_cs_on(DAC161S997_1); dac161s997_cs_on(DAC161S997_1);
@ -151,17 +225,16 @@ void board_spi_cs_on(chip_type_e chip_type)
dac161s997_cs_on(DAC161S997_2); dac161s997_cs_on(DAC161S997_2);
break; break;
default: default:
dac161s997_cs_on(DAC161S997_2);
break; break;
} }
} }
void board_spi_cs_off(chip_type_e chip_type) void board_spi_cs_off(chip_type_e chip_type)
{ {
switch (chip_type) switch(chip_type) {
{
case AD7124: case AD7124:
ad7124_cs_off(); HAL_GPIO_WritePin(SPI2_CS_GPIO_Port, SPI2_CS_Pin, GPIO_PIN_SET); // AD7124_CS1关闭
HAL_Delay(1);
break; break;
case DAC161S997_1: case DAC161S997_1:
dac161s997_cs_off(DAC161S997_1); dac161s997_cs_off(DAC161S997_1);
@ -170,7 +243,20 @@ void board_spi_cs_off(chip_type_e chip_type)
dac161s997_cs_off(DAC161S997_2); dac161s997_cs_off(DAC161S997_2);
break; break;
default: default:
dac161s997_cs_off(DAC161S997_2);
break; break;
} }
} }
// Add helper function for AD7124 SPI communication
int32_t ad7124_spi_transmit_receive(uint8_t *data, uint8_t bytes)
{
ad7124_cs_on();
int32_t result = spi_transmit_receive(&hspi2, data, bytes);
ad7124_cs_off();
return result;
}