#include "ui_task.h"

updata updata_struct_to_ui;

// u_int32_t  timeOut = 10000;

IS3 is3;

// uint16_t  is3_data[515];
// uint16_t  is3_dark_data[515];

typedef struct {
    uint16_t  s_data[515];
    uint16_t  dark_data[515];
    uint16_t  wr_data[515];
    uint16_t  s_average_data[515];
    // uint16_t  opt_data[515];
    // uint16_t  plot_data[515];
} is3_data_t;

is3_data_t is3_data;

EventGroupHandle_t is3_event_group;



DynamicJsonDocument califile_doc(1024);
DynamicJsonDocument SpectralInfo_doc(1024);
DynamicJsonDocument sys_doc(1024);
DynamicJsonDocument file_doc(1024);
String SpectralInfo_data_str;
IRIS_Time_Struct hh3_time_structure;


SpectralData_Section_Header SpectralData_header;
SpectralInfo_Section_Header SpectralInfo_header;
Other__Section_Header       Other_header;
Image_Section_Header        Image_header;
picture image_picture;
HH3_data_struct hh3_data_s_dn;
HH3_data_struct hh3_data_dark_dn;
HH3_data_struct hh3_data_wr_dn;
califlie_data_struct hh3_data_flat_ref;

HH3califlie hh3_califlie_struct;
HH3califlie hh3_flatfile_struct;
SemaphoreHandle_t xMutexInventory = NULL; //创建信号量Handler
EventGroupHandle_t ui_event_group;
EventGroupHandle_t ui_event_group2;
uint32_t dc_wr_time = 0;
uint32_t system_time_count = 0;
uint32_t califile_Count = 0;

uint8_t *file_data = NULL;
const uint32_t file_heap_size = 60 * 1024;
uint32_t stop_polt = 0;
// 任务句柄声明
TaskHandle_t updata_to_ui_TaskHandle;
TaskHandle_t get_is3_TaskHandle;
TaskHandle_t main_2_plot_TaskHandle;
TaskHandle_t main_2_opt_TaskHandle;
TaskHandle_t main_2_dc_TaskHandle;
TaskHandle_t main_2_save_TaskHandle;
TaskHandle_t main_2_wr_TaskHandle;
TaskHandle_t set_it_TaskHandle;
TaskHandle_t main_2_rad_TaskHandle;
TaskHandle_t red_ray_TaskHandle;
TaskHandle_t power_off_TaskHandle;
TaskHandle_t play_music_TaskHandle;
TaskHandle_t fiber_sel_TaskHandle;
TaskHandle_t calculate_average_TaskHandle;
TaskHandle_t ui_time_TaskHandle;
TaskHandle_t show_data_TaskHandle;
TaskHandle_t set_system_time_TaskHandle;
TaskHandle_t save_path_TaskHandle;

volatile uint32_t pc_sta = 0;

void ui_task_init(void)
{
        xTaskCreatePinnedToCore(updata_to_ui,           "updata",       1024*(3 ),     NULL, 21, &updata_to_ui_TaskHandle, 1);
    xTaskCreatePinnedToCore(main_2_opt,             "opt_task",         1024*(4 ),     NULL, 25, &main_2_opt_TaskHandle, 1);
    xTaskCreatePinnedToCore(main_2_plot,            "plot_task",        1024*(2 ),     NULL, 25, &main_2_plot_TaskHandle, 1);
    xTaskCreatePinnedToCore(main_2_dc,              "dc_task",          1024*(4 ),     NULL, 25, &main_2_dc_TaskHandle, 1);
    xTaskCreatePinnedToCore(main_2_save,            "save_task",        1024*(6 +2),     NULL, 25, &main_2_save_TaskHandle, 1);
    xTaskCreatePinnedToCore(main_2_wr,              "wr_task",          1024*(4 ),     NULL, 25, &main_2_wr_TaskHandle, 1);
        xTaskCreatePinnedToCore(get_is3_data,        "get_is3_task",    1024*(6 ),     NULL, 30, &get_is3_TaskHandle, 1);
    xTaskCreatePinnedToCore(set_it_task,            "set_it_task",      1024*(4 ),     NULL, 25, &set_it_TaskHandle, 1);
    xTaskCreatePinnedToCore(main_2_rad,             "set_polt_type",    1024*(2 ),     NULL, 21, &main_2_rad_TaskHandle, 1);
    xTaskCreatePinnedToCore(red_ray_task,           "red_ray_task",     1024*(1),     NULL, 21, &red_ray_TaskHandle, 1);
    xTaskCreatePinnedToCore(power_off_task,         "power_off_task",   1024*(1 ),     NULL, 21, &power_off_TaskHandle, 1);
    xTaskCreatePinnedToCore(play_music_task,        "play_music_task",  1024*(4 ),     NULL, 29, &play_music_TaskHandle, 1);
    xTaskCreatePinnedToCore(fiber_sel_task,         "fiber_sel_task",   1024*(8),     NULL, 21, &fiber_sel_TaskHandle, 1);
    xTaskCreatePinnedToCore(calculate_average_task, "average_task",     1024*(4 ),     NULL, 28, &calculate_average_TaskHandle, 1);
    xTaskCreatePinnedToCore(ui_time_task,           "ui_time_task",     1024*(1 ),     NULL, 21, &ui_time_TaskHandle, 1);
    xTaskCreatePinnedToCore(show_data_task,         "show_data_task",   1024*(8 ),     NULL, 21, &show_data_TaskHandle, 1);
    xTaskCreatePinnedToCore(set_system_time_task,   "set_time_task",    1024*(2 ),     NULL, 21, &set_system_time_TaskHandle, 1);
    xTaskCreatePinnedToCore(save_path_task,         "save_path_task",   1024*(4 ),     NULL, 21, &save_path_TaskHandle, 1);

    xTaskCreatePinnedToCore(pc_mode_task,           "pc_mode_task",     1024*8,     NULL, 21, NULL, 1);
    xTaskCreatePinnedToCore(flat_task,               "flat_task",       1024*8,     NULL, 21, NULL, 1);
}

// 挂起所有任务
void suspend_all_tasks(void)
{
    // xEventGroupWaitBits(is3_event_group, IS3_UPDATA_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
    // xEventGroupWaitBits(is3_event_group, IS3_UPDATA_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
    // vTaskSuspend(updata_to_ui_TaskHandle);


    // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
    // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
    // vTaskSuspend(get_is3_TaskHandle);

    pc_sta = 1;
}
// 恢复所有任务
void resume_all_tasks(void)
{
    // vTaskResume(updata_to_ui_TaskHandle);
    // vTaskResume(get_is3_TaskHandle);
    pc_sta = 0;
}


void get_is3_data(void *pvParameters)
{
    uint16_t read_buff[515];
    uint32_t it = 15;
    uint32_t a;
    double a1, a2, a3, a4;
    a1 = is3.a1;
    a2 = is3.a2;
    a3 = is3.a3;
    a4 = is3.a4;
    // Serial0.printf("a1:%f,a2:%f,a3:%f,a4:%f\n", a1, a2, a3, a4);
    while (1)
    {
        while (pc_sta == 1)
        {
            vTaskDelay(100);
        }
        bool suc = is3.get_data((uint8_t *) read_buff);
        if(suc == false)
        {
            // Serial0.println("get_is3_data fail"); 
            // vTaskDelay(10);
            vTaskDelay(it*2);
            a++;
            // if(a > 20)
            // {
            //     is3.reset();
            //     // vTaskDelay(2000);
            // }
            continue;
        }

        // Serial0.println("get_is3_data ok");

        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {   

            //反
            // int n = 0 ;
            // for (int i = 512; i >= 0; i--)
            // {
            //     // double x= a1*i*i*i + a2*i*i + a3*i + a4;
            //     is3_data.s_data[n] = read_buff[i];
            //     n++;
            // }

            // 正
            for (int i = 0; i < 515; i++)
            {
                is3_data.s_data[i] = read_buff[i];
            }
            // is3_data.s_data[513] = read_buff[513];
            // is3_data.s_data[514] = read_buff[514];
            it = is3.integration_time;
            xSemaphoreGive(xMutexInventory);
        }

        // a++;
        // Serial0.println("get_is3_data ook");

        // // float is3_temperature;
        // // is3.get_is3_temperature(&is3_temperature);

        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE_BIT);
        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE0_BIT);
        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE1_BIT);
        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE2_BIT);
        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE3_BIT);
        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE4_BIT);
        xEventGroupSetBits(is3_event_group, IS3_GET_DATA_DONE5_BIT);
        // Serial0.println("get_is3_data done");
        vTaskDelay(it/2 + 4);
    }    
}

void calculate_average_task(void *pvParameters)
{

    uint16_t average_buffer[515];
    uint32_t S_count= 0;
    while (1)
    {
        uint32_t a=0;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            S_count = updata_struct_to_ui.S_count;
            xSemaphoreGive(xMutexInventory);
        }

        while(S_count--)
        {        
            xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                for(uint16_t i = 0; i < 515; i++)
                {   
                    average_buffer[i] = (average_buffer[i] * a + is3_data.s_data[i])/(a+1);
                }
                xSemaphoreGive(xMutexInventory);
            }
            a++;
        }

        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            for(uint16_t i = 0; i < 512; i++)
            {
                is3_data.s_average_data[i] = average_buffer[i]; 
            }
            xSemaphoreGive(xMutexInventory);
        }
        xEventGroupSetBits(is3_event_group, IS3_AVERAGE_DONE1_BIT);
        xEventGroupSetBits(is3_event_group, IS3_AVERAGE_DONE2_BIT);
    }
}

