wxsmart-test
/
sggt
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

存档：电流mA和电压V输出校准完成，但是量程电压V的下限读取异常。

This commit is contained in:
吴俊潮 2025-06-25 14:44:47 +08:00
parent 3cab4d8fcc
commit 53358b12c6
16 changed files with 20247 additions and 20054 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -42,7 +42,8 @@
"eeprom_spi.h": "c", "eeprom_spi.h": "c",
"math.h": "c", "math.h": "c",
"modbus_register_process.h": "c", "modbus_register_process.h": "c",
"modbus_rtu_master.h": "c" "modbus_rtu_master.h": "c",
"dac7811.h": "c"
}, },
"C_Cpp.errorSquiggles": "disabled", "C_Cpp.errorSquiggles": "disabled",
"idf.pythonInstallPath": "F:\\Espressif\\tools\\idf-python\\3.11.2\\python.exe", "idf.pythonInstallPath": "F:\\Espressif\\tools\\idf-python\\3.11.2\\python.exe",

16
App/APP_WU/Inc/apps_gather.h
View File

@ -94,14 +94,14 @@ extern SIG_TRANSMISSION sig_trans; //通讯模式
#define MY_ABS(pa) ( ( (pa) >= 0 )?( (pa) ):( 0 - (pa) ) ) #define MY_ABS(pa) ( ( (pa) >= 0 )?( (pa) ):( 0 - (pa) ) )
//在 cubeMX 中配置完成之后再返回此处进行更新 //在 cubeMX 中配置完成之后再返回此处进行更新
#define MUX_STACK_SIZE_WORD 128 #define MUX_STACK_SIZE_WORD 128 //实际占用峰值：74 Words，57.8%
#define LVGL_STACK_SIZE_WORD 768 #define LVGL_STACK_SIZE_WORD 768 //实际占用峰值：426 Words，55.5%
#define MENU_STACK_SIZE_WORD 512 #define MENU_STACK_SIZE_WORD 512 //实际占用峰值：262 Words，51.2%
#define RS485_STACK_SIZE_WORD 256 #define RS485_STACK_SIZE_WORD 256 //实际占用峰值：146 Words，57.0%
#define HART_STACK_SIZE_WORD 256 #define HART_STACK_SIZE_WORD 256 //实际占用峰值：59 Words，23.0%
#define BLE_STACK_SIZE_WORD 256 #define BLE_STACK_SIZE_WORD 256 //实际占用峰值：110 Words，43.0%
#define DEFAULT_STACK_SIZE_WORD 128 #define DEFAULT_STACK_SIZE_WORD 128 //实际占用峰值：11 Words，8.6%
#define MONITOR_STACK_SIZE_WORD 128 #define MONITOR_STACK_SIZE_WORD 128 //实际占用峰值：11 Words，8.6%
#define MUX_TASK_PERIOD 50 //多通道输入输出任务周期 #define MUX_TASK_PERIOD 50 //多通道输入输出任务周期
#define LVGL_TASK_PERIOD 5 //LVGL任务周期 #define LVGL_TASK_PERIOD 5 //LVGL任务周期

25
App/APP_WU/Inc/apps_var_def.h
View File

