FluxDC/components/FluxUI/ui_events.c

// This file was generated by SquareLine Studio
// SquareLine Studio version: SquareLine Studio 1.5.1
// LVGL version: 8.3.6
// Project name: ESP32S3_UI

#include "ui.h"
#include "driver/ledc.h"
#include "esp_err.h"
#include "esp_log.h"

#include "FluxWifi.h"
#include "FluxUart.h"
#include "FluxSD.h"

#include "esp_vfs_fat.h"
#include "sdmmc_cmd.h"
#include "driver/sdmmc_host.h"

#include "FluxProtocol.h"

/*包含SNTP的头文件*/
#include "lwip/apps/sntp.h"
#include <time.h>

#define LOWERST_LIGHT_LEVEL (7222)

/*更新当前测试标准*/
static void standardVolumeRefresh(void);
/*根据呼吸频率调整积分时间*/
static void comulateTimeSend(void);

/*创建定时器*/
static void  comulateResultRead(lv_timer_t * timer)
{
	/*下发数据获取指令*/
	flux_frame.DATA[1] = 0;
	flux_frame.DATA[3] = 120;
	flux_frame.FUNC = 0x03;

	/*下发问询120个参数*/
	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame));


	lv_label_set_text(ui_pageHome_labelStartTest,"Test Complete!");
}


/*亮度调节回调函数*/
void on_sliderLight_valueChanged(lv_event_t * e)
{
	uint32_t value = 8192-lv_slider_get_value(e->target);

	if (value>LOWERST_LIGHT_LEVEL)
	{
		value = LOWERST_LIGHT_LEVEL;
	}

    ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, value));
    // Update duty to apply the new value
    ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0));
}


/*设备类型选择回调函数*/
void on_dropdownDeviceType_valueChanged(lv_event_t * e)
{
	char buf[32]={};
	uint16_t index = lv_dropdown_get_selected(e->target);

	lv_dropdown_get_selected_str(e->target,buf,32);
	lv_label_set_text(ui_pageHome_labelTitle, buf);

	if (index == Spirit3)		
	{
		lv_spinbox_set_range(ui_pageHome_spinboxStage,1,4);
	}else{
		lv_spinbox_set_range(ui_pageHome_spinboxStage,1,6);
	}

}


/*SD卡读取回调函数*/
void on_buttonReadSDCard_clicked(lv_event_t * e)
{
	/*首先清空显示页面*/
	lv_textarea_set_text(ui_pageSDCard_textAreaSDCard,"");
    esp_vfs_fat_info(MOUNT_POINT,&total_bytes,&free_bytes);
    free_percent = (float)free_bytes / (float)total_bytes * 100;

	printf("total:%llu free:%llu\n",total_bytes,free_bytes);

	lv_label_set_text_fmt(ui_pageSDCard_labelSDCardFree,"%.2f free",free_percent);
	lv_label_set_text_fmt(ui_pageSDCard_labelSDCardUsed,"used: %.2f GB",(double)(total_bytes-free_bytes)/(1024*1024*1024.0));
	lv_label_set_text_fmt(ui_pageSDCard_labelSDCardSize,"size: %.2f GB",(double)total_bytes/(1024*1024*1024.0));

	lv_arc_set_value(ui_pageSDCard_arcSDCardFree,free_percent);

}


/************************************  测试流程函数  ******************************************* */
/*pageHome 开始测试按键按下回调函数*/
int32_t timeS = 0;
void on_buttonStartTest_clicked(lv_event_t * e)
{

	/*下发积分时间*/
#if 1
	comulateTimeSend();
	uint8_t bytes[4];
	float time = (float)lv_spinbox_get_value(ui_pageFluxRead_spinboxTime);
	memcpy(bytes, &time, 4);

	/*下发命令*/
	flux_frame.ADDR = FLUX_ADDR;
	flux_frame.FUNC = FLUX_FUNC_SET_SINGLE;

	flux_frame.DATA[0] = 0x00;
	flux_frame.DATA[1] = 0x02;
	flux_frame.DATA[2] = bytes[3];
	flux_frame.DATA[3] = bytes[2];

	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame));