void updata_to_ui(void *pvParameters)
{
    uint32_t aa = 0;
    while (1)
    {
        while (pc_sta == 1)
        {
            vTaskDelay(100);
        }
        

        uint32_t Brightness,volume,last_Brightness,last_volume;
        uint8_t system_save = 0;
        uint8_t sd_sta = 0;
        // bool wifi_sw;
        // bool bluetooth_sw;
        bool screen_sw;
        uint16_t screen_keep_time;
        float temperature, humidity ,voltage;
        ds1307_date ds1307_date;
        t_sQMI8658 qmi8658_data;
        hh3_slave_data slave_data = {0,0,0,0,0};
        if(get_sd_card_status() == false) sd_sta = 0;
        else sd_sta = 1;
        get_aht10_data(&temperature, &humidity);
        get_hh3_slave_data(&slave_data);

        qmi8658_fetch_angleFromAcc(&qmi8658_data);  // 获取倾角       
        ds1307_get_time(&ds1307_date);
        float sd_used = get_sd_used_percent();
        voltage = get_voltage();
        if(slave_data.gps_sta != 3)
        {
            slave_data.gps_lat = 39.56;
            slave_data.gps_lon = 116.28;
        }
        if(slave_data.height_sta != 3)
        {
            slave_data.height = 0;
        }
        // Serial0.printf("gps_sta:%d,gps_lat:%f,gps_lon:%f\n", slave_data.gps_sta, slave_data.gps_lat,slave_data.gps_lon);
        // Serial0.printf("height_sta:%d,height:%f\n", slave_data.height_sta, slave_data.height);
        // height_sta
        String system_info;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.sd_used_precent = sd_used;

            // updata_struct_to_ui.W_count = 10;
            // updata_struct_to_ui.D_count = 10;
            // updata_struct_to_ui.S_count = 10;

            
            if(updata_struct_to_ui.mode == 0) dc_wr_time = 0;
            updata_struct_to_ui.dc_wr_time = dc_wr_time;

            updata_struct_to_ui.height_sta = slave_data.height_sta;
            updata_struct_to_ui.gps_sta = slave_data.gps_sta;
            updata_struct_to_ui.gps_lat = slave_data.gps_lat;
            updata_struct_to_ui.gps_lon = slave_data.gps_lon;

            updata_struct_to_ui.voltage = voltage;

            updata_struct_to_ui.temperature = temperature;
            updata_struct_to_ui.humidity = humidity;

            // strcpy(updata_struct_to_ui.save_path, "test");
            // updata_struct_to_ui.save_num = 10;

            updata_struct_to_ui.height = slave_data.height;

            updata_struct_to_ui.integration_time = is3.integration_time;

            updata_struct_to_ui.AngleX = qmi8658_data.AngleX;
            updata_struct_to_ui.AngleY = qmi8658_data.AngleY;
            updata_struct_to_ui.AngleZ = qmi8658_data.AngleZ;

            updata_struct_to_ui.year = ds1307_date.year;
            updata_struct_to_ui.month = ds1307_date.month;
            updata_struct_to_ui.day = ds1307_date.day;
            updata_struct_to_ui.hour = ds1307_date.hour;
            updata_struct_to_ui.minute = ds1307_date.minute;
            updata_struct_to_ui.second = ds1307_date.second;

            hh3_time_structure.timezone = 0;
            hh3_time_structure.year = ds1307_date.year;
            hh3_time_structure.month = ds1307_date.month;
            hh3_time_structure.day = ds1307_date.day;
            hh3_time_structure.hour = ds1307_date.hour;
            hh3_time_structure.minute = ds1307_date.minute;
            hh3_time_structure.second = ds1307_date.second;
            hh3_time_structure.millisecond = 0;

            updata_struct_to_ui.sd_alert = sd_sta;

            String rtcdate_now = String(ds1307_date.year) + "-" + String(ds1307_date.month) + "-" + String(ds1307_date.day) + " " + String(ds1307_date.hour) + ":" + String(ds1307_date.minute) + ":" + String(ds1307_date.second); 
            SpectralInfo_doc["info_type"] = "infolist";
            SpectralInfo_doc["info_number"] = 2;
            JsonArray info_list = SpectralInfo_doc.createNestedArray("info_list");
            // 第一个info对象 - devinfo
            JsonObject info0 = info_list.createNestedObject();
            info0["info_type"] = "devinfo";
            info0["sensor_id"] = is3.info; 
            info0["bandnum"] = is3.bandnum;
            info0["IT"] = is3.integration_time;

            JsonObject wave_coeff = info0.createNestedObject("wave_coeff");
            wave_coeff["a1"] = is3.a1;
            wave_coeff["a2"] = is3.a2;
            wave_coeff["a3"] = is3.a3;
            wave_coeff["a4"] = is3.a4;
            info0["termperature"] = is3.temperature;

            
            // 第二个info对象 - environment
            JsonObject info1 = info_list.createNestedObject();
            info1["info_type"] = "environment";
            info1["MN"] = "IS3-HH";
            info1["SN"] = SN_2;
            info1["version"] = Version_3;
            info1["date"] = rtcdate_now;
            info1["humidity"] = humidity;
            info1["temperature"] = temperature;
            info1["height"] = slave_data.height;
            info1["voltage"] = voltage;

            info1["ForeOptics"] = updata_struct_to_ui.fiber_sel_type;
            info1["FiberLength"] = updata_struct_to_ui.fiber_sel_length;
            info1["FiberWidth"] = updata_struct_to_ui.fiber_sel_width;
            info1["cailifilePath"] = updata_struct_to_ui.fiber_path;
            info1["flatfile_name"] = sys_doc["flatfile_name"];

            info1["save_count"] = updata_struct_to_ui.save_count;
            info1["save_interval"] = updata_struct_to_ui.save_time;
            info1["W_count"] = updata_struct_to_ui.W_count;
            info1["D_count"] = updata_struct_to_ui.D_count;
            info1["S_count"] = updata_struct_to_ui.S_count;

            // info1["mode"] = updata_struct_to_ui.mode;
            JsonObject gps = info1.createNestedObject("gps");
            gps["status"] = slave_data.gps_sta;
            gps["longitude"] = slave_data.gps_lon;
            gps["latitude"] = slave_data.gps_lat;
            

            SpectralInfo_data_str.clear();
            serializeJson(SpectralInfo_doc, SpectralInfo_data_str);
            SpectralInfo_doc.clear();
            ////////////////////////////////////////////////
            Brightness = updata_struct_to_ui.brightness_value;
            volume = updata_struct_to_ui.volume_value;


            /////////////////////////sys_doc/////////////////////////////
            sys_doc["save_data_path"] = updata_struct_to_ui.save_path;

            sys_doc["W_count"] = updata_struct_to_ui.W_count;
            sys_doc["D_count"] = updata_struct_to_ui.D_count;
            sys_doc["S_count"] = updata_struct_to_ui.S_count;

            sys_doc["save_count"] = updata_struct_to_ui.save_count;
            sys_doc["save_time"] = updata_struct_to_ui.save_time ;
            sys_doc["save_data_num"] = updata_struct_to_ui.save_num;

            sys_doc["califile_num"] =    updata_struct_to_ui.califile_num;

            sys_doc["brightness_value"] =  updata_struct_to_ui.brightness_value;
            sys_doc["volume_value"] =  updata_struct_to_ui.volume_value;

            sys_doc["ForeOptics_sel1"] =   updata_struct_to_ui.ForeOptics_sel1 ;
            sys_doc["ForeOptics_sel2"] =   updata_struct_to_ui.ForeOptics_sel2 ;
            sys_doc["ForeOptics_sel3"] =   updata_struct_to_ui.ForeOptics_sel3 ;

            sys_doc["wifi_ssid"] =  updata_struct_to_ui.wifi_ssid;
            sys_doc["wifi_pwd"] =  updata_struct_to_ui.wifi_pwd;
            sys_doc["wifi_sw"] = updata_struct_to_ui.wifi_sw;
            sys_doc["bluetooth_sw"] = updata_struct_to_ui.bluetooth_sw;
            
            sys_doc["screen_keep_time"] = updata_struct_to_ui.screen_keep_time ;
            sys_doc["screen_sw"] =  updata_struct_to_ui.screen_sw;
            sys_doc["set_save_num"] =  updata_struct_to_ui.set_save_num;

            

            system_save =  updata_struct_to_ui.system_save;
            ////////////////////
            screen_keep_time = updata_struct_to_ui.screen_keep_time;
            screen_sw = updata_struct_to_ui.screen_sw;

            if(screen_sw == false) system_time_count = 0;

            if(system_time_count < 60*screen_keep_time) Brightness = Brightness;   
            else if(system_time_count >  60*(screen_keep_time + 1)) Brightness = 0;
            else Brightness  = 50;

            
            xSemaphoreGive(xMutexInventory);
        }
        serializeJson(sys_doc, system_info);
        if(system_save) save_system_info(system_info);

        if(last_Brightness != Brightness)
        {
            setBrightness(Brightness);
            last_Brightness = Brightness;
        }

        if(last_volume != volume)
        {
            last_volume = volume;
            audio.setVolume(volume);
            play_music("/OK2.mp3");
        }
        
    
        if(aa%200 == 0)
        {
            // write_log(system_info, LOG_LEVEL_INFO);
            // write_log(SpectralInfo_data_str, LOG_LEVEL_INFO);
        }
        if(voltage < 4.2) 
        {
            if(aa%20 == 0)
            {
                // play_music("meidian.mp3");
            }
        }

        aa++;
        xEventGroupSetBits(is3_event_group, IS3_UPDATA_BIT);
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

void main_2_plot(void *pvParameters)
{
    uint32_t a;
    while (1)
    {    
        // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        if( stop_polt ) continue;

        uint32_t plot_type,it_time;
        uint16_t max = 0;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.saturation_alert = 0;
            for (uint16_t i = 0; i < 512; i++)
            {
                // updata_struct_to_ui.plot_data[i] = is3_data.s_data[i];
                updata_struct_to_ui.plot_data[i] = is3_data.s_average_data[i];
                max = max < updata_struct_to_ui.plot_data[i] ? updata_struct_to_ui.plot_data[i] : max;
            }

            if(max > 65535 * 0.99)
            {
                updata_struct_to_ui.saturation_alert = 1;
            } 

            plot_type = updata_struct_to_ui.plot_type;
            it_time = is3.integration_time;
            xSemaphoreGive(xMutexInventory);
        }
        if(max > 65535 * 0.99)  play_music("/baojing.mp3");
        //0 dn 1 rad 2 ref
        switch (plot_type)
        {
        case 0:
            { 
                if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
                {
                    for(uint16_t i = 0; i < 512; i++)
                    {
                        updata_struct_to_ui.plot_data[i] = updata_struct_to_ui.plot_data[i] - hh3_data_dark_dn.data[i];
                    }
                    xSemaphoreGive(xMutexInventory);
                }
            }
            break;
        case 1:
            {   
                if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
                {
                    for(uint16_t i = 0; i < 512; i++)
                    {
                        updata_struct_to_ui.plot_data[i] = (double)(updata_struct_to_ui.plot_data[i] - hh3_data_dark_dn.data[i])/ (double)it_time *hh3_califlie_struct.gian.integration_time *(hh3_califlie_struct.gian.data[i] * 1000000);
                    }
                    xSemaphoreGive(xMutexInventory);
                }
            }
            break;
        case 2:
            {
                if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
                {
                    for(uint16_t i = 0; i < 512; i++)
                    {

                        updata_struct_to_ui.plot_data[i] = (float)(updata_struct_to_ui.plot_data[i] - hh3_data_dark_dn.data[i]) / (float)(hh3_data_wr_dn.data[i] - hh3_data_dark_dn.data[i]) *hh3_data_flat_ref.data[i]* 10000;
                    }
                    xSemaphoreGive(xMutexInventory);
                }
            }
            break;        
        default:
            break;
        }
        xEventGroupSetBits(ui_event_group, MAIN_2_PLOT_BIT);
    }
}

void main_2_opt(void *pvParameters)
{
    while (1)
    {

        xEventGroupWaitBits(ui_event_group, MAIN_2_OPT_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        xEventGroupSetBits(ui_event_group, MAIN_2_OPT_ING_BIT);

        play_music("/baoguang.mp3");
        // write_log("start opt", LOG_LEVEL_INFO);      
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.bar_value = 0;
            updata_struct_to_ui.button2_count = 0;
            xSemaphoreGive(xMutexInventory);
        }
        uint32_t n = 100;
        bool suc;

        do
        {
            xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
            suc = is3.set_shutter_time(12);
        } while (!suc);

        xEventGroupClearBits(is3_event_group, IS3_GET_DATA_DONE1_BIT);
        // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        // is3.reset();
        // xEventGroupClearBits(is3_event_group, IS3_GET_DATA_DONE1_BIT);
        // do
        // {
        //     xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        //     suc = is3.set_shutter_time(12);
        // } while (!suc);



        uint16_t  set_shutter_time = is3.integration_time;
        while(n -- )
        {
            uint16_t max = 0;
            xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
            // vTaskSuspend(get_is3_TaskHandle);
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                for (uint16_t i = 0; i < 515; i++)
                {
                    max = max > is3_data.s_data[i] ? max : is3_data.s_data[i];
                }
                xSemaphoreGive(xMutexInventory);
            }

            if ((max  > 65535 * 0.7) && (max  < 65535 * 0.8))
            {          
                // Serial0.println("max > 65535 * 0.7");
                break;
            }

            if(max < ( 65535 * 0.8))
            {
                float bbb = (65535.f*0.8) / (float)max;

                 
                if(bbb > 6) set_shutter_time = set_shutter_time * 4;
                else if(bbb > 3) set_shutter_time = set_shutter_time * 2;
                else if(bbb > 2) set_shutter_time = set_shutter_time * 1.5;
                else if(bbb > 1.4) set_shutter_time = set_shutter_time * 1.3;
                else set_shutter_time = set_shutter_time * 1.2 + 1;
            }
            else
            {
                // set_shutter_time = set_shutter_time / 2;
                float bbb = (65535.f*0.8) / (float)max;
                set_shutter_time = set_shutter_time * bbb - 1;

            }

            
            do
            {
                if(set_shutter_time > 1100) 
                {
                    set_shutter_time = 1100;
                }
                if(set_shutter_time < 12) 
                {
                    set_shutter_time = 12;
                }
                xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE1_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
                suc = is3.set_shutter_time(set_shutter_time);
            } while (!suc);

            if(set_shutter_time == 1100 ||  set_shutter_time == 12) break;
        }

        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            system_time_count = 0;
            updata_struct_to_ui.bar_value = 40;
            updata_struct_to_ui.mode = 1;
            updata_struct_to_ui.plot_type = 0;
            xSemaphoreGive(xMutexInventory);
        }

        stop_polt = 1;
        dark_dn_collect();
        xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        stop_polt = 0;
        play_music("/OK2.mp3");
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.bar_value = 100;
            xSemaphoreGive(xMutexInventory);
        }  
        // write_log("end opt", LOG_LEVEL_INFO);   
        xEventGroupClearBits(ui_event_group, MAIN_2_OPT_ING_BIT);
        // xEventGroupSetBits(ui_event_group, MAIN_2_DC_BIT);
    }
}


void main_2_wr(void *pvParameters)
{
    while (1)
    {
        //wr
        xEventGroupWaitBits(ui_event_group, MAIN_2_WR_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        xEventGroupSetBits(ui_event_group, MAIN_2_WR_ING_BIT);

        play_music("/cankao.mp3");
        // write_log("start wr", LOG_LEVEL_INFO);   
        vTaskDelay(1000);
            //          UBaseType_t watermark = uxTaskGetStackHighWaterMark(NULL);
            //          Serial0.printf("updata_to_ui watermark: %u bytes\n", watermark);
            //          Serial0.printf( "Free DMA heap: %d\n", heap_caps_get_free_size(MALLOC_CAP_DMA));
        uint16_t n;
        float a,b;
        a = 0;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.button2_count = 1;
            updata_struct_to_ui.bar_value = 0;
            n = updata_struct_to_ui.W_count;
            xSemaphoreGive(xMutexInventory);
        }
        b = n;
        while (n--)
        {
            //1更新polt
            xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);        
            //2暗电流采集
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                for (uint16_t i = 0; i < 515; i++)
                {
                    /* code */
                    is3_data.wr_data[i] =((float)is3_data.wr_data[i]*(float)a + (float)is3_data.s_data[i])/(float)(a+1);
                }
                updata_struct_to_ui.bar_value = a/(b)*45;
                xSemaphoreGive(xMutexInventory);
            }
            a++;
        }
        wr_dn_pack(false);

        stop_polt = 1;
        dark_dn_collect();
        
        xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        stop_polt = 0;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            system_time_count = 0;
            if(updata_struct_to_ui.mode == 1) updata_struct_to_ui.mode = 2;
            updata_struct_to_ui.plot_type = 2;

            updata_struct_to_ui.bar_value = 100;
            xSemaphoreGive(xMutexInventory);
        }
        play_music("/OK2.mp3");
        // write_log("end wr", LOG_LEVEL_INFO);   
        xEventGroupClearBits(ui_event_group, MAIN_2_WR_BIT);
        xEventGroupClearBits(ui_event_group, MAIN_2_WR_ING_BIT);
        // xEventGroupSetBits(ui_event_group, MAIN_2_DC_BIT);
    }
}

