TMC4361A 使用（未验证）

prompt
我用STM32F103C8T6 来控制 TMC4361A 运动控制芯片 ，我配置 STM32F103C8T6 的 SPI1 与 TMC4361A 进行通信，配置 PA4 作为片选线，配置 PA8 作为 RCC_MCO 输入时钟输入到 TMC4361A, 并将其连接到TMC4361A的CLK_EXT引脚。我想控制 TMC4361A, 你要 认真仔细阅读 TMC4361A 的手册，然后帮我实现控制。

主要功能：

1. 硬件配置：

   • SPI1配置（PA5/SCK, PA6/MISO, PA7/MOSI）
   • PA4作为片选线
   • PA8配置为MCO输出36MHz时钟给TMC4361A

2. TMC4361A初始化：

   • 验证通信连接
   • 配置基本运动参数
   • 设置时钟频率
   • 配置斜坡生成器

3. 运动控制函数：

   • 绝对位置移动
   • 相对位置移动
   • 速度控制
   • 加速度设置
   • 停止功能

4. 状态监控：

   • 位置读取
   • 速度读取
   • 状态检查
   • 目标到达检测

使用说明：

1. 将代码编译并烧录到STM32F103C8T6
2. 连接硬件：
   • SPI1接线到TMC4361A的SPI接口
   • PA4连接到TMC4361A的CSN引脚
   • PA8连接到TMC4361A的CLK_EXT引脚
3. 通过串口监控运动状态

代码特点：

• 完整的40位SPI通信协议实现
• 详细的寄存器配置
• 示例运动序列
• 完善的错误处理
• 丰富的状态监控

这个代码提供了一个完整的TMC4361A控制框架，您可以根据具体需求修改运动参数和控制逻辑。如果需要连接步进电机驱动器（如TMC2130），还需要配置SPIOUT_CONF寄存器来设置SPI输出到驱动器。

---

/* STM32F103C8T6 控制 TMC4361A 运动控制芯片
 * 配置：
 * - SPI1: PA5(SCK), PA6(MISO), PA7(MOSI)
 * - PA4: CS (片选)
 * - PA8: MCO (时钟输出到TMC4361A)
 */

#include "stm32f1xx_hal.h"
#include 
#include 

// TMC4361A 寄存器地址定义
#define TMC4361A_GENERAL_CONF         0x00
#define TMC4361A_REFERENCE_CONF       0x01
#define TMC4361A_START_CONF           0x02
#define TMC4361A_INPUT_FILT_CONF      0x03
#define TMC4361A_SPIOUT_CONF          0x04
#define TMC4361A_CURRENT_CONF         0x05
#define TMC4361A_SCALE_VALUES         0x06
#define TMC4361A_ENC_IN_CONF          0x07
#define TMC4361A_ENC_IN_DATA          0x08
#define TMC4361A_ENC_OUT_DATA         0x09
#define TMC4361A_STEP_CONF            0x0A
#define TMC4361A_SPI_STATUS_SELECTION 0x0B
#define TMC4361A_EVENT_POS_STAT       0x0C
#define TMC4361A_INTR_CONF            0x0D
#define TMC4361A_EVENTS               0x0E
#define TMC4361A_STATUS               0x0F
#define TMC4361A_SPI_STATUS           0x10
#define TMC4361A_XACTUAL              0x21
#define TMC4361A_VACTUAL              0x22
#define TMC4361A_AACTUAL              0x23
#define TMC4361A_VMAX                 0x24
#define TMC4361A_VSTART               0x25
#define TMC4361A_VSTOP                0x26
#define TMC4361A_VBREAK               0x27
#define TMC4361A_AMAX                 0x28
#define TMC4361A_DMAX                 0x29
#define TMC4361A_ASTART               0x2A
#define TMC4361A_DFINAL               0x2B
#define TMC4361A_DSTOP                0x2C
#define TMC4361A_BOW1                 0x2D
#define TMC4361A_BOW2                 0x2E
#define TMC4361A_BOW3                 0x2F
#define TMC4361A_BOW4                 0x30
#define TMC4361A_CLK_FREQ             0x31
#define TMC4361A_XTARGET              0x37
#define TMC4361A_RAMPMODE             0x35
#define TMC4361A_XLATCHED             0x36

// 运动模式定义
#define TMC4361A_MODE_POSITION        0x00
#define TMC4361A_MODE_VELOCITY_POS    0x01
#define TMC4361A_MODE_VELOCITY_NEG    0x02
#define TMC4361A_MODE_HOLD            0x03

// 状态位定义
#define TMC4361A_STATUS_TARGET_REACHED    (1<<0)
#define TMC4361A_STATUS_VELOCITY_REACHED  (1<<1)
#define TMC4361A_STATUS_POSITION_REACHED  (1<<2)