#endif
	/*基于定时器进行任务调用*/
	lv_timer_t * comulateResultReadTimer;
	comulateResultReadTimer = lv_timer_create(comulateResultRead, 500, NULL);
	lv_timer_set_repeat_count(comulateResultReadTimer, 1);


	timeS = lv_spinbox_get_value(ui_pageFluxRead_spinboxTime);
	lv_timer_set_period(comulateResultReadTimer, timeS*1000+2000);

	/*下发启动测试指令*/
	flux_frame_start.ADDR = FLUX_ADDR;
	flux_frame_start.FUNC = FLUX_FUNC_SET_SINGLE;

	flux_frame_start.DATA[0] = 0x00;
	flux_frame_start.DATA[1] = 0x01;
	flux_frame_start.DATA[2] = 0x00;
	flux_frame_start.DATA[3] = 0x01;
	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame_start));
	
	lv_label_set_text(ui_pageHome_labelStartTest,"Testing...");

	lv_timer_enable(comulateResultReadTimer);

}


/*pageHome 呼吸频率减操作*/
void on_buttonRateMinus_clicked(lv_event_t * e)
{	
	uint16_t value = lv_spinbox_get_value(ui_pageHome_spinboxRate);
	lv_spinbox_set_value(ui_pageHome_spinboxRate,value-5);
}

/*pageHome 呼吸频率加操作*/
void on_buttonRatePlus_clicked(lv_event_t * e)
{
	uint16_t value = lv_spinbox_get_value(ui_pageHome_spinboxRate);
	lv_spinbox_set_value(ui_pageHome_spinboxRate,value+5);
}


/*pageHome 切换挡位之后*/
void on_spinboxStage_valueChanged(lv_event_t * e)
{
	/*获取当前挡位并更新标准体积数据*/
	int32_t value = lv_spinbox_get_value(e->target);
	lv_label_set_text_fmt(ui_pageHome_labelResultStage,"%ld",value);

	standardVolumeRefresh();
}


/*pageHome 频率值改变*/
void on_spinboxRate_valueChanged(lv_event_t * e)
{
	/*更改下方测试结果部分的频率信息*/
	FluxMachineData.breathRate = lv_spinbox_get_value(e->target);
	lv_label_set_text_fmt(ui_pageHome_labelResultRate,"%ld",FluxMachineData.breathRate);

	/*刷新标准体积数据*/
	standardVolumeRefresh();

	/*下发测试时间*/
	comulateTimeSend();

	uint8_t bytes[4];
	float time = (float)lv_spinbox_get_value(ui_pageFluxRead_spinboxTime);
	memcpy(bytes, &time, 4);

	/*下发命令*/
	flux_frame.ADDR = FLUX_ADDR;
	flux_frame.FUNC = FLUX_FUNC_SET_SINGLE;

	flux_frame.DATA[0] = 0x00;
	flux_frame.DATA[1] = 0x02;
	flux_frame.DATA[2] = bytes[3];
	flux_frame.DATA[3] = bytes[2];

	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame));

}


