#define _USE_MATH_DEFINES
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <stdint.h>

#pragma pack(push, 1)
// 帧结构：3字节同步AA4412 + 28字节帧头，总31字节
typedef struct {
    uint8_t Sync[3];              // 同步头 0xAA,0x44,0x12

    uint8_t HeaderLength;         // 偏移3  1B 固定0x1C(28)
    uint16_t MessageID;           // 偏移4  2B 小端
    uint8_t MessageType;          // 偏移6  1B 0二进制/1ASCII
    uint8_t Reserved1;            // 偏移7  1B 保留
    uint16_t MessageLength;       // 偏移8  2B 消息体长度小端
    uint16_t Reserved2;           // 偏移10 2B 保留
    uint8_t IdleTime;             // 偏移12 1B 0~200
    uint8_t TimeStatus;           // 偏移13 1B 20未知 / 160精准
    uint16_t GpsWeek;             // 偏移14 2B GPS周小端
    uint32_t GpsMs;               // 偏移16 4B 本周毫秒小端
    uint32_t Reserved3;           // 偏移20 4B 保留
    uint16_t BdsGpsTimeOffset;    // 偏移24 2B 北斗GPS时差小端
    uint16_t Reserved4;           // 偏移26 2B 保留
} LogFramePrefix;
#pragma pack(pop)

// 小端2字节转主机序 uint16_t
static uint16_t le16(const uint8_t *p)
{
    return (uint16_t)p[0] | ((uint16_t)p[1] << 8);
}

// 小端4字节转主机序 uint32_t
static uint32_t le32(const uint8_t *p)
{
    return (uint32_t)p[0] | ((uint32_t)p[1] << 8)
           | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
}

/**
 * 解析完整一帧
 * buf: 整帧字节缓冲区
 * buf_len: 缓冲区总字节数
 * out: 输出解析后的帧结构体（主机序）
 * msg_body_out: 输出消息体起始地址
 * return: 0成功 / -1长度不足 / -2同步头错误
 */
int parseLogFrame(const uint8_t *buf, int buf_len, LogFramePrefix *out, const uint8_t **msg_body_out)
{
    const int HDR_TOTAL = sizeof(LogFramePrefix);
    if (buf_len < HDR_TOTAL)
    {
        printf("[ERR] 帧数据长度不足31字节\n");
        return -1;
    }
    memcpy(out, buf, HDR_TOTAL);

    // 校验同步头
    if (out->Sync[0] != 0xAA || out->Sync[1] != 0x44 || out->Sync[2] != 0x12)
    {
        printf("[ERR] 同步头AA4412不匹配，非有效帧\n");
        return -2;
    }

    uint8_t *raw = (uint8_t *)buf;
    out->MessageID        = le16(raw + 4);
    out->MessageLength    = le16(raw + 8);
    out->Reserved2        = le16(raw + 10);
    out->GpsWeek          = le16(raw + 14);
    out->GpsMs            = le32(raw + 16);
    out->Reserved3        = le32(raw + 20);
    out->BdsGpsTimeOffset = le16(raw + 24);
    out->Reserved4        = le16(raw + 26);

    *msg_body_out = buf + HDR_TOTAL;
    return 0;
}