void save_path_task(void *pvParameters)
{
    String data_path = "/data";
    while(1)
    {
        xEventGroupWaitBits(ui_event_group, MAIN_2_SAVE_PATH_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        uint32_t save_time;
        uint32_t save_num;
        String  save_str,SpectralInfo_str;
        uint16_t year,month,day;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            save_time  = updata_struct_to_ui.save_time;
            save_str   = updata_struct_to_ui.save_path;
            save_num   = updata_struct_to_ui.save_num;

            year       = updata_struct_to_ui.year;
            month      = updata_struct_to_ui.month;
            day        = updata_struct_to_ui.day;

            xSemaphoreGive(xMutexInventory);
        }
        // String date_now = String(year) + "_" + String(month) + "_" + String(day);
        String date_now = String(year) + "_";
        if(month < 10) date_now = date_now + "0" + String(month) + "_";
        else date_now = date_now + String(month) + "_";

        if(day < 10) date_now = date_now + "0" + String(day);
        else date_now = date_now + String(day);

        String save_path = data_path+ "/" + date_now ;
        // SD_MMC.mkdir(save_path);//////
        save_path = save_path + "/";

        // String  file_name = save_str + String(save_num) + ".iris";
        char file_name_buf[128];
        String  file_name;

        sprintf(file_name_buf, "%s%04d.iris", save_str.c_str(), save_num);
        file_name = String(file_name_buf);

        while (SD_MMC.exists(save_path + file_name))
        {
            save_num++;
            sprintf(file_name_buf, "%s%04d.iris", save_str.c_str(), save_num);
            file_name = String(file_name_buf);
        }

        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.save_num = save_num;
            xSemaphoreGive(xMutexInventory);
        }
        char file_num_str[32];
        snprintf(file_num_str, sizeof(file_num_str), "%04u", save_num);
        lv_textarea_set_text(guider_ui.Setting_filename_ta_2, file_num_str);
    }
}

void main_2_save(void *pvParameters)
{
    uint32_t save_num  = 0;
    String data_path = "/data";
    while (1)
    {
        //save
        xEventGroupWaitBits(ui_event_group, MAIN_2_SAVE_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        USB_CAM_SetResolution(800,480);
        if(get_sd_card_status() == false)
        {
            continue;
        }
        xEventGroupSetBits(ui_event_group,MAIN_2_SAVE_ING_BIT);

        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.button2_count = 2;
            updata_struct_to_ui.bar_value = 0;
            image_picture.length = 0;
            xSemaphoreGive(xMutexInventory);
        }
        close_ceju();
        
        play_music("/baocun.mp3");
        // write_log("start save", LOG_LEVEL_INFO);
        //打开相机
        
        
        vTaskDelay(100);

        // if(image_picture.length  != 0)
        // {
        //     // play_music("/baojing.mp3");
        //   vTaskDelay(5 * 1000);  
        // }

        uint16_t save_count;
        uint32_t save_time;
        uint32_t save_num;
        uint8_t mode;
        String  save_str,SpectralInfo_str;
        uint16_t year,month,day;
        // hour,minute,second;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            
            updata_struct_to_ui.button2_count = 2;

            save_count = updata_struct_to_ui.save_count;
            save_time  = updata_struct_to_ui.save_time;
            save_str   = updata_struct_to_ui.save_path;
            save_num   = updata_struct_to_ui.save_num;
            mode       = updata_struct_to_ui.mode;
            year       = updata_struct_to_ui.year;
            month      = updata_struct_to_ui.month;
            day        = updata_struct_to_ui.day;
            // hour       = updata_struct_to_ui.hour;
            // minute     = updata_struct_to_ui.minute;
            // second     = updata_struct_to_ui.second;
            SpectralInfo_str = SpectralInfo_data_str;
            xSemaphoreGive(xMutexInventory);
        }

        String date_now = String(year) + "_";
        if(month < 10) date_now += "0" + String(month) + "_";
        else date_now += String(month) + "_";

        if(day < 10) date_now += "0" + String(day);
        else date_now += String(day);


        String save_path = data_path + "/" + date_now ;
        // SD_MMC.mkdir(save_path);
        if(SD_MMC.exists(save_path) == false)
        {
            SD_MMC.mkdir(save_path);
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                save_num   = updata_struct_to_ui.set_save_num;
                updata_struct_to_ui.save_num = save_num;
                xSemaphoreGive(xMutexInventory);
            }
        }

        save_path = save_path + "/";

        char file_name_buf[128];
        String  file_name;

        sprintf(file_name_buf, "%s%04d.iris", save_str.c_str(), save_num);
        file_name = String(file_name_buf);

        while (SD_MMC.exists(save_path + file_name))
        {
            save_num++;
            sprintf(file_name_buf, "%s%04d.iris", save_str.c_str(), save_num);
            file_name = String(file_name_buf);
        }

        float a=0,b;
        b=save_count;
        xEventGroupClearBits(is3_event_group, IS3_AVERAGE_DONE2_BIT);
        xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        while(save_count --)
        {
            xEventGroupWaitBits(is3_event_group, IS3_AVERAGE_DONE2_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
            // xEventGroupClearBits(is3_event_group, IS3_CAM_DONE_BIT);
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                // system_time_count = 0;
                updata_struct_to_ui.save_num = save_num;
                SpectralInfo_str = SpectralInfo_data_str;
                updata_struct_to_ui.system_save = 1;
                image_picture.length = 0;
                image_picture.Squantity = 0;
                
                xSemaphoreGive(xMutexInventory);
            }
            
            // char file_name_buf[64];
            sprintf(file_name_buf, "%s%04d.iris", save_str.c_str(), save_num);

            file_name = String(file_name_buf);
            // file_name = save_str + String(save_num) + ".iris";
            // Serial0.println(String(save_count));
            // Serial0.println("save_path : " + save_path + file_name);
            header_pack(SpectralInfo_str);
            // Serial0.println("header_pack");
            Ground_DN_pack();
            // Serial0.println("Ground_DN_pack");
            wr_dn_pack(true);
            // Serial0.println("wr_dn_pack");
            dark_dn_pack(true);
            // Serial0.println("dark_dn_pack");
            flat_ref_pack();
            // Serial0.println("flat_ref_pack");
            picture_pack(save_str,String(save_num));
            // Serial0.println("picture_pack");
            save_data(save_path,file_name,SpectralInfo_str);
            // Serial0.println("save_data");
            a++;
            save_num++;
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                updata_struct_to_ui.save_num = save_num;
                updata_struct_to_ui.bar_value = a/(b) * 90;
                
                xSemaphoreGive(xMutexInventory);
            }
            uint32_t t = save_time * 1000;
            if(save_count != 0)  vTaskDelay(t);

            // write_log("end save", LOG_LEVEL_INFO);   
            xEventGroupClearBits(is3_event_group, IS3_AVERAGE_DONE2_BIT);
        }
        read_data_from_file(save_path + file_name);
        
        USB_CAM_SetResolution(480,320);
        play_music("/OK2.mp3");
        open_ceju();
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.system_save = 1;
            updata_struct_to_ui.bar_value = 100;
            xSemaphoreGive(xMutexInventory);
        }
        xEventGroupClearBits(ui_event_group, MAIN_2_SAVE_BIT);
        xEventGroupClearBits(ui_event_group, MAIN_2_SAVE_ING_BIT);
    }
}

void dark_dn_collect()
{
    bool shutter_flag = false;
    xEventGroupClearBits(is3_event_group, IS3_GET_DATA_DONE4_BIT);
    do
    {
        xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE4_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        // Serial0.println("dark_dn_collect");
        shutter_flag = is3.close_shutter();
    } while (!shutter_flag);
    vTaskDelay(500);
    // xEventGroupClearBits(is3_event_group, IS3_GET_DATA_DONE4_BIT);
    xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE4_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
    // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE4_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
    // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE4_BIT, pdTRUE, pdFALSE, portMAX_DELAY);

    uint16_t n;
    float a = 0;
    float bar ;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {        
        n = updata_struct_to_ui.D_count;
        bar = updata_struct_to_ui.bar_value;
        xSemaphoreGive(xMutexInventory);
    }
    float b = n;
    while (n--)
    {
        //1更新polt
        xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE4_BIT, pdTRUE, pdFALSE, portMAX_DELAY);        
        //2暗电流采集
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            for (uint16_t i = 0; i < 515; i++)
            {
                /* code */
                is3_data.dark_data[i] = (is3_data.dark_data[i]*a + is3_data.s_data[i])/(a+1);
            }
            a++;
            
            if(bar > 30) updata_struct_to_ui.bar_value = a/b *45 + 45;
            else
            {
                updata_struct_to_ui.bar_value = a/b *90;
            }
            xSemaphoreGive(xMutexInventory);
        }
        // Serial0.printf("dark n : %d\n",n);
    }

    dark_dn_pack(false);

    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        system_time_count = 0;
        if(updata_struct_to_ui.mode == 0) updata_struct_to_ui.mode = 1; 
        dc_wr_time = 0;
        xSemaphoreGive(xMutexInventory);
    }
    
    // vTaskSuspend(get_is3_TaskHandle); 
    xEventGroupClearBits(is3_event_group, IS3_GET_DATA_DONE4_BIT);  
    do
    {
        xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE4_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        shutter_flag = is3.open_shutter();
    } while (!shutter_flag);
    
    // vTaskResume(main_2_plot_TaskHandle);
}

void main_2_dc(void *pvParameters)
{
    
    while(1)
    {
        //dc

        xEventGroupWaitBits(ui_event_group, MAIN_2_DC_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        xEventGroupSetBits(ui_event_group, MAIN_2_DC_ING_BIT);

        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.bar_value = 0;
            xSemaphoreGive(xMutexInventory);
        } 
        play_music("/andianliu.mp3");
        // write_log("start dc ", LOG_LEVEL_INFO);   
        // vTaskSuspend(get_is3_TaskHandle);

        dark_dn_collect();


        // vTaskDelay(2000 / portTICK_PERIOD_MS);
        vTaskDelay(1000);
        play_music("/OK2.mp3");
        
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            updata_struct_to_ui.button2_count = 4;
            updata_struct_to_ui.bar_value = 100;
            xSemaphoreGive(xMutexInventory);
        }
        // write_log("end dc ", LOG_LEVEL_INFO);

        xEventGroupClearBits(ui_event_group, MAIN_2_DC_BIT);
        xEventGroupClearBits(ui_event_group, MAIN_2_DC_ING_BIT);

    }
}


void power_off_task(void *pvParameters)
{
    while(1)
    {
        xEventGroupWaitBits(ui_event_group,POWER_OFF_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        // write_log("power", LOG_LEVEL_INFO);   
        vTaskDelay(3000);
        // xEventGroupWaitBits(is3_event_group,IS3_GET_DATA_DONE5_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        // xEventGroupWaitBits(ui_event_group,TOP_UPDATA_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        vTaskSuspend(updata_to_ui_TaskHandle);
        // vTaskSuspend(get_is3_TaskHandle);
        SD_MMC.end();
        esp_restart(); 
    }
}


void set_it_task(void *pvParameters)
{ 
    while(1)
    {
        xEventGroupWaitBits(ui_event_group, SET_INTEGRATION_TIME_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        
        uint32_t shutter_time ;
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            shutter_time = updata_struct_to_ui.set_integration_time;
            xSemaphoreGive(xMutexInventory);
        }
        bool suc;
        
        // vTaskSuspend(get_is3_TaskHandle);  
        do
        {
            // xEventGroupWaitBits(is3_event_group, IS3_GET_DATA_DONE5_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
            suc = is3.set_shutter_time(shutter_time);
            vTaskDelay(1);
        } while (!suc);
        // vTaskResume(get_is3_TaskHandle);

        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.mode = 0;
            updata_struct_to_ui.button2_count = 0;
            updata_struct_to_ui.plot_type = 0;
            xSemaphoreGive(xMutexInventory);
        }
        play_music("/OK2.mp3");
        // write_log("set_it : " + String(shutter_time), LOG_LEVEL_INFO);
        // xEventGroupSetBits(ui_event_group, MAIN_2_DC_BIT);
    }
}

void main_2_rad(void *pvParameters)
{ 
    while(1)
    {
        xEventGroupWaitBits(ui_event_group,MAIN_2_RAD_BIT,pdTRUE,pdFALSE,portMAX_DELAY);

        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.button2_count = 3;
            updata_struct_to_ui.plot_type ++;
            updata_struct_to_ui.plot_type = updata_struct_to_ui.plot_type > 2 ? 0 : updata_struct_to_ui.plot_type;

            switch (updata_struct_to_ui.mode)
            {
                case 0:
                    updata_struct_to_ui.plot_type = 0;
                    break;
                case 1:
                    updata_struct_to_ui.plot_type = updata_struct_to_ui.plot_type > 1 ? 0 : updata_struct_to_ui.plot_type;
                    if(updata_struct_to_ui.califile_num == 0 && updata_struct_to_ui.plot_type == 1) updata_struct_to_ui.plot_type = 0;
                    break;
                case 2:
                    updata_struct_to_ui.plot_type = updata_struct_to_ui.plot_type > 2 ? 0 : updata_struct_to_ui.plot_type;
                    if(updata_struct_to_ui.califile_num == 0 && updata_struct_to_ui.plot_type == 1) updata_struct_to_ui.plot_type = 2;
                    break;        
                    
                default:
                    break;
            }
            xSemaphoreGive(xMutexInventory);
        }
    }
}


void red_ray_task(void* arg) {
    while (1) 
    {
        xEventGroupWaitBits(is3_event_group,RED_RAY_BIT,pdTRUE,  pdFALSE,portMAX_DELAY);
        EventBits_t uxBits = xEventGroupGetBits(ui_event_group);
        if ((uxBits & MAIN_2_OPT_ING_BIT) || (uxBits & MAIN_2_DC_ING_BIT) || (uxBits & MAIN_2_WR_ING_BIT) || (uxBits & MAIN_2_SAVE_ING_BIT)) continue;
        red_ray_on();
        vTaskDelay(1000);
        red_ray_off();
    }
}