// 硬件定义
#define TMC4361A_CS_PIN       GPIO_PIN_4
#define TMC4361A_CS_PORT      GPIOA
#define TMC4361A_CS_LOW()     HAL_GPIO_WritePin(TMC4361A_CS_PORT, TMC4361A_CS_PIN, GPIO_PIN_RESET)
#define TMC4361A_CS_HIGH()    HAL_GPIO_WritePin(TMC4361A_CS_PORT, TMC4361A_CS_PIN, GPIO_PIN_SET)

// 全局变量
SPI_HandleTypeDef hspi1;
UART_HandleTypeDef huart1;

// 函数声明
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_SPI1_Init(void);
void MX_USART1_UART_Init(void);
void MX_MCO_Init(void);
void TMC4361A_Init(void);
void TMC4361A_WriteRegister(uint8_t address, uint32_t data);
uint32_t TMC4361A_ReadRegister(uint8_t address);
void TMC4361A_SetPosition(int32_t position);
void TMC4361A_SetVelocity(int32_t velocity);
void TMC4361A_SetAcceleration(uint32_t acceleration);
void TMC4361A_SetMaxVelocity(uint32_t max_velocity);
void TMC4361A_MoveAbsolute(int32_t position);
void TMC4361A_MoveRelative(int32_t distance);
void TMC4361A_Stop(void);
uint32_t TMC4361A_GetStatus(void);
int32_t TMC4361A_GetPosition(void);
int32_t TMC4361A_GetVelocity(void);
uint8_t TMC4361A_IsTargetReached(void);

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    
    MX_GPIO_Init();
    MX_SPI1_Init();
    MX_USART1_UART_Init();
    MX_MCO_Init();
    
    HAL_Delay(100);  // 等待TMC4361A上电稳定
    
    TMC4361A_Init();
    
    char msg[100];
    sprintf(msg, "TMC4361A初始化完成\r\n");
    HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
    
    // 示例：设置运动参数
    TMC4361A_SetMaxVelocity(1000000);     // 最大速度
    TMC4361A_SetAcceleration(500000);     // 加速度
    TMC4361A_SetVelocity(800000);         // 目标速度
    
    while (1)
    {
        // 示例运动序列
        sprintf(msg, "开始绝对位置移动到10000\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        TMC4361A_MoveAbsolute(10000);
        
        // 等待运动完成
        while(!TMC4361A_IsTargetReached()) {
            int32_t current_pos = TMC4361A_GetPosition();
            sprintf(msg, "当前位置: %ld\r\n", current_pos);
            HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
            HAL_Delay(100);
        }
        
        sprintf(msg, "到达目标位置\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        HAL_Delay(2000);
        
        // 相对移动
        sprintf(msg, "开始相对移动-5000步\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        TMC4361A_MoveRelative(-5000);
        
        // 等待运动完成
        while(!TMC4361A_IsTargetReached()) {
            int32_t current_pos = TMC4361A_GetPosition();
            sprintf(msg, "当前位置: %ld\r\n", current_pos);
            HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
            HAL_Delay(100);
        }
        
        sprintf(msg, "到达目标位置\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        HAL_Delay(2000);
    }
}

// MCO时钟输出配置 - 输出到PA8
void MX_MCO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    // 使能GPIOA时钟
    __HAL_RCC_GPIOA_CLK_ENABLE();
    
    // 配置PA8为MCO输出
    GPIO_InitStruct.Pin = GPIO_PIN_8;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // 配置MCO输出系统时钟/2 (36MHz)
    HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_SYSCLK, RCC_MCODIV_2);
}

// SPI1初始化
void MX_SPI1_Init(void)
{
    hspi1.Instance = SPI1;
    hspi1.Init.Mode = SPI_MODE_MASTER;
    hspi1.Init.Direction = SPI_DIRECTION_2LINES;
    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
    hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
    hspi1.Init.NSS = SPI_NSS_SOFT;
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;  // 约2.25MHz
    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi1.Init.CRCPolynomial = 10;
    
    if (HAL_SPI_Init(&hspi1) != HAL_OK)
    {
        Error_Handler();
    }
}

// GPIO初始化
void MX_GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    
    // 配置CS引脚 (PA4)
    HAL_GPIO_WritePin(TMC4361A_CS_PORT, TMC4361A_CS_PIN, GPIO_PIN_SET);
    
    GPIO_InitStruct.Pin = TMC4361A_CS_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(TMC4361A_CS_PORT, &GPIO_InitStruct);
}

// UART初始化
void MX_USART1_UART_Init(void)
{
    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
        Error_Handler();
    }
}