/*pageHome 标准体积数据刷新*/
static void standardVolumeRefresh(void)
{
	/*获取当前的呼吸频率及挡位*/
	fluxProtocol.currentBPM = lv_spinbox_get_value(ui_pageHome_spinboxRate);
	fluxProtocol.currentStage = lv_spinbox_get_value(ui_pageHome_spinboxStage);

	/*获取当前测试设备类型*/
	fluxProtocol.currentDevice = lv_dropdown_get_selected(ui_pageSetting_dropdownDeviceType);

	if (fluxProtocol.currentDevice == Spirit3)
	{
		/*判定当前测试设备为Spirit-3*/
		/*获取标准体积数据*/
		fluxProtocol.nominalVolumeStage = Spirit3_Volume[fluxProtocol.currentStage-1];
	}else if (fluxProtocol.currentDevice == Spirit6)	
	{
		/*判定当前测试设备为Spirit-6*/
		fluxProtocol.nominalVolumeStage = Spirit6_Volume[fluxProtocol.currentStage-1];
	}else if(fluxProtocol.currentDevice ==  YU_Lite8)
	{
		/*判定当前测试设备为YU-Lite-8*/
		fluxProtocol.nominalVolumeStage = YULite8_Volume[fluxProtocol.currentStage-1];
	}

	float Volume_nominal = fluxProtocol.nominalVolumeStage /fluxProtocol.currentBPM*1.0;
	float VolumeMax = Volume_nominal*1.15;
	float VolumeMin = Volume_nominal*0.85;
	
	lv_label_set_text_fmt(ui_pageHome_labelNominalVolume,"%.2f",Volume_nominal);
	lv_label_set_text_fmt(ui_pageHome_labelNominalVolumeMax,"%.2f",VolumeMax);
	lv_label_set_text_fmt(ui_pageHome_labelNominalVolumeMin,"%.2f",VolumeMin);

	/*根据标准值判定当前检测结果是否合格*/
	RefreshResult();
}


/*pageFluxRead 获取当前流量数据*/
void on_buttonReadFlux_clicked(lv_event_t * e)
{
	flux_frame.DATA[1] = 0;
	flux_frame.DATA[3] = 120;
	flux_frame.FUNC = FLUX_FUNC_READ;

	/*下发问询120个参数*/
	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame));

}


/*更新测试结果 —— 功能已屏蔽*/
void on_labelTestVolume_valueChanged(lv_event_t * e)
{
	#if 0
	/* 测试结果刷新放到label更新函数中 */
	RefreshResult();
	#endif
}


/*更新工作模式 —— 功能已屏蔽*/
void on_dropDownWorkmode_valueChanged(lv_event_t * e)
{
	#if 0
	FluxMachineData.workMode = (enum FluxMachineWorkMode)lv_dropdown_get_selected(e->target);
	#endif
}


/*向流量计下发计时时间*/
void on_spinboxTime_valueChanged(lv_event_t * e)
{
	#if 0
	/* 0x10 设置多个参数报文格式 */
	/* 地址 功能码 起始地址 寄存器数量 字节计数（写入寄存器数量*2） 数据1   数据2 。。。 CRC	*/
	/* 0x01 0x10  0x00 02  0x00 02    0x04                     0x0078  0x0077 CRC*/

	/*下发配置参数（其实只是配置时间）*/
	flux_frame2Reg.ADDR = FLUX_ADDR;
	flux_frame2Reg.FUNC = FLUX_FUNC_SET;

	/*时间寄存器起始地址*/
	flux_frame2Reg.regAddr = 0x0002;
	flux_frame2Reg.regNum = 0x0002;

	flux_frame2Reg.ByteNum = 0x04;

	/*将时间的浮点数转为字节数组*/
	uint8_t bytes[4];
	float time = (float)lv_spinbox_get_value(e->target);
	memcpy(bytes, &time, 4);

	ESP_LOGI("FluxProtocol", "time:%f", time);
	ESP_LOGI("FluxProtocol", "time:0-%02x 1-%02x 2-%02x 3-%02x", bytes[0],bytes[1],bytes[2],bytes[3]);

	flux_frame2Reg.DATA[0] = bytes[3];
	flux_frame2Reg.DATA[1] = bytes[2];
	flux_frame2Reg.DATA[2] = bytes[1];
	flux_frame2Reg.DATA[3] = bytes[0];

	ESP_ERROR_CHECK(ModbusRTU_Send_0x10(ECHO_UART_PORT_NUM1,&flux_frame2Reg));
	#elif 0
	/*使用0306报文格式*/
	uint8_t bytes[4];
	float time = (float)lv_spinbox_get_value(ui_pageFluxRead_spinboxTime);
	memcpy(bytes, &time, 4);

	/*下发命令*/
	flux_frame.ADDR = FLUX_ADDR;
	flux_frame.FUNC = FLUX_FUNC_SET_SINGLE;

	flux_frame.DATA[0] = 0x00;
	flux_frame.DATA[1] = 0x02;
	flux_frame.DATA[2] = bytes[3];
	flux_frame.DATA[3] = bytes[2];

	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame));

	#endif
}


