//hal库实现
int fputc(int ch, FILE *f) 
{
    // 阻塞式发送单个字符
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);//这里调用发送api
    return ch;
}

//标准库实现
#include "stm32f10x.h" // 请根据你的具体芯片系列修改头文件，例如 stm32f4xx.h
#include <stdio.h>

int fputc(int ch, FILE *f) {
    /* 1. 将单个字符写入 USART1 的数据寄存器 (DR) */
    USART_SendData(USART1, (uint8_t)ch);
    
    /* 2. 轮询等待发送完成标志位 (TC: Transmission Complete) 被置位 */
    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {
        // 阻塞等待，直到单字节数据完全发送出去
    }
    
    return ch;
}

//hal库实现
#include "stdarg.h"

#define TX_BUFFER_SIZE 128
uint8_t Serial_TxData[TX_BUFFER_SIZE];

uint16_t APP_Printf_DMA(char *format, ...)
{
    // 1. 等待上一次 UART/DMA 发送完成
    // 在 HAL 库中，直接检查串口的状态机比直接查 DMA 状态更可靠
    while (huart1.gState != HAL_UART_STATE_READY) {
        // 阻塞等待直到串口空闲
    }
    
    // 2. 变参处理与字符串格式化
    va_list args;
    va_start(args, format);
    uint16_t len = vsnprintf((char *)Serial_TxData, TX_BUFFER_SIZE, format, args);
    va_end(args);

    // 3. 启动 DMA 发送
    // HAL库会自动处理源地址、传输大小和 DMA 使能
    HAL_UART_Transmit_DMA(&huart1, Serial_TxData, len);

    return len;
}

//标准库实现
#include "stm32f10x.h" 
#include <stdio.h>
#include <stdarg.h>

#define TX_BUFFER_SIZE 128
uint8_t Serial_TxData[TX_BUFFER_SIZE];

// STM32F1 的 USART1_TX 映射在 DMA1 的 Channel4
#define UARTx_TX_DMA_CHANNEL   DMA1_Channel4

uint16_t APP_Printf_DMA(char *format, ...) 
{
    // 1. 等待上一次 DMA 传输完成
    // 在标准库中，最稳妥的方法是检查 DMA 剩余数据量是否为 0
    while (DMA_GetCurrDataCounter(UARTx_TX_DMA_CHANNEL) != 0) {
        // 阻塞等待，直到上一次的数据全部搬运到串口
    }
    
    // 2. 变参处理与字符串格式化（与底层库无关，代码不变）
    va_list args;
    va_start(args, format);
    uint16_t len = vsnprintf((char *)Serial_TxData, TX_BUFFER_SIZE, format, args);
    va_end(args);

    // 3. 重新触发 DMA 发送
    // 【关键】标准库规定：必须先关闭 DMA 通道，才能修改 CNDTR 寄存器（传输数据量）
    DMA_Cmd(UARTx_TX_DMA_CHANNEL, DISABLE);
    
    // 填入本次需要发送的字节数
    DMA_SetCurrDataCounter(UARTx_TX_DMA_CHANNEL, len);
    
    // 重新开启 DMA，数据开始自动发送
    DMA_Cmd(UARTx_TX_DMA_CHANNEL, ENABLE);

    return len;
}

//hal库

//hal库里面的中断是每开一次，只会运行一次的
void APP_UART_Init(void) 
{
    ringbuffer_init(&uart_ring, ring_mem, RING_BUF_SIZE);

    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, dma_rx_buf, DMA_BUF_SIZE);
    __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);
}


//这个是中断回调函数，*huart这个句柄记录着这个串口的所有信息，Size的话就是记录着这次收到了多少个字节
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
    if (huart->Instance == USART1) 
    {
        ringbuffer_write(&uart_ring, dma_rx_buf, Size);
        
        HAL_UARTEx_ReceiveToIdle_DMA(&huart1, dma_rx_buf, DMA_BUF_SIZE);
        __HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT);//关闭半满中断
    }
}

void uart_task(void) 
{
    if (huart1.gState != HAL_UART_STATE_READY) return;
    uint16_t count = ringbuffer_get_count(&uart_ring);
    if(count==0)return;
    count=(count > RING_BUF_SIZE)?RING_BUF_SIZE:count;
    uint16_t read_len = ringbuffer_read(&uart_ring, process_buf, count); 
}

// 【致命雷区防范】必须设置 1 字节对齐！防止编译器自动插入内存空位导致字节错位！
#pragma pack(push, 1) 
typedef struct {
    uint16_t header;    // 帧头，占用 2 字节 (例如 0x55AA，需注意系统的大小端模式)
    uint8_t  cmd;       // 指令控制码，占用 1 字节
    float    temp_val;  // 传感器有效数据，占用 4 字节 (标准 IEEE 754 浮点数)
    uint8_t  checksum;  // 校验和，占用 1 字节 (如 CRC8 或累加和)
} SensorFrame_t;
#pragma pack(pop)   // 恢复编译器默认的对齐设置

// 假设 process_buf 是 DMA 接收到的 8 字节原始数组
// 解析时的操作（指针魔法）：
SensorFrame_t *frame = (SensorFrame_t *)process_buf;

// 像访问普通变量一样直接读取，C 语言会自动帮你处理底层的字节拼接
if (frame->header == 0x55AA && check_crc(process_buf, len) == frame->checksum) {
    float my_temp = frame->temp_val; // 直接拿到 float 数据，无需手写移位拼接代码
}

// 1. 定义解析过程中可能经历的所有状态
typedef enum {
    STATE_WAIT_HEADER1, // 等待帧头1 (例如 0xAA)
    STATE_WAIT_HEADER2, // 等待帧头2 (例如 0x55)
    STATE_READ_LEN,     // 读取当前数据包指示的 Payload 长度
    STATE_READ_PAYLOAD, // 根据长度，循环读取有效数据
    STATE_CHECK_CRC     // 接收校验码并进行比对
} ParserState_e;

ParserState_e rx_state = STATE_WAIT_HEADER1; // 初始化状态机

// 2. 将缓冲区读出的数据逐个字节传入此函数
void protocol_parse_byte(uint8_t byte) 
{
    switch (rx_state) {
        case STATE_WAIT_HEADER1:
            if (byte == 0xAA) rx_state = STATE_WAIT_HEADER2;
            break;
            
        case STATE_WAIT_HEADER2:
            if (byte == 0x55) rx_state = STATE_READ_LEN;
            else rx_state = STATE_WAIT_HEADER1; // 校验失败，立刻打回原形
            break;
            
        case STATE_READ_LEN:
            expected_len = byte;     // 记录本帧应接收的长度
            payload_idx = 0;
            rx_state = STATE_READ_PAYLOAD;
            break;
            
        case STATE_READ_PAYLOAD:
            payload_buf[payload_idx++] = byte; // 收集有效数据
            if (payload_idx >= expected_len) rx_state = STATE_CHECK_CRC; // 收集够了，准备校验
            break;
            
        case STATE_CHECK_CRC:
            if (byte == calculate_crc(payload_buf, expected_len)) {
                // 🎉 校验通过，完整且正确地收到一帧数据！执行业务逻辑！
                execute_command(payload_buf);
            }
            rx_state = STATE_WAIT_HEADER1; // 解析完一包，状态机复位，准备接客下一包
            break;
    }
}