// TMC4361A初始化
void TMC4361A_Init(void)
{
    HAL_Delay(10);
    
    // 读取版本信息验证通信
    uint32_t version = TMC4361A_ReadRegister(0x73);  // VERSION寄存器
    char msg[50];
    sprintf(msg, "TMC4361A版本: 0x%08lX\r\n", version);
    HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
    
    // 基本配置
    TMC4361A_WriteRegister(TMC4361A_GENERAL_CONF, 0x00000001);  // 使能驱动器
    TMC4361A_WriteRegister(TMC4361A_REFERENCE_CONF, 0x00000000); // 参考配置
    TMC4361A_WriteRegister(TMC4361A_START_CONF, 0x00000000);    // 启动配置
    TMC4361A_WriteRegister(TMC4361A_STEP_CONF, 0x00000000);     // 步进配置
    TMC4361A_WriteRegister(TMC4361A_SPIOUT_CONF, 0x00000004);   // SPI输出配置
    
    // 设置时钟频率 (36MHz)
    TMC4361A_WriteRegister(TMC4361A_CLK_FREQ, 36000000);
    
    // 设置默认运动参数
    TMC4361A_WriteRegister(TMC4361A_VMAX, 1000000);    // 最大速度
    TMC4361A_WriteRegister(TMC4361A_AMAX, 500000);     // 最大加速度
    TMC4361A_WriteRegister(TMC4361A_DMAX, 500000);     // 最大减速度
    TMC4361A_WriteRegister(TMC4361A_VSTART, 0);        // 起始速度
    TMC4361A_WriteRegister(TMC4361A_VSTOP, 0);         // 停止速度
    TMC4361A_WriteRegister(TMC4361A_ASTART, 0);        // 起始加速度
    TMC4361A_WriteRegister(TMC4361A_DFINAL, 0);        // 最终减速度
    TMC4361A_WriteRegister(TMC4361A_DSTOP, 0);         // 停止减速度
    
    // 设置弓形参数
    TMC4361A_WriteRegister(TMC4361A_BOW1, 0);
    TMC4361A_WriteRegister(TMC4361A_BOW2, 0);
    TMC4361A_WriteRegister(TMC4361A_BOW3, 0);
    TMC4361A_WriteRegister(TMC4361A_BOW4, 0);
    
    // 设置位置模式
    TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_POSITION);
    
    HAL_Delay(10);
}

// 写寄存器
void TMC4361A_WriteRegister(uint8_t address, uint32_t data)
{
    uint8_t tx_data[5];
    uint8_t rx_data[5];
    
    // 构造40位数据报：[地址(8位)|数据(32位)]
    tx_data[0] = address | 0x80;  // 写操作，设置MSB
    tx_data[1] = (data >> 24) & 0xFF;
    tx_data[2] = (data >> 16) & 0xFF;
    tx_data[3] = (data >> 8) & 0xFF;
    tx_data[4] = data & 0xFF;
    
    TMC4361A_CS_LOW();
    HAL_SPI_TransmitReceive(&hspi1, tx_data, rx_data, 5, HAL_MAX_DELAY);
    TMC4361A_CS_HIGH();
    
    HAL_Delay(1);
}

// 读寄存器
uint32_t TMC4361A_ReadRegister(uint8_t address)
{
    uint8_t tx_data[5];
    uint8_t rx_data[5];
    
    // 构造40位数据报：[地址(8位)|数据(32位)]
    tx_data[0] = address & 0x7F;  // 读操作，清除MSB
    tx_data[1] = 0x00;
    tx_data[2] = 0x00;
    tx_data[3] = 0x00;
    tx_data[4] = 0x00;
    
    TMC4361A_CS_LOW();
    HAL_SPI_TransmitReceive(&hspi1, tx_data, rx_data, 5, HAL_MAX_DELAY);
    TMC4361A_CS_HIGH();
    
    // 需要再次读取才能获得实际数据
    TMC4361A_CS_LOW();
    HAL_SPI_TransmitReceive(&hspi1, tx_data, rx_data, 5, HAL_MAX_DELAY);
    TMC4361A_CS_HIGH();
    
    return ((uint32_t)rx_data[1] << 24) | 
           ((uint32_t)rx_data[2] << 16) | 
           ((uint32_t)rx_data[3] << 8) | 
           (uint32_t)rx_data[4];
}

// 设置最大速度
void TMC4361A_SetMaxVelocity(uint32_t max_velocity)
{
    TMC4361A_WriteRegister(TMC4361A_VMAX, max_velocity);
}

// 设置加速度
void TMC4361A_SetAcceleration(uint32_t acceleration)
{
    TMC4361A_WriteRegister(TMC4361A_AMAX, acceleration);
    TMC4361A_WriteRegister(TMC4361A_DMAX, acceleration);
}

// 设置速度
void TMC4361A_SetVelocity(int32_t velocity)
{
    if (velocity > 0) {
        TMC4361A_WriteRegister(TMC4361A_VMAX, velocity);
        TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_VELOCITY_POS);
    } else if (velocity < 0) {
        TMC4361A_WriteRegister(TMC4361A_VMAX, -velocity);
        TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_VELOCITY_NEG);
    } else {
        TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_HOLD);
    }
}

