// /*
//   CAN总线数据处理

//   添加中断接收功能。
// */

// /* Includes ----------------------------------------------------------------- */
// // #include "can.h"
// #include "task\user_task.h"
// #include "device\can.h"
// #include "bsp\buzzer.h"
// // #include "cmsis_os.h"
#include "task\user_task.h"
#include "device\can.h"
#include "bsp\buzzer.h"
#include "bsp\led.h"
#include "gpio.h"
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
// /* Private typedef ---------------------------------------------------------- */

// CAN_t can;
// CAN_RawRx_t can_rx;
// CAN_Output_t can_out;
typedef struct {
    uint32_t tx_mailbox;           // 发送邮箱编号
    uint32_t tx_status;            // 发送状态 (HAL_OK, HAL_ERROR, etc.)
    uint32_t last_tx_id;           // 最后发送的 CAN ID
    uint8_t last_tx_data[8];       // 最后发送的数据
    uint8_t last_tx_dlc;           // 最后发送的数据长度
} CAN_TxStatus_t;
// CAN_Params_t can_param = {
//     .sick = BSP_CAN_1,
// };
// // /* Private define ----------------------------------------------------------- */

// // /* Private variables -------------------------------------------------------- */

CAN_TxStatus_t can_tx_status = {0};
// // /* Private function prototypes ---------------------------------------------- */


// // CAN_RxMessage_t rx_msg;
// /* Exported functions ------------------------------------------------------- */
// void Task_Can(void *argument) {
//     (void)argument; // 消除未使用参数的警告
//     const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_CAN; // 100Hz
//     uint32_t tick = osKernelGetTickCount(); /* 控制任务运行频率的计时 */
//     // HAL_Delay(5000); // 延时 1 秒
//     CAN_Init(&can, &can_param); // 初始化CAN
//     // BSP_Buzzer_Set(0.9, 0.8); // 设置蜂鸣器频率和占空比
//     while (1) {
//         tick += delay_tick; /* 计算下一个唤醒时刻 */
//         // BSP_Buzzer_Start();
        
        
//         while (osMessageQueueGet(can.msgq_raw, &can_rx, 0, 0) == osOK) {
//             // BSP_Buzzer_Start();
//           }
//           HAL_Delay(10); // 延时 1 秒
//         //   BSP_Buzzer_Stop();
//         osDelayUntil(tick); /* 运行结束，等待下一次唤醒 */
//     }
// }


/* Private typedef ---------------------------------------------------------- */
CAN_t can;
CAN_RawRx_t can_rx;
CAN_RawTx_t can_tx;

CAN_Params_t can_param = {
    .sick = BSP_CAN_1,
    .c_board = BSP_CAN_2,
};

/* Exported functions ------------------------------------------------------- */
// void Task_Can(void *argument) {
//     (void)argument; // 消除未使用参数的警告
//     const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_CAN; // 100Hz
//     uint32_t tick = osKernelGetTickCount(); /* 控制任务运行频率的计时 */

//     // 初始化 CAN
//     if (CAN_Init(&can, &can_param) != DEVICE_OK) {
//         // printf("CAN 初始化失败！\n");
//         return;
//     }

//     // 配置发送数据
//     can_tx.tx_header.StdId = 0x123; // 测试用 CAN ID
//     can_tx.tx_header.RTR = CAN_RTR_DATA;
//     can_tx.tx_header.IDE = CAN_ID_STD;
//     can_tx.tx_header.DLC = 8; // 数据长度
//     uint8_t test_data[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
//     memcpy(can_tx.tx_data, test_data, sizeof(test_data));
//     BSP_Buzzer_Set(0.1, 0.1); // 设置蜂鸣器频率和占空比
//     while (1) {
//         tick += delay_tick; /* 计算下一个唤醒时刻 */

//         // 发送数据
//         if (HAL_CAN_AddTxMessage(BSP_CAN_GetHandle(BSP_CAN_1), &can_tx.tx_header, can_tx.tx_data, &can.mailbox.sick) == HAL_OK) {
//             // 等待接收数据
//             if (osMessageQueueGet(can.msgq_raw, &can_rx, NULL, osWaitForever) == osOK) {
//                 // 验证接收数据是否正确
//                 if (can_rx.rx_header.StdId == can_tx.tx_header.StdId &&
//                     memcmp(can_rx.rx_data, test_data, sizeof(test_data)) == 0) {
//                     // 数据一致，启动蜂鸣器
//                     // BSP_Buzzer_Start();
//                 } else {
//                     // 数据不一致，停止蜂鸣器
//                     BSP_Buzzer_Stop();
//                 }
//             }
//         } else {
//             // 发送失败，停止蜂鸣器
//             BSP_Buzzer_Stop();
//         }