/*启动流量计*/
void on_buttonFluxStart_clicked(lv_event_t * e)
{
	FLUX_TEST_START;
}


/*根据spinbox中的值下发积分时间*/
/*注意：此处修改了spinboxTime 的值，不可以在spinboxTime_valueChanged中调用！！*/
static void comulateTimeSend(void)
{
	/*获取当前呼吸频率*/
	FluxMachineData.breathRate = lv_spinbox_get_value(ui_pageHome_spinboxRate);

	uint16_t currntTimes = lv_dropdown_get_selected(ui_pageFluxRead_dropdownPulseTimes);

	ESP_LOGI("comulateTimeSend","currentTimes:%d",currntTimes);

	if (currntTimes == 0)
	{
		/* 10次脉冲计量 */
		switch (FluxMachineData.breathRate)
		{
		case 15:
			/*呼吸频率为15BPM时，积分时间设定为40秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,40);
			break;
		
		case 20:
			/*呼吸频率为20BPM时，积分时间设定为30秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,30);
			break;
		case 25:
			/*呼吸频率为25BPM时，积分时间设定为24秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,24);
			break;
		case 30:
			/*呼吸频率为30BPM时，积分时间设定为20秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,20);
			break;
		case 35:
			/*呼吸频率为35BPM时，积分时间设定为16秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,18);
			break;
		case 40:
			/*呼吸频率为40BPM时，积分时间设定为15秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,15);
			break;
		default:
			break;
		}
	}else if (currntTimes == 1)
	{
		/* 20次脉冲 */
		switch (FluxMachineData.breathRate)
		{
		case 15:
			/*呼吸频率为15BPM时，积分时间设定为40秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,80);
			break;
		
		case 20:
			/*呼吸频率为20BPM时，积分时间设定为30秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,60);
			break;
		case 25:
			/*呼吸频率为25BPM时，积分时间设定为24秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,48);
			break;
		case 30:
			/*呼吸频率为30BPM时，积分时间设定为20秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,40);
			break;
		case 35:
			/*呼吸频率为35BPM时，积分时间设定为16秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,36);
			break;
		case 40:
			/*呼吸频率为40BPM时，积分时间设定为15秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,30);
			break;
		default:
			break;
		}
	}else if (currntTimes == 2)
	{
		/* 30次脉冲 */

		switch (FluxMachineData.breathRate)
		{
		case 15:
			/*呼吸频率为15BPM时，积分时间设定为40秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,120);
			break;
		
		case 20:
			/*呼吸频率为20BPM时，积分时间设定为30秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,90);
			break;
		case 25:
			/*呼吸频率为25BPM时，积分时间设定为24秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,72);
			break;
		case 30:
			/*呼吸频率为30BPM时，积分时间设定为20秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,60);
			break;
		case 35:
			/*呼吸频率为35BPM时，积分时间设定为16秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,54);
			break;
		case 40:
			/*呼吸频率为40BPM时，积分时间设定为15秒*/
			lv_spinbox_set_value(ui_pageFluxRead_spinboxTime,45);
			break;
		default:
			break;
		}

	}
	
}

/*获取呼吸脉冲次数*/
void on_dropdownPulseTimes_valueChanged(lv_event_t * e)
{
	/*下发测试时间*/
	comulateTimeSend();

	uint8_t bytes[4];
	float time = (float)lv_spinbox_get_value(ui_pageFluxRead_spinboxTime);
	memcpy(bytes, &time, 4);

	/*下发命令*/
	flux_frame.ADDR = FLUX_ADDR;
	flux_frame.FUNC = FLUX_FUNC_SET_SINGLE;

	flux_frame.DATA[0] = 0x00;
	flux_frame.DATA[1] = 0x02;
	flux_frame.DATA[2] = bytes[3];
	flux_frame.DATA[3] = bytes[2];

	ESP_ERROR_CHECK(ModbusRTU_Send_0306(ECHO_UART_PORT_NUM1,&flux_frame));
}