// 绝对位置移动
void TMC4361A_MoveAbsolute(int32_t position)
{
    TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_POSITION);
    TMC4361A_WriteRegister(TMC4361A_XTARGET, position);
}

// 相对位置移动
void TMC4361A_MoveRelative(int32_t distance)
{
    int32_t current_pos = TMC4361A_GetPosition();
    TMC4361A_MoveAbsolute(current_pos + distance);
}

// 停止运动
void TMC4361A_Stop(void)
{
    TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_HOLD);
}

// 获取状态
uint32_t TMC4361A_GetStatus(void)
{
    return TMC4361A_ReadRegister(TMC4361A_STATUS);
}

// 获取当前位置
int32_t TMC4361A_GetPosition(void)
{
    return (int32_t)TMC4361A_ReadRegister(TMC4361A_XACTUAL);
}

// 获取当前速度
int32_t TMC4361A_GetVelocity(void)
{
    return (int32_t)TMC4361A_ReadRegister(TMC4361A_VACTUAL);
}

// 检查是否到达目标位置
uint8_t TMC4361A_IsTargetReached(void)
{
    uint32_t status = TMC4361A_GetStatus();
    return (status & TMC4361A_STATUS_TARGET_REACHED) ? 1 : 0;
}

// 系统时钟配置
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
    
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        Error_Handler();
    }
    
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    
    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
    {
        Error_Handler();
    }
}

// 错误处理函数
void Error_Handler(void)
{
    __disable_irq();
    while (1)
    {
    }
}

// HAL回调函数
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    if(hspi->Instance==SPI1)
    {
        __HAL_RCC_SPI1_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();
        
        // SPI1 GPIO配置
        // PA5 ------> SPI1_SCK
        // PA6 ------> SPI1_MISO
        // PA7 ------> SPI1_MOSI
        GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_7;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        
        GPIO_InitStruct.Pin = GPIO_PIN_6;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    }
}

void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    if(huart->Instance==USART1)
    {
        __HAL_RCC_USART1_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();
        
        // USART1 GPIO配置
        // PA9 ------> USART1_TX
        // PA10 ------> USART1_RX
        GPIO_InitStruct.Pin = GPIO_PIN_9;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        
        GPIO_InitStruct.Pin = GPIO_PIN_10;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    }
}

---

引脚分析和连接方案

1. 电源引脚

• VCC (引脚26, 36): 连接3.3V电源
• GND (引脚6, 16, 25, 35): 连接地
• VDD1V8 (引脚17, 34): 1.8V内部电源，通常连接去耦电容到地

2. SPI通信引脚（必须连接）

• SCKIN (引脚4): 连接STM32的SPI1_SCK (PA5)
• SDIIN (引脚5): 连接STM32的SPI1_MOSI (PA7)
• SDQIN (引脚7): 连接STM32的SPI1_MISO (PA6)
• NSCSIN (引脚3): 连接STM32的PA4作为片选

3. 时钟引脚

• CLK_EXT (引脚37): 连接STM32的PA8 (MCO输出)

4. 输出到步进驱动器的SPI引脚

• A_SCLK (引脚40): SPI时钟输出到驱动器
• NSCSDRV_SDO (引脚30): 片选输出到驱动器
• SCKDRV_NSDO (引脚29): 数据输出到驱动器

5. 步进脉冲和方向引脚

• STPOUT_PWMA (引脚23): 步进脉冲输出A
• DIROUT_PWMB (引脚22): 方向输出B

6. 控制和状态引脚

• NRST (引脚39): 复位引脚，连接STM32的GPIO或直接上拉
• STOPL (引脚13): 左限位开关输入
• STOPR (引脚15): 右限位开关输入
• HOME_REF (引脚14): 原点参考输入
• TARGET_REACHED (引脚31): 目标到达状态输出
• START (引脚20): 启动信号输入

让我更新代码以适配实际的引脚连接：## 详细的TMC4361A控制步骤

第一步：硬件连接

根据引脚图，以下是必要的连接：

STM32F103C8T6    ->    TMC4361A
PA5 (SPI1_SCK)   ->    SCKIN (引脚4)
PA6 (SPI1_MISO)  ->    SDQIN (引脚7)
PA7 (SPI1_MOSI)  ->    SDIIN (引脚5)
PA4 (GPIO)       ->    NSCSIN (引脚3)
PA8 (MCO)        ->    CLK_EXT (引脚37)
PA1 (GPIO)       ->    NRST (引脚39)
PA2 (GPIO)       ->    START (引脚20)
PA3 (GPIO)       ->    TARGET_REACHED (引脚31)
3.3V             ->    VCC (引脚26, 36)
GND              ->    GND (引脚6, 16, 25, 35)