void play_music_task(void* arg)
{
    while (1)
    {
        xEventGroupWaitBits(ui_event_group,MUSIC_BIT,pdTRUE,pdFALSE,portMAX_DELAY);

        String music_path;
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            music_path = updata_struct_to_ui.music_path;
            memset(updata_struct_to_ui.music_path,'\0',sizeof(updata_struct_to_ui.music_path));
            xSemaphoreGive(xMutexInventory);
        }

        const char* path = music_path.c_str();
        // Serial0.println(path);
        if(language == chinese) audio.connecttoFS(SPIFFS, path);
        else if(language == english) 
        {
            music_path = "/config/music/english/" + music_path;
            const char* path_2 = music_path.c_str();
            audio.connecttoFS(SD_MMC, path_2);
        }
        
        
        while (audio.isRunning())
        {
            audio.loop();
            vTaskDelay(1);
        }
    }
    
}

bool is_leap_year(uint32_t year) {
    return ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
}
void set_system_time_task(void *pvParameters)
{
    while(1)
    {
        xEventGroupWaitBits(ui_event_group,SET_SYSTEM_TIME_BIT,pdTRUE,pdFALSE,portMAX_DELAY);
        bool flag = true;

        uint16_t year,month,day,hour,minute,second;
        if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
        {
            const char * year_str = lv_textarea_get_text(guider_ui.Setting_system_ta_3);
            year = (uint32_t)atoi(year_str);
            const char * month_str = lv_textarea_get_text(guider_ui.Setting_system_ta_5);
            month = (uint32_t)atoi(month_str);
            const char * day_str = lv_textarea_get_text(guider_ui.Setting_system_ta_4);
            day = (uint32_t)atoi(day_str);
            const char * hour_str = lv_textarea_get_text(guider_ui.Setting_system_ta_7);
            hour = (uint32_t)atoi(hour_str);
            const char * minute_str = lv_textarea_get_text(guider_ui.Setting_system_ta_6);
            minute = (uint32_t)atoi(minute_str);
            const char * second_str = lv_textarea_get_text(guider_ui.Setting_system_ta_8);
            second = (uint32_t)atoi(second_str);

            xSemaphoreGive(lvgl_mutex);
        }

        if(year < 2000 || year > 2099) flag = false;;
        if(month < 1 || month > 12) flag = false;
        if(day < 1 || day > 31) flag = false;
        if(hour < 0 || hour > 23) flag = false;
        if(minute < 0 || minute > 59) flag = false;
        if(second < 0 || second > 59) flag = false;

        const uint8_t days_in_month[12] = {
                31, 28, 31, 30, 31, 30,
                31, 31, 30, 31, 30, 31
            };


        uint8_t max_day = days_in_month[month - 1];

        if(month == 2 && is_leap_year(year)) {
            max_day = 29;
        }

        if(day < 1 || day > max_day) flag = false;


        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.set_time_flag = flag;
            xSemaphoreGive(xMutexInventory);
        }
        if(!flag) continue;


        ds1307_set_time(year, month, day, hour, minute, second);
    }
}


void fiber_sel_task(void* arg)
{
    while(1)
    {
        xEventGroupWaitBits(ui_event_group,FiBER_SEL_BIT , pdTRUE, pdFALSE, portMAX_DELAY);
        String fiber_type , fiber_length, fiber_width;
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            fiber_type = updata_struct_to_ui.fiber_sel_type;
            fiber_length = updata_struct_to_ui.fiber_sel_length;
            fiber_width = updata_struct_to_ui.fiber_sel_width;
            xSemaphoreGive(xMutexInventory);
        }
        uint32_t a = find_califile(fiber_type, fiber_length, fiber_width);
        califile_read(a);      
    }
}



void ui_time_task(void *pvParameters)
{
    while (1)
    {
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            dc_wr_time ++;
            if(updata_struct_to_ui.mode == 0) dc_wr_time = 0;
            system_time_count ++;
            xSemaphoreGive(xMutexInventory);
        }
        vTaskDelay(1000);
    }
    
}

void save_system_info(String system_info)
{
    // if(!get_sd_card_status()) return;

    File file;
    file = SPIFFS.open("/system_tem.json", FILE_WRITE);
    // file = SD_MMC.open(system_tem_path, FILE_WRITE);
    file.println(system_info);
    file.flush();
    file.close();

    // Serial0.println("system_info="+ system_info);
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        updata_struct_to_ui.system_save = 0;
        xSemaphoreGive(xMutexInventory);
    }

}

String read_system_info()
{
    String system_info;

    // if(SD_MMC.exists(system_tem_path))
    if(SPIFFS.exists("/system_tem.json"))
    {
        File file;
        // file = SD_MMC.open(system_tem_path, FILE_READ);
        file = SPIFFS.open("/system_tem.json", FILE_READ);
        system_info = file.readString();
        
        file.flush();
        file.close();
    }
    else
    {
        return "-1";
    }
    // Serial0.println("system_temp : "+system_info);
    return system_info;
}

bool califile_init()
{
    File root = SD_MMC.open(califile_path);
    if (!root || !root.isDirectory()) {
        // Serial0.println("Failed to open directory");
        root.close();
        return false;
    }
    File file = root.openNextFile();
    // Serial0.println("Listing files in directory:");
    while (file) 
    {
        if (!file.isDirectory()) 
        {
            califile_Count++;
            califile_doc[String(califile_path)][String(califile_Count)]["name"] = String(file.name());
            // Serial0.printf("FILE: %s, SIZE: %d bytes\n", file.name(), file.size());
        } 
        else 
        {
            // Serial0.printf("DIR : %s\n", file.name());
        }
        file.close();
        file = root.openNextFile();
    }
    String cali_str;
    serializeJson(califile_doc, cali_str);
    // Serial0.println(cali_str);
    // Serial0.println("califile_Count: " + String(califile_Count));

    root.close();

    return true;
}


bool califile_read(uint32_t califile_num)
{ 
    if(califile_num == 0)
    {
        String str = "NULL";
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.califile_num = califile_num;
            memset(&hh3_califlie_struct, 1, sizeof(hh3_califlie_struct));

            memset(updata_struct_to_ui.fiber_path, '\0', 100);
            strcpy(updata_struct_to_ui.fiber_path, str.c_str());
            xSemaphoreGive(xMutexInventory);
        }
        return false;
    }

    String califile_name = califile_doc[String(califile_path)][String(califile_num)]["name"];
    String read_file_path = String(califile_path) + "/" + califile_name;
    if(califile_name.indexOf("_180d") != -1) 
    {
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.IRAD = 1;
            xSemaphoreGive(xMutexInventory);
        }
    }
    else
    {
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.IRAD = 0;
            xSemaphoreGive(xMutexInventory);
        }
    }
    // Serial0.println("read_file_path: " + read_file_path);
    // if(!SD_MMC.exists(read_file_path))
    // {   
    //     Serial0.println("File not exist : "+ read_file_path);

    //     String str = "NULL";
    //     if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
    //     {
    //         updata_struct_to_ui.califile_num = califile_num;
    //         memset(&hh3_califlie_struct, 1, sizeof(hh3_califlie_struct));

    //         memset(updata_struct_to_ui.fiber_path, '\0', 100);
    //         strcpy(updata_struct_to_ui.fiber_path, str.c_str());
    //         xSemaphoreGive(xMutexInventory);
    //     }
    //     return false;
    // }

    File file = SD_MMC.open(read_file_path,FILE_READ);
    uint32_t file_size = file.size();
    file.read((uint8_t *)&hh3_califlie_struct, sizeof(hh3_califlie_struct));
    file.flush();
    file.close();
    
    if(hh3_califlie_struct.gian.GroundType != califile || file_size < sizeof(hh3_califlie_struct)/2)
    {
        String str = "NULL";
        if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
        {
            updata_struct_to_ui.califile_num = califile_num;
            memset(&hh3_califlie_struct, 1, sizeof(hh3_califlie_struct));

            memset(updata_struct_to_ui.fiber_path, '\0', 100);
            strcpy(updata_struct_to_ui.fiber_path, str.c_str());
            xSemaphoreGive(xMutexInventory);
        }
        // Serial0.println(read_file_path + " is not a califlie file");
        return false;
    }


    if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
    {
        updata_struct_to_ui.califile_num = califile_num;
        memset(updata_struct_to_ui.fiber_path, '\0', 100);
        strcpy(updata_struct_to_ui.fiber_path, read_file_path.c_str());

        updata_struct_to_ui.system_save = 1;
        xSemaphoreGive(xMutexInventory);
    }

    return true;
}


void fiber_fields() {
    uint32_t a = califile_Count;

    // String fiber_type = "无\n光纤\n";
    // String fiber_width = "无\n";
    // String fiber_length = "无\n";

    String fiber_type = "光纤\n";
    String fiber_width = "";
    String fiber_length = "";

    uint32_t fiber_count = 0;
    while(a)
    {
        String name = califile_doc[String(califile_path)][String(a)]["name"];
        int f_pos = name.indexOf("_F_");
        if (f_pos != -1) 
        {
            int m_pos = name.indexOf("m_", f_pos);
            if (m_pos != -1) {
                String m_Str = name.substring(f_pos + 3, m_pos);
                if(fiber_length.indexOf(m_Str) == -1) fiber_length = fiber_length +  m_Str + '\n';
            }
            int d_pos = name.indexOf("d", f_pos);
            
            if (d_pos != -1 && d_pos > name.indexOf("m", f_pos)) 
            {
                String d_Str = name.substring(m_pos+2, d_pos);
                if(fiber_width.indexOf(d_Str) == -1) fiber_width = fiber_width +  d_Str + '\n';
            }
            fiber_count++;
        } 
        else 
        {
            int d_pos = name.indexOf("d");
            if (d_pos != -1) 
            {
                int start = name.lastIndexOf("_", d_pos - 1);
                if (start != -1) 
                {
                    String d_Str = name.substring(start + 1, d_pos);
                    if(fiber_type.indexOf(d_Str) == -1) fiber_type = fiber_type + d_Str + '\n';
                }
            }
        }
        a--;
    }
    if(fiber_count == 0) fiber_type = fiber_type.substring(7, fiber_type.length());
    strcpy(updata_struct_to_ui.fiber_type, fiber_type.c_str());
    strcpy(updata_struct_to_ui.fiber_length, fiber_length.c_str());
    strcpy(updata_struct_to_ui.fiber_width, fiber_width.c_str());

    updata_struct_to_ui.fiber_type[fiber_type.length()-1] = '\0';
    // updata_struct_to_ui.fiber_length[fiber_length.length()-1] = '\0';
    // updata_struct_to_ui.fiber_width[fiber_width.length()-1] = '\0';
}

uint32_t find_califile(String fiber_type, String fiber_length, String fiber_width)
{
    uint32_t a;
    if(xSemaphoreTake(xMutexInventory, 1000) == pdPASS)
    {
        a = califile_Count;
        xSemaphoreGive(xMutexInventory);
    }

    // Serial0.println("fiber_type: " + fiber_type);
    // Serial0.println("fiber_length: " + fiber_length);
    // Serial0.println("fiber_width: " + fiber_width);

    // 处理 fiber_type
    if (fiber_type == "g") {
        fiber_type = "_F_";
    } else if ((fiber_type != "w") && (fiber_type != "_F_")) {
        fiber_type = "_" + fiber_type + "d_";
    } else {
        fiber_type = "-1";
    }
    // 处理 fiber_length
    if (fiber_length != "w") {
        fiber_length = "_" + fiber_length + "m_";
    } else {
        fiber_length = "-1";
    }
    // 处理 fiber_width
    if (fiber_width != "w") {
        fiber_width = "_" + fiber_width + "d_";
    } else {
        fiber_width = "-1";
    }

    if(fiber_type == "-1")
    {
        return 0;
    }
    String name2;
    // String find_str;
    // if(fiber_type == "_F_") find_str = fiber_type + fiber_length + fiber_width;
    // else find_str = fiber_type;
    while(a)
    {
        String name = califile_doc[String(califile_path)][String(a)]["name"];

        // Serial0.println("name:" + name);

        if(fiber_type == "_F_")
        {
            if((name.indexOf(fiber_type) != -1) && (name.indexOf(fiber_length) != -1 )&& (name.indexOf(fiber_width) != -1))
            {
                name2 = name;
                break;               
            }
            // if(name.indexOf(find_str) != -1)
            // {
            //     name2 = name;
            //     break;
            // }
        }
        else
        {
            if((name.indexOf(fiber_type) != -1) && (name.indexOf("_F_") == -1))
            {
                name2 = name;
                break;
            }
        }
        a--;
    }
    
    return a;
}