// 打印帧全部解析信息
void printFrameInfo(const LogFramePrefix *hdr, const uint8_t *msg_body, int body_len)
{
    printf("==================== 帧头部解析结果 ====================\n");
    printf("同步 Sync: 0x%02X,0x%02X,0x%02X\n", hdr->Sync[0], hdr->Sync[1], hdr->Sync[2]);
    printf("HeaderLength: 0x%02X (%d 字节头)\n", hdr->HeaderLength, hdr->HeaderLength);
    printf("MessageID: %u (0x%04X)\n", hdr->MessageID, hdr->MessageID);

    const char *typeStr;
    if (hdr->MessageType == 0) typeStr = "二进制";
    else if (hdr->MessageType == 1) typeStr = "ASCII";
    else typeStr = "简化ASCII";
    printf("MessageType: %u (%s)\n", hdr->MessageType, typeStr);

    printf("Reserved1: 0x%02X\n", hdr->Reserved1);
    printf("MessageLength: %u 字节\n", hdr->MessageLength);
    printf("Reserved2: 0x%04X\n", hdr->Reserved2);
    printf("IdleTime: %d (空闲占比 %.1f%%)\n", hdr->IdleTime, hdr->IdleTime / 2.0);

    const char *timeState;
    if (hdr->TimeStatus == 160) timeState = "时间精准";
    else if (hdr->TimeStatus == 20) timeState = "时间未知";
    else timeState = "未知状态";
    printf("TimeStatus: %d (%s)\n", hdr->TimeStatus, timeState);

    printf("GPS Week: %u 周\n", hdr->GpsWeek);
    printf("GPS Ms(本周毫秒): %u\n", hdr->GpsMs);
    printf("Reserved3: 0x%08X\n", hdr->Reserved3);
    printf("BDS-GPS时差(ms): %d\n", hdr->BdsGpsTimeOffset);
    printf("Reserved4: 0x%04X\n", hdr->Reserved4); // 修复字段名错误

    printf("==================== 消息体信息 ====================\n");
    printf("消息体实际可用长度: %d 字节\n", body_len);
    if (body_len > 0)
    {
        int show = body_len > 16 ? 16 : body_len;
        printf("消息体前%d字节预览: ", show);
        for (int i = 0; i < show; i++)
            printf("%02X ", msg_body[i]);
        printf("\n");
    }
    printf("====================================================\n\n");
}

// 全局缓冲区
static unsigned char sta_byte_u[256];
static unsigned char sta_len_u = 0;
static uint8_t frame_buf[65536]; // 单帧缓存
static int frame_idx = 0;
static int expect_total = 0;     // 本帧总字节数

// 单帧缓存重置
static void reset_frame(void)
{
    memset(frame_buf, 0, sizeof(frame_buf));
    frame_idx = 0;
    expect_total = 0;
    sta_len_u = 0;
    memset(sta_byte_u, 0, sizeof(sta_byte_u));
}

/**
 * 流式解析函数：串口分段输入缓存，识别AA4412帧头，收完整帧自动解析打印
 * str: 分段接收字节数组
 * len: 当前分段长度
 */
void unicore_static_rinex_run(char* str, int len)
{
    int i;
    for (i = 0; i < len; i++)
    {
        uint8_t ch = (uint8_t)str[i];
        sta_byte_u[sta_len_u++] = ch;

        // 识别帧头 AA 44 12
        if (sta_len_u >= 3
            && sta_byte_u[sta_len_u - 3] == 0xAA
            && sta_byte_u[sta_len_u - 2] == 0x44
            && sta_byte_u[sta_len_u - 1] == 0x12)
        {
            // 新帧起始，清空缓存
            reset_frame();
            frame_buf[frame_idx++] = 0xAA;
            frame_buf[frame_idx++] = 0x44;
            frame_buf[frame_idx++] = 0x12;
            sta_len_u = 0;
            continue;
        }

        // 正在接收一帧
        if (frame_idx > 0)
        {
            frame_buf[frame_idx++] = ch;

            // 帧头第8、9字节是消息长度小端，计算整帧总长 = 31 + MessageLength
            if (frame_idx == 10)
            {
                uint16_t msg_len = le16(frame_buf + 8);
                expect_total = 31 + msg_len;
            }

            // 收齐完整帧，解析打印
            if (frame_idx >= expect_total && expect_total != 0)
            {
                LogFramePrefix frame;
                const uint8_t *msg_body = NULL;
                int ret = parseLogFrame(frame_buf, frame_idx, &frame, &msg_body);
                if (ret == 0)
                {
                    int body_len = frame_idx - sizeof(LogFramePrefix);
                    printf("===== 收到完整帧，解析结果 =====\n");
                    printFrameInfo(&frame, msg_body, body_len);
                }
                // 解析完成，清空等待下一帧
                reset_frame();
            }
        }
    }
}