第二步：步进驱动器连接

TMC4361A的步进脉冲输出：

• STPOUT_PWMA (引脚23): 连接到步进驱动器的STEP输入
• DIROUT_PWMB (引脚22): 连接到步进驱动器的DIR输入

第三步：限位开关连接（可选）

• STOPL (引脚13): 左限位开关
• STOPR (引脚15): 右限位开关
• HOME_REF (引脚14): 原点开关

第四步：控制流程

1. 初始化阶段：

   • 硬件复位TMC4361A
   • 配置SPI通信
   • 设置时钟频率
   • 配置运动参数

2. 运动控制：

   • 设置目标位置到XTARGET寄存器
   • 设置运动模式到RAMPMODE寄存器
   • 监控TARGET_REACHED引脚状态

3. 状态监控：

   • 通过SPI读取位置和速度
   • 监控硬件状态引脚
   • 处理限位开关信号

第五步：关键寄存器配置

1. GENERAL_CONF (0x00): 总体配置
2. CLK_FREQ (0x31): 时钟频率设置
3. VMAX (0x24): 最大速度
4. AMAX (0x28): 最大加速度
5. XTARGET (0x37): 目标位置
6. RAMPMODE (0x35): 运动模式

实际应用建议

1. 首次使用：

   • 先验证SPI通信是否正常（读取版本寄存器）
   • 逐步测试基本功能
   • 使用串口监控状态

2. 调试技巧：

   • 监控TARGET_REACHED引脚状态
   • 读取XACTUAL寄存器验证位置
   • 检查STATUS寄存器的错误位

3. 性能优化：

   • 根据实际电机特性调整速度和加速度参数
   • 使用弓形参数优化运动曲线
   • 配置适当的限位开关处理

/* STM32F103C8T6 控制 TMC4361A 运动控制芯片
 * 配置：
 * - SPI1: PA5(SCK), PA6(MISO), PA7(MOSI)
 * - PA4: CS (片选)
 * - PA8: MCO (时钟输出到TMC4361A)
 */

#include "stm32f1xx_hal.h"
#include 
#include 

// TMC4361A 寄存器地址定义
#define TMC4361A_GENERAL_CONF         0x00
#define TMC4361A_REFERENCE_CONF       0x01
#define TMC4361A_START_CONF           0x02
#define TMC4361A_INPUT_FILT_CONF      0x03
#define TMC4361A_SPIOUT_CONF          0x04
#define TMC4361A_CURRENT_CONF         0x05
#define TMC4361A_SCALE_VALUES         0x06
#define TMC4361A_ENC_IN_CONF          0x07
#define TMC4361A_ENC_IN_DATA          0x08
#define TMC4361A_ENC_OUT_DATA         0x09
#define TMC4361A_STEP_CONF            0x0A
#define TMC4361A_SPI_STATUS_SELECTION 0x0B
#define TMC4361A_EVENT_POS_STAT       0x0C
#define TMC4361A_INTR_CONF            0x0D
#define TMC4361A_EVENTS               0x0E
#define TMC4361A_STATUS               0x0F
#define TMC4361A_SPI_STATUS           0x10
#define TMC4361A_XACTUAL              0x21
#define TMC4361A_VACTUAL              0x22
#define TMC4361A_AACTUAL              0x23
#define TMC4361A_VMAX                 0x24
#define TMC4361A_VSTART               0x25
#define TMC4361A_VSTOP                0x26
#define TMC4361A_VBREAK               0x27
#define TMC4361A_AMAX                 0x28
#define TMC4361A_DMAX                 0x29
#define TMC4361A_ASTART               0x2A
#define TMC4361A_DFINAL               0x2B
#define TMC4361A_DSTOP                0x2C
#define TMC4361A_BOW1                 0x2D
#define TMC4361A_BOW2                 0x2E
#define TMC4361A_BOW3                 0x2F
#define TMC4361A_BOW4                 0x30
#define TMC4361A_CLK_FREQ             0x31
#define TMC4361A_XTARGET              0x37
#define TMC4361A_RAMPMODE             0x35
#define TMC4361A_XLATCHED             0x36

// 运动模式定义
#define TMC4361A_MODE_POSITION        0x00
#define TMC4361A_MODE_VELOCITY_POS    0x01
#define TMC4361A_MODE_VELOCITY_NEG    0x02
#define TMC4361A_MODE_HOLD            0x03

// 状态位定义
#define TMC4361A_STATUS_TARGET_REACHED    (1<<0)
#define TMC4361A_STATUS_VELOCITY_REACHED  (1<<1)
#define TMC4361A_STATUS_POSITION_REACHED  (1<<2)