void system_data_init()
{   

    ui_event_group = xEventGroupCreate();
    if (ui_event_group == NULL) {

        while (1)
        {
            // Serial0.println("ui_event_group create fail!");
            vTaskDelay(1000 / portTICK_PERIOD_MS);  // 停住系统防止崩溃
        } 
    }

    ui_event_group2 = xEventGroupCreate();
    if (ui_event_group == NULL) {

        while (1)
        {
            // Serial0.println("ui_event_group create fail!");
            vTaskDelay(1000 / portTICK_PERIOD_MS);  // 停住系统防止崩溃
        } 
    }
    is3_event_group = xEventGroupCreate();
    if (is3_event_group == NULL) {
        while (1)
        {
            // Serial0.println("is3_event_group create fail!");
            vTaskDelay(1000 / portTICK_PERIOD_MS);  // 停住系统防止崩溃
        } 
    }
    xMutexInventory = xSemaphoreCreateMutex(); //创建MUTEX
    //  if(xMutexInventory == NULL)  Serial0.println("xMutexInventory is NULL");

    image_picture.data  = (uint8_t *)heap_caps_malloc(55 * 1024, MALLOC_CAP_SPIRAM);
    assert(image_picture.data != NULL);

    file_data  = (uint8_t *)heap_caps_malloc(file_heap_size, MALLOC_CAP_SPIRAM);
    memset(file_data, 0, file_heap_size);
    califile_init();
    if(califile_Count != 0) fiber_fields();

    uint32_t califile_num = 0;
    String system_info =  read_system_info();
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {

        if(system_info !="-1")
        {
            deserializeJson(sys_doc, system_info);
            String save_data_path  = sys_doc["save_data_path"];

            updata_struct_to_ui.W_count = sys_doc["W_count"];
            updata_struct_to_ui.W_count = updata_struct_to_ui.W_count > 1 ? updata_struct_to_ui.W_count : 1;
            
            updata_struct_to_ui.D_count = sys_doc["D_count"];
            updata_struct_to_ui.D_count = updata_struct_to_ui.D_count > 1 ? updata_struct_to_ui.D_count : 1;

            updata_struct_to_ui.S_count = sys_doc["S_count"];
            updata_struct_to_ui.S_count = updata_struct_to_ui.S_count > 1 ? updata_struct_to_ui.S_count : 1;

            updata_struct_to_ui.save_count = sys_doc["save_count"];
            updata_struct_to_ui.save_count = updata_struct_to_ui.save_count > 1 ? updata_struct_to_ui.save_count : 1;
            updata_struct_to_ui.save_time = sys_doc["save_time"];
            updata_struct_to_ui.save_time = updata_struct_to_ui.save_time > 0 ? updata_struct_to_ui.save_time : 0;
            
            updata_struct_to_ui.califile_num = sys_doc["califile_num"];
            califile_num = updata_struct_to_ui.califile_num;
            updata_struct_to_ui.brightness_value = sys_doc["brightness_value"];
            updata_struct_to_ui.brightness_value = updata_struct_to_ui.brightness_value > 50 ? updata_struct_to_ui.brightness_value : 50;
            updata_struct_to_ui.volume_value = sys_doc["volume_value"];

            updata_struct_to_ui.ForeOptics_sel1 = sys_doc["ForeOptics_sel1"];
            updata_struct_to_ui.ForeOptics_sel2 = sys_doc["ForeOptics_sel2"];
            updata_struct_to_ui.ForeOptics_sel3 = sys_doc["ForeOptics_sel3"];

            updata_struct_to_ui.wifi_sw = sys_doc["wifi_sw"];
            updata_struct_to_ui.bluetooth_sw = sys_doc["bluetooth_sw"];

            String  wifi_ssid =  sys_doc["wifi_ssid"];
            String  wifi_pwd = sys_doc["wifi_pwd"] ;

            strcpy(updata_struct_to_ui.wifi_ssid,wifi_ssid.c_str());
            strcpy(updata_struct_to_ui.wifi_pwd,wifi_pwd.c_str());

            updata_struct_to_ui.screen_keep_time = sys_doc["screen_keep_time"];
            updata_struct_to_ui.screen_keep_time = updata_struct_to_ui.screen_keep_time > 1 ? updata_struct_to_ui.screen_keep_time : 1;
            updata_struct_to_ui.screen_sw = sys_doc["screen_sw"];

            updata_struct_to_ui.set_save_num = sys_doc["set_save_num"];

            strcpy(updata_struct_to_ui.save_path, save_data_path.c_str());
            updata_struct_to_ui.save_num = sys_doc["save_data_num"];
        }

        if ( system_info =="-1" || updata_struct_to_ui.W_count == 0)
        {
            updata_struct_to_ui.W_count = 10;
            updata_struct_to_ui.D_count = 25;
            updata_struct_to_ui.S_count = 10;

            updata_struct_to_ui.save_count = 1;
            updata_struct_to_ui.save_time = 0;

            updata_struct_to_ui.brightness_value = 255;
            updata_struct_to_ui.volume_value = 21;

            updata_struct_to_ui.set_save_num = 0;
            
            strcpy(updata_struct_to_ui.save_path, "data");
            updata_struct_to_ui.save_num = 00;
        }

        updata_struct_to_ui.bar_value = 0;
        updata_struct_to_ui.mode = 0;
        updata_struct_to_ui.plot_type = 0;

        updata_struct_to_ui.button1_count = 0;
        updata_struct_to_ui.button2_count = 0;

        updata_struct_to_ui.set_time_flag = true;
        xSemaphoreGive(xMutexInventory);
    }
    if(califile_num != 0) califile_read(califile_num);
    else
    {
        // if(califile_Count != 0) califile_read(1);
        // else  califile_read(0);
    }
    
    ds1307_date now;
    ds1307_get_time(&now);
    // String date_now = String(now.year) + "_" + String(now.month) + "_" + String(now.day);
    String date_now = String(now.year) + "_";

    if(now.month < 10) date_now = date_now+"0" + String(now.month) + "_";
    else date_now = date_now + String(now.month) + "_";

    if(now.day < 10) date_now = date_now + "0" + String(now.day);
    else date_now = date_now + String(now.day);

    String save_path = "/data/" + date_now ;

    if(SD_MMC.exists(save_path) == false)
    {
        // SD_MMC.mkdir(save_path);
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            uint32_t save_num = updata_struct_to_ui.set_save_num;
            updata_struct_to_ui.save_num = save_num;
            xSemaphoreGive(xMutexInventory);
        }
    }
}

void header_pack(String SpectralInfo_str)
{
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        
        uint32_t SpectralData_Squantity = 2;
        uint32_t SpectralData_SectionLength = 2 + sizeof(hh3_data_s_dn) + sizeof(hh3_data_dark_dn);
        if(updata_struct_to_ui.mode == 2) 
        {
            SpectralData_Squantity += 2;
            SpectralData_SectionLength = SpectralData_SectionLength+sizeof(hh3_data_wr_dn) + sizeof(hh3_data_flat_ref);
        }
        if(hh3_califlie_struct.gian.GroundType == califile)
        {
            SpectralData_Squantity ++;
            SpectralData_SectionLength += sizeof(hh3_califlie_struct.gian);
        }

        SpectralData_header.SectionFlag = SpectralData;
        SpectralData_header.SectionLength = SpectralData_SectionLength;
        SpectralData_header.Squantity = SpectralData_Squantity;

        SpectralInfo_header.SectionFlag = SpectralInfo;
        SpectralInfo_header.SectionLength = SpectralInfo_str.length() + 2 + 2 + 1;
        SpectralInfo_header.Squantity = SpectralInfo_Squantity;
        SpectralInfo_header.info1_length = SpectralInfo_str.length();
        SpectralInfo_header.info1_type = 0x00;

        Other_header.SectionFlag = Other;
        Other_header.SectionLength = 0;

        Image_header.SectionFlag = Image;
        Image_header.SectionLength = 0;

        xSemaphoreGive(xMutexInventory);
    }
}

void Ground_DN_pack()
{
    String  save_str;
    uint32_t save_num;
    uint16_t max = 0;
    String name;
    char file_name_buf[64];
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        save_str   = updata_struct_to_ui.save_path;
        save_num   = updata_struct_to_ui.save_num;

        //name
        sprintf(file_name_buf, "%s%04d_Ground_DN", save_str.c_str(), save_num);
        // name = save_str + String(save_num) +"_" + "Ground_DN";
        name = String(file_name_buf);
        memset(hh3_data_s_dn.name,'\0',100);
        memcpy(hh3_data_s_dn.name,name.c_str(),name.length());
        hh3_data_s_dn.name[name.length()] = '\0';
        //sensor_id
        memcpy(hh3_data_s_dn.sensor_id,(uint8_t *)&is3.info,is3.info.length());        
        hh3_data_s_dn.sensor_id[is3.info.length()] = '\0';
        hh3_data_s_dn.FiberID = hh3_FiberID;

        //date
        hh3_data_s_dn.date = hh3_time_structure;
        hh3_data_s_dn.integration_time = is3.integration_time;
        hh3_data_s_dn.gain = 0.0;

        hh3_data_s_dn.data_type = DATA_TYPE_UINT16;
        hh3_data_s_dn.PixelSize = 2;
        hh3_data_s_dn.GroundType = s_dn;
        hh3_data_s_dn.band_num = 515;
        hh3_data_s_dn.ValidFlag = 1 ;
        
        for (uint16_t i = 0; i < 515; i++)
        {
            hh3_data_s_dn.data[i] = is3_data.s_average_data[i];
            max = max < is3_data.s_average_data[i] ? is3_data.s_average_data[i] : max;
        }
        if(max > 65535 * 0.99) hh3_data_s_dn.ValidFlag = 0; 

        xSemaphoreGive(xMutexInventory);
    }
}
void dark_dn_pack(bool flag)
{
    uint32_t save_num;
    String  save_str;
    uint16_t max = 0;
    String name;
    char name_buf[64];
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        save_str   = updata_struct_to_ui.save_path;
        save_num   = updata_struct_to_ui.save_num;


        // name = save_str+String(save_num) + "_dark_dn";
        sprintf(name_buf, "%s%04d_dark_dn", save_str.c_str(), save_num);
        name = String(name_buf);

        memset(hh3_data_dark_dn.name,'\0',100);
        memcpy(hh3_data_dark_dn.name,name.c_str(),name.length());
        hh3_data_dark_dn.name[name.length()] = '\0';
        if(flag) 
        {
            xSemaphoreGive(xMutexInventory);
            return; 
        }
        // hh3_data_dark_dn.sensor_id
        memcpy(hh3_data_dark_dn.sensor_id,(uint8_t *)&is3.info,is3.info.length());            
        hh3_data_dark_dn.sensor_id[is3.info.length()] = '\0';
        hh3_data_dark_dn.FiberID = hh3_FiberID;

        hh3_data_dark_dn.date = hh3_time_structure;
        hh3_data_dark_dn.integration_time = is3.integration_time;
        hh3_data_dark_dn.gain = 0.0;

        hh3_data_dark_dn.data_type = DATA_TYPE_UINT16;
        hh3_data_dark_dn.PixelSize = 2;
        hh3_data_dark_dn.GroundType =  dark_dn;
        hh3_data_dark_dn.band_num = 515;
        hh3_data_dark_dn.ValidFlag = 1 ;
        
        for (uint16_t i = 0; i < 515; i++)
        {
            hh3_data_dark_dn.data[i] = is3_data.dark_data[i];
            max = max < is3_data.dark_data[i] ? is3_data.dark_data[i] : max;
        }
        if(max > 65535 * 0.99) hh3_data_dark_dn.ValidFlag = 0; 

        xSemaphoreGive(xMutexInventory);
    }
}

void wr_dn_pack(bool flag)
{
    uint32_t save_num;
    String  save_str;
    uint16_t max = 0;
    String name;
    char file_name_buf[64];
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        save_str   = updata_struct_to_ui.save_path;
        save_num   = updata_struct_to_ui.save_num;

        // name = save_str+String(save_num) + "_flat_dn";
        sprintf(file_name_buf, "%s%04d_flat_dn", save_str.c_str(), save_num);
        name = String(file_name_buf);

        memset(hh3_data_wr_dn.name,'\0',100);
        memcpy(hh3_data_wr_dn.name,name.c_str(),name.length());
        hh3_data_wr_dn.name[name.length()] = '\0';
        if(flag) 
        {
            xSemaphoreGive(xMutexInventory);
            return;
        }
        
        // hh3_data_wr_dn.sensor_id
        memcpy(hh3_data_wr_dn.sensor_id,(uint8_t *)&is3.info,is3.info.length());            
        hh3_data_wr_dn.sensor_id[is3.info.length()] = '\0';
        hh3_data_wr_dn.FiberID = hh3_FiberID;

        hh3_data_wr_dn.date = hh3_time_structure;
        hh3_data_wr_dn.integration_time = is3.integration_time;
        hh3_data_wr_dn.gain = 0.0;

        hh3_data_wr_dn.data_type = DATA_TYPE_UINT16;
        hh3_data_wr_dn.PixelSize = 2;
        hh3_data_wr_dn.GroundType =  flat_dn;
        hh3_data_wr_dn.band_num = 515;
        hh3_data_wr_dn.ValidFlag = 1 ;
        
        for (uint16_t i = 0; i < 515; i++)
        {
            hh3_data_wr_dn.data[i] = is3_data.wr_data[i];
            max = max < is3_data.wr_data[i] ? is3_data.wr_data[i] : max;
        }
        if(max > 65535 * 0.99) hh3_data_wr_dn.ValidFlag = 0; 

        xSemaphoreGive(xMutexInventory);
    }
}

