828F/applications/lvgl/ui_data_csv.c

#include <rtthread.h>
#include <guider/custom/custom.h>
#include <guider/generated/events_init.h>
#include <guider/generated/gui_guider.h>
#include <guider/generated/widgets_init.h>
#include "libcsv.h"
#include "lvgl.h"

#define CSV_MAX_ROWS    260         // 最大行数
#define CSV_MAX_COLS    48          // 每行最大列数
#define CSV_MAX_FIELD   64         // 每个字段最大长度

// ============ 数据结构定义 ============
typedef struct {
    int row;                        // 当前行号
    int col;                        // 当前列号
    int total_rows;                 // 总行数
    int max_cols;                   // 最大列数
    int col_widths[CSV_MAX_COLS];   // 宽度（像素）
    char data[CSV_MAX_ROWS][CSV_MAX_COLS][CSV_MAX_FIELD];  // 固定二维数组
} UserData;

// ============ 字段回调函数 ============
void field_callback(void *data, size_t size, void *user_data) {
    UserData *user = (UserData *)user_data;

    // 检查边界
    if (user->row >= CSV_MAX_ROWS) {
        //rt_kprintf("[W] 超出最大行数 %d\n", CSV_MAX_ROWS);
        return;
    }
    if (user->col >= CSV_MAX_COLS) {
        //rt_kprintf("[W] 超出最大列数 %d\n", CSV_MAX_COLS);
        return;
    }

    // 限制字段长度
    size_t copy_size = size;
    if (copy_size >= CSV_MAX_FIELD) {
        copy_size = CSV_MAX_FIELD - 1;
        //rt_kprintf("[W] 字段截断\n");
    }

    // 复制数据到固定数组
    rt_memcpy(user->data[user->row][user->col], data, copy_size);
    user->data[user->row][user->col][copy_size] = '\0';

    // 计算当前字段宽度并更新列宽
    int field_width = size * 18;  // 假设每个字符 8 像素（英文）
    // 中文字符需要 ×2：field_width = copy_size * 16;
    if (field_width > user->col_widths[user->col]) {
        user->col_widths[user->col] = field_width;
    }
    // 调试输出
    //rt_kprintf("R:%d C:%d V:\"%s\"\n", user->row, user->col, user->data[user->row][user->col]);

    // 列号+1
    user->col++;

    // 更新最大列数
    if (user->col > user->max_cols) {
        user->max_cols = user->col;
    }

    // 更新总行数
    if (user->row + 1 > user->total_rows) {
        user->total_rows = user->row + 1;
    }
}

// ============ 行回调函数 ============
void row_callback(int c, void *user_data) {
    UserData *user = (UserData *)user_data;

    // 行结束，重置列号，行号+1
    user->row++;
    user->col = 0;
}

// ============ 获取指定单元格数据 ============
const char* csv_get_cell(UserData *user, int row, int col) {
    if (user == NULL) {
        return NULL;
    }
    if (row < 0 || row >= user->total_rows) {
        return NULL;
    }
    if (col < 0 || col >= user->max_cols) {
        return NULL;
    }
    return user->data[row][col];
}

// ============ 获取列宽 ============
int csv_get_col_width(UserData *user, int col) {
    if (user == NULL) return 0;
    if (col < 0 || col >= user->max_cols) return 0;
    return user->col_widths[col];
}

// ============ 获取行数 ============
int csv_get_row_count(UserData *user) {
    return user ? user->total_rows : 0;
}

// ============ 获取列数 ============
int csv_get_col_count(UserData *user) {
    return user ? user->max_cols : 0;
}

// ============ 清空数据 ============
void csv_clear_data(UserData *user) {
    if (user == NULL) {
        return;
    }
    user->row = 0;
    user->col = 0;
    user->total_rows = 0;
    user->max_cols = 0;
    for(int i = 0; i < CSV_MAX_COLS; i++)
    {
        user->col_widths[i] = 0;
    }
}

// ============ 解析后创建 LVGL 表格 ============
int parse_csv_string(const char *csv_data, UserData *user)
{
    if (csv_data == NULL) {
        //rt_kprintf("[E] NOT DATA\n");
        return -1;
    }

    if (user == NULL) {
        //rt_kprintf("[E] NOT USER DATA\n");
        return -1;
    }

    // 初始化 UserData
    csv_clear_data(user);

    /*if (container != NULL) {
        lv_obj_set_size(container, LV_PCT(100), LV_SIZE_CONTENT);
        lv_obj_set_style_pad_all(container, 0, LV_PART_MAIN);
    }*/

    struct csv_parser parser;
    csv_init(&parser, 0);

    size_t data_len = rt_strlen(csv_data);
    if (csv_parse(&parser, csv_data, data_len, field_callback, row_callback, user) != data_len) {
        //rt_kprintf("[E] ERR: %s\n", csv_strerror(csv_error(&parser)));
        csv_fini(&parser, field_callback, row_callback, user);
      csv_free(&parser);
      return -1;
    }

    csv_fini(&parser, field_callback, row_callback, user);
    csv_free(&parser);
    //rt_kprintf("ROW: %d\n COL:%d", user->total_rows,user->max_cols);
    return 0;
}

// ============ 全局指针 ============
static UserData *user = NULL;
extern struct rt_memheap sdram_heap;

int parse_csv_to_table(lv_obj_t *container, const char *csv_data) {
    if (container == NULL || csv_data == NULL) {
        return -1;
    }

    user = (UserData *)rt_memheap_alloc(&sdram_heap, sizeof(UserData));

    // 解析 CSV
    if (parse_csv_string(csv_data, user) != 0) {
        return -1;
    }

    // 表格
    lv_obj_set_size(container, LV_PCT(100), LV_SIZE_CONTENT);
    lv_obj_set_style_pad_all(container, 0, LV_PART_MAIN);
    lv_table_set_col_cnt(container,user->max_cols);
    lv_table_set_row_cnt(container,user->total_rows);

    // 设置列宽
    for (int col = 0; col < user->max_cols; col++) {
        lv_table_set_col_width(container, col, user->col_widths[col]);
        //rt_kprintf("COL=%d W=%d\n", col, user->col_widths[col]);
    }

    // 填充表格数据
    for (int i = 0; i < user->total_rows; i++) {
        for (int j = 0; j < user->max_cols; j++) {
            const char *val = csv_get_cell(user, i, j);
            lv_table_set_cell_value(container, i, j, val ? val : "");
        }
    }

    // 释放内存
    rt_memheap_free(user);

    return 0;
}

char value_[512] = {0};
int parse_csv_to_inf(lv_obj_t *container, const char *csv_data ,int W_data,int H_data) {
    if (csv_data == NULL) {
        return 0;
    }

    user = (UserData *)rt_memheap_alloc(&sdram_heap, sizeof(UserData));
    int text_row = 0;

    // 解析 CSV
    if (parse_csv_string(csv_data, user) != 0) {
        return 0;
    }

    // 填充数据
    for (int i = 0; i < 512; i++)
    {
        value_[i] = 0;
    }
    for (int j = 0; j < user->max_cols; j++) {
        text_row = j*28;
        rt_snprintf(value_, sizeof(value_),"%s%s:%s\n",value_,csv_get_cell(user, 0, j),csv_get_cell(user, 1, j));
    }

    // 显示框大小
    if (text_row<H_data) {
        text_row=H_data;
    }
    lv_obj_set_size(container, W_data, text_row);
    lv_label_set_text(container,value_);

    // 释放内存
    rt_memheap_free(user);

    return 0;
}