// 硬件定义
#define TMC4361A_CS_PIN       GPIO_PIN_4   // NSCSIN (引脚3)
#define TMC4361A_CS_PORT      GPIOA
#define TMC4361A_NRST_PIN     GPIO_PIN_1   // NRST (引脚39)
#define TMC4361A_NRST_PORT    GPIOA
#define TMC4361A_START_PIN    GPIO_PIN_2   // START (引脚20)
#define TMC4361A_START_PORT   GPIOA
#define TMC4361A_TARGET_PIN   GPIO_PIN_3   // TARGET_REACHED (引脚31)
#define TMC4361A_TARGET_PORT  GPIOA

#define TMC4361A_CS_LOW()     HAL_GPIO_WritePin(TMC4361A_CS_PORT, TMC4361A_CS_PIN, GPIO_PIN_RESET)
#define TMC4361A_CS_HIGH()    HAL_GPIO_WritePin(TMC4361A_CS_PORT, TMC4361A_CS_PIN, GPIO_PIN_SET)
#define TMC4361A_RESET_LOW()  HAL_GPIO_WritePin(TMC4361A_NRST_PORT, TMC4361A_NRST_PIN, GPIO_PIN_RESET)
#define TMC4361A_RESET_HIGH() HAL_GPIO_WritePin(TMC4361A_NRST_PORT, TMC4361A_NRST_PIN, GPIO_PIN_SET)
#define TMC4361A_START_TRIGGER() HAL_GPIO_WritePin(TMC4361A_START_PORT, TMC4361A_START_PIN, GPIO_PIN_SET); HAL_Delay(1); HAL_GPIO_WritePin(TMC4361A_START_PORT, TMC4361A_START_PIN, GPIO_PIN_RESET)
#define TMC4361A_IS_TARGET_REACHED() HAL_GPIO_ReadPin(TMC4361A_TARGET_PORT, TMC4361A_TARGET_PIN)

// 全局变量
SPI_HandleTypeDef hspi1;
UART_HandleTypeDef huart1;

// 函数声明
void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_SPI1_Init(void);
void MX_USART1_UART_Init(void);
void MX_MCO_Init(void);
void TMC4361A_Init(void);
void TMC4361A_WriteRegister(uint8_t address, uint32_t data);
uint32_t TMC4361A_ReadRegister(uint8_t address);
void TMC4361A_SetPosition(int32_t position);
void TMC4361A_SetVelocity(int32_t velocity);
void TMC4361A_SetAcceleration(uint32_t acceleration);
void TMC4361A_SetMaxVelocity(uint32_t max_velocity);
void TMC4361A_MoveAbsolute(int32_t position);
void TMC4361A_MoveRelative(int32_t distance);
void TMC4361A_Stop(void);
uint32_t TMC4361A_GetStatus(void);
int32_t TMC4361A_GetPosition(void);
int32_t TMC4361A_GetVelocity(void);
uint8_t TMC4361A_IsTargetReached(void);

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    
    MX_GPIO_Init();
    MX_SPI1_Init();
    MX_USART1_UART_Init();
    MX_MCO_Init();
    
    HAL_Delay(100);  // 等待TMC4361A上电稳定
    
    TMC4361A_Init();
    
    char msg[100];
    sprintf(msg, "TMC4361A初始化完成\r\n");
    HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
    
    // 示例：设置运动参数
    TMC4361A_SetMaxVelocity(1000000);     // 最大速度
    TMC4361A_SetAcceleration(500000);     // 加速度
    TMC4361A_SetVelocity(800000);         // 目标速度
    
    while (1)
    {
        // 示例运动序列
        sprintf(msg, "开始绝对位置移动到10000\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        TMC4361A_MoveAbsolute(10000);
        
        // 等待运动完成
        while(!TMC4361A_IsTargetReached()) {
            int32_t current_pos = TMC4361A_GetPosition();
            sprintf(msg, "当前位置: %ld\r\n", current_pos);
            HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
            HAL_Delay(100);
        }
        
        sprintf(msg, "到达目标位置\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        HAL_Delay(2000);
        
        // 相对移动
        sprintf(msg, "开始相对移动-5000步\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        TMC4361A_MoveRelative(-5000);
        
        // 等待运动完成
        while(!TMC4361A_IsTargetReached()) {
            int32_t current_pos = TMC4361A_GetPosition();
            sprintf(msg, "当前位置: %ld\r\n", current_pos);
            HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
            HAL_Delay(100);
        }
        
        sprintf(msg, "到达目标位置\r\n");
        HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        
        HAL_Delay(2000);
    }
}

// MCO时钟输出配置 - 输出到PA8
void MX_MCO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    // 使能GPIOA时钟
    __HAL_RCC_GPIOA_CLK_ENABLE();
    
    // 配置PA8为MCO输出
    GPIO_InitStruct.Pin = GPIO_PIN_8;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // 配置MCO输出系统时钟/2 (36MHz)
    HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_SYSCLK, RCC_MCODIV_2);
}

