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"
#include "SC828_DATA_table.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,int flags) {
    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;
    }
    int data_row  = user->total_rows;

    // 表格
    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 + flags, j);
            lv_table_set_cell_value(container, i, j, val ? val : "");
        }
    }

    // 释放内存
    rt_memheap_free(user);

    return data_row;
}

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;
}

// ============ 处理启动信息 ============
#include "Variable.h"
//处理信息表
int run_csv_to_table(const char *csv_data) {
    if (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(guider_ui.screen_run_step, LV_PCT(100), LV_SIZE_CONTENT);
    lv_obj_set_style_pad_all(guider_ui.screen_run_step, 0, LV_PART_MAIN);
    lv_table_set_col_cnt(guider_ui.screen_run_step,user->max_cols);
    lv_table_set_row_cnt(guider_ui.screen_run_step,user->total_rows);
    lv_table_set_col_width(guider_ui.screen_run_step, 0, 80);
    lv_table_set_col_width(guider_ui.screen_run_step, 1, 370);
    lv_table_set_cell_value(guider_ui.screen_run_step,0,0,"步");
    lv_table_set_cell_value(guider_ui.screen_run_step,0,1,"工艺");

    //先停止清除任务缓存信息
    DATA_INSTRUCTION_STOP();

    // 填充表格数据
    for (int i = 1; i < user->total_rows; i++) {
        lv_table_set_cell_value_fmt(guider_ui.screen_run_step, i, 0,"%d",i);
        lv_table_set_cell_value(guider_ui.screen_run_step, i, 1,csv_get_cell(user, i, 2));

        //数据组信息
        step_table[i-1].RUN = 0;
        rt_snprintf(step_table[i-1].Dyelot ,1,csv_get_cell(user, i, 0));
        rt_snprintf(step_table[i-1].StepID ,1,csv_get_cell(user, i, 1));
        rt_snprintf(step_table[i-1].StepName ,1,csv_get_cell(user, i, 2));
        rt_snprintf(step_table[i-1].ParameterName ,1,csv_get_cell(user, i, 3));
        step_table[i-1].Parameter1 = atof(csv_get_cell(user, i, 4));
        step_table[i-1].Parameter2 = atof(csv_get_cell(user, i, 5));
        step_table[i-1].Parameter3 = atof(csv_get_cell(user, i, 6));
        step_table[i-1].Parameter4 = atof(csv_get_cell(user, i, 7));
        step_table[i-1].Parameter5 = atof(csv_get_cell(user, i, 8));
        step_table[i-1].P6 = atoi(csv_get_cell(user, i, 9));
        step_table[i-1].P7 = atoi(csv_get_cell(user, i, 10));
        step_table[i-1].P8 = atoi(csv_get_cell(user, i, 11));
        step_table[i-1].P9 = atoi(csv_get_cell(user, i, 12));
        step_table[i-1].P10 = atoi(csv_get_cell(user, i, 13));
        step_table[i-1].Parameter1_S1 = atof(csv_get_cell(user, i, 14));
        step_table[i-1].Parameter2_S1 = atof(csv_get_cell(user, i, 15));
        step_table[i-1].Parameter3_S1 = atof(csv_get_cell(user, i, 16));
        step_table[i-1].Parameter4_S1 = atof(csv_get_cell(user, i, 17));
        step_table[i-1].Parameter5_S1 = atof(csv_get_cell(user, i, 18));
        step_table[i-1].Parameter1_S2 = atof(csv_get_cell(user, i, 19));
        step_table[i-1].Parameter2_S2 = atof(csv_get_cell(user, i, 20));
        step_table[i-1].Parameter3_S2 = atof(csv_get_cell(user, i, 21));
        step_table[i-1].Parameter4_S2 = atof(csv_get_cell(user, i, 22));
        step_table[i-1].Parameter5_S2 = atof(csv_get_cell(user, i, 23));
        step_table[i-1].Parameter1_S3 = atof(csv_get_cell(user, i, 24));
        step_table[i-1].Parameter2_S3 = atof(csv_get_cell(user, i, 25));
        step_table[i-1].Parameter3_S3 = atof(csv_get_cell(user, i, 26));
        step_table[i-1].Parameter4_S3 = atof(csv_get_cell(user, i, 27));
        step_table[i-1].Parameter5_S3 = atof(csv_get_cell(user, i, 28));
        step_table[i-1].ReDye = atoi(csv_get_cell(user, i, 29));
        rt_snprintf(step_table[i-1].StepID_S1, 3,csv_get_cell(user, i, 30));
        rt_snprintf(step_table[i-1].StepID_S2, 3,csv_get_cell(user, i, 31));
        rt_snprintf(step_table[i-1].StepID_S3, 3,csv_get_cell(user, i, 32));
    }

    // 释放内存
    rt_memheap_free(user);

    return 0;
}

//处理启动设置
int run_csv_to_set(const char *csv_data) {
    if (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;
    }

    //数据组信息
    rt_snprintf(Work,sizeof(Work),csv_get_cell(user, 1, 0));
    rt_snprintf(Dye,sizeof(Dye),csv_get_cell(user, 1, 1));
    rt_snprintf(Process,sizeof(Process),"%s:%s","工艺",csv_get_cell(user, 1, 2));
    Pump = atoi(csv_get_cell(user, 1, 3));
    Fan = atoi(csv_get_cell(user, 1, 4));
    Swing = atoi(csv_get_cell(user, 1, 5));
    Pull1 = atoi(csv_get_cell(user, 1, 6));
    Pull2=Pull1; Pull3=Pull1; Pull4=Pull1; Pull5=Pull1;Pull6=Pull1;

    // 释放内存
    rt_memheap_free(user);

    return 0;
}

// ============ 处理启动信息 ============
//处理程序表
IO_STEP_DATA step_csv_to_table(const char *csv_data) {
    IO_STEP_DATA temp = {0};

    if (csv_data == NULL) {
        return temp;
    }

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

    // 解析 CSV
    if (parse_csv_string(csv_data, user) != 0) {
        return temp;
    }
        //数据组信息
    temp.RUN = 0;
        rt_snprintf(temp.Dyelot ,1,csv_get_cell(user, 1, 0));
        rt_snprintf(temp.StepID ,1,csv_get_cell(user, 1, 1));
        rt_snprintf(temp.StepName ,1,csv_get_cell(user, 1, 2));
        rt_snprintf(temp.ParameterName ,1,csv_get_cell(user, 1, 3));
        temp.Parameter1 = atof(csv_get_cell(user, 1, 4));
        temp.Parameter2 = atof(csv_get_cell(user, 1, 5));
        temp.Parameter3 = atof(csv_get_cell(user, 1, 6));
        temp.Parameter4 = atof(csv_get_cell(user, 1, 7));
        temp.Parameter5 = atof(csv_get_cell(user, 1, 8));
        temp.P6 = atoi(csv_get_cell(user, 1, 9));
        temp.P7 = atoi(csv_get_cell(user, 1, 10));
        temp.P8 = atoi(csv_get_cell(user, 1, 11));
        temp.P9 = atoi(csv_get_cell(user, 1, 12));
        temp.P10 = atoi(csv_get_cell(user, 1, 13));
        temp.Parameter1_S1 = atof(csv_get_cell(user, 1, 14));
        temp.Parameter2_S1 = atof(csv_get_cell(user, 1, 15));
        temp.Parameter3_S1 = atof(csv_get_cell(user, 1, 16));
        temp.Parameter4_S1 = atof(csv_get_cell(user, 1, 17));
        temp.Parameter5_S1 = atof(csv_get_cell(user, 1, 18));
        temp.Parameter1_S2 = atof(csv_get_cell(user, 1, 19));
        temp.Parameter2_S2 = atof(csv_get_cell(user, 1, 20));
        temp.Parameter3_S2 = atof(csv_get_cell(user, 1, 21));
        temp.Parameter4_S2 = atof(csv_get_cell(user, 1, 22));
        temp.Parameter5_S2 = atof(csv_get_cell(user, 1, 23));
        temp.Parameter1_S3 = atof(csv_get_cell(user, 1, 24));
        temp.Parameter2_S3 = atof(csv_get_cell(user, 1, 25));
        temp.Parameter3_S3 = atof(csv_get_cell(user, 1, 26));
        temp.Parameter4_S3 = atof(csv_get_cell(user, 1, 27));
        temp.Parameter5_S3 = atof(csv_get_cell(user, 1, 28));
        temp.ReDye = atoi(csv_get_cell(user, 1, 29));
        rt_snprintf(temp.StepID_S1, 3,csv_get_cell(user, 1, 30));
        rt_snprintf(temp.StepID_S2, 3,csv_get_cell(user, 1, 31));
        rt_snprintf(temp.StepID_S3, 3,csv_get_cell(user, 1, 32));

    // 释放内存
    rt_memheap_free(user);

    return temp;
}