// 测试主函数1：内置完整帧直接解析
int main(void)
{
    // 测试用完整帧数据
    uint8_t hex_sta[] = {
        0xAA,0x44,0x12,0x1C,0xF9,0x04,0x00,0x01,0x46,0x02,0xC0,0x34,0x59,0xA0,0x76,0x09,0x60,0x93,0x40,0x17,0xFC,0xD7,0x23,0x00,0x00,0x00,0x12,0x00,0x42,0x02,0x00,
        0x00,0x01,0x1F,0x00,0xB4,0x1A,0x55,0x85,0x8D,0x04,0x20,0xE1,0xFF,0xFF,0xFF,0x01,0x10,0x47,0x07,0x70,0xFC,0x00,0x10,0x00,0x84,0x00,0x00,0x00,0xE7,0xCF,0xDB,0xA8,0x5D,0x83,0x7A,0xFF,0x03,0x1C,0x00,0xF4,0xC3,0x00,0x85,0x57,0x01,0x30,0x81,0x00,0x00,0x00,0x63,0x99,0x04,0x20,0x25,0x80,0x35,0x00,0xE4,0xFF,0xFF,0xFF,0x01,0x6B,0x8B,0xB4,0x48,0x2A,0x83,0xA5,0xFD,0xE7,0xFF,0xFF,0xFF,0x01,0x71,0x87,0x7C,0x78,0x93,0x05,0x9B,0xFD,0x08,0x02,0x00,0xF8,0x5B,0xEA,0x85,0x16,0x00,0x10,0xE1,0xFF,0xFF,0xFF,0x01,0x6E,0x69,0x18,0x70,0x3F,0x00,0x47,0x00,0x12,0x90,0x20,0x40,0x36,0xDA,0x08,0xF0,0xFF,0xFF,0x1F,0xFE,0x1F,0xFF,0xFF,0xFF,0x21,0x4F,0x29,0x0C,0xD8,0xE2,0x00,0xF8,0xFF,0x15,0x80,0x20,0xAC,0xFD,0xD8,0x88,0xFD,0xFF,0xFF,0x1F,0xFE,0x1F,0xFF,0xFF,0xFF,0x21,0x4E,0x09,0x07,0x00,0x71,0x81,0xC4,0xFF,0x02,0x0F,0x17,0xD8,0xB4,0x3B,0x05,0xE2,0x07,0x10,0x81,0x00,0x00,0x00,0xE3,0x19,0x07,0x28,0x19,0x80,0x65,0x00,0x03,0x13,0x1A,0x7C,0xC1,0x8A,0x05,0x63,0xFC,0x2F,0xE1,0x96,0x23,0x00,0x29,0x6B,0x5F,0x18,0x0D,0x01,0xBC,0xFF,0xE4,0xFF,0xFF,0xFF,0x01,0x8D,0x69,0x1A,0x11,0x19,0x80,0xA4,0xFF,0x0C,0x12,0x14,0x3C,0x6B,0xB4,0x85,0x62,0xFB,0x1F,0x84,0x00,0x00,0x00,0x82,0x39,0x0E,0x18,0x34,0x00,0x0B,0xAE,0x05,0x02,0x60,0x58,0x36,0xDA,0x88,0xF0,0xFF,0xFF,0x1F,0xFE,0x2F,0xFF,0xFF,0xFF,0x01,0x52,0x87,0x0C,0x50,0x28,0x00,0x8E,0xFF,0x0B,0x0E,0x60,0x04,0x0B,0xCF,0x85,0xC7,0x04,0x20,0xE1,0xF6,0xC2,0x00,0x2A,0x6B,0x5F,0x60,0xFE,0x00,0x52,0x00,0xED,0xFF,0xFF,0xFF,0x01,0xEB,0x4A,0x0B,0xF8,0x47,0x00,0x0B,0x00,0x0D,0x1A,0x60,0x24,0xD3,0xB1,0x05,0x46,0x05,0x30,0xE1,0xDE,0xC6,0x00,0xE9,0x2B,0x98,0x68,0xA5,0x00,0x1F,0x00,0xF3,0x2A,0x80,0x00,0x0A,0x88,0xD3,0xF1,0x00,0x08,0x04,0x40,0x00,0xF4,0xFF,0xFF,0xFF,0x01,0xEF,0xC8,0xA7,0xC8,0x9B,0x03,0xDC,0xFF,0x0E,0x0A,0x60,0x98,0xB1,0xAF,0x88,0x82,0xFF,0x2F,0xE1,0x9A,0x01,0x00,0xE5,0x53,0x1D,0x38,0x7E,0x80,0xF9,0xFF,0xE3,0x52,0x0D,0x00,0xE6,0xD1,0x05,0x98,0x1C,0x80,0xB2,0xFF,0x17,0x15,0x60,0x8C,0x85,0x77,0x85,0xE5,0x02,0x20,0x8D,0x00,0x00,0x00,0x63,0x79,0x0F,0x00,0x36,0x00,0x16,0xAB,0x94,0x00,0x00,0x00,0x46,0x19,0x35,0x50,0xD3,0x00,0xE1,0xA9,0x01,0x0F,0x50,0xD0,0x01,0xB0,0xF8,0x65,0xDF,0xB3,0xFE,0x11,0xA8,0xB0,0x02,0xF0,0x9B,0x06,0x83,0x80,0x0A,0x2F,0xFF,0xE2,0x06,0x22,0x00,0xE6,0x6D,0x98,0x09,0x67,0x05,0x97,0xFF,0xE3,0x8E,0x03,0x00,0xE4,0x91,0xEF,0xC8,0xAC,0x03,0x41,0x00,0x06,0x07,0x50,0x07,0xCD,0x59,0xD0,0x6A,0x50,0x02,0x30,0xE1,0x5E,0x3D,0x00,0x69,0xED,0x30,0xF0,0x03,0x20,0x02,0x50,0x00,0xE2,0xFF,0xFF,0xFF,0x01,0x0F,0x89,0xD2,0xC8,0x17,0x06,0x15,0x00,0xE3,0xFF,0xFF,0xFF,0x01,0x4D,0x69,0x93,0xA8,0x18,0x85,0x58,0x00,0x07,0x0D,0x50,0xE4,0x29,0x18,0x86,0x89,0xFF,0x3F,0xE1,0xFF,0xFF,0xFF,0x01,0xEB,0xEB,0x3A,0xE0,0x1E,0x00,0xFF,0xFF,0xFF,0xE2,0xFF,0xFF,0xFF,0x01,0x34,0x85,0xC6,0x28,0xC3,0x03,0xD9,0xFF,0xE3,0xFF,0xFF,0xFF,0x01,0xAF,0xA9,0x97,0x48,0x91,0x05,0xED,0xFF,0x09,0x08,0x50,0xFC,0x1F,0xDF,0x85,0x3B,0x01,0x30,0x81,0x00,0x00,0x00,0xE3,0x39,0xF2,0x88,0xBD,0x83,0x25,0x00,0xE2,0xFF,0xFF,0xFF,0x01,0x8A,0xEB,0x1C,0x10,0x9B,0x01,0xC1,0xFD,0xE3,0xFF,0xFF,0xFF,0x01,0xAB,0xAB,0x01,0xB0,0x8B,0x81,0xBB,0xFD,0x3F,0x9F,0x55,0xAA
    };
    int total_len = sizeof(hex_sta);
    // 直接送入流式解析接口
    unicore_static_rinex_run((char *)hex_sta, total_len);
    return 0;
}