// SPI1初始化
void MX_SPI1_Init(void)
{
    hspi1.Instance = SPI1;
    hspi1.Init.Mode = SPI_MODE_MASTER;
    hspi1.Init.Direction = SPI_DIRECTION_2LINES;
    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
    hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
    hspi1.Init.NSS = SPI_NSS_SOFT;
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;  // 约2.25MHz
    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi1.Init.CRCPolynomial = 10;
    
    if (HAL_SPI_Init(&hspi1) != HAL_OK)
    {
        Error_Handler();
    }
}

// GPIO初始化
void MX_GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    
    // 配置CS引脚 (PA4 -> NSCSIN引脚3)
    HAL_GPIO_WritePin(TMC4361A_CS_PORT, TMC4361A_CS_PIN, GPIO_PIN_SET);
    GPIO_InitStruct.Pin = TMC4361A_CS_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(TMC4361A_CS_PORT, &GPIO_InitStruct);
    
    // 配置NRST引脚 (PA1 -> NRST引脚39)
    HAL_GPIO_WritePin(TMC4361A_NRST_PORT, TMC4361A_NRST_PIN, GPIO_PIN_SET);
    GPIO_InitStruct.Pin = TMC4361A_NRST_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(TMC4361A_NRST_PORT, &GPIO_InitStruct);
    
    // 配置START引脚 (PA2 -> START引脚20)
    HAL_GPIO_WritePin(TMC4361A_START_PORT, TMC4361A_START_PIN, GPIO_PIN_RESET);
    GPIO_InitStruct.Pin = TMC4361A_START_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(TMC4361A_START_PORT, &GPIO_InitStruct);
    
    // 配置TARGET_REACHED引脚 (PA3 -> TARGET_REACHED引脚31)
    GPIO_InitStruct.Pin = TMC4361A_TARGET_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(TMC4361A_TARGET_PORT, &GPIO_InitStruct);
}

// UART初始化
void MX_USART1_UART_Init(void)
{
    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
        Error_Handler();
    }
}

// TMC4361A初始化
void TMC4361A_Init(void)
{
    HAL_Delay(10);
    
    // 读取版本信息验证通信
    uint32_t version = TMC4361A_ReadRegister(0x73);  // VERSION寄存器
    char msg[50];
    sprintf(msg, "TMC4361A版本: 0x%08lX\r\n", version);
    HAL_UART_Transmit(&huart1, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
    
    // 基本配置
    TMC4361A_WriteRegister(TMC4361A_GENERAL_CONF, 0x00000001);  // 使能驱动器
    TMC4361A_WriteRegister(TMC4361A_REFERENCE_CONF, 0x00000000); // 参考配置
    TMC4361A_WriteRegister(TMC4361A_START_CONF, 0x00000000);    // 启动配置
    TMC4361A_WriteRegister(TMC4361A_STEP_CONF, 0x00000000);     // 步进配置
    TMC4361A_WriteRegister(TMC4361A_SPIOUT_CONF, 0x00000004);   // SPI输出配置
    
    // 设置时钟频率 (36MHz)
    TMC4361A_WriteRegister(TMC4361A_CLK_FREQ, 36000000);
    
    // 设置默认运动参数
    TMC4361A_WriteRegister(TMC4361A_VMAX, 1000000);    // 最大速度
    TMC4361A_WriteRegister(TMC4361A_AMAX, 500000);     // 最大加速度
    TMC4361A_WriteRegister(TMC4361A_DMAX, 500000);     // 最大减速度
    TMC4361A_WriteRegister(TMC4361A_VSTART, 0);        // 起始速度
    TMC4361A_WriteRegister(TMC4361A_VSTOP, 0);         // 停止速度
    TMC4361A_WriteRegister(TMC4361A_ASTART, 0);        // 起始加速度
    TMC4361A_WriteRegister(TMC4361A_DFINAL, 0);        // 最终减速度
    TMC4361A_WriteRegister(TMC4361A_DSTOP, 0);         // 停止减速度
    
    // 设置弓形参数
    TMC4361A_WriteRegister(TMC4361A_BOW1, 0);
    TMC4361A_WriteRegister(TMC4361A_BOW2, 0);
    TMC4361A_WriteRegister(TMC4361A_BOW3, 0);
    TMC4361A_WriteRegister(TMC4361A_BOW4, 0);
    
    // 设置位置模式
    TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_POSITION);
    
    HAL_Delay(10);
}

// 写寄存器
void TMC4361A_WriteRegister(uint8_t address, uint32_t data)
{
    uint8_t tx_data[5];
    uint8_t rx_data[5];
    
    // 构造40位数据报：[地址(8位)|数据(32位)]
    tx_data[0] = address | 0x80;  // 写操作，设置MSB
    tx_data[1] = (data >> 24) & 0xFF;
    tx_data[2] = (data >> 16) & 0xFF;
    tx_data[3] = (data >> 8) & 0xFF;
    tx_data[4] = data & 0xFF;
    
    TMC4361A_CS_LOW();
    HAL_SPI_TransmitReceive(&hspi1, tx_data, rx_data, 5, HAL_MAX_DELAY);
    TMC4361A_CS_HIGH();
    
    HAL_Delay(1);
}