void flat_ref_pack()
{
    // uint8_t mode;

    // String  save_str;
    // uint32_t save_num;
    // uint16_t max = 0;
    // String name;
    // char file_name_buf[64];
    // if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    // {
    //     save_str   = updata_struct_to_ui.save_path;
    //     save_num   = updata_struct_to_ui.save_num;
    //     mode = updata_struct_to_ui.mode;
    //     xSemaphoreGive(xMutexInventory);
    // }
    // if(mode != 2) return;

    //name
    // name = save_str + String(save_num) +"_" + "flat_ref";
    // sprintf(file_name_buf, "%s%04d.iris", save_str.c_str(), save_num);
    // name = String(file_name_buf);
    // memset(hh3_data_flat_ref.name,'\0',100);
    // memcpy(hh3_data_flat_ref.name,name.c_str(),name.length());
    // hh3_data_flat_ref.name[name.length()] = '\0';
    // //sensor_id
    // memcpy(hh3_data_flat_ref.sensor_id,(uint8_t *)&is3.info,is3.info.length());            
    // hh3_data_flat_ref.sensor_id[is3.info.length()] = '\0';
    // hh3_data_flat_ref.FiberID = hh3_FiberID;

    // hh3_data_flat_ref.date = hh3_time_structure;
    // hh3_data_flat_ref.integration_time = is3.integration_time;
    // hh3_data_flat_ref.gain = 0.0;

    // hh3_data_flat_ref.data_type = DATA_TYPE_FLOAT64;
    // hh3_data_flat_ref.PixelSize = 8;
    // hh3_data_flat_ref.GroundType = flat_ref;
    // hh3_data_flat_ref.band_num = 512;
    // hh3_data_flat_ref.ValidFlag = 1 ;
    
    // for (uint16_t i = 0; i < 512; i++)
    // {
    //     hh3_data_flat_ref.data[i] = (double)(is3_data.s_average_data[i] - hh3_data_dark_dn.data[i]) / (double)(hh3_data_wr_dn.data[i] - hh3_data_dark_dn.data[i]);
    // }
    // if(max > 65535 * 0.99) hh3_data_flat_ref.ValidFlag = 0; 
}


void picture_pack(String name,String num)
{
    if(get_cam_status() == 0)  
    {
        // Serial0.println("cam stop");
        return;
    }
    // image_picture.length = 0;
    
    if(image_picture.length == 0)
    {
        xEventGroupClearBits(is3_event_group, IS3_CAM_DONE_BIT);
        xEventGroupWaitBits(is3_event_group, IS3_CAM_DONE_BIT, pdTRUE, pdFALSE, 100 / portTICK_PERIOD_MS);
    }

    if(image_picture.length == 0)   return;
    vTaskDelay(1);
    // String name_str = name + num + ".jpg";
    char file_name_buf[64];
    sprintf(file_name_buf, "%s%04d.jpg", name.c_str(), num);
    String name_str = String(file_name_buf);
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {    
        Image_header.SectionFlag = Image;
        image_picture.Squantity = Image_Squantity;
        Image_header.SectionLength = image_picture.length + sizeof(image_picture) - sizeof(uint8_t *);
        memcpy(image_picture.name,name_str.c_str(),name_str.length());
        image_picture.length = image_picture.length + 100 + 10 + 1;
        image_picture.date = hh3_time_structure;
        image_picture.type = 0;
        xSemaphoreGive(xMutexInventory);
    }
    vTaskDelay(10);
}

void save_data(String path ,String name,String SpectralInfo_str)
{
    uint8_t mode;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        mode = updata_struct_to_ui.mode;
        xSemaphoreGive(xMutexInventory);
    }
    File file;
    file = SD_MMC.open(path + name,FILE_WRITE);
    
    //SpectralData_Section
    file.write((uint8_t *)&SpectralData_header,sizeof(SpectralData_header));
    //地物DN
    file.write((uint8_t *)&hh3_data_s_dn,sizeof(hh3_data_s_dn));
    // file.flush();
    //白板DN
    if(mode == 2)
    {
        file.write((uint8_t *)&hh3_data_wr_dn,sizeof(hh3_data_wr_dn));
    }
    //DARK_DN
    file.write((uint8_t *)&hh3_data_dark_dn,sizeof(hh3_data_dark_dn));
    //flat_ref
    // file.flush();
    if(mode == 2)
    {
        // file.write((uint8_t *)&hh3_data_wr_dn,sizeof(hh3_data_wr_dn));
        file.write((uint8_t *)&hh3_data_flat_ref,sizeof(hh3_data_flat_ref));
    }
    //califlie
    if(hh3_califlie_struct.gian.GroundType == califile) file.write((uint8_t *)&hh3_califlie_struct.gian,sizeof(hh3_califlie_struct.gian));
    // file.flush();
    //SpectralInfo_Section
    file.write((uint8_t *)&SpectralInfo_header,sizeof(SpectralInfo_header));
    file.write((uint8_t *)SpectralInfo_str.c_str(),SpectralInfo_str.length());
    // file.flush();
    //other_Section
    file.write((uint8_t *)&Other_header,sizeof(Other_header));

    //Image_Section
    file.write((uint8_t *)&Image_header,sizeof(Image_header));
    // file.flush();
    if(image_picture.Squantity > 0)
    {
        file.flush();
        file.write((uint8_t *)&image_picture,sizeof(image_picture) - sizeof(uint8_t *));
        file.write(image_picture.data,image_picture.length - sizeof(image_picture.name) - sizeof(image_picture.date)  - sizeof(image_picture.type));
    }
    file.flush();
    file.close();
}

void print_heap_detail() {
    Serial0.printf("Heap : %u bytes\n", heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
    Serial0.printf("Heap : %u bytes\n", heap_caps_get_largest_free_block(MALLOC_CAP_DEFAULT));
    Serial0.printf(": %u bytes\n", heap_caps_get_total_size(MALLOC_CAP_DEFAULT));
    Serial0.printf(": %u bytes\n", heap_caps_get_minimum_free_size(MALLOC_CAP_DEFAULT));

    Serial0.printf("PSRAM : %u bytes\n", heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
    Serial0.printf("PSRAM : %u bytes\n", heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM));
    Serial0.printf("PSRAM : %u bytes\n", heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM));
}


void show_data_task(void *pvParameters)
{
    String path = "/data";
    uint32_t path_deep = 0;
    uint32_t page_log[100]= {0};
    uint16_t file_s_dn[512];
    uint8_t plot_type = 0;
    show_data_structure.mode = 0xff;
    read_file_point file_point = {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
    bool first_flag = true;
    memset(page_log,0,sizeof(page_log));
    
    while(1)
    {
        xEventGroupWaitBits(ui_event_group, SHOW_DATA_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
        if(get_sd_card_status() == false) 
        {
            if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
            {
                lv_obj_set_size(guider_ui.screen_data_spinner_1, 1, 1);
                lv_label_set_text(guider_ui.screen_data_label_17, "");
                lv_obj_clear_state(guider_ui.screen_data_btnm_1, LV_STATE_DISABLED);
                xSemaphoreGive(lvgl_mutex);
            }
            continue;
        }
        
        if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
        {
            lv_obj_set_size(guider_ui.screen_data_spinner_1, 41, 52);
            lv_label_set_text(guider_ui.screen_data_label_17, "加载中");
            lv_obj_add_state(guider_ui.screen_data_btnm_1, LV_STATE_DISABLED);  // 禁用按钮
            xSemaphoreGive(lvgl_mutex);
        }
        
        // lock_screen();

        uint32_t mode;
        String target_path = "/";
        uint32_t target_page =0;
        uint32_t total_page = 0;
        String read_path;
        bool flag = false;
        
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            mode  = show_data_structure.mode;
            target_page = show_data_structure.target_page;
            target_page = target_page - 1;
            target_path += show_data_structure.target_path;
            plot_type = show_data_structure.plot_type;
            if(mode == 7) plot_type++;
            plot_type = plot_type > 3 ? 0 : plot_type;
            show_data_structure.plot_type = plot_type;

            total_page = show_data_structure.total_page;
            xSemaphoreGive(xMutexInventory);
        }
        //更新列表
            //0下一页 1上一页 2跳转 3返回 4进入 5加载 6查看数据 7改变曲线
        uint32_t page = page_log[path_deep];
        switch (mode)
        {
            case 0:
                if(total_page == 0 ) break;
                if((page_log[path_deep] + 1 )< total_page)
                {
                    page_log[path_deep]++;
                    page = page_log[path_deep];
                    show_page(path, page);
                }
                break;
            case 1:
                if(total_page == 0 ) break;
                if(page_log[path_deep] > 0)
                {
                    page_log[path_deep]--;
                    page = page_log[path_deep];
                    show_page(path, page);
                }
                break;
            case 2:
                if(page_log[path_deep] != target_page)
                {
                    if(target_page > total_page) target_page = total_page - 1;
                    // if(target_page < 0) target_page = 0;

                    page_log[path_deep] = target_page;
                    page = page_log[path_deep];
                    show_page(path, page);
                }
                break;
            case 3: 
                {
                    int slashIndex = path.lastIndexOf('/');
                    if (slashIndex > 0) 
                    {
                        path = path.substring(0, slashIndex);
                        if (path_deep > 0) path_deep--;

                        total_page = get_file_num(path);
                        page = page_log[path_deep];
                        show_page(path, page);
                    }
                    break;
                }
            case 4:
                {
                    path = path  + target_path;
                    path_deep ++;
                    page_log[path_deep] = 0;
                    total_page = get_file_num(path);
                    // page = page_log[path_deep];
                    page = total_page - 1;
                    page_log[path_deep] = page;
                    show_page(path, page);
                    break;   
                }
            case 5:
                { 
                    flag = file_data_analysis(&file_point);
                    if(flag) change_plot_type(file_point,plot_type);
                    if(flag) show_picture(&file_point);

                    total_page = get_file_num(path);
                    page = total_page - 1;
                    show_page(path, page);
                    break;
                }
            case 6:
                {                    
                    read_path = path + target_path;

                    // plot_type = 0;
                    // if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
                    // {   
                    //     show_data_structure.plot_type = plot_type;
                    //     xSemaphoreGive(xMutexInventory);
                    // }
                    flag = read_data_from_file(read_path);
                    if(flag) flag = file_data_analysis(&file_point);
                    if(flag) change_plot_type(file_point,plot_type);
                    if(flag) show_picture(&file_point);
                    break;  
                }
            case 7:
                {
                    change_plot_type(file_point,plot_type);
                    break;  
                }
            default:
                break;
        }
        
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            show_data_structure.total_page = total_page;
            show_data_structure.now_page = page + 1;
            if(total_page ==  0) show_data_structure.now_page = 0;
            show_data_structure.mode = 0xff;
            xSemaphoreGive(xMutexInventory);
        }
        xEventGroupSetBits(ui_event_group,SHOW_DATA_DONE_BIT);
        


        if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
        {
            lv_obj_set_size(guider_ui.screen_data_spinner_1, 1, 1);
            lv_label_set_text(guider_ui.screen_data_label_17, "");
            lv_obj_clear_state(guider_ui.screen_data_btnm_1, LV_STATE_DISABLED);
            xSemaphoreGive(lvgl_mutex);
        }
        xEventGroupClearBits(ui_event_group,SHOW_DATA_BIT);
    }

}

//0 dn 1 rad 2ref 3dark_dn
void change_plot_type(read_file_point file_point,uint8_t plot_type)
{
    if((file_point.s_dn_data == NULL )|| (file_point.dark_dn_data == NULL) || (file_point.data_info == NULL))
    {
        return;
    } 
    uint16_t str_len;
    memcpy(&str_len,file_point.data_info,2);

    char temp_str[str_len + 1];
    memcpy(temp_str, file_point.data_info + 2 + 1, str_len);
    temp_str[str_len] = '\0';

    String SpectralInfo_str(temp_str);

    // file_doc
    deserializeJson(file_doc, SpectralInfo_str);
    uint32_t dn_it;
    One_Spectral_Data_Struct *p = file_point.s_dn_data;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        memcpy(show_data_structure.file_name,p->Name,sizeof(show_data_structure.file_name));

        show_data_structure.year = p->CollectionTime.year;
        show_data_structure.month = p->CollectionTime.month;
        show_data_structure.day = p->CollectionTime.day;
        show_data_structure.hour = p->CollectionTime.hour;
        show_data_structure.minute = p->CollectionTime.minute;
        show_data_structure.second = p->CollectionTime.second;

        show_data_structure.IT = p->Exposure;
        dn_it = p->Exposure;

        JsonObject info1 = file_doc["info_list"][1];  // 如果确定是第二个对象
        show_data_structure.W_count = info1["W_count"] | 0;
        show_data_structure.D_count = info1["D_count"] | 0;
        show_data_structure.S_count = info1["S_count"] | 0;
        show_data_structure.height  = info1["height"].as<float>();
        xSemaphoreGive(xMutexInventory);
    }

    if(plot_type == 1)
    {
        if(file_point.califile_data == NULL) plot_type++;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {   
            show_data_structure.plot_type = plot_type;
            xSemaphoreGive(xMutexInventory);
        }
    }
    
    if(plot_type == 2)
    {
        if(file_point.wr_dn_data == NULL) plot_type++;
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {   
            show_data_structure.plot_type = plot_type;
            xSemaphoreGive(xMutexInventory);
        }
    }
    
    uint16_t *dn =    (uint16_t *)(file_point.s_dn_data->SpectralDataAddress);
    uint16_t *dark =  (uint16_t *)(file_point.dark_dn_data->SpectralDataAddress);

    
    switch (plot_type)
    {
        case 0:
        {
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {   

                for (uint16_t i = 0; i < 512; i++)
                {
                    show_data_structure.plot_data[i] = (int)dn[i] - (int)dark[i];
                }
                xSemaphoreGive(xMutexInventory);
            }
        }
        break;
        case 1://rad
        {     
            if(file_point.califile_data == NULL) return;
            double *gian = (double *)(file_point.califile_data->SpectralDataAddress);
            double gain_it = file_point.califile_data->Exposure;

            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {   
                for (uint16_t i = 0; i < 512; i++)
                {
                    show_data_structure.plot_data[i] = (double)(dn[i] - dark[i])/ (double)dn_it * gain_it * (gian[i] * 1000000);
                }
                xSemaphoreGive(xMutexInventory);
            }
        }
        break;
        case 2: //ref
        {     
            if(file_point.wr_dn_data == NULL) return;
            uint16_t *wr = (uint16_t *)(file_point.wr_dn_data->SpectralDataAddress);

            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {   
                for (uint16_t i = 0; i < 512; i++)
                {
                    show_data_structure.plot_data[i] = (float)(dn[i] - dark[i]) / (float)(wr[i] - dark[i]) *  10000;
                }
                xSemaphoreGive(xMutexInventory);
            }
        }
        break;
        case 3: //dark_dn
        {     
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {   
                for (uint16_t i = 0; i < 512; i++)
                {
                    show_data_structure.plot_data[i] =  dark[i];
                }
                xSemaphoreGive(xMutexInventory);
            }
        }
        break;
    
    default:
        break;
    }
}