@ -89,23 +89,14 @@ typedef enum
typedef struct typedef struct
{ {
uint16_t lvgl_stack_consume; //LVGL任务栈占用 uint16_t lvgl_stack_consume; //LVGL任务栈占用，峰值
uint16_t menu_stack_consume; //menu任务栈占用 uint16_t menu_stack_consume; //menu任务栈占用，峰值
uint16_t mux_stack_consume; //mux任务栈占用 uint16_t mux_stack_consume; //mux任务栈占用，峰值
uint16_t rs485_stack_consume; //485任务栈占用 uint16_t rs485_stack_consume; //485任务栈占用，峰值
uint16_t hart_stack_consume; //HART任务栈占用 uint16_t hart_stack_consume; //HART任务栈占用，峰值
uint16_t ble_stack_consume; //蓝牙任务栈占用 uint16_t ble_stack_consume; //蓝牙任务栈占用，峰值
uint16_t default_stack_consume; //默认任务 uint16_t default_stack_consume; //默认任务，峰值
uint16_t monitor_stack_consume; //状态监控任务 uint16_t monitor_stack_consume; //状态监控任务，峰值
uint16_t lvgl_stack_consume_max; //LVGL任务栈占用，峰值
uint16_t menu_stack_consume_max; //menu任务栈占用，峰值
uint16_t mux_stack_consume_max; //mux任务栈占用，峰值
uint16_t rs485_stack_consume_max; //485任务栈占用，峰值
uint16_t hart_stack_consume_max; //HART任务栈占用，峰值
uint16_t ble_stack_consume_max; //蓝牙任务栈占用，峰值
uint16_t default_stack_consume_max; //默认任务，峰值
uint16_t monitor_stack_consume_max; //状态监控任务，峰值
uint8_t cpu_consume; //cpu使用率，0-100 uint8_t cpu_consume; //cpu使用率，0-100
uint8_t mem_consume; //内存使用率，0-100 uint8_t mem_consume; //内存使用率，0-100

2
App/APP_WU/Src/app_screen_main.c
View File

@ -330,7 +330,7 @@ void runtime_show(void)
void battery_show(void) void battery_show(void)
{ {
//每隔3秒读取一次当前电量 //每隔2秒读取一次当前电量
if(battery_2000ms_flag) if(battery_2000ms_flag)
{ {
battery_2000ms_flag = 0; battery_2000ms_flag = 0;

2
App/DAC7811/dac7811.h
View File

@ -2,6 +2,8 @@
#define __DAC7811_H_ #define __DAC7811_H_
#include "data_type_def.h" #include "data_type_def.h"
#define CALIBRATE_RES_OHM_OUT_POINTS 11
extern BOOL dac7811_spi_init_flag; extern BOOL dac7811_spi_init_flag;
void fun_dac7811_operate(float32 *data_pv); void fun_dac7811_operate(float32 *data_pv);

90
App/DAC8552/dac8552.c
View File

@ -57,18 +57,24 @@ void set_dac8552_channel_value(dac8552x_object *dac, dac8552_ld_type ld, dac8552
void dac8552_operation(float32 *data1, float32 *data2) void dac8552_operation(float32 *data1, float32 *data2)
{ {
uint16_t data = 0; uint16_t data = 0;
float32 temp = 0.0f; float32 temp1 = *data1, temp2 = *data2;
dac8552_init(&dac8552, dac8552_transmit_data, dac8552_cs); dac8552_init(&dac8552, dac8552_transmit_data, dac8552_cs);
if (data1 != NULL) if (data1 != NULL)
{ {
// 4~20mA输出 temp1 = calibrate_cur_ma(temp1);
if (*data1 > 25.0f) if(temp1 > 25.0f)
*data1 = 25.0f; {
else if (*data1 < 0.0f) temp1 = 25.0f;
*data1 = 0.0f; }
temp = (*data1) * 100.0f; else if(temp1 < 0.0f)
data = (uint16_t)(65535.0f * temp / 2500.0f); {
temp1 = 0.0f;
}
mux_signal.sv_calibrated = temp1;
temp1 = (temp1) * 100.0f;
data = (uint16_t)(65535.0f * temp1 / 2500.0f);
set_dac8552_channel_value(&dac8552, LD_CH_B, SEL_BUF_B, PD_NONE, data); set_dac8552_channel_value(&dac8552, LD_CH_B, SEL_BUF_B, PD_NONE, data);
// set_dac8552_channel_value(&dac8552, LD_CH_A, SEL_BUF_A, PD_NONE, data); // set_dac8552_channel_value(&dac8552, LD_CH_A, SEL_BUF_A, PD_NONE, data);
} }
@ -81,9 +87,73 @@ void dac8552_operation(float32 *data1, float32 *data2)
else if (*data2 > 2.5f) else if (*data2 > 2.5f)
*data2 = 2.5f; *data2 = 2.5f;
temp = (*data2) * 0.5f + 1.25f; temp2 = (*data2) * 0.5f + 1.25f;
data = (uint16_t)(65535.0f * temp / 2.5f); data = (uint16_t)(65535.0f * temp2 / 2.5f);
// set_dac8552_channel_value(&dac8552, LD_CH_B, SEL_BUF_B, PD_NONE, data); // set_dac8552_channel_value(&dac8552, LD_CH_B, SEL_BUF_B, PD_NONE, data);
set_dac8552_channel_value(&dac8552, LD_CH_A, SEL_BUF_A, PD_NONE, data); set_dac8552_channel_value(&dac8552, LD_CH_A, SEL_BUF_A, PD_NONE, data);
} }
} }
float cur_ma_out_calibrate_table[CALIBRATE_CUR_MA_OUT_POINTS] = {0};
uint8_t curma_out_cal_enable = 0;
float32 calibrate_cur_ma(float32 raw)
{
float result = 0;
switch (curma_out_cal_enable)
{
case 0: //开机后只读一次
{
uint16_t cal_check = 0;
cal_check = eeprom_readdata(CAL_CUR_MA_OUT_ADDR_FLAG) << 8;
cal_check |= eeprom_readdata(CAL_CUR_MA_OUT_ADDR_FLAG + 8) & 0x00FF;
if(cal_check != 0xAAAA)
{
//不存在校准数据
curma_out_cal_enable = 2;
}
else
{
curma_out_cal_enable = 2;
// //存在校准数据
// curma_out_cal_enable = 1;
// //将读到的数据存储至cur_ma_out_calibrate_table[CALIBRATE_CUR_MA_OUT_POINTS]
// eeprom_dataread_single(EEPROM_TAG_CAL_CUR_MA_OUT);
}
}
break;
case 1: //执行校准
{
//计算区间间隔（按照规定的点数，在量程范围内平均分配）
float interval = (float32)(CALIBRATE_CUR_MA_OUT_END - CALIBRATE_CUR_MA_OUT_START)/(float32)(CALIBRATE_CUR_MA_OUT_POINTS - 1);
for( uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS - 1; i++)
{
if( (cur_ma_out_calibrate_table[i] <= raw)&&(raw <= cur_ma_out_calibrate_table[i + 1]) )
{
result = CALIBRATE_CUR_MA_OUT_START + i*interval; //所处区间的左端点
result += interval * (raw - cur_ma_out_calibrate_table[i])/(cur_ma_out_calibrate_table[i + 1] - cur_ma_out_calibrate_table[i]);
break;
}
}
}
break;
case 2: //不执行校准
{
result = raw;
}
break;
default:
break;
}
return result;
}

21
App/DAC8552/dac8552.h
View File

@ -1,14 +1,16 @@
/*
* @Author: DaMingSY zxm5337@163.com
* @Date: 2024-09-04 16:55:41
* @LastEditors: DaMingSY zxm5337@163.com
* @LastEditTime: 2024-09-11 11:48:45
* @FilePath: \signal_generator\App\DAC8552\dac8552.h
* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
*/
#ifndef __DAC8552_DRIVER_H #ifndef __DAC8552_DRIVER_H
#define __DAC8552_DRIVER_H #define __DAC8552_DRIVER_H
#include "data_type_def.h" #include "data_type_def.h"
#include "eeprom_spi.h"
#define CALIBRATE_CUR_MA_OUT_START 0
#define CALIBRATE_CUR_MA_OUT_END 25
#define CALIBRATE_CUR_MA_OUT_POINTS 11
#define CALIBRATE_VOL_MV_OUT_START -2.5f
#define CALIBRATE_VOL_MV_OUT_END 2.5f
#define CALIBRATE_VOL_MV_OUT_POINTS 11
typedef enum typedef enum
{ {
@ -43,8 +45,11 @@ typedef struct dac8552_object
} dac8552x_object; } dac8552x_object;
extern dac8552x_object dac8552; extern dac8552x_object dac8552;
extern float cur_ma_out_calibrate_table[CALIBRATE_CUR_MA_OUT_POINTS];
void dac8552_init(dac8552x_object *dac, dac8552_write write, dac8552_chip_select cs); void dac8552_init(dac8552x_object *dac, dac8552_write write, dac8552_chip_select cs);
void dac8552_operation(float32 *data1, float32 *data2); void dac8552_operation(float32 *data1, float32 *data2);
float32 calibrate_cur_ma(float32 raw);
#endif #endif

358
App/EEPROM/eeprom_spi.c
View File

@ -210,202 +210,6 @@ uint8_t eeprom_readdata(int32_t addr_long)
return rxd; return rxd;
} }
#if DATA_SAVE_ALL
//存储参数，全部
void eeprom_datasave(void)
{
uint8_t temp_h = 0, temp_l = 0;
//VOL V
temp_h = tabdata.item0_page0_vup[0] >> 8;
temp_l = tabdata.item0_page0_vup[0] & 0xFF;
eeprom_writedata(VOL_V_UP_ADDR, temp_h);
eeprom_writedata(VOL_V_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page0_vlow[0] >> 8;
temp_l = tabdata.item0_page0_vlow[0] & 0xFF;
eeprom_writedata(VOL_V_LOW_ADDR, temp_h);
eeprom_writedata(VOL_V_LOW_ADDR + 8, temp_l);
//出现错误后，提前返回
if(system_sts.eeprom_write_error) return;
//VOL mV
temp_h = tabdata.item0_page0_vup[1] >> 8;
temp_l = tabdata.item0_page0_vup[1] & 0xFF;
eeprom_writedata(VOL_MV_UP_ADDR, temp_h);
eeprom_writedata(VOL_MV_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page0_vlow[1] >> 8;
temp_l = tabdata.item0_page0_vlow[1] & 0xFF;
eeprom_writedata(VOL_MV_LOW_ADDR, temp_h);
eeprom_writedata(VOL_MV_LOW_ADDR + 8, temp_l);
//CUR
temp_h = tabdata.item0_page0_cup >> 8;
temp_l = tabdata.item0_page0_cup & 0xFF;
eeprom_writedata(CUR_UP_ADDR, temp_h);
eeprom_writedata(CUR_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page0_clow >> 8;
temp_l = tabdata.item0_page0_clow & 0xFF;
eeprom_writedata(CUR_LOW_ADDR, temp_h);
eeprom_writedata(CUR_LOW_ADDR + 8, temp_l);
//RES
temp_h = tabdata.item0_page0_rup >> 8;
temp_l = tabdata.item0_page0_rup & 0xFF;
eeprom_writedata(RES_UP_ADDR, temp_h);
eeprom_writedata(RES_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_rlow >> 8;
temp_l = tabdata.item0_page1_rlow & 0xFF;
eeprom_writedata(RES_LOW_ADDR, temp_h);
eeprom_writedata(RES_LOW_ADDR + 8, temp_l);
//FRE
temp_h = tabdata.item0_page1_fup >> 8;
temp_l = tabdata.item0_page1_fup & 0xFF;
eeprom_writedata(FRE_UP_ADDR, temp_h);
eeprom_writedata(FRE_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_flow >> 8;
temp_l = tabdata.item0_page1_flow & 0xFF;
eeprom_writedata(FRE_LOW_ADDR, temp_h);
eeprom_writedata(FRE_LOW_ADDR + 8, temp_l);
//TC K
temp_h = tabdata.item0_page1_TCup[0] >> 8;
temp_l = tabdata.item0_page1_TCup[0] & 0xFF;
eeprom_writedata(TC_K_UP_ADDR, temp_h);
eeprom_writedata(TC_K_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[0] >> 8;
temp_l = tabdata.item0_page1_TClow[0] & 0xFF;
eeprom_writedata(TC_K_LOW_ADDR, temp_h);
eeprom_writedata(TC_K_LOW_ADDR + 8, temp_l);
//TC S
temp_h = tabdata.item0_page1_TCup[1] >> 8;
temp_l = tabdata.item0_page1_TCup[1] & 0xFF;
eeprom_writedata(TC_S_UP_ADDR, temp_h);
eeprom_writedata(TC_S_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[1] >> 8;
temp_l = tabdata.item0_page1_TClow[1] & 0xFF;
eeprom_writedata(TC_S_LOW_ADDR, temp_h);
eeprom_writedata(TC_S_LOW_ADDR + 8, temp_l);
//TC N
temp_h = tabdata.item0_page1_TCup[2] >> 8;
temp_l = tabdata.item0_page1_TCup[2] & 0xFF;
eeprom_writedata(TC_N_UP_ADDR, temp_h);
eeprom_writedata(TC_N_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[2] >> 8;
temp_l = tabdata.item0_page1_TClow[2] & 0xFF;
eeprom_writedata(TC_N_LOW_ADDR, temp_h);
eeprom_writedata(TC_N_LOW_ADDR + 8, temp_l);
//TC B
temp_h = tabdata.item0_page1_TCup[3] >> 8;
temp_l = tabdata.item0_page1_TCup[3] & 0xFF;
eeprom_writedata(TC_B_UP_ADDR, temp_h);
eeprom_writedata(TC_B_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[3] >> 8;
temp_l = tabdata.item0_page1_TClow[3] & 0xFF;
eeprom_writedata(TC_B_LOW_ADDR, temp_h);
eeprom_writedata(TC_B_LOW_ADDR + 8, temp_l);
//TC E
temp_h = tabdata.item0_page1_TCup[4] >> 8;
temp_l = tabdata.item0_page1_TCup[4] & 0xFF;
eeprom_writedata(TC_E_UP_ADDR, temp_h);
eeprom_writedata(TC_E_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[4] >> 8;
temp_l = tabdata.item0_page1_TClow[4] & 0xFF;
eeprom_writedata(TC_E_LOW_ADDR, temp_h);
eeprom_writedata(TC_E_LOW_ADDR + 8, temp_l);
//TC J
temp_h = tabdata.item0_page1_TCup[5] >> 8;
temp_l = tabdata.item0_page1_TCup[5] & 0xFF;
eeprom_writedata(TC_J_UP_ADDR, temp_h);
eeprom_writedata(TC_J_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[5] >> 8;
temp_l = tabdata.item0_page1_TClow[5] & 0xFF;
eeprom_writedata(TC_J_LOW_ADDR, temp_h);
eeprom_writedata(TC_J_LOW_ADDR + 8, temp_l);
//TC R
temp_h = tabdata.item0_page1_TCup[6] >> 8;
temp_l = tabdata.item0_page1_TCup[6] & 0xFF;
eeprom_writedata(TC_R_UP_ADDR, temp_h);
eeprom_writedata(TC_R_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[6] >> 8;
temp_l = tabdata.item0_page1_TClow[6] & 0xFF;
eeprom_writedata(TC_R_LOW_ADDR, temp_h);
eeprom_writedata(TC_R_LOW_ADDR + 8, temp_l);
//TC T
temp_h = tabdata.item0_page1_TCup[7] >> 8;
temp_l = tabdata.item0_page1_TCup[7] & 0xFF;
eeprom_writedata(TC_T_UP_ADDR, temp_h);
eeprom_writedata(TC_T_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page1_TClow[7] >> 8;
temp_l = tabdata.item0_page1_TClow[7] & 0xFF;
eeprom_writedata(TC_T_LOW_ADDR, temp_h);
eeprom_writedata(TC_T_LOW_ADDR + 8, temp_l);
//RTD
temp_h = tabdata.item0_page2_RTDup >> 8;
temp_l = tabdata.item0_page2_RTDup & 0xFF;
eeprom_writedata(RTD_UP_ADDR, temp_h);
eeprom_writedata(RTD_UP_ADDR + 8, temp_l);
temp_h = tabdata.item0_page2_RTDlow >> 8;
temp_l = tabdata.item0_page2_RTDlow & 0xFF;
eeprom_writedata(RTD_LOW_ADDR, temp_h);
eeprom_writedata(RTD_LOW_ADDR + 8, temp_l);
//采样间隔
temp_h = tabdata.item1_page0_sample_interval >> 8;
temp_l = tabdata.item1_page0_sample_interval & 0xFF;
eeprom_writedata(SAMPLE_INTERVAL_ADDR, temp_h);
eeprom_writedata(SAMPLE_INTERVAL_ADDR + 8, temp_l);
//描点数量
temp_h = tabdata.item1_page0_plot_num >> 8;
temp_l = tabdata.item1_page0_plot_num & 0xFF;
eeprom_writedata(PLOT_COUNT_ADDR, temp_h);
eeprom_writedata(PLOT_COUNT_ADDR + 8, temp_l);
//输入曲线颜色
temp_h = tabdata.item1_page0_color_input >> 8;
temp_l = tabdata.item1_page0_color_input & 0xFF;
eeprom_writedata(INPUT_COLOR_ADDR, temp_h);
eeprom_writedata(INPUT_COLOR_ADDR + 8, temp_l);
//输出曲线颜色
temp_h = tabdata.item1_page0_color_output >> 8;
temp_l = tabdata.item1_page0_color_output & 0xFF;
eeprom_writedata(OUTPUT_COLOR_ADDR, temp_h);
eeprom_writedata(OUTPUT_COLOR_ADDR + 8, temp_l);
//语言选择
temp_h = tabdata.item3_page0_language >> 8;
temp_l = tabdata.item3_page0_language & 0xFF;
eeprom_writedata(LANGUAGE_SELECT_ADDR, temp_h);
eeprom_writedata(LANGUAGE_SELECT_ADDR + 8, temp_l);
}
#else
//保存修改过的数据 //保存修改过的数据
void eeprom_datasave_changed(void) void eeprom_datasave_changed(void)
{ {
@ -422,7 +226,7 @@ void eeprom_datasave_changed(void)
tabdata.item0_page0_vup[1] = tab_temp.item0_page0_vup[1]; tabdata.item0_page0_vup[1] = tab_temp.item0_page0_vup[1];
tabdata.item0_page0_vlow[1] = tab_temp.item0_page0_vlow[1]; tabdata.item0_page0_vlow[1] = tab_temp.item0_page0_vlow[1];
eeprom_datasave_single(0); eeprom_datasave_single(EEPROM_TAG_VOLTAGE);
} }
if( (tab_temp.item0_page0_cup != tabdata.item0_page0_cup)||(tab_temp.item0_page0_clow != tabdata.item0_page0_clow) ) if( (tab_temp.item0_page0_cup != tabdata.item0_page0_cup)||(tab_temp.item0_page0_clow != tabdata.item0_page0_clow) )
@ -430,7 +234,7 @@ void eeprom_datasave_changed(void)
tabdata.item0_page0_cup = tab_temp.item0_page0_cup; tabdata.item0_page0_cup = tab_temp.item0_page0_cup;
tabdata.item0_page0_clow = tab_temp.item0_page0_clow; tabdata.item0_page0_clow = tab_temp.item0_page0_clow;
eeprom_datasave_single(1); eeprom_datasave_single(EEPROM_TAG_CURRENT);
} }
if( (tab_temp.item0_page0_rup != tabdata.item0_page0_rup)||(tab_temp.item0_page1_rlow != tabdata.item0_page1_rlow) ) if( (tab_temp.item0_page0_rup != tabdata.item0_page0_rup)||(tab_temp.item0_page1_rlow != tabdata.item0_page1_rlow) )
@ -438,7 +242,7 @@ void eeprom_datasave_changed(void)
tabdata.item0_page0_rup = tab_temp.item0_page0_rup; tabdata.item0_page0_rup = tab_temp.item0_page0_rup;
tabdata.item0_page1_rlow = tab_temp.item0_page1_rlow; tabdata.item0_page1_rlow = tab_temp.item0_page1_rlow;
eeprom_datasave_single(2); eeprom_datasave_single(EEPROM_TAG_RESISTANCE);
} }
if( (tab_temp.item0_page1_fup != tabdata.item0_page1_fup)||(tab_temp.item0_page1_flow != tabdata.item0_page1_flow) ) if( (tab_temp.item0_page1_fup != tabdata.item0_page1_fup)||(tab_temp.item0_page1_flow != tabdata.item0_page1_flow) )
@ -446,7 +250,7 @@ void eeprom_datasave_changed(void)
tabdata.item0_page1_fup = tab_temp.item0_page1_fup; tabdata.item0_page1_fup = tab_temp.item0_page1_fup;
tabdata.item0_page1_flow = tab_temp.item0_page1_flow; tabdata.item0_page1_flow = tab_temp.item0_page1_flow;
eeprom_datasave_single(3); eeprom_datasave_single(EEPROM_TAG_FREQUENCE);
} }
for(uint8_t i = 0 ; i < 8; i++) for(uint8_t i = 0 ; i < 8; i++)
@ -456,6 +260,7 @@ void eeprom_datasave_changed(void)
tabdata.item0_page1_TCup[i] = tab_temp.item0_page1_TCup[i]; tabdata.item0_page1_TCup[i] = tab_temp.item0_page1_TCup[i];
tabdata.item0_page1_TClow[i] = tab_temp.item0_page1_TClow[i]; tabdata.item0_page1_TClow[i] = tab_temp.item0_page1_TClow[i];
//数组索引0-7，标签4-11
eeprom_datasave_single( i + 4 ); eeprom_datasave_single( i + 4 );
} }
} }
@ -465,54 +270,55 @@ void eeprom_datasave_changed(void)
tabdata.item0_page2_RTDup = tab_temp.item0_page2_RTDup; tabdata.item0_page2_RTDup = tab_temp.item0_page2_RTDup;
tabdata.item0_page2_RTDlow = tab_temp.item0_page2_RTDlow; tabdata.item0_page2_RTDlow = tab_temp.item0_page2_RTDlow;
eeprom_datasave_single(12); eeprom_datasave_single(EEPROM_TAG_RTD);
} }
if(tab_temp.item1_page0_sample_interval != tabdata.item1_page0_sample_interval) if(tab_temp.item1_page0_sample_interval != tabdata.item1_page0_sample_interval)
{ {
tabdata.item1_page0_sample_interval = tab_temp.item1_page0_sample_interval; tabdata.item1_page0_sample_interval = tab_temp.item1_page0_sample_interval;
eeprom_datasave_single(13); eeprom_datasave_single(EEPROM_TAG_SAMPLE_INTERVAL);
} }
if(tab_temp.item1_page0_plot_num != tabdata.item1_page0_plot_num) if(tab_temp.item1_page0_plot_num != tabdata.item1_page0_plot_num)
{ {
tabdata.item1_page0_plot_num = tab_temp.item1_page0_plot_num; tabdata.item1_page0_plot_num = tab_temp.item1_page0_plot_num;
eeprom_datasave_single(14); eeprom_datasave_single(EEPROM_TAG_PLOT_COUNT);
} }
if(tab_temp.item1_page0_color_input != tabdata.item1_page0_color_input) if(tab_temp.item1_page0_color_input != tabdata.item1_page0_color_input)
{ {
tabdata.item1_page0_color_input = tab_temp.item1_page0_color_input; tabdata.item1_page0_color_input = tab_temp.item1_page0_color_input;
eeprom_datasave_single(15); eeprom_datasave_single(EEPROM_TAG_INPUT_COLOR);
} }
if(tab_temp.item1_page0_color_output != tabdata.item1_page0_color_output) if(tab_temp.item1_page0_color_output != tabdata.item1_page0_color_output)
{ {
tabdata.item1_page0_color_output = tab_temp.item1_page0_color_output; tabdata.item1_page0_color_output = tab_temp.item1_page0_color_output;
eeprom_datasave_single(16); eeprom_datasave_single(EEPROM_TAG_OUTPUT_COLOR);
} }
if(tab_temp.item3_page0_language != tabdata.item3_page0_language) if(tab_temp.item3_page0_language != tabdata.item3_page0_language)
{ {
tabdata.item3_page0_language = tab_temp.item3_page0_language; tabdata.item3_page0_language = tab_temp.item3_page0_language;
eeprom_datasave_single(17); eeprom_datasave_single(EEPROM_TAG_LANGUAGE);
} }
} }
#endif
void eeprom_datasave_single(uint8_t tag) void eeprom_datasave_single(uint8_t tag)
{ {
//16bits h --- l
//32bits: h --- mh --- ml --- l
uint8_t temp_h = 0, temp_l = 0; uint8_t temp_h = 0, temp_l = 0;
uint8_t temp_mh = 0, temp_ml = 0;
switch (tag) switch (tag)
{ {
case 0: case EEPROM_TAG_VOLTAGE:
{ {
//VOL V //VOL V
temp_h = tabdata.item0_page0_vup[0] >> 8; temp_h = tabdata.item0_page0_vup[0] >> 8;
@ -538,7 +344,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 1: case EEPROM_TAG_CURRENT:
{ {
//CUR //CUR
temp_h = tabdata.item0_page0_cup >> 8; temp_h = tabdata.item0_page0_cup >> 8;
@ -553,7 +359,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 2: case EEPROM_TAG_RESISTANCE:
{ {
//RES //RES
temp_h = tabdata.item0_page0_rup >> 8; temp_h = tabdata.item0_page0_rup >> 8;
@ -568,7 +374,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 3: case EEPROM_TAG_FREQUENCE:
{ {
//FRE //FRE
temp_h = tabdata.item0_page1_fup >> 8; temp_h = tabdata.item0_page1_fup >> 8;
@ -583,7 +389,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 4: case EEPROM_TAG_TC_K:
{ {
//TC K //TC K
temp_h = tabdata.item0_page1_TCup[0] >> 8; temp_h = tabdata.item0_page1_TCup[0] >> 8;
@ -598,7 +404,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 5: case EEPROM_TAG_TC_S:
{ {
//TC S //TC S
temp_h = tabdata.item0_page1_TCup[1] >> 8; temp_h = tabdata.item0_page1_TCup[1] >> 8;
@ -613,7 +419,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 6: case EEPROM_TAG_TC_N:
{ {
//TC N //TC N
temp_h = tabdata.item0_page1_TCup[2] >> 8; temp_h = tabdata.item0_page1_TCup[2] >> 8;
@ -628,7 +434,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 7: case EEPROM_TAG_TC_B:
{ {
//TC B //TC B
temp_h = tabdata.item0_page1_TCup[3] >> 8; temp_h = tabdata.item0_page1_TCup[3] >> 8;
@ -643,7 +449,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 8: case EEPROM_TAG_TC_E:
{ {
//TC E //TC E
temp_h = tabdata.item0_page1_TCup[4] >> 8; temp_h = tabdata.item0_page1_TCup[4] >> 8;
@ -658,7 +464,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 9: case EEPROM_TAG_TC_J:
{ {
//TC J //TC J
temp_h = tabdata.item0_page1_TCup[5] >> 8; temp_h = tabdata.item0_page1_TCup[5] >> 8;
@ -673,7 +479,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 10: case EEPROM_TAG_TC_R:
{ {
//TC R //TC R
temp_h = tabdata.item0_page1_TCup[6] >> 8; temp_h = tabdata.item0_page1_TCup[6] >> 8;
@ -688,7 +494,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 11: case EEPROM_TAG_TC_T:
{ {
//TC T //TC T
temp_h = tabdata.item0_page1_TCup[7] >> 8; temp_h = tabdata.item0_page1_TCup[7] >> 8;
@ -703,7 +509,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 12: case EEPROM_TAG_RTD:
{ {
//RTD //RTD
temp_h = tabdata.item0_page2_RTDup >> 8; temp_h = tabdata.item0_page2_RTDup >> 8;
@ -718,7 +524,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 13: case EEPROM_TAG_SAMPLE_INTERVAL:
{ {
//采样间隔 //采样间隔
temp_h = tabdata.item1_page0_sample_interval >> 8; temp_h = tabdata.item1_page0_sample_interval >> 8;
@ -728,7 +534,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 14: case EEPROM_TAG_PLOT_COUNT:
{ {
//描点数量 //描点数量
temp_h = tabdata.item1_page0_plot_num >> 8; temp_h = tabdata.item1_page0_plot_num >> 8;
@ -738,7 +544,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 15: case EEPROM_TAG_INPUT_COLOR:
{ {
//输入曲线颜色 //输入曲线颜色
temp_h = ((uint8_t)tabdata.item1_page0_color_input) >> 8; temp_h = ((uint8_t)tabdata.item1_page0_color_input) >> 8;
@ -748,7 +554,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 16: case EEPROM_TAG_OUTPUT_COLOR:
{ {
//输出曲线颜色 //输出曲线颜色
temp_h = ((uint8_t)tabdata.item1_page0_color_output) >> 8; temp_h = ((uint8_t)tabdata.item1_page0_color_output) >> 8;
@ -758,7 +564,7 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case 17: case EEPROM_TAG_LANGUAGE:
{ {
//语言选择 //语言选择
temp_h = ((uint8_t)tabdata.item3_page0_language) >> 8; temp_h = ((uint8_t)tabdata.item3_page0_language) >> 8;
@ -768,6 +574,52 @@ void eeprom_datasave_single(uint8_t tag)
} }
break; break;
case EEPROM_TAG_CAL_CUR_MA_OUT:
{
uint32_t flt[CALIBRATE_CUR_MA_OUT_POINTS] = {0};
memcpy(flt, cur_ma_out_calibrate_table, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS; i++)
{
temp_h = flt[i] >> 24;
temp_mh = flt[i] >> 16;
temp_ml = flt[i] >> 8;
temp_l = flt[i] & 0xFF;
eeprom_writedata(CAL_CUR_MA_OUT_ADDR_START + 32*i, temp_h);
eeprom_writedata(CAL_CUR_MA_OUT_ADDR_START + 32*i + 8, temp_mh);
eeprom_writedata(CAL_CUR_MA_OUT_ADDR_START + 32*i + 16, temp_ml);
eeprom_writedata(CAL_CUR_MA_OUT_ADDR_START + 32*i + 24, temp_l);
}
}
break;
case EEPROM_TAG_CAL_VOL_V_OUT:
{
uint32_t flt[CALIBRATE_VOL_V_OUT_POINTS] = {0};
memcpy(flt, vol_v_out_calibrate_table, sizeof(flt));
for(uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS; i++)
{
temp_h = flt[i] >> 24;
temp_mh = flt[i] >> 16;
temp_ml = flt[i] >> 8;
temp_l = flt[i] & 0xFF;
eeprom_writedata(CAL_VOL_V_OUT_ADDR_START + 32*i, temp_h);
eeprom_writedata(CAL_VOL_V_OUT_ADDR_START + 32*i + 8, temp_mh);
eeprom_writedata(CAL_VOL_V_OUT_ADDR_START + 32*i + 16, temp_ml);
eeprom_writedata(CAL_VOL_V_OUT_ADDR_START + 32*i + 24, temp_l);
}
}
break;
case EEPROM_TAG_CAL_VOL_MV_OUT:
{}
break;
case EEPROM_TAG_CAL_RES_OHM_OUT:
{}
break;
default: default:
break; break;
} }
@ -933,6 +785,60 @@ void eeprom_dataread(void)
tabdata.item3_page0_language = (LANGUAGES)( ( temp_h << 8 ) + temp_l ); tabdata.item3_page0_language = (LANGUAGES)( ( temp_h << 8 ) + temp_l );
} }
//读取指定数据
void eeprom_dataread_single(uint8_t tag)
{
//16bits h --- l
//32bits: h --- mh --- ml --- l
uint8_t temp_h = 0, temp_l = 0;
uint8_t temp_mh = 0, temp_ml = 0;
switch (tag)
{
case EEPROM_TAG_CAL_CUR_MA_OUT:
{
uint32_t flt[CALIBRATE_CUR_MA_OUT_POINTS] = {0};
for(uint8_t i = 0; i < CALIBRATE_CUR_MA_OUT_POINTS; i++)
{
temp_h = eeprom_readdata(CAL_CUR_MA_OUT_ADDR_START + 32*i);
temp_mh = eeprom_readdata(CAL_CUR_MA_OUT_ADDR_START + 32*i + 8);
temp_ml = eeprom_readdata(CAL_CUR_MA_OUT_ADDR_START + 32*i + 16);
temp_l = eeprom_readdata(CAL_CUR_MA_OUT_ADDR_START + 32*i + 24);
flt[i] = (temp_h << 24)|(temp_mh << 16)|(temp_ml << 8)|(temp_l);
}
memcpy(cur_ma_out_calibrate_table, flt, sizeof(cur_ma_out_calibrate_table));
}
break;
case EEPROM_TAG_CAL_VOL_V_OUT:
{
uint32_t flt[CALIBRATE_VOL_V_OUT_POINTS] = {0};
for(uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS; i++)
{
temp_h = eeprom_readdata(CAL_VOL_V_OUT_ADDR_START + 32*i);
temp_mh = eeprom_readdata(CAL_VOL_V_OUT_ADDR_START + 32*i + 8);
temp_ml = eeprom_readdata(CAL_VOL_V_OUT_ADDR_START + 32*i + 16);
temp_l = eeprom_readdata(CAL_VOL_V_OUT_ADDR_START + 32*i + 24);
flt[i] = (temp_h << 24)|(temp_mh << 16)|(temp_ml << 8)|(temp_l);
}
memcpy(vol_v_out_calibrate_table, flt, sizeof(vol_v_out_calibrate_table));
}
break;
case EEPROM_TAG_CAL_VOL_MV_OUT:
{}
break;
case EEPROM_TAG_CAL_RES_OHM_OUT:
{}
break;
}
}
//判断EEPROM内是否已存在数据 //判断EEPROM内是否已存在数据
uint8_t eeprom_device_check(void) uint8_t eeprom_device_check(void)
{ {

196
App/EEPROM/eeprom_spi.h
View File

@ -2,9 +2,11 @@
#define _EEPROM_SPI_H_ #define _EEPROM_SPI_H_
#include "apps_gather.h" #include "apps_gather.h"
#include "dac.h"
#include "dac8552.h"
#include "dac7811.h"
//模拟SPI, CS->PB9, WR->PD6, SCLK->PB3, MOSI->PB5, MISO->PB4 //模拟SPI, CS->PB9, WR->PD6, SCLK->PB3, MOSI->PB5, MISO->PB4
//CS->PB9 //CS->PB9
#define EEPROM_CS_H HAL_GPIO_WritePin(EEPROM_CS_GPIO_Port, EEPROM_CS_Pin, GPIO_PIN_SET) #define EEPROM_CS_H HAL_GPIO_WritePin(EEPROM_CS_GPIO_Port, EEPROM_CS_Pin, GPIO_PIN_SET)
#define EEPROM_CS_L HAL_GPIO_WritePin(EEPROM_CS_GPIO_Port, EEPROM_CS_Pin, GPIO_PIN_RESET) #define EEPROM_CS_L HAL_GPIO_WritePin(EEPROM_CS_GPIO_Port, EEPROM_CS_Pin, GPIO_PIN_RESET)
@ -31,116 +33,123 @@
#define READ_MEMORY 0x03 #define READ_MEMORY 0x03
#define READ_STATUS 0x05 #define READ_STATUS 0x05
//my address //0x7D0 - 0x7E0(2000 - 2016)，标记后写入0xAAAA（连续16位“1”“0”交替）
//{ #define DEVICE_CHECK 0x0007D0
//0x7D0 - 0x7E0(2000 - 2016)，标记后写入0xAAAA（连续16位“1”“0”交替） #define EE_START_ADDR 0x000000
#define DEVICE_CHECK 0x0007D0 #define EE_INTERVAL 16
#define EE_START_ADDR 0x000000
#define EE_INTERVAL 16
//电压V上限，tag：0，EE_START_ADDR + 0*EE_INTERVAL //电压量程
#define VOL_V_UP_ADDR EE_START_ADDR #define EEPROM_TAG_VOLTAGE 0
#define VOL_V_UP_ADDR EE_START_ADDR //电压V上限，tag：0，EE_START_ADDR + 0*EE_INTERVAL
#define VOL_V_LOW_ADDR (VOL_V_UP_ADDR + EE_INTERVAL) //电压V下限，tag：0，EE_START_ADDR + 1*EE_INTERVAL
#define VOL_MV_UP_ADDR (VOL_V_LOW_ADDR + EE_INTERVAL) //电压mV上限，tag：0，EE_START_ADDR + 2*EE_INTERVAL
#define VOL_MV_LOW_ADDR (VOL_MV_UP_ADDR + EE_INTERVAL) //电压mV下限，tag：0，EE_START_ADDR + 3*EE_INTERVAL
//电压V下限，tag：0，EE_START_ADDR + 1*EE_INTERVAL //电流量程
#define VOL_V_LOW_ADDR (VOL_V_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_CURRENT 1
#define CUR_UP_ADDR (VOL_MV_LOW_ADDR + EE_INTERVAL) //电流上限，tag：1，EE_START_ADDR + 4*EE_INTERVAL
#define CUR_LOW_ADDR (CUR_UP_ADDR + EE_INTERVAL) //电流下限，tag：1，EE_START_ADDR + 5*EE_INTERVAL
//电压mV上限，tag：0，EE_START_ADDR + 2*EE_INTERVAL //电阻量程
#define VOL_MV_UP_ADDR (VOL_V_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_RESISTANCE 2
#define RES_UP_ADDR (CUR_LOW_ADDR + EE_INTERVAL) //电阻上限，tag：2，EE_START_ADDR + 6*EE_INTERVAL
#define RES_LOW_ADDR (RES_UP_ADDR + EE_INTERVAL) //电阻下限，tag：2，EE_START_ADDR + 7*EE_INTERVAL
//电压mV下限，tag：0，EE_START_ADDR + 3*EE_INTERVAL //频率量程
#define VOL_MV_LOW_ADDR (VOL_MV_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_FREQUENCE 3
#define FRE_UP_ADDR (RES_LOW_ADDR + EE_INTERVAL) //频率上限，tag：3，EE_START_ADDR + 8*EE_INTERVAL
#define FRE_LOW_ADDR (FRE_UP_ADDR + EE_INTERVAL) //频率下限，tag：3，EE_START_ADDR + 9*EE_INTERVAL
//电流上限，tag：1，EE_START_ADDR + 4*EE_INTERVAL //TC_K量程
#define CUR_UP_ADDR (VOL_MV_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_K 4
#define TC_K_UP_ADDR (FRE_LOW_ADDR + EE_INTERVAL) //TC_K上限，tag：4，EE_START_ADDR + 10*EE_INTERVAL
#define TC_K_LOW_ADDR (TC_K_UP_ADDR + EE_INTERVAL) //TC_K下限，tag：4，EE_START_ADDR + 11*EE_INTERVAL
//电流下限，tag：1，EE_START_ADDR + 5*EE_INTERVAL //TC_S量程
#define CUR_LOW_ADDR (CUR_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_S 5
#define TC_S_UP_ADDR (TC_K_LOW_ADDR + EE_INTERVAL) //TC_S上限，tag：5，EE_START_ADDR + 12*EE_INTERVAL
#define TC_S_LOW_ADDR (TC_S_UP_ADDR + EE_INTERVAL) //TC_S下限，tag：5，EE_START_ADDR + 13*EE_INTERVAL
//电阻上限，tag：2，EE_START_ADDR + 6*EE_INTERVAL //TC_N量程
#define RES_UP_ADDR (CUR_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_N 6
#define TC_N_UP_ADDR (TC_S_LOW_ADDR + EE_INTERVAL) //TC_N上限，tag：6，EE_START_ADDR + 14*EE_INTERVAL
#define TC_N_LOW_ADDR (TC_N_UP_ADDR + EE_INTERVAL) //TC_N下限，tag：6，EE_START_ADDR + 15*EE_INTERVAL
//电阻下限，tag：2，EE_START_ADDR + 7*EE_INTERVAL //TC_B量程
#define RES_LOW_ADDR (RES_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_B 7
#define TC_B_UP_ADDR (TC_N_LOW_ADDR + EE_INTERVAL) //TC_B上限，tag：7，EE_START_ADDR + 16*EE_INTERVAL
#define TC_B_LOW_ADDR (TC_B_UP_ADDR + EE_INTERVAL) //TC_B下限，tag：7，EE_START_ADDR + 17*EE_INTERVAL
//频率上限，tag：3，EE_START_ADDR + 8*EE_INTERVAL //TC_E量程
#define FRE_UP_ADDR (RES_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_E 8
#define TC_E_UP_ADDR (TC_B_LOW_ADDR + EE_INTERVAL) //TC_E上限，tag：8，EE_START_ADDR + 18*EE_INTERVAL
#define TC_E_LOW_ADDR (TC_E_UP_ADDR + EE_INTERVAL) //TC_E下限，tag：8，EE_START_ADDR + 19*EE_INTERVAL
//频率下限，tag：3，EE_START_ADDR + 9*EE_INTERVAL //TC_J量程
#define FRE_LOW_ADDR (FRE_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_J 9
#define TC_J_UP_ADDR (TC_E_LOW_ADDR + EE_INTERVAL) //TC_J上限，tag：9，EE_START_ADDR + 20*EE_INTERVAL
#define TC_J_LOW_ADDR (TC_J_UP_ADDR + EE_INTERVAL) //TC_J下限，tag：9，EE_START_ADDR + 21*EE_INTERVAL
//TC_K上限，tag：4，EE_START_ADDR + 10*EE_INTERVAL //TC_R量程
#define TC_K_UP_ADDR (FRE_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_R 10
#define TC_R_UP_ADDR (TC_J_LOW_ADDR + EE_INTERVAL) //TC_R上限，tag：10，EE_START_ADDR + 22*EE_INTERVAL
#define TC_R_LOW_ADDR (TC_R_UP_ADDR + EE_INTERVAL) //TC_R下限，tag：10，EE_START_ADDR + 23*EE_INTERVAL
//TC_K下限，tag：4，EE_START_ADDR + 11*EE_INTERVAL //TC_T量程
#define TC_K_LOW_ADDR (TC_K_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_TC_T 11
#define TC_T_UP_ADDR (TC_R_LOW_ADDR + EE_INTERVAL) //TC_T上限，tag：11，EE_START_ADDR + 24*EE_INTERVAL
#define TC_T_LOW_ADDR (TC_T_UP_ADDR + EE_INTERVAL) //TC_T下限，tag：11，EE_START_ADDR + 25*EE_INTERVAL
//TC_S上限，tag：5，EE_START_ADDR + 12*EE_INTERVAL //RTD量程
#define TC_S_UP_ADDR (TC_K_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_RTD 12
#define RTD_UP_ADDR (TC_T_LOW_ADDR + EE_INTERVAL) //RTD上限，tag：12，EE_START_ADDR + 26*EE_INTERVAL
#define RTD_LOW_ADDR (RTD_UP_ADDR + EE_INTERVAL) //RTD下限，tag：12，EE_START_ADDR + 27*EE_INTERVAL
//TC_S下限，tag：5，EE_START_ADDR + 13*EE_INTERVAL //采样间隔
#define TC_S_LOW_ADDR (TC_S_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_SAMPLE_INTERVAL 13
#define SAMPLE_INTERVAL_ADDR (RTD_LOW_ADDR + EE_INTERVAL) //采样间隔（画点时间间隔），tag：13，EE_START_ADDR + 28*EE_INTERVAL
//TC_N上限，tag：6，EE_START_ADDR + 14*EE_INTERVAL //描点数量
#define TC_N_UP_ADDR (TC_S_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_PLOT_COUNT 14
#define PLOT_COUNT_ADDR (SAMPLE_INTERVAL_ADDR + EE_INTERVAL) //描点数量，tag：14，EE_START_ADDR + 29*EE_INTERVAL
//TC_N下限，tag：6，EE_START_ADDR + 15*EE_INTERVAL //输入曲线&图例颜色
#define TC_N_LOW_ADDR (TC_N_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_INPUT_COLOR 15
#define INPUT_COLOR_ADDR (PLOT_COUNT_ADDR + EE_INTERVAL) //输入曲线颜色，tag：15，EE_START_ADDR + 30*EE_INTERVAL
//TC_B上限，tag：7，EE_START_ADDR + 16*EE_INTERVAL //输出曲线&图例颜色
#define TC_B_UP_ADDR (TC_N_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_OUTPUT_COLOR 16
#define OUTPUT_COLOR_ADDR (INPUT_COLOR_ADDR + EE_INTERVAL) //输出曲线颜色，tag：16，EE_START_ADDR + 31*EE_INTERVAL
//TC_B下限，tag：7，EE_START_ADDR + 17*EE_INTERVAL //语言选择
#define TC_B_LOW_ADDR (TC_B_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_LANGUAGE 17
#define LANGUAGE_SELECT_ADDR (OUTPUT_COLOR_ADDR + EE_INTERVAL) //语言选择，tag：17，EE_START_ADDR + 32*EE_INTERVAL
//TC_E上限，tag：8，EE_START_ADDR + 18*EE_INTERVAL //电流输出校准mA（11个点，10个间隔）
#define TC_E_UP_ADDR (TC_B_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_CAL_CUR_MA_OUT 18 //电流mA输出值校准，tag：18
#define CAL_CUR_MA_OUT_ADDR_FLAG (LANGUAGE_SELECT_ADDR + EE_INTERVAL) //有效标志，是否存在数据，存在：0xAAAA
#define CAL_CUR_MA_OUT_ADDR_START (CAL_CUR_MA_OUT_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 34*EE_INTERVAL
#define CAL_CUR_MA_OUT_ADDR_END (CAL_CUR_MA_OUT_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_CUR_MA_OUT_POINTS) //EE_START_ADDR + 56*EE_INTERVAL
//TC_E下限，tag：8，EE_START_ADDR + 19*EE_INTERVAL //电压输出校准V（11个点，10个间隔）
#define TC_E_LOW_ADDR (TC_E_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_CAL_VOL_V_OUT 19 //电压V输出值校准，tag：19
#define CAL_VOL_V_OUT_ADDR_FLAG CAL_CUR_MA_OUT_ADDR_END //有效标志，是否存在数据，存在：0xAAAA
#define CAL_VOL_V_OUT_ADDR_START (CAL_VOL_V_OUT_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 57*EE_INTERVAL
#define CAL_VOL_V_OUT_ADDR_END (CAL_VOL_V_OUT_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_VOL_V_OUT_POINTS) //EE_START_ADDR + 79*EE_INTERVAL
//TC_J上限，tag：9，EE_START_ADDR + 20*EE_INTERVAL //电压输出校准mV（11个点，10个间隔）
#define TC_J_UP_ADDR (TC_E_LOW_ADDR + EE_INTERVAL) #define EEPROM_TAG_CAL_VOL_MV_OUT 20 //电压mV输出值校准，tag：20
#define CAL_VOL_MV_OUT_ADDR_FLAG CAL_VOL_V_OUT_ADDR_END //有效标志，是否存在数据，存在：0xAAAA
#define CAL_VOL_MV_OUT_ADDR_START (CAL_VOL_MV_OUT_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 80*EE_INTERVAL
#define CAL_VOL_MV_OUT_ADDR_END (CAL_VOL_MV_OUT_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_VOL_MV_OUT_POINTS) //EE_START_ADDR + 102*EE_INTERVAL
//TC_J下限，tag：9，EE_START_ADDR + 21*EE_INTERVAL //电阻输出校准Ω（11个点，10个间隔）
#define TC_J_LOW_ADDR (TC_J_UP_ADDR + EE_INTERVAL) #define EEPROM_TAG_CAL_RES_OHM_OUT 21 //电阻Ω输出值校准，tag：21
#define CAL_RES_OHM_OUT_ADDR_FLAG CAL_VOL_MV_OUT_ADDR_END //有效标志，是否存在数据，存在：0xAAAA
#define CAL_RES_OHM_OUT_ADDR_START (CAL_RES_OHM_OUT_ADDR_FLAG + EE_INTERVAL) //数据起始地址，EE_START_ADDR + 103*EE_INTERVAL
#define CAL_RES_OHM_OUT_ADDR_END (CAL_RES_OHM_OUT_ADDR_START + 2 * EE_INTERVAL * CALIBRATE_RES_OHM_OUT_POINTS) //EE_START_ADDR + 125*EE_INTERVAL
//TC_R上限，tag：10，EE_START_ADDR + 22*EE_INTERVAL //根据需求后续在此处向后添加
#define TC_R_UP_ADDR (TC_J_LOW_ADDR + EE_INTERVAL)
//TC_R下限，tag：10，EE_START_ADDR + 23*EE_INTERVAL
#define TC_R_LOW_ADDR (TC_R_UP_ADDR + EE_INTERVAL)
//TC_T上限，tag：11，EE_START_ADDR + 24*EE_INTERVAL
#define TC_T_UP_ADDR (TC_R_LOW_ADDR + EE_INTERVAL)
//TC_T下限，tag：11，EE_START_ADDR + 25*EE_INTERVAL
#define TC_T_LOW_ADDR (TC_T_UP_ADDR + EE_INTERVAL)
//RTD上限，tag：12，EE_START_ADDR + 26*EE_INTERVAL
#define RTD_UP_ADDR (TC_T_LOW_ADDR + EE_INTERVAL)
//RTD下限，tag：12，EE_START_ADDR + 27*EE_INTERVAL
#define RTD_LOW_ADDR (RTD_UP_ADDR + EE_INTERVAL)
//采样间隔（画点时间间隔），tag：13，EE_START_ADDR + 28*EE_INTERVAL
#define SAMPLE_INTERVAL_ADDR (RTD_LOW_ADDR + EE_INTERVAL)
//描点数量，tag：14，EE_START_ADDR + 29*EE_INTERVAL
#define PLOT_COUNT_ADDR (SAMPLE_INTERVAL_ADDR + EE_INTERVAL)
//输入曲线颜色，tag：15，EE_START_ADDR + 30*EE_INTERVAL
#define INPUT_COLOR_ADDR (PLOT_COUNT_ADDR + EE_INTERVAL)
//输出曲线颜色，tag：16，EE_START_ADDR + 31*EE_INTERVAL
#define OUTPUT_COLOR_ADDR (INPUT_COLOR_ADDR + EE_INTERVAL)
//语言选择，tag：17，EE_START_ADDR + 32*EE_INTERVAL
#define LANGUAGE_SELECT_ADDR (OUTPUT_COLOR_ADDR + EE_INTERVAL)
//根据需求后续在此处向后添加
//}
#define DATA_SAVE_ALL 0
void eeprom_spi_init(void); void eeprom_spi_init(void);
void eeprom_spi_writebyte(uint8_t wrt_data); void eeprom_spi_writebyte(uint8_t wrt_data);
@ -158,17 +167,12 @@ uint8_t eeprom_device_check(void);
//保存指定数据 //保存指定数据
void eeprom_datasave_single(uint8_t tag); void eeprom_datasave_single(uint8_t tag);
#if DATA_SAVE_ALL
//存储参数，全部
void eeprom_datasave(void);
#else
//保存修改过的数据 //保存修改过的数据
void eeprom_datasave_changed(void); void eeprom_datasave_changed(void);
#endif //读取指定数据
void eeprom_dataread_single(uint8_t tag);

59
App/MUX_SIGNAL/mux_signal.c
View File

@ -120,6 +120,65 @@ void pwr_cosume(BOOL rst, uint32_t ms)
// //PWR12_CTRL(GPIO_PIN_RESET); // //PWR12_CTRL(GPIO_PIN_RESET);
// } // }
// } // }
CALIBRATE_FLAGS cal_flags = CAL_FLAG_NONE;
void deal_calibrate_affair(void)
{
if( cal_flags == CAL_FLAG_NONE ) return;
switch (cal_flags)
{
case CAL_FLAG_CUR_MA_OUT:
{
//存入cur_ma_out_calibrate_table[CALIBRATE_CUR_MA_OUT_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_CUR_MA_OUT);
//写入0xAAAA标志
eeprom_writedata(CAL_CUR_MA_OUT_ADDR_FLAG, 0xAA);
eeprom_writedata(CAL_CUR_MA_OUT_ADDR_FLAG + 8, 0xAA);
}
break;
case CAL_FLAG_VOUT_V_OUT:
{
//存入vol_v_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS]的数据
eeprom_datasave_single(EEPROM_TAG_CAL_VOL_V_OUT);
//写入0xAAAA标志
eeprom_writedata(CAL_VOL_V_OUT_ADDR_FLAG, 0xAA);
eeprom_writedata(CAL_VOL_V_OUT_ADDR_FLAG + 8, 0xAA);
}
break;
case CAL_FLAG_VOUT_MV_OUT:
{}
break;
case CAL_FLAG_RES_OHM_OUT:
{}
break;
case CAL_FLAG_CUR_MA_IN:
{}
break;
case CAL_FLAG_VOUT_V_IN:
{}
break;
case CAL_FLAG_VOUT_MV_IN:
{}
break;
case CAL_FLAG_RES_OHM_IN:
{}
break;
default:
break;
}
cal_flags = CAL_FLAG_NONE;
}
uint8_t pulse = 50; uint8_t pulse = 50;
float32 fre_set_mux = 0; float32 fre_set_mux = 0;

18
App/MUX_SIGNAL/mux_signal.h
View File

@ -26,6 +26,19 @@ typedef enum
} CHANNEL; } CHANNEL;
typedef enum
{
CAL_FLAG_CUR_MA_OUT = 0,
CAL_FLAG_VOUT_V_OUT,
CAL_FLAG_VOUT_MV_OUT,
CAL_FLAG_RES_OHM_OUT,
CAL_FLAG_CUR_MA_IN,
CAL_FLAG_VOUT_V_IN,
CAL_FLAG_VOUT_MV_IN,
CAL_FLAG_RES_OHM_IN,
CAL_FLAG_NONE
}CALIBRATE_FLAGS;
typedef struct typedef struct
{ {
uint8_t capture_cnt; uint8_t capture_cnt;
@ -42,6 +55,7 @@ typedef struct
float32 data_sv; float32 data_sv;
float32 data_pv; float32 data_pv;
float32 pwr_delay; float32 pwr_delay;
float32 sv_calibrated;
} st_mux_signal; } st_mux_signal;
extern st_freq_signal freq_signal; extern st_freq_signal freq_signal;
@ -51,4 +65,8 @@ void pwr_cosume(BOOL rst, uint32_t ms);
void mux_signal_switch(st_mux_signal *mux_signal); void mux_signal_switch(st_mux_signal *mux_signal);
void frequence_output(uint32_t freq, uint8_t pulse, uint8_t pwm_select); void frequence_output(uint32_t freq, uint8_t pulse, uint8_t pwm_select);
//加载校准所需的参数，EEPROM读取
void load_calibrate_data(void);
void deal_calibrate_affair(void);
#endif #endif

11
Core/Inc/dac.h
View File

@ -29,19 +29,26 @@ extern "C" {
#include "main.h" #include "main.h"
/* USER CODE BEGIN Includes */ /* USER CODE BEGIN Includes */
#include "data_type_def.h"
#include "mux_signal.h"
#include "eeprom_spi.h"
/* USER CODE END Includes */ /* USER CODE END Includes */
extern DAC_HandleTypeDef hdac; extern DAC_HandleTypeDef hdac;
/* USER CODE BEGIN Private defines */ /* USER CODE BEGIN Private defines */
#define CALIBRATE_VOL_V_OUT_START 0
#define CALIBRATE_VOL_V_OUT_END 30
#define CALIBRATE_VOL_V_OUT_POINTS 11
/* USER CODE END Private defines */ /* USER CODE END Private defines */
void MX_DAC_Init(void); void MX_DAC_Init(void);
/* USER CODE BEGIN Prototypes */ /* USER CODE BEGIN Prototypes */
void dac_set_voltage(float *vol); void dac_set_voltage(float *vol);
float calibrate_vol_v(float raw);
extern float vol_v_out_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS];
/* USER CODE END Prototypes */ /* USER CODE END Prototypes */
#ifdef __cplusplus #ifdef __cplusplus

81
Core/Src/dac.c
View File

@ -124,18 +124,30 @@ void HAL_DAC_MspDeInit(DAC_HandleTypeDef* dacHandle)
} }
/* USER CODE BEGIN 1 */ /* USER CODE BEGIN 1 */
float vol_v_out_calibrate_table[CALIBRATE_VOL_V_OUT_POINTS] = {0};
uint8_t volv_out_cal_enable = 0;
void dac_set_voltage(float *vol) void dac_set_voltage(float *vol)
{ {
if (vol == NULL) if (vol == NULL)
return; return;
float temp = *vol; float temp = *vol;
/**********在此处进行电压输出（V）校准，temp为目标值**********/
temp = calibrate_vol_v(temp);
// 0~30v输出 //限幅
if (*vol > 30.0f) if( temp > 30.0f )
*vol = 30.0f; {
else if (*vol < 0.0f) temp = 30.0f;
*vol = 0.0f; }
else if ( temp < 0.0f )
{
temp = 0.0f;
}
mux_signal.sv_calibrated = temp;
/**********************************************************/
temp /= 10.0f; temp /= 10.0f;
temp = temp * 4096 / 3.0f; temp = temp * 4096 / 3.0f;
@ -145,4 +157,63 @@ void dac_set_voltage(float *vol)
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, temp); HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, temp);
} }
float calibrate_vol_v(float raw)
{
float result = 0;
switch (volv_out_cal_enable)
{
case 0: //开机后只读一次
{
uint16_t cal_check = 0;
cal_check = eeprom_readdata(CAL_VOL_V_OUT_ADDR_FLAG) << 8;
cal_check |= eeprom_readdata(CAL_VOL_V_OUT_ADDR_FLAG + 8) & 0x00FF;
if(cal_check != 0xAAAA)
{
//不存在校准数据
volv_out_cal_enable = 2;
}
else
{
//存在校准数据
volv_out_cal_enable = 1;
//将读到的数据存储至vol_v_calibrate_table
eeprom_dataread_single(EEPROM_TAG_CAL_VOL_V_OUT);
}
}
break;
case 1: //执行校准
{
//计算区间间隔（按照规定的点数，在量程范围内平均分配）
float interval = (float32)(CALIBRATE_VOL_V_OUT_END - CALIBRATE_VOL_V_OUT_START)/(float32)(CALIBRATE_VOL_V_OUT_POINTS - 1);
for( uint8_t i = 0; i < CALIBRATE_VOL_V_OUT_POINTS - 1; i++)
{
if( (vol_v_out_calibrate_table[i] <= raw)&&(raw <= vol_v_out_calibrate_table[i + 1]) )
{
result = CALIBRATE_VOL_V_OUT_START + i*interval; //所处区间的左端点
result += interval * (raw - vol_v_out_calibrate_table[i])/(vol_v_out_calibrate_table[i + 1] - vol_v_out_calibrate_table[i]);
break;
}
}
}
break;
case 2: //不执行校准
{
result = raw;
}
break;
default:
break;
}
return result;
}
/* USER CODE END 1 */ /* USER CODE END 1 */

21
Core/Src/freertos.c
View File

@ -164,13 +164,11 @@ void StartDefaultTask(void const * argument)
{ {
/* USER CODE BEGIN StartDefaultTask */ /* USER CODE BEGIN StartDefaultTask */
uint8_t default_enable = 0; uint8_t default_enable = 0;
system_sts.default_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
system_sts.default_stack_consume = DEFAULT_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.default_stack_consume = DEFAULT_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.default_stack_consume_max < system_sts.default_stack_consume) system_sts.default_stack_consume_max = system_sts.default_stack_consume;
//一般情况下不启用本任务 //一般情况下不启用本任务
if( !default_enable ) vTaskSuspend(NULL); if( !default_enable ) vTaskSuspend(NULL);
@ -190,7 +188,6 @@ void StartDefaultTask(void const * argument)
void start_task_lcd(void const * argument) void start_task_lcd(void const * argument)
{ {
/* USER CODE BEGIN start_task_lcd */ /* USER CODE BEGIN start_task_lcd */
system_sts.lvgl_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
@ -200,7 +197,6 @@ void start_task_lcd(void const * argument)
lv_timer_handler(); //LVGL刷新任务 lv_timer_handler(); //LVGL刷新任务
system_sts.lvgl_stack_consume = LVGL_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.lvgl_stack_consume = LVGL_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.lvgl_stack_consume_max < system_sts.lvgl_stack_consume) system_sts.lvgl_stack_consume_max = system_sts.lvgl_stack_consume;
osDelay(LVGL_TASK_PERIOD); osDelay(LVGL_TASK_PERIOD);
} }
/* USER CODE END start_task_lcd */ /* USER CODE END start_task_lcd */
@ -218,7 +214,6 @@ float32 fre_set_hart = 0;
void start_task_hart(void const * argument) void start_task_hart(void const * argument)
{ {
/* USER CODE BEGIN start_task_hart */ /* USER CODE BEGIN start_task_hart */
system_sts.hart_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
@ -250,7 +245,6 @@ void start_task_hart(void const * argument)
} }
system_sts.hart_stack_consume = HART_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.hart_stack_consume = HART_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.hart_stack_consume_max < system_sts.hart_stack_consume) system_sts.hart_stack_consume_max = system_sts.hart_stack_consume;
osDelay(HART_TASK_PERIOD); osDelay(HART_TASK_PERIOD);
} }
/* USER CODE END start_task_hart */ /* USER CODE END start_task_hart */
@ -267,7 +261,6 @@ uint8_t ble_send_test = 0;
void start_task_ble(void const * argument) void start_task_ble(void const * argument)
{ {
/* USER CODE BEGIN start_task_ble */ /* USER CODE BEGIN start_task_ble */
system_sts.ble_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
@ -289,7 +282,6 @@ void start_task_ble(void const * argument)
} }
system_sts.ble_stack_consume = BLE_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.ble_stack_consume = BLE_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.ble_stack_consume_max < system_sts.ble_stack_consume) system_sts.ble_stack_consume_max = system_sts.ble_stack_consume;
osDelay(BLE_TASK_PERIOD); osDelay(BLE_TASK_PERIOD);
} }
/* USER CODE END start_task_ble */ /* USER CODE END start_task_ble */
@ -305,7 +297,6 @@ void start_task_ble(void const * argument)
void start_rs485(void const * argument) void start_rs485(void const * argument)
{ {
/* USER CODE BEGIN start_rs485 */ /* USER CODE BEGIN start_rs485 */
system_sts.rs485_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
@ -319,7 +310,6 @@ void start_rs485(void const * argument)
modbus_registers_update(); modbus_registers_update();
system_sts.rs485_stack_consume = RS485_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.rs485_stack_consume = RS485_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.rs485_stack_consume_max < system_sts.rs485_stack_consume) system_sts.rs485_stack_consume_max = system_sts.rs485_stack_consume;
osDelay(RS485_TASK_PERIOD); osDelay(RS485_TASK_PERIOD);
} }
/* USER CODE END start_rs485 */ /* USER CODE END start_rs485 */
@ -337,8 +327,7 @@ lv_mem_monitor_t my_mon;
void start_mux_analog(void const * argument) void start_mux_analog(void const * argument)
{ {
/* USER CODE BEGIN start_mux_analog */ /* USER CODE BEGIN start_mux_analog */
SIG24130_Init(); //多路输入输出初始化 SIG24130_Init(); //多路输入输出初始化
system_sts.mux_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for (;;) for (;;)
{ {
@ -370,6 +359,9 @@ void start_mux_analog(void const * argument)
//输出&输入通道切换 //输出&输入通道切换
mux_signal_switch(&mux_signal); mux_signal_switch(&mux_signal);
//处理校准事件
deal_calibrate_affair();
//内存、内存碎片、CPU占用监控 //内存、内存碎片、CPU占用监控
my_monitor_cnt++; my_monitor_cnt++;
if( my_monitor_cnt * MUX_TASK_PERIOD >= 200) if( my_monitor_cnt * MUX_TASK_PERIOD >= 200)
@ -385,7 +377,6 @@ void start_mux_analog(void const * argument)
} }
system_sts.mux_stack_consume = MUX_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.mux_stack_consume = MUX_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.mux_stack_consume_max < system_sts.mux_stack_consume) system_sts.mux_stack_consume_max = system_sts.mux_stack_consume;
osDelay(MUX_TASK_PERIOD); osDelay(MUX_TASK_PERIOD);
} }
/* USER CODE END start_mux_analog */ /* USER CODE END start_mux_analog */
@ -402,7 +393,6 @@ void start_menu(void const * argument)
{ {
/* USER CODE BEGIN start_menu */ /* USER CODE BEGIN start_menu */
screen_data_init(); screen_data_init();
system_sts.menu_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for(;;) for(;;)
{ {
@ -412,7 +402,6 @@ void start_menu(void const * argument)
screen_run(); screen_run();
system_sts.menu_stack_consume = MENU_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.menu_stack_consume = MENU_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.menu_stack_consume_max < system_sts.menu_stack_consume) system_sts.menu_stack_consume_max = system_sts.menu_stack_consume;
osDelay(MENU_TASK_PERIOD); osDelay(MENU_TASK_PERIOD);
} }
/* USER CODE END start_menu */ /* USER CODE END start_menu */
@ -429,7 +418,6 @@ void start_task_monitor(void const * argument)
{ {
/* USER CODE BEGIN start_task_monitor */ /* USER CODE BEGIN start_task_monitor */
uint8_t monitor_enable = 0; uint8_t monitor_enable = 0;
system_sts.monitor_stack_consume_max = 0;
/* Infinite loop */ /* Infinite loop */
for(;;) for(;;)
{ {
@ -439,7 +427,6 @@ void start_task_monitor(void const * argument)
//HAL_UART_Transmit(&huart3, (uint8_t *)task_status, 255, 0xFFFF); //HAL_UART_Transmit(&huart3, (uint8_t *)task_status, 255, 0xFFFF);
system_sts.monitor_stack_consume = MONITOR_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL); system_sts.monitor_stack_consume = MONITOR_STACK_SIZE_WORD - uxTaskGetStackHighWaterMark(NULL);
if(system_sts.monitor_stack_consume_max < system_sts.monitor_stack_consume) system_sts.monitor_stack_consume_max = system_sts.monitor_stack_consume;
//一般情况下不启用本任务 //一般情况下不启用本任务
if( !monitor_enable ) vTaskSuspend(NULL); if( !monitor_enable ) vTaskSuspend(NULL);

15
MDK-ARM/signal_generator.uvoptx
View File

@ -260,6 +260,21 @@
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>progout_data,0x0A</ItemText> <ItemText>progout_data,0x0A</ItemText>
</Ww> </Ww>
<Ww>
<count>21</count>
<WinNumber>1</WinNumber>
<ItemText>cal_flags,0x0A</ItemText>
</Ww>
<Ww>
<count>22</count>
<WinNumber>1</WinNumber>
<ItemText>vol_v_out_calibrate_table,0x0A</ItemText>
</Ww>
<Ww>
<count>23</count>
<WinNumber>1</WinNumber>
<ItemText>cur_ma_out_calibrate_table,0x0A</ItemText>
</Ww>
</WatchWindow1> </WatchWindow1>
<WatchWindow2> <WatchWindow2>
<Ww> <Ww>

39383
MDK-ARM/signal_generator/signal_generator.hex
View File

File diff suppressed because it is too large Load Diff