/*
// 文件读取主函数（取消注释可使用二进制文件解析）
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./parse bin_data.dat\n");
        return 1;
    }
    FILE *fp = fopen(argv[1], "rb");
    if (!fp)
    {
        perror("open file failed");
        return -1;
    }
    char buf[1024];
    int rd;
    while ((rd = fread(buf, 1, sizeof(buf), fp)) > 0)
    {
        unicore_static_rinex_run(buf, rd);
    }
    fclose(fp);
    return 0;
}
*/



#define _USE_MATH_DEFINES
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <stdint.h>
#include <stdint.h>

#pragma pack(push, 1)

// 日志帧头部结构体，完全匹配截图表格，总28字节头部（不含3字节同步头AA4412）
typedef struct {
    uint8_t Sync[3];              // 固定 AA 44 12

    uint8_t HeaderLength;         // 偏移3  1B 头长度固定0x1C(28)
    uint16_t MessageID;           // 偏移4  2B 消息ID 小端
    uint8_t MessageType;          // 偏移6  1B 00=二进制 01=ASCII 10=简化ASCII
    uint8_t Reserved1;            // 偏移7  1B 保留
    uint16_t MessageLength;       // 偏移8  2B 消息体长度 小端
    uint16_t Reserved2;           // 偏移10 2B 保留
    uint8_t IdleTime;             // 偏移12 1B 空闲计数0~200
    uint8_t TimeStatus;           // 偏移13 1B 20未知/160精准
    uint16_t GpsWeek;             // 偏移14 2B GPS周数 小端
    uint32_t GpsMs;               // 偏移16 4B 本周毫秒 小端
    uint32_t Reserved3;           // 偏移20 4B 保留(可选)
    uint16_t BdsGpsTimeOffset;    // 偏移24 2B 北斗-GPS时差 小端(可选)
    uint16_t Reserved4;           // 偏移26 2B 保留(可选)
} LogFramePrefix; // // 总3+28=31字节头部前缀

