/*
 * test.c
 *
 *  Created on: 2025年9月17日
 *      Author: ADMINJxy
 */

/* 头文件：寄存器定义来自 Halcogen 生成的 sys_common.h 和 system.h */
#include "HL_system.h"
#include "HL_esm.h"

#include "test.h"

// 初始化帧解析器
void frame_parser_init(FrameParser *parser) {
    memset(parser, 0, sizeof(FrameParser));
    parser->state = STATE_HEADER1;
}

// 重置帧解析器状态
void frame_parser_reset(FrameParser *parser) {
    parser->state = STATE_HEADER1;
    parser->buffer_len = 0;
    parser->expected_len = 0;
    parser->checksum = 0;
}




// 解析帧数据
// 返回成功解析的帧数量
int parse_frame_data(FrameParser *parser, const uint8_t *data, uint16_t len,
                    FrameCallback callback, void *user_data) {
    int frame_count = 0;

    for (uint16_t i = 0; i < len; i++) {
        uint8_t byte = data[i];

        switch (parser->state) {
            case STATE_HEADER1:
                if (byte == 0xEB) {
                    // 找到帧头第一个字节
                    parser->buffer[0] = byte;
                    parser->buffer_len = 1;
                    parser->checksum = byte;
                    parser->state = STATE_HEADER2;
                }
                break;

            case STATE_HEADER2:
                if (byte == 0x90) {
                    // 找到帧头第二个字节
                    parser->buffer[1] = byte;
                    parser->buffer_len = 2;
                    parser->checksum += byte;
                    parser->state = STATE_TYPE;
                } else {
                    // 帧头不匹配，重新寻找
                    frame_parser_reset(parser);
                    // 重新检查当前字节，可能是下一个帧头的开始
                    if (byte == 0xEB) {
                        parser->buffer[0] = byte;
                        parser->buffer_len = 1;
                        parser->checksum = byte;
                        parser->state = STATE_HEADER2;
                    }
                }
                break;

            case STATE_TYPE:
                // 类型标识
                parser->buffer[2] = byte;
                parser->buffer_len = 3;
                parser->checksum += byte;
                parser->state = STATE_COUNT;
                break;

            case STATE_COUNT:
                // 序列计数
                parser->buffer[3] = byte;
                parser->buffer_len = 4;
                parser->checksum += byte;
                parser->state = STATE_LENGTH;
                break;

            case STATE_LENGTH:
                // 指令长度
                parser->buffer[4] = byte;
                parser->buffer_len = 5;
                parser->checksum += byte;
                parser->data_len = byte;
                parser->expected_len = 5 + byte + 1 + 1; // 头部5字节 + 数据长度+1 + 校验和

                if (parser->data_len == 0) {
                    // 没有数据域，直接进入校验和状态
                    parser->state = STATE_CHECKSUM;
                } else {
                    parser->state = STATE_DATA;
                }
                break;

            case STATE_DATA:
                // 指令数据
                if (parser->buffer_len < parser->expected_len - 1) {
                    parser->buffer[parser->buffer_len] = byte;
                    parser->checksum += byte;
                    parser->buffer_len++;

                    // 检查是否接收完所有数据
                    if (parser->buffer_len == parser->expected_len - 1) {
                        parser->state = STATE_CHECKSUM;
                    }
                }
                break;

            case STATE_CHECKSUM:
                // 校验和
                uint8_t calculated_checksum = parser->checksum & 0xFF;

                if (calculated_checksum == byte) {
                    // 校验成功，解析完整帧
                    FrameData frame;
                    frame.type = parser->buffer[2];
                    frame.count = parser->buffer[3];
                    frame.data_len = parser->buffer[4];
                    frame.checksum = byte;

                    // 分配内存并复制指令数据
                    if (frame.data_len > 0) {
                        frame.data = (uint8_t*)pvPortMalloc(frame.data_len);
                        if (frame.data) {
                            memcpy(frame.data, &parser->buffer[5], frame.data_len);
                        }
                    } else {
                        frame.data = NULL;
                    }

                    // 调用回调函数
                    if (callback) {
                        callback(&frame, user_data);
                    }

                    // 释放数据内存
                    if (frame.data) {
                        vPortFree(frame.data);
                    }//在运行的时候在释放

                    frame_count++;
                } else {
                    // 校验失败，可以记录错误日志
                    printf("Checksum error: expected 0x%02X, got 0x%02X\n",
                           calculated_checksum, byte);
                }

                // 无论校验是否成功，都重置状态寻找下一帧
                frame_parser_reset(parser);
                break;
        }

        // 防止缓冲区溢出
        if (parser->buffer_len >= sizeof(parser->buffer)) {
            frame_parser_reset(parser);
        }
    }

    return frame_count;
}