//         osDelayUntil(tick); /* 运行结束，等待下一次唤醒 */
//     }
// }
// ...existing code...

// void Task_Can(void *argument) {
//     (void)argument; // 消除未使用参数的警告
//     const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_CAN; // 100Hz
//     uint32_t tick = osKernelGetTickCount(); /* 控制任务运行频率的计时 */

//     // 初始化 CAN1 和 CAN2
    
//     // CAN_Params_t can2_param = {.sick = BSP_CAN_2};

//     if (CAN_Init(&can, &can_param) != DEVICE_OK) {
//         return;
//     }


//     // 配置 CAN1 发送数据
//     // can_tx.tx_header.StdId = 0x200; // 测试用 CAN ID
//     // can_tx.tx_header.RTR = CAN_RTR_DATA;
//     // can_tx.tx_header.IDE = CAN_ID_STD;
//     // can_tx.tx_header.DLC = 8; // 数据长度
//     // uint8_t test_data[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
//     // memcpy(can_tx.tx_data, test_data, sizeof(test_data));

//     while (1) {
//         tick += delay_tick; /* 计算下一个唤醒时刻 */

//         // CAN1 发送数据
//         // can_tx_status.tx_status = HAL_CAN_AddTxMessage(
//         //     BSP_CAN_GetHandle(BSP_CAN_1),
//         //     &can_tx.tx_header,
//         //     can_tx.tx_data,
//         //     &can_tx_status.tx_mailbox
//         // );

//         // if (can_tx_status.tx_status == HAL_OK) {
//         //     // 更新发送状态
//         //     can_tx_status.last_tx_id = can_tx.tx_header.StdId;
//         //     can_tx_status.last_tx_dlc = can_tx.tx_header.DLC;
//         //     memcpy(can_tx_status.last_tx_data, can_tx.tx_data, can_tx.tx_header.DLC);
//         // }

//         // CAN2 接收数据
//         // if (osMessageQueueGet(can.msgq_raw, &can_rx, NULL, 0) == osOK) {
//         //     if (can_rx.rx_header.StdId == can_tx.tx_header.StdId &&
//         //         memcmp(can_rx.rx_data, test_data, sizeof(test_data)) == 0) {
//         //         // 数据一致，点亮 LED
//         //         BSP_LED_Set(BSP_LED_RED, BSP_LED_ON, 0);
//         //     } else {
//         //         // 数据不一致，熄灭 LED
//         //         BSP_LED_Set(BSP_LED_RED, BSP_LED_ON, 1);
//         //     }
//         // }

//         osDelayUntil(tick); /* 运行结束，等待下一次唤醒 */
//     }
// }

void Task_Can(void *argument) {
    (void)argument; // 消除未使用参数的警告
    const uint32_t delay_tick = osKernelGetTickFreq() / TASK_FREQ_CAN; // 100Hz
    uint32_t tick = osKernelGetTickCount(); /* 控制任务运行频率的计时 */

    // 初始化 CAN1 和 CAN2
    if (CAN_Init(&can, &can_param) != DEVICE_OK) {
        return;
    }

    // 配置 CAN1 发送数据
    can_tx.tx_header.StdId = 0x200; // 测试用 CAN ID
    can_tx.tx_header.RTR = CAN_RTR_DATA;
    can_tx.tx_header.IDE = CAN_ID_STD;
    can_tx.tx_header.DLC = 8; // 数据长度
    uint8_t test_data[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
    memcpy(can_tx.tx_data, test_data, sizeof(test_data));

    while (1) {
        tick += delay_tick; /* 计算下一个唤醒时刻 */

        // CAN1 发送数据
        if (HAL_CAN_AddTxMessage(
                BSP_CAN_GetHandle(BSP_CAN_2),
                &can_tx.tx_header,
                can_tx.tx_data,
                &can.mailbox.sick) == HAL_OK) {
            
            // CAN2 接收数据
            if (osMessageQueueGet(can.msgq_raw, &can_rx, NULL, osWaitForever) == osOK) {
                // 验证接收数据是否正确
                if (can_rx.rx_header.StdId == can_tx.tx_header.StdId &&
                    memcmp(can_rx.rx_data, test_data, sizeof(test_data)) == 0) {
                    // 数据一致，点亮红色 LED
                    BSP_LED_Set(BSP_LED_RED, BSP_LED_ON, 0);
                } else {
                    // 数据不一致，熄灭红色 LED
                    BSP_LED_Set(BSP_LED_RED, BSP_LED_ON, 1);
                }
            }
        }

        osDelayUntil(tick); /* 运行结束，等待下一次唤醒 */
    }
}