#pragma pack(pop)

// 小端转本机u16
static uint16 le16(const uint8_t *p)
{
    return (uint16)p[0] | ((uint16)p[1] << 8);
}
// 小端转本机u32
static uint32 le32(const uint8_t *p)
{
    return (uint32)p[0] | ((uint32)p[1] << 8) | ((uint32)p[2] << 16) | ((uint32)p[3] << 24);
}

/**
 * @brief 解析帧前缀（同步+28字节头）
 * @param buf 原始hex数组首地址
 * @param buf_len 数组总长度，必须>=31
 * @param out 输出解析好的结构体（多字节已转主机序）
 * @param msg_body_out 输出消息体起始指针
 * @return 0成功，-1长度不足，-2同步头校验失败
 */
int parseLogFrame(const uint8_t *buf, int buf_len, LogFramePrefix *out, const uint8_t **msg_body_out)
{
    if (buf_len < sizeof(LogFramePrefix))
    {
        printf("错误：数据长度不足31字节\n");
        return -1;
    }
    // 先拷贝原始字节（未转换大小端）
    memcpy(out, buf, sizeof(LogFramePrefix));

    // 校验同步头 AA 44 12
    if (out->Sync[0] != 0xAA || out->Sync[1] != 0x44 || out->Sync[2] != 0x12)
    {
        printf("错误：同步头不匹配，非目标帧\n");
        return -2;
    }

    // 小端多字节字段转主机序
    uint8_t *pRaw = (uint8_t *)buf;
    out->MessageID        = le16(pRaw + 4);
    out->MessageLength    = le16(pRaw + 8);
    out->Reserved2        = le16(pRaw + 10);
    out->GpsWeek          = le16(pRaw + 14);
    out->GpsMs            = le32(pRaw + 16);
    out->Reserved3        = le32(pRaw + 20);
    out->BdsGpsTimeOffset = le16(pRaw + 24);
    out->Reserved4        = le16(pRaw + 26);

    // 消息体起始位置 = 31字节头部之后
    *msg_body_out = buf + sizeof(LogFramePrefix);
    return 0;
}

