sggt/App/APP_WU/Src/app_screen_main.c

1908 lines
60 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include "app_screen_main.h"
MENU_DATA m5data; //界面参数初始化
PLOT_DATA pltdata; //chart绘图参数初始化
void screen_data_init(void)
{
//general
m5data.scr_now = SCREEN_INIT; //初始界面为开机动画
m5data.tick_prv = -1; //前一时刻,用于计时
m5data.tick_cur = -1; //当前时刻,用于计时
m5data.menu_reset_flag = 0; //复位使能标志置1后复位复位完成后变回0
physical_quantity_init();
//screen_init
m5data.scr_init_flag = 0; //是否进行过初始化(开机动画)
//screen_main
main_data_init();
//screen_setting
tab_data_init();
m5data.key_setting_enable = 0; //按键默认不使能
}
//主界面参数初始化
void main_data_init(void)
{
m5data.key_main_enable = 0; //按键默认不使能
m5data.runtime_seconds = 0; //秒
m5data.runtime_minutes = 0; //分钟
m5data.runtime_hours = 0; //小时
memset(m5data.runtime_show, 0, 16); //存放显示时间的字符串
m5data.battery_cnt = 0; //电池计数
m5data.io_cursor = 3; //当前游标位置,[0000,000]:0~6
m5data.io_cursor_prv = 3; //前一时刻游标位置
#if NIXIE_CUBE_ENABLE
m5data.twk_flag = 0; //0停止闪烁1开始闪烁
m5data.twk_flip = 0; //0显示1不显示
m5data.twk_cnt = 0; //闪烁计数
#endif
m5data.overflow_flag_low = 0; //向上溢出
m5data.overflow_flag_up = 0; //向下溢出
m5data.sign_flag_in = 0; //默认不显示符号
m5data.sign_flag_out = 0; //默认不显示符号
m5data.io_on2off = IO_OFF; //初始为关闭状态
m5data.io_mode = IO_OUTPUT; //默认工作模式0输入IN1输出OUT
for(uint8_t i = 0; i < 7; i++) //用于数值显示的数组初值为0
{
m5data.i_numbers[i] = 0; //输入值/测量值
m5data.o_numbers[i] = 0; //输出值/设定值
}
m5data.input_mode = CUR.tag; //输入功能初始为电流模式
m5data.input_mode_type = CUR.typ; //电流单位为mA
m5data.output_mode = CUR.tag; //输出功能初始为电流模式
m5data.output_mode_type = CUR.typ; //电压单位初始为mA
sig_channel_select(m5data.io_mode, m5data.output_mode_type); //默认通道
//绘图数据初始化
plot_data_init();
}
//绘图数据初始化
void plot_data_init(void)
{
//chart组件显示int,绘图值
pltdata.y_pri_low = 0; //主轴的显示下限0通常不做修改
pltdata.y_pri_up = 100; //主轴的显示上限100通常不做修改
pltdata.y_scd_low = 0; //副轴的显示下限0通常不做修改
pltdata.y_scd_up = 100; //副轴的显示上限100通常不做修改
pltdata.y_pri_value = 0; //主轴的实时显示值0~100
pltdata.y_pri_value_prv = 0; //前一时刻的曲线绘图值
pltdata.y_scd_value = 0; //副轴的实时显示值0~100
pltdata.y_scd_value_prv = 0; //前一时刻的曲线绘图值
pltdata.y_scd_value_prv = 0; //前一时刻的实时显示值。
pltdata.pri_wait_tick = 0; //主轴等待滴答数
pltdata.scd_wait_tick = 0; //副轴等待滴答数
//chart组件显示int,实际值
pltdata.yreal_pri_low = 0; //实际值的显示下限,主轴
pltdata.yreal_pri_up = 0; //实际值的显示上限,主轴
pltdata.yreal_scd_low = 0; //实际值的显示下限,副轴
pltdata.yreal_scd_up = 0; //实际值的显示上限,副轴
pltdata.yreal_pri_value = 0; //主轴的实时值,即输出/设定值
pltdata.yreal_scd_value = 0; //副轴的实时值,即输入/测量值
pltdata.yreal_scd_value_prv = 0; //前一时刻的输入测量值
}
void menu_reset(void)
{
//界面复位
if(m5data.scr_now == SCREEN_INIT)
{
//如果正处于开机动画中,立即返回。
return;
}
//加载初始界面
setup_scr_screen_init(&guider_ui);
lv_scr_load(guider_ui.screen_init);
//释放内存
switch (m5data.scr_now)
{
case SCREEN_MAIN:
{
lv_obj_del(guider_ui.screen_main);
}
break;
case SCREEN_SETTING:
{
lv_obj_del(guider_ui.screen_setting);
}
break;
default:
break;
}
//参数复位内部会对m5data.scr_now进行更改因此放置于最后。
screen_data_init();
}
//KEY_MAIN
void key_functions_main(void)
{
uint8_t cursor_temp = 0; //临时游标,替代枚举变量进行加减运算
switch (key)
{
case KEY_OUT:
{
key = 0;
//交替按下 in 和 out 时,只改变输入/输出,连续按同一个键的时候才改变类型
if(m5data.io_mode == IO_INPUT)
{
m5data.io_mode = IO_OUTPUT;
m5data.output_mode = m5data.input_mode;
io_on2off_status(); //更新状态指示
}
else
{
cursor_temp = (uint8_t)m5data.output_mode;
cursor_temp = (cursor_temp >= 5)?(0):(cursor_temp + 1);
m5data.output_mode = (SIG_FUNCTIONS)cursor_temp;
}
switch (m5data.output_mode)
{
case SIG_VOLTAGE: //电压
{
m5data.output_mode_type = VOLTAGE_V;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_CURRENT: //电流
{
m5data.output_mode_type = CURRENT_MA;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_RESISTANT: //电阻
{
m5data.output_mode_type = RESISTANT_OHM;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_FREQUENCE: //频率
{
m5data.output_mode_type = FREQUENCE_KHZ;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_TC: //热电偶
{
m5data.output_mode_type = TC_K;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_RTD: //热电阻
{
m5data.output_mode_type = RTD_DC;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
default:
break;
}
}
break;
case KEY_UP:
{
key = 0;
if(m5data.io_mode == IO_INPUT)
{
return;
}
#if NIXIE_CUBE_ENABLE
m5data.twk_flag = 1; // 上、下、左、右 任意一个键按下后,闪烁开始
m5data.twk_cnt = 0; //每次按下后闪烁计数清零
#endif
keyset_output(1);
}
break;
case KEY_MENU:
{
if( m5data.tick_prv == -1 )
{
//恢复默认工作模式关闭、电压V输出
set_working_mode(SIG_CURRENT, CURRENT_MA);
//加载菜单界面
setup_scr_screen_setting(&guider_ui);
scr_setting_recover();
delay_cnt(100);
lv_scr_load(guider_ui.screen_setting);
//按键标志置0等待一段时间后再切换至设置菜单的按键功能
m5data.key_main_enable = 0;
m5data.tick_prv = xTaskGetTickCount(); //记录起始时刻
}else
{
m5data.tick_cur = xTaskGetTickCount(); //记录当前时刻
if(m5data.tick_cur < m5data.tick_prv) //防止溢出当前tick小于前一刻的tick
{
m5data.tick_prv = -1; //溢出后复位并返回
m5data.tick_cur = -1;
return;
}
if( (m5data.tick_cur - m5data.tick_prv) >= screen_switch_wait) //tick间隔达到目标后执行功能
{
//清除主界面对象,释放内存
lv_obj_del(guider_ui.screen_main);
//等待结束,切换成设置菜单的按键功能
m5data.scr_now = SCREEN_SETTING; //当前界面为详细设置菜单
m5data.key_setting_enable = 1;
key = 0;
m5data.tick_prv = -1;
m5data.tick_cur = -1;
}
}
}
break;
case KEY_IN:
{
key = 0;
if(m5data.io_mode == IO_OUTPUT)
{
m5data.io_mode = IO_INPUT;
//继承之前的输出类型
m5data.input_mode = m5data.output_mode;
io_on2off_status(); //更新状态指示
}
else
{
//枚举类型不能直接运算于是使用临时变量cursor_temp
cursor_temp = (uint8_t)m5data.input_mode;
cursor_temp = (cursor_temp >= 5)?(0):(cursor_temp + 1);
m5data.input_mode = (SIG_FUNCTIONS)cursor_temp;
}
switch (m5data.input_mode)
{
case SIG_VOLTAGE: //电压
{
m5data.input_mode_type = VOLTAGE_V;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_CURRENT: //电流
{
m5data.input_mode_type = CURRENT_MA;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_RESISTANT: //电阻
{
m5data.input_mode_type = RESISTANT_OHM;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_FREQUENCE: //频率
{
m5data.input_mode_type = FREQUENCE_KHZ;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_TC: //热电偶
{
m5data.input_mode_type = TC_K;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_RTD: //热电阻
{
m5data.input_mode_type = RTD_DC;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
default:
break;
}
}
break;
case KEY_LEFT:
{
key = 0;
if(m5data.io_mode == IO_INPUT)
{
return;
}
#if NIXIE_CUBE_ENABLE
// m5data.twk_flag = 1; //上、下、左、右 任意一个键按下后,闪烁开始
// m5data.twk_cnt = 0; //每次按下后闪烁计数清零
#endif
//避免游标移动的瞬间,前一刻的数值处于闪烁熄灭的状态,移动游标前重新显示一次当前数值
set_nixie_cube(IO_OUTPUT, m5data.io_cursor, m5data.o_numbers[m5data.io_cursor]);
m5data.io_cursor_prv = m5data.io_cursor;
m5data.io_cursor = (m5data.io_cursor <= 0)?(6):(m5data.io_cursor - 1);
set_cursor_position();
}
break;
case KEY_OK:
{
key = 0;
//主界面用OK键控制开关ON&OFF
if(m5data.io_on2off == IO_ON)
{
m5data.io_on2off = IO_OFF;
}
else
{
m5data.io_on2off = IO_ON;
}
io_on2off_status(); //更新ON/OFF/IN/OUT状态指示
}
break;
case KEY_RIGHT:
{
key = 0;
if(m5data.io_mode == IO_INPUT)
{
return;
}
#if NIXIE_CUBE_ENABLE
m5data.twk_flag = 1; // 上、下、左、右 任意一个键按下后,闪烁开始
m5data.twk_cnt = 0; //每次按下后闪烁计数清零
#endif
//避免游标移动的瞬间,前一刻的数值处于闪烁熄灭的状态,移动游标前重新显示一次当前数值
set_nixie_cube(IO_OUTPUT, m5data.io_cursor, m5data.o_numbers[m5data.io_cursor]);
m5data.io_cursor_prv = m5data.io_cursor;
m5data.io_cursor = (m5data.io_cursor >= 6)?(0):(m5data.io_cursor + 1);
set_cursor_position();
}
break;
case KEY_SWITCH:
{
key = 0;
switch (m5data.io_mode) //输入、输出模式切换
{
case IO_OUTPUT:
{
switch (m5data.output_mode) //功能切换
{
case SIG_VOLTAGE:
{
cursor_temp = (uint8_t)m5data.output_mode_type;
cursor_temp = !cursor_temp;
m5data.output_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_CURRENT:
{
m5data.output_mode_type = CURRENT_MA;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_RESISTANT: //电阻
{
m5data.output_mode_type = RESISTANT_OHM;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_FREQUENCE: //频率
{
m5data.output_mode_type = FREQUENCE_KHZ;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_TC: //热电偶
{
cursor_temp = (uint8_t)m5data.output_mode_type;
cursor_temp = (cursor_temp >= 12)?(5):(cursor_temp + 1);
m5data.output_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case SIG_RTD: //热电阻
{
m5data.output_mode_type = RTD_DC;
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
default:
break;
}
}
break;
case IO_INPUT:
{
switch (m5data.input_mode)
{
case SIG_VOLTAGE:
{
cursor_temp = (uint8_t)m5data.input_mode_type;
cursor_temp = !cursor_temp;
m5data.input_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_CURRENT:
{
m5data.input_mode_type = CURRENT_MA;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_RESISTANT: //电阻
{
m5data.input_mode_type = RESISTANT_OHM;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_FREQUENCE: //频率
{
m5data.input_mode_type = FREQUENCE_KHZ;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_TC: //热电偶
{
cursor_temp = (uint8_t)m5data.input_mode_type;
cursor_temp = (cursor_temp >= 12)?(5):(cursor_temp + 1);
m5data.input_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
case SIG_RTD: //热电阻
{
m5data.input_mode_type = RTD_DC;
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
default:
break;
}
}
break;
default:
break;
}
}
break;
case KEY_SOURCE:
{
//电源开关靠硬件电路实现,此处可做预留
key = 0;
}
break;
case KEY_DOWN:
{
key = 0;
if(m5data.io_mode == IO_INPUT)
{
return;
}
#if NIXIE_CUBE_ENABLE
m5data.twk_flag = 1; // 上、下、左、右 任意一个键按下后,闪烁开始
m5data.twk_cnt = 0; //每次按下后闪烁计数清零
#endif
keyset_output(-1);
}
break;
case KEY_BACK: //闲置,预留
{
key = 0;
}
break;
default:
{
key = 0;
}
break;
}
}
uint8_t init_step = 0;
void scr_init_run(void)
{
switch (init_step)
{
case 0:
{
if( init_set_bar(0, 30, 1500) )
{
init_step = 1;
}
}
break;
case 1:
{
if( init_set_bar(60, 100, 1500) )
{
init_step = 2;
}
}
break;
case 2:
{
// //开机动画结束后,清除初始界面内部组件,保留对象,释放内存
// lv_obj_clean(guider_ui.screen_init);
//加载主界面
setup_scr_screen_main(&guider_ui);
scr_main_recover();
delay_cnt(500);
init_step = 3;
}
break;
case 3:
{
if( m5data.tick_prv == -1 )
{
lv_scr_load(guider_ui.screen_main);
//删除初始界面对象,释放剩余内存
lv_obj_del(guider_ui.screen_init);
m5data.tick_prv = xTaskGetTickCount(); //记录起始时刻
}else
{
m5data.tick_cur = xTaskGetTickCount(); //记录当前时刻
if(m5data.tick_cur < m5data.tick_prv) //防止溢出当前tick小于前一刻的tick
{
m5data.tick_prv = -1; //溢出后复位并返回
m5data.tick_cur = -1;
return;
}
if(m5data.tick_cur - m5data.tick_prv >= screen_switch_wait) //tick间隔达到目标后执行功能
{
init_step = 4;
m5data.tick_prv = -1;
m5data.tick_cur = -1;
}
}
}
break;
case 4:
{
m5data.scr_init_flag = 1; //开机动画结束,只执行一次
m5data.scr_now = SCREEN_MAIN; //开机动画结束后,默认进入主界面
m5data.key_main_enable = 1;
init_step = 0;
}
break;
default:
break;
}
}
//进度条设置, start[0, end], end[start,100], interval[ms]结束后返回1
//时间轴:开始 -> 设置起点 -> 等待interval[ms] -> 设置终点 -> 等待interval[ms] -> 结束
uint8_t bar_anime_step = 0;
uint8_t init_set_bar(uint8_t start, uint8_t end, uint16_t interval)
{
switch (bar_anime_step)
{
case 0:
{
if( m5data.tick_prv == -1 )
{
//如果当前值就是起点,那么直接设置终点,并转至下一步
if( lv_bar_get_value(guider_ui.screen_init_bar_1) == start )
{
lv_bar_set_value(guider_ui.screen_init_bar_1, end, LV_ANIM_ON);
bar_anime_step = 1;
}
else
{
lv_bar_set_value(guider_ui.screen_init_bar_1, start, LV_ANIM_ON);
m5data.tick_prv = xTaskGetTickCount(); //记录起始时刻
}
}
else
{
m5data.tick_cur = xTaskGetTickCount(); //记录当前时刻
if(m5data.tick_cur < m5data.tick_prv) //防止溢出当前tick小于前一刻的tick
{
m5data.tick_prv = -1; //溢出后复位并返回
m5data.tick_cur = -1;
return 0;
}
if( (m5data.tick_cur - m5data.tick_prv) >= interval) //tick间隔达到目标后执行功能
{
m5data.tick_prv = -1;
m5data.tick_cur = -1;
lv_bar_set_value(guider_ui.screen_init_bar_1, end, LV_ANIM_ON);
bar_anime_step = 1;
}
}
}
break;
case 1:
{
if( m5data.tick_prv == -1 )
{
m5data.tick_prv = xTaskGetTickCount(); //记录起始时刻
}else
{
m5data.tick_cur = xTaskGetTickCount(); //记录当前时刻
if(m5data.tick_cur < m5data.tick_prv) //防止溢出当前tick小于前一刻的tick
{
m5data.tick_prv = -1; //溢出后复位并返回
m5data.tick_cur = -1;
return 0;
}
if( (m5data.tick_cur - m5data.tick_prv) >= interval) //tick间隔达到目标后执行功能
{
m5data.tick_prv = -1;
m5data.tick_cur = -1;
bar_anime_step = 0;
return 1;
}
}
}
break;
default:
break;
}
return 0;
}
void scr_main_run(void)
{
//实时更新设定值
sig_sv_update(); //不做延时,尽快响应
//运行时间显示
runtime_show(); //1000ms
//电池电量显示
battery_show(); //3000ms
//动态曲线绘制
plot_drawing(); //1500ms
//当前输入值/测量值显示
input_value_show(); //500ms
#if NIXIE_CUBE_ENABLE
//数值闪烁
num_twinkle(); //1000ms
#endif
}
#if EEPROM_MONITOR_ENABLE
//eeprom状态监控置于运行时间显示内部
uint8_t ee_status_test = 0;
void eep_status_monitor(void)
{
EEPROM_CS_L;
delay_cnt(10);
eeprom_spi_writebyte(WRITE_ENABLE);
delay_cnt(10);
EEPROM_CS_H;
EEPROM_CS_L;
delay_cnt(10);
eeprom_spi_writebyte(READ_STATUS);
ee_status_test = eeprom_spi_readbyte();
delay_cnt(10);
EEPROM_CS_H;
}
#endif
void runtime_show(void)
{
if(heart_1000ms_flag)
{
heart_1000ms_flag = 0;
m5data.runtime_seconds ++;
if( m5data.runtime_seconds > 59) //秒溢出
{
m5data.runtime_minutes ++; //溢出后分钟进一
m5data.runtime_seconds = 0;
}
if(m5data.runtime_minutes > 59) //分钟溢出
{
m5data.runtime_hours ++; //溢出后小时进一
m5data.runtime_minutes = 0;
}
if(m5data.runtime_hours > 99) //小时溢出
{
m5data.runtime_seconds = 0; //溢出后全部归零
m5data.runtime_minutes = 0;
m5data.runtime_hours = 0;
}
// 000000该字符串的长度大于8因此runtime_show应该分配大于8的内存
sprintf(m5data.runtime_show, "%02d:%02d:%02d",m5data.runtime_hours, m5data.runtime_minutes, m5data.runtime_seconds);
lv_span_set_text(guider_ui.screen_main_spangroup_time_span, m5data.runtime_show);
#if EEPROM_MONITOR_ENABLE
eep_status_monitor();
#endif
}
}
void battery_show(void)
{
//每隔3秒读取一次当前电量
if(battery_2000ms_flag)
{
battery_2000ms_flag = 0;
read_battery();
if( (charge_flag == 1)&&(charging_flag == 0) )
{
//正在充电,并且充电尚未结束时,循环播放动画
m5data.battery_cnt = (m5data.battery_cnt >= 5)?(0):(m5data.battery_cnt + 1);
lv_img_set_src(guider_ui.screen_main_animimg_battery, screen_main_animimg_battery_imgs[m5data.battery_cnt]);
}
else
{
//充电停止时,根据剩余电量显示对应帧
switch (bat_cpa)
{
case 0:
{
m5data.battery_cnt = 1;
}
break;
case 1:
{
m5data.battery_cnt = 2;
}
break;
case 3:
{
m5data.battery_cnt = 3;
}
break;
case 7:
{
m5data.battery_cnt = 4;
}
break;
case 15:
{
m5data.battery_cnt = 5;
}
break;
default:
{
m5data.battery_cnt = 0;
}
break;
}
lv_img_set_src(guider_ui.screen_main_animimg_battery, screen_main_animimg_battery_imgs[m5data.battery_cnt]);
}
}
}
//设置游标位置【0000.000】0~7
//中间有个小数点,小数点的显示宽度与数字不同,间隔与两个起点在头文件中设置
// 【】IO_CURSOR_INTERVAL【】IO_CURSOR_INTERVAL【】IO_CURSOR_INTERVAL【】.【】IO_CURSOR_INTERVAL【】IO_CURSOR_INTERVAL【】
// ↑ IO_CURSOR_START1 ↑ IO_CURSOR_START2
void set_cursor_position(void)
{
if(m5data.io_cursor <= 3)
{
lv_obj_set_pos(guider_ui.screen_main_img_cursor, IO_CURSOR_START1 + IO_CURSOR_INTERVAL * m5data.io_cursor, IO_CURSOR_Y);
}
else
{
lv_obj_set_pos(guider_ui.screen_main_img_cursor, IO_CURSOR_START2 + IO_CURSOR_INTERVAL * (m5data.io_cursor - 4), IO_CURSOR_Y);
}
}
//设置数码管符号位0->熄灭1->显示负号
void set_nixie_cube_sign(uint8_t on2off, uint8_t sg)
{
switch (on2off)
{
case IO_INPUT:
{
switch (sg)
{
case 0:
{
//熄灭负号
m5data.sign_flag_in = 0;
lv_img_set_src(guider_ui.screen_main_ani_in_sign, screen_main_ani_in_sign_imgs[0]);
}
break;
case 1:
{
//显示负号
m5data.sign_flag_in = 1;
lv_img_set_src(guider_ui.screen_main_ani_in_sign, screen_main_ani_in_sign_imgs[1]);
}
break;
default:
break;
}
}
break;
case IO_OUTPUT:
{
switch (sg)
{
case 0:
{
//熄灭负号
m5data.sign_flag_out = 0;
lv_img_set_src(guider_ui.screen_main_ani_out_sign, screen_main_ani_out_sign_imgs[0]);
}
break;
case 1:
{
//显示负号
m5data.sign_flag_out = 1;
lv_img_set_src(guider_ui.screen_main_ani_out_sign, screen_main_ani_out_sign_imgs[1]);
}
break;
default:
break;
}
}
break;
default:
break;
}
}
//设置数码管显示值io_slc-输入/输出pos-第几个数字(99代表全部)num->(可正可负)实际数值
void set_nixie_cube(uint8_t io_slc, uint8_t pos, int32_t num)
{
switch (io_slc)
{
case IO_INPUT:
{
switch (pos)
{
case 99:
{
if( (num < 0)&&(m5data.sign_flag_in == 0) )
{
//出现负数并且没有显示负号时
set_nixie_cube_sign(IO_INPUT, 1);
}
else if(( (num >= 0)&&(m5data.sign_flag_in == 1) ))
{
//数值为非负数,但仍然显示负号时
set_nixie_cube_sign(IO_INPUT, 0);
}
//负数转正数
num = ( num >= 0 )?(num):(0 - num);
int32_t temp = 0;
//显示当前测量值,从左往右 0->6
temp = (num/1000000 > 9)?(0):(num/1000000);
if(temp != m5data.i_numbers[0])
{
lv_img_set_src(guider_ui.screen_main_ani_in_0, screen_main_ani_in_0_imgs[temp]);
m5data.i_numbers[0] = temp;
}
temp = (num/100000) % 10;
if(temp != m5data.i_numbers[1])
{
lv_img_set_src(guider_ui.screen_main_ani_in_1, screen_main_ani_in_1_imgs[temp]);
m5data.i_numbers[1] = temp;
}
temp = (num/10000) % 10;
if(temp != m5data.i_numbers[2])
{
lv_img_set_src(guider_ui.screen_main_ani_in_2, screen_main_ani_in_2_imgs[temp]);
m5data.i_numbers[2] = temp;
}
temp = (num/1000) % 10;
if(temp != m5data.i_numbers[3])
{
lv_img_set_src(guider_ui.screen_main_ani_in_3, screen_main_ani_in_3_imgs[temp]);
m5data.i_numbers[3] = temp;
}
temp = (num/100) % 10;
if(temp != m5data.i_numbers[4])
{
lv_img_set_src(guider_ui.screen_main_ani_in_4, screen_main_ani_in_4_imgs[temp]);
m5data.i_numbers[4] = temp;
}
temp = (num/10) % 10;
if(temp != m5data.i_numbers[5])
{
lv_img_set_src(guider_ui.screen_main_ani_in_5, screen_main_ani_in_5_imgs[temp]);
m5data.i_numbers[5] = temp;
}
temp = num % 10;
if(temp != m5data.i_numbers[6])
{
lv_img_set_src(guider_ui.screen_main_ani_in_6, screen_main_ani_in_6_imgs[temp]);
m5data.i_numbers[6] = temp;
}
}
break;
default:
break;
}
}
break;
//只负责数字部分,不管符号
case IO_OUTPUT:
{
switch (pos)
{
case 0:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_0, screen_main_ani_out_0_imgs[num]);
}
break;
case 1:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_1, screen_main_ani_out_1_imgs[num]);
}
break;
case 2:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_2, screen_main_ani_out_2_imgs[num]);
}
break;
case 3:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_3, screen_main_ani_out_3_imgs[num]);
}
break;
case 4:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_4, screen_main_ani_out_4_imgs[num]);
}
break;
case 5:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_5, screen_main_ani_out_5_imgs[num]);
}
break;
case 6:
{
if(num > 10)
{
num = 10;
}
else if(num < 0)
{
num = 0;
}
lv_img_set_src(guider_ui.screen_main_ani_out_6, screen_main_ani_out_6_imgs[num]);
}
break;
default:
break;
}
}
break;
default:
break;
}
}
//RE按键修改输出值
void keyset_output(int8_t key_step)
{
float32 pv = 0, sv = 0;
uint8_t cursor = 0;
cursor = m5data.io_cursor;
pv = get_output_value();
sv = pv + key_step * my_power(10, ( 3 - cursor ) );
if( sv > pltdata.yreal_pri_up ) sv = pltdata.yreal_pri_up;
if( sv < pltdata.yreal_pri_low ) sv = pltdata.yreal_pri_low;
set_output( sv );
}
//设置当前的输出值(实际值-> (无符号)数组),可直接输入负数
//记录缓存变化的位置
uint8_t change_flag[7] = {0};
void set_output_array(int32_t pvo)
{
int32_t temp = 0;
pvo = (pvo > 0)?(pvo):(0 - pvo);
//将实际值转换成7个独立数字
for(uint8_t i = 0; i < 7; i++)
{
temp = ( pvo / (int32_t)my_power( 10,( 6 - i ) ) ) % 10;
if(temp != m5data.o_numbers[i])
{
m5data.o_numbers[i] = temp;
change_flag[i] = 1;
}
}
if( m5data.o_numbers[0] > 9 ) m5data.o_numbers[0] = 9;
}
//设置输出值:数字显示 + 符号 + 缓存sto实际值(有符号)
void set_output(float32 sto)
{
if( (sto < 0)&&(m5data.sign_flag_out == 0) )
{
//出现负数并且没有显示负号时
set_nixie_cube_sign(IO_OUTPUT, 1);
}
else if(( (sto >= 0)&&(m5data.sign_flag_out == 1) ))
{
//数值为非负数,但仍然显示负号时
set_nixie_cube_sign(IO_OUTPUT, 0);
}
//乘以1000用于绕开 int32 和 float32 之间的转换
sto *= 1000;
//配合 set_output_array(int32_t) 进行四舍五入取整
sto = (sto >= 0)?( sto + (float32)0.5 ):( sto - (float32)0.5 );
//更新缓存
set_output_array(sto);
//刷新改变的位置
for(uint8_t i = 0;i < 7;i++)
{
if(change_flag[i])
{
set_nixie_cube(IO_OUTPUT, i, m5data.o_numbers[i]);
change_flag[i] = 0;
}
}
}
//获取当前设定的输出值
float32 get_output_value(void)
{
float32 pvo = 0;
pvo = m5data.o_numbers[0]*1000 + m5data.o_numbers[1]*100 + 10*m5data.o_numbers[2] + \
m5data.o_numbers[3] + m5data.o_numbers[4]*(float32)0.1 + m5data.o_numbers[5]*(float32)0.01 + m5data.o_numbers[6]*(float32)0.001;
pvo = (m5data.sign_flag_out)?(0 - pvo):(pvo);
return pvo;
}
void input_value_show(void)
{
if(input_500ms_flag)
{
input_500ms_flag = 0;
//获取输入值
pltdata.yreal_scd_value = mux2real(mux_signal.data_pv);
if( MY_ABS(pltdata.yreal_scd_value - pltdata.yreal_scd_value_prv) < (float32)0.01)
{
//变化值过小的情况下不更新显示内容
return;
}
else
{
//记录前一时刻的值,用于计算变化量
pltdata.yreal_scd_value_prv = pltdata.yreal_scd_value;
}
int32_t pvi = 0;
//输入显示限幅
if(pltdata.yreal_scd_value >= pltdata.yreal_scd_up)
{
pvi = pltdata.yreal_scd_up*1000;
}
else if (pltdata.yreal_scd_value <= pltdata.yreal_scd_low)
{
pvi = pltdata.yreal_scd_low*1000;
}
else
{
pvi = (int32_t)(pltdata.yreal_scd_value*1000); //副轴用于绘制实时输入测量值
}
set_nixie_cube(IO_INPUT, 99, pvi);
}
}
void io_on2off_status(void)
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_IN, "输入:");
lv_label_set_text(guider_ui.screen_main_label_OUT, "输出:");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_IN, "IN:");
lv_label_set_text(guider_ui.screen_main_label_OUT, "OUT:");
}
break;
default:
break;
}
switch (m5data.io_on2off)
{
case IO_ON:
{
lv_label_set_text(guider_ui.screen_main_label_ONOFF, "ON");
switch (m5data.io_mode)
{
case IO_OUTPUT:
{
//输入变回黑色,输出变为绿色
lv_obj_set_style_text_color(guider_ui.screen_main_label_IN, lv_color_hex(0x000000), LV_PART_MAIN|LV_STATE_DEFAULT);
lv_obj_set_style_text_color(guider_ui.screen_main_label_OUT, lv_color_hex(0x06ff00), LV_PART_MAIN|LV_STATE_DEFAULT);
}
break;
case IO_INPUT:
{
//输出变回黑色,输入变为绿色
lv_obj_set_style_text_color(guider_ui.screen_main_label_IN, lv_color_hex(0x06ff00), LV_PART_MAIN|LV_STATE_DEFAULT);
lv_obj_set_style_text_color(guider_ui.screen_main_label_OUT, lv_color_hex(0x000000), LV_PART_MAIN|LV_STATE_DEFAULT);
}
break;
default:
break;
}
}
break;
case IO_OFF:
{
lv_label_set_text(guider_ui.screen_main_label_ONOFF, "OFF");
switch (m5data.io_mode)
{
case IO_OUTPUT:
{
//输入变回黑色,输出变为红色
lv_obj_set_style_text_color(guider_ui.screen_main_label_IN, lv_color_hex(0x000000), LV_PART_MAIN|LV_STATE_DEFAULT);
lv_obj_set_style_text_color(guider_ui.screen_main_label_OUT, lv_color_hex(0xff0027), LV_PART_MAIN|LV_STATE_DEFAULT);
}
break;
case IO_INPUT:
{
//输出变回黑色,输入变为红色
lv_obj_set_style_text_color(guider_ui.screen_main_label_IN, lv_color_hex(0x06ff00), LV_PART_MAIN|LV_STATE_DEFAULT);
lv_obj_set_style_text_color(guider_ui.screen_main_label_OUT, lv_color_hex(0x000000), LV_PART_MAIN|LV_STATE_DEFAULT);
}
break;
default:
break;
}
}
break;
default:
break;
}
}
void scr_main_recover(void)
{
// 运行时间 和 电池电量 在主界面的函数中已存在,无需额外恢复
// 曲线需要在 setup_scr_screen_main.c 中修改
io_on2off_status(); //IN&OUT, ON&OFF
//输入&输出、工作模式&类型
switch (m5data.io_mode) //输入、输出模式切换
{
case IO_OUTPUT:
{
set_working_mode(m5data.output_mode, m5data.output_mode_type);
}
break;
case IO_INPUT:
{
set_working_mode(m5data.input_mode, m5data.input_mode_type);
}
break;
default:
break;
}
//曲线设置项同步
lv_chart_set_point_count(guider_ui.screen_main_chart_1, tabdata.item1_page0_plot_num);
for(uint8_t i = 0; i < tabdata.item1_page0_plot_num; i++)
{
lv_chart_set_next_value(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_0, 0);
lv_chart_set_next_value(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_1, 0);
}
//输入/输出曲线、图例、上下限颜色更新
scr_main_color_update();
}
//颜色更新
void scr_main_color_update(void)
{
//输入
lv_chart_set_series_color(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_1, lv_color_hex( color_table[tabdata.item1_page0_color_input] ));
lv_obj_set_style_line_color(guider_ui.screen_main_line_legend_IN, lv_color_hex( color_table[tabdata.item1_page0_color_input] ), LV_PART_MAIN|LV_STATE_DEFAULT);
set_obj_color(guider_ui.screen_main_label_area_IN, tabdata.item1_page0_color_input);
//输出
lv_chart_set_series_color(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_0, lv_color_hex( color_table[tabdata.item1_page0_color_output] ));
lv_obj_set_style_line_color(guider_ui.screen_main_line_legend_OUT, lv_color_hex( color_table[tabdata.item1_page0_color_output] ), LV_PART_MAIN|LV_STATE_DEFAULT);
set_obj_color(guider_ui.screen_main_label_area_OUT, tabdata.item1_page0_color_output);
}
#if NIXIE_CUBE_ENABLE
//数值闪烁
void num_twinkle(void)
{
if(m5data.twk_flag == 0)
{
//不需要闪烁的情况下直接返回
//防止空白残留
set_nixie_cube(IO_OUTPUT, m5data.io_cursor, m5data.o_numbers[ m5data.io_cursor ]);
return;
}
else
{
if(twk_1000ms_flag)
{
twk_1000ms_flag = 0;
//闪烁指定位置 m5data.io_cursor
if(m5data.twk_flip)
{
set_nixie_cube(IO_OUTPUT, m5data.io_cursor, m5data.o_numbers[ m5data.io_cursor ]);
m5data.twk_flip = 0;
}else
{
set_nixie_cube(IO_OUTPUT, m5data.io_cursor, 10);
m5data.twk_flip = 1;
}
m5data.twk_cnt++;
}
}
if(m5data.twk_cnt > TWINKLE_CNT_MAX) // TWINKLE_CNT_MAX秒无动作上、下、左、右无按下后停止闪烁
{
m5data.twk_cnt = 0;
m5data.twk_flip = 0;
m5data.twk_flag = 0;
m5data.io_cursor_prv = m5data.io_cursor;
//防止空白残留
set_nixie_cube(IO_OUTPUT, m5data.io_cursor, m5data.o_numbers[ m5data.io_cursor ]);
}
}
#endif
//实时曲线绘制
//将实际值线性转换成绘图值
void plot_drawing(void)
{
if(plot_ms_flag)
{
plot_ms_flag = 0;
//输出曲线
//{
//将独立数字转换成实际值
pltdata.yreal_pri_value = get_output_value();
//改变之前先记录前一时刻的绘图值
pltdata.y_pri_value_prv = pltdata.y_pri_value;
//将实际值线性转换成chart组件上的绘图值pltdata.y_pri_low~up一般0~100
pltdata.y_pri_value = ( pltdata.y_pri_up - pltdata.y_pri_low ) * \
( pltdata.yreal_pri_value - pltdata.yreal_pri_low ) / ( pltdata.yreal_pri_up - pltdata.yreal_pri_low );
if( MY_ABS(pltdata.y_pri_value - pltdata.y_pri_value_prv) < 1 )
{
//变化幅度小的情况下不更新显示值
//等待一段时间后不再更新
if(pltdata.pri_wait_tick < tabdata.item1_page0_plot_num)
{
pltdata.pri_wait_tick++;
//数值限幅
if(pltdata.y_pri_value >= pltdata.y_pri_up) pltdata.y_pri_value = pltdata.y_pri_up;
if(pltdata.y_pri_value <= pltdata.y_pri_low) pltdata.y_pri_value = pltdata.y_pri_low;
lv_chart_set_next_value(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_0, pltdata.y_pri_value);
}
}
else
{
//变化幅度较大时,等待计数清零
pltdata.pri_wait_tick = 0;
//数值限幅
if(pltdata.y_pri_value >= pltdata.y_pri_up) pltdata.y_pri_value = pltdata.y_pri_up;
if(pltdata.y_pri_value <= pltdata.y_pri_low) pltdata.y_pri_value = pltdata.y_pri_low;
lv_chart_set_next_value(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_0, pltdata.y_pri_value);
}
//}
//输入曲线
//{
//改变之前先记录前一时刻的绘图值
pltdata.y_scd_value_prv = pltdata.y_scd_value;
//将实际值线性转换成chart组件上的绘图值pltdata.y_pri_low~up一般0~100
pltdata.y_scd_value = ( pltdata.y_scd_up - pltdata.y_scd_low ) * \
( pltdata.yreal_scd_value - pltdata.yreal_scd_low ) / ( pltdata.yreal_scd_up - pltdata.yreal_scd_low );
if( MY_ABS(pltdata.y_scd_value - pltdata.y_scd_value_prv) < 1 )
{
//变化幅度小的情况下不更新显示值
//等待一段时间后不再更新
if(pltdata.scd_wait_tick < tabdata.item1_page0_plot_num)
{
pltdata.scd_wait_tick++;
//数值限幅
if(pltdata.y_scd_value >= pltdata.y_scd_up) pltdata.y_scd_value = pltdata.y_scd_up;
if(pltdata.y_scd_value <= pltdata.y_scd_low) pltdata.y_scd_value = pltdata.y_scd_low;
lv_chart_set_next_value(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_1, pltdata.y_scd_value);
}
}
else
{
pltdata.scd_wait_tick = 0;
//数值限幅
if(pltdata.y_scd_value >= pltdata.y_scd_up) pltdata.y_scd_value = pltdata.y_scd_up;
if(pltdata.y_scd_value <= pltdata.y_scd_low) pltdata.y_scd_value = pltdata.y_scd_low;
lv_chart_set_next_value(guider_ui.screen_main_chart_1, guider_ui.screen_main_chart_1_1, pltdata.y_scd_value);
}
//}
}
}
//更新上下限&显示,曲线上下限,数值上下限
void up2down_update(int16_t low, int16_t up)
{
//曲线的主轴&副轴上下限
pltdata.yreal_pri_up = up;
pltdata.yreal_scd_up = up;
pltdata.yreal_pri_low = low;
pltdata.yreal_scd_low = low;
//数值上下限显示
char str_tep[33];
sprintf(str_tep, "%d/%d", low, up);
lv_label_set_text(guider_ui.screen_main_label_area_IN, str_tep);
lv_label_set_text(guider_ui.screen_main_label_area_OUT, str_tep);
}
//设置工作模式和工作模式类型
void set_working_mode(SIG_FUNCTIONS mode, SIG_FUNCTIONS_TYPE type)
{
//为保障安全,切换工作模式后:功能关闭,输入输出值清零
//{
//功能关闭
m5data.io_on2off = IO_OFF;
io_on2off_status(); //更新ON/OFF/IN/OUT状态指示
//数码管输入显示置零
set_nixie_cube(IO_INPUT, 99, 0);
//数码管输出值置零
set_output(0);
//游标恢复至小数点前1位个位
m5data.io_cursor = 3;
m5data.io_cursor_prv = 3;
set_cursor_position();
#if NIXIE_CUBE_ENABLE
//闪烁参数清零
m5data.twk_flag = 0; //闪烁中止
m5data.twk_cnt = 0; //闪烁计数清零
m5data.twk_flip = 0; //0显示1不显示
#endif
//}
switch (mode)
{
//电压
case SIG_VOLTAGE:
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "电压");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "Volt");
}
break;
default:
break;
}
switch (type)
{
case VOLTAGE_MV:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "mV");
up2down_update(tabdata.item0_page0_vlow[1], tabdata.item0_page0_vup[1]);
}
break;
case VOLTAGE_V:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "V");
up2down_update(tabdata.item0_page0_vlow[0], tabdata.item0_page0_vup[0]);
}
break;
default:
break;
}
}
break;
//电流
case SIG_CURRENT:
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "电流");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "Cur");
}
break;
default:
break;
}
switch (type)
{
case CURRENT_MA:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "mA");
up2down_update(tabdata.item0_page0_clow, tabdata.item0_page0_cup);
}
break;
default:
break;
}
}
break;
//电阻
case SIG_RESISTANT:
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "电阻");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "Res");
}
break;
default:
break;
}
switch (type)
{
case RESISTANT_OHM:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "Ω");
up2down_update(tabdata.item0_page1_rlow, tabdata.item0_page0_rup);
}
break;
default:
break;
}
}
break;
//频率
case SIG_FREQUENCE:
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "频率");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "Fre");
}
break;
default:
break;
}
switch (type)
{
case FREQUENCE_KHZ:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "KHz");
up2down_update(tabdata.item0_page1_flow, tabdata.item0_page1_fup);
}
break;
default:
break;
}
}
break;
//热电偶
case SIG_TC:
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "热电偶");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "Tc");
}
break;
default:
break;
}
uint8_t temp = 0;
temp = (uint8_t)type;
temp -= 5; //[5,12]->[0,7]
up2down_update(tabdata.item0_page1_TClow[temp], tabdata.item0_page1_TCup[temp]);
switch (type)
{
case TC_K:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "K ℃");
}
break;
case TC_S:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "S ℃");
}
break;
case TC_N:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "N ℃");
}
break;
case TC_B:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "B ℃");
}
break;
case TC_E:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "E ℃");
}
break;
case TC_J:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "J ℃");
}
break;
case TC_R:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "R ℃");
}
break;
case TC_T:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "T ℃");
}
break;
default:
break;
}
}
break;
//热电阻
case SIG_RTD:
{
switch (tabdata.item3_page0_language)
{
case MENU_SIMPLYFY_CHINESE:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "热电阻");
}
break;
case MENU_ENGLISH:
{
lv_label_set_text(guider_ui.screen_main_label_Mode, "RTD");
}
break;
default:
break;
}
switch (type)
{
case RTD_DC:
{
lv_label_set_text(guider_ui.screen_main_label_unit, "");
up2down_update(tabdata.item0_page2_RTDlow, tabdata.item0_page2_RTDup);
}
break;
default:
break;
}
}
break;
default:
break;
}
// //当前输入数值更新为新的上下限
// pltdata.yreal_scd_value = pltdata.yreal_scd_low;
// pltdata.yreal_scd_value_prv = pltdata.yreal_scd_low;
// set_nixie_cube(IO_INPUT, 99, pltdata.yreal_scd_low*1000);
//当前输出数值更新为新的上下限
if( pltdata.yreal_pri_low > 0 )
{
set_output(pltdata.yreal_pri_low);
}
//通道选择与切换
sig_channel_select(m5data.io_mode, type);
}