// 读寄存器
uint32_t TMC4361A_ReadRegister(uint8_t address)
{
    uint8_t tx_data[5];
    uint8_t rx_data[5];
    
    // 构造40位数据报：[地址(8位)|数据(32位)]
    tx_data[0] = address & 0x7F;  // 读操作，清除MSB
    tx_data[1] = 0x00;
    tx_data[2] = 0x00;
    tx_data[3] = 0x00;
    tx_data[4] = 0x00;
    
    TMC4361A_CS_LOW();
    HAL_SPI_TransmitReceive(&hspi1, tx_data, rx_data, 5, HAL_MAX_DELAY);
    TMC4361A_CS_HIGH();
    
    // 需要再次读取才能获得实际数据
    TMC4361A_CS_LOW();
    HAL_SPI_TransmitReceive(&hspi1, tx_data, rx_data, 5, HAL_MAX_DELAY);
    TMC4361A_CS_HIGH();
    
    return ((uint32_t)rx_data[1] << 24) | 
           ((uint32_t)rx_data[2] << 16) | 
           ((uint32_t)rx_data[3] << 8) | 
           (uint32_t)rx_data[4];
}

// 设置最大速度
void TMC4361A_SetMaxVelocity(uint32_t max_velocity)
{
    TMC4361A_WriteRegister(TMC4361A_VMAX, max_velocity);
}

// 设置加速度
void TMC4361A_SetAcceleration(uint32_t acceleration)
{
    TMC4361A_WriteRegister(TMC4361A_AMAX, acceleration);
    TMC4361A_WriteRegister(TMC4361A_DMAX, acceleration);
}

// 设置速度
void TMC4361A_SetVelocity(int32_t velocity)
{
    if (velocity > 0) {
        TMC4361A_WriteRegister(TMC4361A_VMAX, velocity);
        TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_VELOCITY_POS);
    } else if (velocity < 0) {
        TMC4361A_WriteRegister(TMC4361A_VMAX, -velocity);
        TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_VELOCITY_NEG);
    } else {
        TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_HOLD);
    }
}

// 绝对位置移动
void TMC4361A_MoveAbsolute(int32_t position)
{
    TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_POSITION);
    TMC4361A_WriteRegister(TMC4361A_XTARGET, position);
}

// 相对位置移动
void TMC4361A_MoveRelative(int32_t distance)
{
    int32_t current_pos = TMC4361A_GetPosition();
    TMC4361A_MoveAbsolute(current_pos + distance);
}

// 停止运动
void TMC4361A_Stop(void)
{
    TMC4361A_WriteRegister(TMC4361A_RAMPMODE, TMC4361A_MODE_HOLD);
}

// 获取状态
uint32_t TMC4361A_GetStatus(void)
{
    return TMC4361A_ReadRegister(TMC4361A_STATUS);
}

// 获取当前位置
int32_t TMC4361A_GetPosition(void)
{
    return (int32_t)TMC4361A_ReadRegister(TMC4361A_XACTUAL);
}

// 获取当前速度
int32_t TMC4361A_GetVelocity(void)
{
    return (int32_t)TMC4361A_ReadRegister(TMC4361A_VACTUAL);
}

// 检查是否到达目标位置
uint8_t TMC4361A_IsTargetReached(void)
{
    uint32_t status = TMC4361A_GetStatus();
    return (status & TMC4361A_STATUS_TARGET_REACHED) ? 1 : 0;
}

// 系统时钟配置
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
    
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        Error_Handler();
    }
    
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    
    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
    {
        Error_Handler();
    }
}

// 错误处理函数
void Error_Handler(void)
{
    __disable_irq();
    while (1)
    {
    }
}

// HAL回调函数
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    if(hspi->Instance==SPI1)
    {
        __HAL_RCC_SPI1_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();
        
        // SPI1 GPIO配置
        // PA5 ------> SPI1_SCK
        // PA6 ------> SPI1_MISO
        // PA7 ------> SPI1_MOSI
        GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_7;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        
        GPIO_InitStruct.Pin = GPIO_PIN_6;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    }
}

void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    
    if(huart->Instance==USART1)
    {
        __HAL_RCC_USART1_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();
        
        // USART1 GPIO配置
        // PA9 ------> USART1_TX
        // PA10 ------> USART1_RX
        GPIO_InitStruct.Pin = GPIO_PIN_9;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        
        GPIO_InitStruct.Pin = GPIO_PIN_10;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    }
}