// 打印解析后的全部结构体内容
void printFrameInfo(const LogFramePrefix *hdr, const uint8_t *msg_body, int body_len)
{
    printf("==================== 帧头部解析结果 ====================\n");
    printf("同步 Sync: 0x%02X,0x%02X,0x%02X\n", hdr->Sync[0], hdr->Sync[1], hdr->Sync[2]);
    printf("HeaderLength: 0x%02X (%d 字节头)\n", hdr->HeaderLength, hdr->HeaderLength);
    printf("MessageID: %u (0x%04X)\n", hdr->MessageID, hdr->MessageID);

    const char *typeStr;
    if (hdr->MessageType == 0) typeStr = "二进制";
    else if (hdr->MessageType == 1) typeStr = "ASCII";
    else typeStr = "简化ASCII";
    printf("MessageType: %u (%s)\n", hdr->MessageType, typeStr);

    printf("Reserved1: 0x%02X\n", hdr->Reserved1);
    printf("MessageLength: %u 字节\n", hdr->MessageLength);
    printf("Reserved2: 0x%04X\n", hdr->Reserved2);
    printf("IdleTime: %d (空闲占比 %.1f%%)\n", hdr->IdleTime, hdr->IdleTime / 2.0);

    const char *timeState;
    if (hdr->TimeStatus == 160) timeState = "时间精准";
    else if (hdr->TimeStatus == 20) timeState = "时间未知";
    else timeState = "未知状态";
    printf("TimeStatus: %d (%s)\n", hdr->TimeStatus, timeState);

    printf("GPS Week: %u 周\n", hdr->GpsWeek);
    printf("GPS Ms(本周毫秒): %u\n", hdr->GpsMs);
    printf("Reserved3: 0x%08X\n", hdr->Reserved3);
    printf("BDS-GPS时差(ms): %d\n", hdr->BdsGpsTimeOffset);
    printf("Reserved4: 0x%04X\n", hdr->Reserved);

    printf("==================== 消息体信息 ====================\n");
    printf("消息体实际可用长度: %d 字节\n", body_len);
    if (body_len > 0)
    {
        printf("消息体前16字节预览: ");
        int show = body_len > 16 ? 16 : body_len;
        for (int i = 0; i < show; i++)
            printf("%02X ", msg_body[i]);
        printf("\n");
    }
    printf("====================================================\n\n");
}

LogFramePrefix log_frame_prefix;

static unsigned char sta_byte_u[256];  
static unsigned char sta_len_u = 0;


static unsigned char hex_sta[65536];
static int  hex_sta_flags = 0;
static int  sta_data_len      = 0;
static int  sta_Body_len      = 0;
 


static void init_hex_sta_var(void)
{
   hex_sta_flags = 0;
   memset(hex_sta, 0, sizeof(hex_sta));
   sta_data_len = 0;
   sta_Body_len = 0;
}

void  unicore_static_rinex_run(char* str, int len)
{

    int i = 0,j = 0;
    int tmp_len = 0;
    for(i = 0; i < len; i++ , sta_len_u++){
 
        sta_byte_u[sta_len_u] = str[i];
       // printf("%02X ", sta_byte_u[sta_len_u]);
//3.1-----------------------------------
        if((sta_byte_u[sta_len_u] == 0x1c) && 
        (sta_byte_u[(unsigned char)(sta_len_u-1)] == 0x12) && 
        (sta_byte_u[(unsigned char)(sta_len_u-2)] == 0x44) && 
        (sta_byte_u[(unsigned char)(sta_len_u-3)] == 0xaa)){ 
              printf("\n--------start---------------\n");
              init_hex_sta_var();
              hex_sta_flags = 1;
              hex_sta[0] = 0xaa;
              hex_sta[1] = 0x44;
              hex_sta[2] = 0x12;
              sta_data_len = 3;
        }  
//3.2--------------------------------------------------------
        if(hex_sta_flags == 1){
               if(sta_data_len < 11){
                 if(sta_data_len == 8){
                    sta_Body_len = (unsigned char) (str[i] & 0xff);
                 }

                 if(sta_data_len == 9){
                    tmp_len = (unsigned char) (str[i] & 0xff);
                    sta_Body_len += (tmp_len << 8);
                 }
               }

              hex_sta[sta_data_len++] = str[i];
              if(sta_data_len >= sta_Body_len + 32){   // 提取一帧静态数据;
                    printf("\n-----------------------\n");
                    for(j = 0; j < sta_data_len; j++)
                       printf("%02X", hex_sta[j]);
                    printf("\n-----------------------\n");
              }
        }
    }
}