static void  updata_dir(lv_event_t *e)
{

    uint8_t mode;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        mode = show_data_structure.mode;
        xSemaphoreGive(xMutexInventory);
    }

    if(mode == 0xff) 
    {
        lv_obj_t * obj = lv_event_get_target(e);
        const char *dir = lv_list_get_btn_text(guider_ui.screen_data_list_1, obj);
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            show_data_structure.mode = 4;
            strcpy(show_data_structure.target_path, dir);
            xSemaphoreGive(xMutexInventory);
        }
        xEventGroupSetBits(ui_event_group, SHOW_DATA_BIT);
    }
    
}

//更新数据
static void  updata_data(lv_event_t *e)
{
    uint8_t mode;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        mode = show_data_structure.mode;
        xSemaphoreGive(xMutexInventory);
    }

    if(mode == 0xff)
    {
        lv_obj_t * obj = lv_event_get_target(e);
        const char *dir = lv_list_get_btn_text(guider_ui.screen_data_list_1, obj);
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            show_data_structure.mode = 6;
            strcpy(show_data_structure.target_path, dir);
            xSemaphoreGive(xMutexInventory);
        }
        xEventGroupSetBits(ui_event_group, SHOW_DATA_BIT);
    } 
}

// 0_0 /data
// static uint32_t show_page(String path, uint32_t page) 
// {
//     File root = SD_MMC.open(path);
//     if (!root || !root.isDirectory()) {
        
//         return 0;
//     }

//     if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
//     {
//         lv_obj_clean(guider_ui.screen_data_list_1);  // 清空列表
//         xSemaphoreGive(lvgl_mutex);
//     }
    
//     // lv_obj_invalidate(guider_ui.screen_data_list_1); // 强制刷新父对象
//     // vTaskDelay(50);
    
    
//     uint32_t start_index = page * ITEMS_PER_PAGE;
//     uint32_t end_index = start_index + ITEMS_PER_PAGE;
//     uint32_t current_index = 0;

//     File file = root.openNextFile();
//     uint32_t count = 0;
//     while (file) 
//     {
//         // Serial0.println("current_index" + String(current_index));
//         if (current_index >= start_index)
//         {
//             String filename = file.name();

//             bool isDir = file.isDirectory();      
//             const char* icon = isDir ? LV_SYMBOL_DIRECTORY : LV_SYMBOL_FILE;

//             if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
//             {

//                 guider_ui.screen_data_list_1_btn = lv_list_add_btn(guider_ui.screen_data_list_1, icon, filename.c_str());
//                 lv_obj_t* label = lv_obj_get_child(guider_ui.screen_data_list_1_btn, 1); 

//                 if (label != NULL) 
//                 {
//                     lv_label_set_long_mode(label, LV_LABEL_LONG_CLIP);
//                 }
                
//                 if(isDir) lv_obj_add_event_cb(guider_ui.screen_data_list_1_btn,updata_dir, LV_EVENT_CLICKED, NULL);
//                 else lv_obj_add_event_cb(guider_ui.screen_data_list_1_btn,updata_data, LV_EVENT_CLICKED, NULL);

//                 xSemaphoreGive(lvgl_mutex);
//             }

//         }

//         file = root.openNextFile();
        
//         current_index++;
//         if(current_index >= end_index) break;

//         count++;
//         if(count%20 == 0) vTaskDelay(1);
//     }
//     root.close();
//     return end_index;
// }
// static uint32_t get_file_num(String path)
// {
//     uint32_t file_count = 0;

//     File root = SD_MMC.open(path);
    
//     if (!root) 
//     {
//         // Serial0.println("Failed to open directory");
//         return 0;
//     }
//     if (!root.isDirectory()) 
//     {
//         // Serial0.println("Not a directory");
//         root.close();
//         return 0;
//     }
    
//     if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
//     {
//         lv_obj_clean(guider_ui.screen_data_list_1);  // 清空列表
//         xSemaphoreGive(lvgl_mutex);
//     }
//     // lv_obj_clean(guider_ui.screen_data_list_1);  // 清空列表
//     // vTaskDelay(50);

    
//     uint32_t count = 0;
//     File file = root.openNextFile();
//     while (file)
//     {
//         file_count++;
//         // file.close();               // 关闭当前文件
//         file = root.openNextFile(); // 获取下一个文件

//         if(count%20 == 0) vTaskDelay(1);
//     }
//     root.close();

//     uint32_t total_page = ceil((float)file_count / ITEMS_PER_PAGE);

//     if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
//     {
//         show_data_structure.total_page = total_page;
//         xSemaphoreGive(xMutexInventory);
//     }
//     // Serial0.println("file_count:" + String(file_count));
//     // Serial0.println("total_page:" + String(total_page));
//     return total_page;
// }
///////////////////////////////////////////////////////////////////////////////
#include "driver/sdmmc_host.h"
#include <dirent.h>

static uint32_t get_file_num(String path_str)
{
    uint32_t file_count = 0;
    esp_err_t ret;
    DIR *dir;
    struct dirent *ent;
    lv_obj_t * btn;
    
    path_str = "/sdcard" + path_str;
    const char *path = path_str.c_str();
    // Serial0.println("path:" + String(path));
    if ((dir = opendir(path))!= NULL) 
    { 
        // 打开目录
        while ((ent = readdir(dir))!= NULL) 
        {
            file_count++;
        }
        closedir(dir);
    } 
    else 
    {
        // Serial0.println("Failed to open directory");
        return 0;
    }
    uint32_t total_page = ceil((float)file_count / ITEMS_PER_PAGE);
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        show_data_structure.total_page = total_page;
        xSemaphoreGive(xMutexInventory);
    }
    // Serial0.println("file_count:" + String(file_count));
    // Serial0.println("total_page:" + String(total_page));
    return total_page;
}

static uint32_t show_page(String path, uint32_t page) 
{
    File root = SD_MMC.open(path);
    if (!root || !root.isDirectory()) {
        
        return 0;
    }
    root.close();


    if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
    {
        lv_obj_clean(guider_ui.screen_data_list_1);  // 清空列表
        xSemaphoreGive(lvgl_mutex);
    }

    uint32_t start_index = page * ITEMS_PER_PAGE;
    uint32_t end_index = start_index + ITEMS_PER_PAGE;
    uint32_t current_index = 0;
    uint32_t count = 0;


    esp_err_t ret;
    DIR *dir;
    struct dirent *ent;
    lv_obj_t * btn;
    path = "/sdcard" + path;
    const char *path_str = path.c_str();
    if ((dir = opendir(path_str))!= NULL) 
    { 
        // 打开目录
        while ((ent = readdir(dir))!= NULL) 
        {
            if (current_index >= start_index)
            {
                if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
                {
                    if (ent->d_type == DT_REG)// 如果是常规文件
                    { 
                        guider_ui.screen_data_list_1_btn = lv_list_add_btn(guider_ui.screen_data_list_1, LV_SYMBOL_FILE,  (const char *)ent->d_name);
                        lv_obj_t* label_1 = lv_obj_get_child(guider_ui.screen_data_list_1_btn, 1); 

                        if (label_1 != NULL) 
                        {
                            lv_label_set_long_mode(label_1, LV_LABEL_LONG_CLIP);
                        }

                        lv_obj_add_event_cb(guider_ui.screen_data_list_1_btn,updata_data, LV_EVENT_CLICKED, NULL);
                    }
                    else if (ent->d_type == DT_DIR) 
                    { 
                        guider_ui.screen_data_list_1_btn = lv_list_add_btn(guider_ui.screen_data_list_1, LV_SYMBOL_DIRECTORY,  (const char *)ent->d_name);
                        lv_obj_t* label_2 = lv_obj_get_child(guider_ui.screen_data_list_1_btn, 1); 

                        if (label_2 != NULL) 
                        {
                            lv_label_set_long_mode(label_2, LV_LABEL_LONG_CLIP);
                        }
                        lv_obj_add_event_cb(guider_ui.screen_data_list_1_btn,updata_dir, LV_EVENT_CLICKED, NULL);

                    }

                    xSemaphoreGive(lvgl_mutex);
                }
            }
            current_index++;
            if(current_index >= end_index) break;

            // count++;
            // if(count%20 == 0) vTaskDelay(1);

        }
        closedir(dir);
    } 
    else 
    {
        return 0;
    }
    return end_index;
}
///////////////////////////////////////////////////

bool read_data_from_file(String path)
{
    if(path.indexOf(".iris") < 0) 
    {
        // Serial0.println("file_type_error");
        return false;
    }
    memset(file_data,0,file_heap_size);
    bool flag = false;
    uint32_t size;
    uint32_t type;
    File file;
    file = SD_MMC.open(path,FILE_READ);
    size = file.size();

    if(size && (size < file_heap_size)) 
    {

        file.read(file_data,size);
        flag = true;
    }
    file.close();

    // Serial0.println("file size:" + String(size));
    // Serial0.println("if read:" + String(flag));
    // Serial0.printf("file_data:%x %x %x %x\n",file_data[0],file_data[1],file_data[2],file_data[3]);
    // Serial0.write(file_data,4);
    return flag;
}


bool file_data_analysis(read_file_point *p)
{
    // p = {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
    p->califile_data = NULL;
    p->dark_dn_data = NULL;
    p->flat_ref_data = NULL;
    p->s_dn_data = NULL;
    p->wr_dn_data= NULL;

    p->data_info = NULL;
    p->image_info = NULL;

    uint32_t SpectralData_pos,Spectralinfo_pos,Other_pos,Image_pos;
    uint32_t pos=0;

    uint32_t header;
    uint32_t length = 0;
    memcpy(&header,file_data,4);
    if(header != SpectralData) return false;

    for (uint16_t i = 0; i < 4; i++)
    {
        memcpy(&header,file_data+pos,4);
        memcpy(&length,file_data+pos+4,8);
        
        // Serial0.printf("i:%d\n",i);
        // Serial0.printf("header:%x,length:%d\n",header,length);

        if((header == SpectralData)) SpectralData_pos = pos;
        else if((header == SpectralInfo)) Spectralinfo_pos = pos;
        else if((header == Other) ) Other_pos = pos;
        else if((header == Image)) Image_pos = pos;
 

        pos = pos + 4 + 8 + length;
    }

    // Serial0.printf("SpectralData_pos:%d\n",SpectralData_pos);
    // Serial0.printf("SpectralInfo_pos:%d\n",Spectralinfo_pos);
    // Serial0.printf("Other_pos:%d\n",Other_pos);
    // Serial0.printf("Image_pos:%d\n",Image_pos);

    // SpectralData_len
    uint64_t SpectralData_len = 0;
    memcpy(&SpectralData_len,file_data+SpectralData_pos+4,8);
    // Serial0.printf("SpectralData_len:%d\n",SpectralData_len);
    uint16_t SpectralData_quantity = 0;
    memcpy(&SpectralData_quantity,file_data+SpectralData_pos+12,2);
    // Serial0.printf("SpectralData_quantity:%d\n",SpectralData_quantity);

    uint32_t offset = 4 + 8 + 2;
    for(int i = 0;i < SpectralData_quantity;i++)
    {
        One_Spectral_Data_Struct *Spectral_Data_Structure;

        // memcpy(&Spectral_Data_Structure,file_data+offset,sizeof(Spectral_Data_Structure)-sizeof(Spectral_Data_Structure.SpectralDataAddress));
        Spectral_Data_Structure = (One_Spectral_Data_Struct *)(file_data+offset);

        
        switch (Spectral_Data_Structure->GroundType)
        {
            case s_dn: 
                p->s_dn_data = Spectral_Data_Structure;
                p->s_dn_data->SpectralDataAddress = file_data + offset + sizeof(One_Spectral_Data_Struct) - sizeof(uint8_t *);
                break;
            case flat_dn:
                p->wr_dn_data = Spectral_Data_Structure;
                p->wr_dn_data->SpectralDataAddress = file_data + offset + sizeof(One_Spectral_Data_Struct) - sizeof(uint8_t *);
                break;
            case dark_dn:
                p->dark_dn_data = Spectral_Data_Structure;
                p->dark_dn_data->SpectralDataAddress = file_data + offset + sizeof(One_Spectral_Data_Struct) - sizeof(uint8_t *);
                break;
            case flat_ref:
                p->flat_ref_data = Spectral_Data_Structure;
                p->flat_ref_data->SpectralDataAddress = file_data + offset + sizeof(One_Spectral_Data_Struct) - sizeof(uint8_t *);
                break;
            case califile:
                p->califile_data = Spectral_Data_Structure;
                p->califile_data->SpectralDataAddress = file_data + offset + sizeof(One_Spectral_Data_Struct) - sizeof(uint8_t *);
                break;
            default:
                break;
        }
        offset = offset + sizeof(One_Spectral_Data_Struct)-sizeof(uint8_t *) + Spectral_Data_Structure->Bands*Spectral_Data_Structure->PixelSize;
    }

    uint64_t Spectralinfo_len;
    memcpy(&Spectralinfo_len,file_data+Spectralinfo_pos+4,sizeof(uint64_t));
    // Serial0.printf("Spectralinfo_len:%d\n",Spectralinfo_len);

    offset = 4 + 8 + 2;
    if(Spectralinfo_len) p->data_info = file_data + Spectralinfo_pos + offset;
    else p->data_info = NULL;

    uint64_t image_len;
    memcpy(&image_len,file_data+Image_pos+4,sizeof(uint64_t));
    // Serial0.printf("image_len:%d\n",image_len);
    if(image_len != 0) 
    {
        p->image_info = (picture *)(file_data + Image_pos + 4 + 8);
        // p->image_info->data = (uint8_t *)(file_data + Image_pos + 4 + 8 +  2 + 8 + 100 + 10 + 1);
    }
    else p->image_info = NULL;

    return true;
}