// int main(void)
// {
//     // 你提供的完整十六进制数据转为uint8数组 hex_sta
//     uint8_t hex_sta[] = {
//         0xAA,0x44,0x12,0x1C,0xF9,0x04,0x00,0x01,0x46,0x02,0xC0,0x34,0x59,0xA0,0x76,0x09,0x60,0x93,0x40,0x17,0xFC,0xD7,0x23,0x00,0x00,0x00,0x12,0x00,0x42,0x02,0x00,
//         0x00,0x01,0x1F,0x00,0xB4,0x1A,0x55,0x85,0x8D,0x04,0x20,0xE1,0xFF,0xFF,0xFF,0x01,0x10,0x47,0x07,0x70,0xFC,0x00,0x10,0x00,0x84,0x00,0x00,0x00,0xE7,0xCF,0xDB,0xA8,0x5D,0x83,0x7A,0xFF,0x03,0x1C,0x00,0xF4,0xC3,0x00,0x85,0x57,0x01,0x30,0x81,0x00,0x00,0x00,0x63,0x99,0x04,0x20,0x25,0x80,0x35,0x00,0xE4,0xFF,0xFF,0xFF,0x01,0x6B,0x8B,0xB4,0x48,0x2A,0x83,0xA5,0xFD,0xE7,0xFF,0xFF,0xFF,0x01,0x71,0x87,0x7C,0x78,0x93,0x05,0x9B,0xFD,0x08,0x02,0x00,0xF8,0x5B,0xEA,0x85,0x16,0x00,0x10,0xE1,0xFF,0xFF,0xFF,0x01,0x6E,0x69,0x18,0x70,0x3F,0x00,0x47,0x00,0x12,0x90,0x20,0x40,0x36,0xDA,0x08,0xF0,0xFF,0xFF,0x1F,0xFE,0x1F,0xFF,0xFF,0xFF,0x21,0x4F,0x29,0x0C,0xD8,0xE2,0x00,0xF8,0xFF,0x15,0x80,0x20,0xAC,0xFD,0xD8,0x88,0xFD,0xFF,0xFF,0x1F,0xFE,0x1F,0xFF,0xFF,0xFF,0x21,0x4E,0x09,0x07,0x00,0x71,0x81,0xC4,0xFF,0x02,0x0F,0x17,0xD8,0xB4,0x3B,0x05,0xE2,0x07,0x10,0x81,0x00,0x00,0x00,0xE3,0x19,0x07,0x28,0x19,0x80,0x65,0x00,0x03,0x13,0x1A,0x7C,0xC1,0x8A,0x05,0x63,0xFC,0x2F,0xE1,0x96,0x23,0x00,0x29,0x6B,0x5F,0x18,0x0D,0x01,0xBC,0xFF,0xE4,0xFF,0xFF,0xFF,0x01,0x8D,0x69,0x1A,0x11,0x19,0x80,0xA4,0xFF,0x0C,0x12,0x14,0x3C,0x6B,0xB4,0x85,0x62,0xFB,0x1F,0x84,0x00,0x00,0x00,0x82,0x39,0x0E,0x18,0x34,0x00,0x0B,0xAE,0x05,0x02,0x60,0x58,0x36,0xDA,0x88,0xF0,0xFF,0xFF,0x1F,0xFE,0x2F,0xFF,0xFF,0xFF,0x01,0x52,0x87,0x0C,0x50,0x28,0x00,0x8E,0xFF,0x0B,0x0E,0x60,0x04,0x0B,0xCF,0x85,0xC7,0x04,0x20,0xE1,0xF6,0xC2,0x00,0x2A,0x6B,0x5F,0x60,0xFE,0x00,0x52,0x00,0xED,0xFF,0xFF,0xFF,0x01,0xEB,0x4A,0x0B,0xF8,0x47,0x00,0x0B,0x00,0x0D,0x1A,0x60,0x24,0xD3,0xB1,0x05,0x46,0x05,0x30,0xE1,0xDE,0xC6,0x00,0xE9,0x2B,0x98,0x68,0xA5,0x00,0x1F,0x00,0xF3,0x2A,0x80,0x00,0x0A,0x88,0xD3,0xF1,0x00,0x08,0x04,0x40,0x00,0xF4,0xFF,0xFF,0xFF,0x01,0xEF,0xC8,0xA7,0xC8,0x9B,0x03,0xDC,0xFF,0x0E,0x0A,0x60,0x98,0xB1,0xAF,0x88,0x82,0xFF,0x2F,0xE1,0x9A,0x01,0x00,0xE5,0x53,0x1D,0x38,0x7E,0x80,0xF9,0xFF,0xE3,0x52,0x0D,0x00,0xE6,0xD1,0x05,0x98,0x1C,0x80,0xB2,0xFF,0x17,0x15,0x60,0x8C,0x85,0x77,0x85,0xE5,0x02,0x20,0x8D,0x00,0x00,0x00,0x63,0x79,0x0F,0x00,0x36,0x00,0x16,0xAB,0x94,0x00,0x00,0x00,0x46,0x19,0x35,0x50,0xD3,0x00,0xE1,0xA9,0x01,0x0F,0x50,0xD0,0x1B,0x0F,0x86,0x5D,0xFB,0x3F,0xE1,0x1A,0x8B,0x00,0x2F,0x09,0xB0,0x68,0x38,0x00,0xA2,0xFF,0xE2,0x06,0x22,0x00,0xE6,0x6D,0x98,0x09,0x67,0x05,0x97,0xFF,0xE3,0x8E,0x03,0x00,0xE4,0x91,0xEF,0xC8,0xAC,0x03,0x41,0x00,0x06,0x07,0x50,0x7C,0xD5,0x9D,0x06,0xA5,0x02,0x30,0xE1,0x5E,0x3D,0x00,0x69,0xED,0x30,0xF0,0x03,0x20,0x02,0x50,0x00,0xE2,0xFF,0xFF,0xFF,0x01,0x0F,0x89,0xD2,0xC8,0x17,0x06,0x15,0x00,0xE3,0xFF,0xFF,0xFF,0x01,0x4D,0x69,0x93,0xA8,0x18,0x85,0x58,0x00,0x07,0x0D,0x50,0xE4,0x29,0x18,0x86,0x89,0xFF,0x3F,0xE1,0xFF,0xFF,0xFF,0x01,0xEB,0xEB,0x3A,0xE0,0x1E,0x00,0xFF,0xFF,0xFF,0xE2,0xFF,0xFF,0xFF,0x01,0x34,0x85,0xC6,0x28,0xC3,0x03,0xD9,0xFF,0xE3,0xFF,0xFF,0xFF,0x01,0xAF,0xA9,0x97,0x48,0x91,0x05,0xED,0xFF,0x09,0x08,0x50,0xFC,0x1F,0xDF,0x85,0x3B,0x01,0x30,0x81,0x00,0x00,0x00,0xE3,0x39,0xF2,0x88,0xBD,0x83,0x25,0x00,0xE2,0xFF,0xFF,0xFF,0x01,0x8A,0xEB,0x1C,0x10,0x9B,0x01,0xC1,0xFD,0xE3,0xFF,0xFF,0xFF,0x01,0xAB,0xAB,0x01,0xB0,0x8B,0x81,0xBB,0xFD,0x3F,0x9F,0x55,0xD2,0xAA
//     };
//     int total_len = sizeof(hex_sta);

//     LogFramePrefix frame;
//     const uint8_t *msgBody = NULL;
//     int ret = parseLogFrame(hex_sta, total_len, &frame, &msgBody);
//     if (ret != 0)
//     {
//         printf("解析失败！\n");
//         return -1;
//     }

//     // 计算实际消息体长度
//     int bodyTotalLen = total_len - sizeof(LogFramePrefix);
//     printFrameInfo(&frame, msgBody, bodyTotalLen);

//     return 0;
// }




int main(int argc, char *argv[])
{
    
    char rcv[1024];
    int ret = 0;
    if (argc != 2)
    {
        printf("Usage: %s bin_file\n", argv[0]);
        return 1;
    }


    FILE *fp = fopen(argv[1], "rb");
    if (!fp)
    {
        perror("fopen failed");
        return -1;
    }
   
     while(1){
        ret = fread(rcv, 1, sizeof(rcv), fp);
        printf("ret = %d\n", ret);
        if(ret <= 0)
            break;
        unicore_static_rinex_run(rcv, ret);

     }
    return 0;
}