bool picture_output(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t* bitmap)
{

  if (y >= 204) return 0;  // 忽略底部多余区域

  for (int j = 0; j < h; j++) {
    int yy = y + j;
    if (yy >= 204) continue;  // 裁剪下边界

    for (int i = 0; i < w; i++) {
      int xx = x + i;
      if (xx >= 324) continue;  // 裁剪右边界

      int dst_idx = yy * 324 + xx;

      buf_screen_data_canvas_1[dst_idx].full = bitmap[j * w + i];
    }
  }

  return 1;
}

void clear_screen(uint16_t color = 0xffff)  // 白色，RGB565
{
    for (int y = 0; y < 204; ++y)
    {
        for (int x = 0; x < 324; ++x)
        {
            int idx = y * 324 + x;
            buf_screen_data_canvas_1[idx].full = color;
        }
    }
}

void show_picture(read_file_point *p)
{
    clear_screen(0xffff);
    if(p->image_info == NULL) 
    {
        // buf_screen_data_canvas_1[dst_idx].full = bitmap[j * w + i];
        clear_screen(0xffff);
        // Serial0.println("p->image_info == NULL");
        return;
    }

    if( p->image_info->Squantity != 1 ) 
    {
        clear_screen(0xffff);
        // Serial0.println("no picture");
        return;
    }

    uint64_t picture_len = p->image_info->length - 100 - 10 -1;
    // Serial0.printf("picture_len : %d",picture_len);
    char p_name[100] ;
    memcpy(p_name,p->image_info->name,100);


    xEventGroupSetBits(ui_event_group,CAM_STOP_BIT);
    TJpgDec.setJpgScale(1);  // 缩小
    TJpgDec.setSwapBytes(false);  // RGB转换
    TJpgDec.setCallback(picture_output);
    TJpgDec.drawJpg(0, 0, (uint8_t *)p->image_info + 2 + 8 + 100 + 10 + 1,picture_len);
    vTaskDelay(200);
    initJPEGDecoder();
}




void pc_mode_task(void *pvParameters)
{
    while (1)
    {
        xEventGroupWaitBits(ui_event_group, PC_MODE_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
        play_music("diannaomoshi.mp3");
        suspend_all_tasks();
        is3.reset();
        uint32_t i = 0;
        uint8_t s0rx_buf[1024 * 2];
        uint8_t s1rx_buf[1024 * 2];
        while (1)
        {
            EventBits_t uxBits = xEventGroupGetBits(ui_event_group);
            if(!(uxBits & PC_MODE_BIT)) break;

            // 1. Serial0 -> Serial1
            // if (Serial0.available()) 
            if(my_usart_available(0))
            {
                // int byte_from_pc = Serial0.readBytes(s0rx_buf,1024);
                int byte_from_pc =  uart_read_bytes(0,s0rx_buf,1024*2,10);
                Serial1.write(s0rx_buf,byte_from_pc);
            }

            // 2. Serial1 -> Serial0
            // if (Serial1.available()) 
            if(my_usart_available(1))
            {
                // int byte_from_uart = Serial1.readBytes(s1rx_buf,1024);
                int byte_from_uart =  uart_read_bytes(1,s1rx_buf,1024*2,10);
                Serial0.write(s1rx_buf,byte_from_uart);
            }
            
            if(i == 1000) 
            {
                vTaskDelay(1);
                i = 0;
            }
            i++;
        }
        // Serial1.flush();
        is3.reset();
        is3.set_shutter_time(is3.integration_time);
        resume_all_tasks();
        vTaskDelay(200);
    }
}

bool read_flat_file(String file_name)
{
    String path = "/config/flatfile/" + file_name;
    File file = SD_MMC.open(path);
    if(!file)
    {
        return false;
    }
    file.read((uint8_t *)(&hh3_flatfile_struct),sizeof(hh3_flatfile_struct));
    file.close();
    // Serial0.printf("file_name:%s\n",file_name.c_str());
    // Serial0.printf("GroundType:%d\n",hh3_flatfile_struct.gian.GroundType);
    if(hh3_flatfile_struct.gian.GroundType != 5)
    {
        return false;
    }
    // uint32_t bandnum = hh3_flatfile_struct.gian.band_num;
    uint32_t bandnum = 512;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        // memcpy(&hh3_data_flat_ref,&hh3_flatfile_struct.gian,sizeof(hh3_data_flat_ref));
        for(int i = 0; i < bandnum; i++)
        {
            flat_structure.plot_data[i] = hh3_flatfile_struct.gian.data[i] * 10000;
        }
        xSemaphoreGive(xMutexInventory);
    }
    xEventGroupSetBits(ui_event_group2,flat_plot_BIT);
    // if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
    // {
    //     int32_t nn = 511;
    //     for (uint16_t i = 0; i < 512; i++)
    //     {
    //         guider_ui.Setting_ckb_chart_1_0->y_points[i] =  flat_structure.plot_data[i];
    //         nn--;
    //     }
    //     lv_chart_set_range(guider_ui.Setting_ckb_chart_1, LV_CHART_AXIS_PRIMARY_Y, 0, 1.25 * 10000); //设置坐标y轴范围
    //     lv_chart_refresh(guider_ui.Setting_ckb_chart_1);
    //     xSemaphoreGive(lvgl_mutex);
    // }

    // if(hh3_flatfile_struct.gian.GroundType == 5)
    // {
    //      memcpy(&hh3_data_flat_ref,&hh3_flatfile_struct.gian,sizeof(hh3_data_flat_ref));
    //     return true;
    // }
    return true;
}
//更新数据
static lv_obj_t * plat_last_btn;   // 记录上一次点击的按钮
static void flatfile_read(lv_event_t *e)
{
    // static lv_obj_t *last_btn;   // 记录上一次点击的按钮
    lv_obj_t * obj = lv_event_get_target(e);
    const char *dir = lv_list_get_btn_text(guider_ui.screen_data_list_1,obj);
    if(plat_last_btn && plat_last_btn != obj)
    {
        lv_obj_set_style_bg_color(plat_last_btn,
                                  lv_color_hex(0xFFFFFF),      // 默认背景色
                                  LV_PART_MAIN | LV_STATE_DEFAULT);
    }
    lv_obj_set_style_bg_color(obj, lv_color_hex(0x0E49F8), LV_PART_MAIN|LV_STATE_DEFAULT);
    plat_last_btn = obj;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        flat_structure.flat_type = 1;
        strcpy(flat_structure.flat_file_name,dir);
        xSemaphoreGive(xMutexInventory);
    }
    xEventGroupSetBits(ui_event_group2, flat_BIT);

}

void add_flatfile_item()
{
    String path = "/config/flatfile";
    File root = SD_MMC.open(path);
    if (!root || !root.isDirectory()) 
    {
        return;
    }
    root.close();
    String flat_name;
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        String str = sys_doc["flatfile_name"];
        flat_name = str;
        xSemaphoreGive(xMutexInventory);
    }

    esp_err_t ret;
    DIR *dir;
    struct dirent *ent;
    lv_obj_t * btn;
    path = "/sdcard" + path;
    const char *path_str = path.c_str();

    if ((dir = opendir(path_str))!= NULL) 
    { 
        // 打开目录
        uint8_t num = 0;
        while ((ent = readdir(dir))!= NULL) 
        {
            if (xSemaphoreTake(lvgl_mutex, portMAX_DELAY)) 
            {
                if (ent->d_type == DT_REG)// 如果是常规文件
                { 
                    guider_ui.Setting_ckb_list_1_btn = lv_list_add_btn(guider_ui.Setting_ckb_list_1, LV_SYMBOL_FILE,  (const char *)ent->d_name);
                    lv_obj_t* label_1 = lv_obj_get_child(guider_ui.Setting_ckb_list_1_btn, 1); 
                    if(String(ent->d_name)  == flat_name)
                    {
                        lv_obj_set_style_bg_color(guider_ui.Setting_ckb_list_1_btn, lv_color_hex(0x0E49F8), LV_PART_MAIN|LV_STATE_DEFAULT);
                        plat_last_btn = guider_ui.Setting_ckb_list_1_btn;
                    }
                    if (label_1 != NULL) 
                    {
                        lv_label_set_long_mode(label_1, LV_LABEL_LONG_CLIP);
                    }
                    lv_obj_add_event_cb(guider_ui.Setting_ckb_list_1_btn,flatfile_read, LV_EVENT_CLICKED, NULL);
                }
                else if(ent->d_type == DT_DIR) 
                { 

                }
                xSemaphoreGive(lvgl_mutex);
            }
            num++;
            if (num > 20) break;
        }
        closedir(dir);
        read_flat_file(flat_name);
    }
}
void reset_flat_sturct()
{
    hh3_data_flat_ref.name[0] = '\0';
    hh3_data_flat_ref.sensor_id[0] = '\0';
    hh3_data_flat_ref.FiberID =  0;
    hh3_data_flat_ref.date = {0,0,0,0,0,0,0,0};
    hh3_data_flat_ref.integration_time = 0;
    hh3_data_flat_ref.gain = 0;
    hh3_data_flat_ref.data_type = 0x21;
    hh3_data_flat_ref.PixelSize = 8;
    hh3_data_flat_ref.GroundType = 5;
    hh3_data_flat_ref.band_num = 515;
    hh3_data_flat_ref.ValidFlag = 0;
    // memset(hh3_data_flat_ref.data,1,sizeof(hh3_data_flat_ref.data));
    if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
    {
        for(int i = 0; i < hh3_data_flat_ref.band_num; i++)
        {
            hh3_data_flat_ref.data[i] = 1;
        }
        xSemaphoreGive(xMutexInventory);
    }


}


void flat_task(void *pvParameters)
{
    reset_flat_sturct();
    uint8_t flag = 0;
    bool reset = false;
    while(1)
    {
        uint8_t flat_type;
        String flat_file_name;
        if(flag == 0)
        {
            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
            {
                String str = sys_doc["flatfile_name"];
                strcpy(flat_structure.flat_file_name,str.c_str());
                flat_file_name = str;
                xSemaphoreGive(xMutexInventory);
            }
            read_flat_file(flat_file_name);
            flag = 1;
        }
        xEventGroupWaitBits(ui_event_group2,flat_BIT,pdTRUE,pdFALSE,portMAX_DELAY);
        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
        {
            flat_type = flat_structure.flat_type;
            flat_file_name = flat_structure.flat_file_name;
            xSemaphoreGive(xMutexInventory);
        }

        // Serial0.println("flat_task");
        switch (flat_type)
        {
            case 0:        //加载
                add_flatfile_item();
                break;
            case 1:         //读取
                read_flat_file(flat_file_name);
                reset = false;
                break;
            case 2:         //保存
                {
                    if(reset)
                    {
                        reset_flat_sturct();
                        if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
                        {
                            for(int i = 0; i < 512; i++)
                            {
                                flat_structure.plot_data[i] = hh3_data_flat_ref.data[i] * 10000;
                                // flat_structure.plot_data[i] = 1 * 10000;
                            }
                            sys_doc["flatfile_name"] = "flat_default.iris";
                            updata_struct_to_ui.system_save = 1;
                            xSemaphoreGive(xMutexInventory);
                        }
                    }
                    else
                    {
                        if(hh3_flatfile_struct.gian.GroundType == 5)
                        {
                            if(xSemaphoreTake(xMutexInventory, timeOut) == pdPASS)
                            {
                                sys_doc["flatfile_name"] = flat_file_name;
                                updata_struct_to_ui.system_save = 1;
                                xSemaphoreGive(xMutexInventory);
                            }
                            memcpy(&hh3_data_flat_ref,&hh3_flatfile_struct.gian,sizeof(hh3_data_flat_ref));
                        }
                    }

                    play_music("/OK2.mp3");
                    break;
                }
            case 3:        //还原默认
                {
                    reset = true;

                    if(xSemaphoreTake(lvgl_mutex, portMAX_DELAY))
                    {
                        for (uint16_t i = 0; i < 512; i++)
                        {
                            guider_ui.Setting_ckb_chart_1_0->y_points[i] = 1 * 10000;

                        }

                        lv_chart_set_range(guider_ui.Setting_ckb_chart_1, LV_CHART_AXIS_PRIMARY_Y, 0, 1.25 * 10000); //设置坐标y轴范围
                        lv_chart_refresh(guider_ui.Setting_ckb_chart_1);
                        xSemaphoreGive(lvgl_mutex);
                    }
                    // xEventGroupSetBits(ui_event_group2,flat_plot_BIT);
                    play_music("/OK2.mp3");
                    break;
                }
                
            default:
                break;
        }

  
    }
}