更新：

1、本地按键&上位机modbus指令冲突处理：量程、描点个数、曲线颜色、语言选择；
2、主界面：数据范围“/”修改成“~”；

.vscode/c_cpp_properties.json

@@ -1,20 +1,20 @@
 {
-    "configurations": [
-        {
-            "name": "Win32",
-            "includePath": [
-                "${workspaceFolder}/**"
-            ],
-            "defines": [
-                "_DEBUG",
-                "UNICODE",
-                "_UNICODE"
-            ],
-            "compilerPath": "C:\\TDM-GCC-64\\bin\\gcc.exe",
-            "cStandard": "c11",
-            "cppStandard": "c++17",
-            "intelliSenseMode": "windows-gcc-x64"
-        }
-    ],
-    "version": 4
+  "configurations": [
+    {
+      "name": "windows-gcc-x64",
+      "includePath": [
+        "${workspaceFolder}/**"
+      ],
+      "defines": [
+        "_DEBUG",
+        "UNICODE",
+        "_UNICODE"
+      ],
+      "compilerPath": "E:/Softwares/mingw64/bin/gcc.exe",
+      "cStandard": "${default}",
+      "cppStandard": "${default}",
+      "intelliSenseMode": "windows-gcc-x64"
+    }
+  ],
+  "version": 4
 }

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "C/C++ Runner: Debug Session",
+      "type": "cppdbg",
+      "request": "launch",
+      "args": [],
+      "stopAtEntry": false,
+      "externalConsole": true,
+      "cwd": "f:/Desktop/Work/00_Projects/04_Signal_Generator/00_Code/00_New/signal_generator/App/APP_WU/Src",
+      "program": "f:/Desktop/Work/00_Projects/04_Signal_Generator/00_Code/00_New/signal_generator/App/APP_WU/Src/build/Debug/outDebug",
+      "MIMode": "gdb",
+      "miDebuggerPath": "gdb",
+      "setupCommands": [
+        {
+          "description": "Enable pretty-printing for gdb",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        }
+      ]
+    }
+  ]
+}

.vscode/settings.json

@@ -1,29 +1,106 @@
 {
-    "files.associations": {
-        "main.h": "c",
-        "cmsis_os.h": "c",
-        "task.h": "c",
-        "freertos.h": "c",
-        "stm32f4xx_hal.h": "c",
-        "stm32f4xx_hal_conf.h": "c",
-        "stddef.h": "c",
-        "stdint.h": "c",
-        "usart.h": "c",
-        "string": "c",
-        "data_type_def.h": "c",
-        "gpio.h": "c",
-        "limits": "c",
-        "ble.h": "c",
-        "dac8552.h": "c",
-        "spi.h": "c",
-        "ads1220ipwr.h": "c",
-        "dac.h": "c",
-        "mux_signal.h": "c",
-        "stm32f407xx.h": "c",
-        "utils.h": "c",
-        "type_traits": "c",
-        "stm32f4xx_hal_adc.h": "c",
-        "stm32f4xx_hal_def.h": "c",
-        "stm32_hal_legacy.h": "c"
-    }
+  "files.associations": {
+    "main.h": "c",
+    "cmsis_os.h": "c",
+    "task.h": "c",
+    "freertos.h": "c",
+    "stm32f4xx_hal.h": "c",
+    "stm32f4xx_hal_conf.h": "c",
+    "stddef.h": "c",
+    "stdint.h": "c",
+    "usart.h": "c",
+    "string": "c",
+    "data_type_def.h": "c",
+    "gpio.h": "c",
+    "limits": "c",
+    "ble.h": "c",
+    "dac8552.h": "c",
+    "spi.h": "c",
+    "ads1220ipwr.h": "c",
+    "dac.h": "c",
+    "mux_signal.h": "c",
+    "stm32f407xx.h": "c",
+    "utils.h": "c",
+    "type_traits": "c",
+    "stm32f4xx_hal_adc.h": "c",
+    "stm32f4xx_hal_def.h": "c",
+    "stm32_hal_legacy.h": "c",
+    "timer.h": "c",
+    "lv_span.h": "c",
+    "apps_gather.h": "c",
+    "ip5310_i2c.h": "c",
+    "app_screen_main.h": "c",
+    "algorithm": "c",
+    "app_screen_setting.h": "c",
+    "key_functions.h": "c",
+    "sstream": "c",
+    "modbus_485.h": "c",
+    "hart.h": "c",
+    "string_view": "c",
+    "app_screen_setting_trans.h": "c",
+    "key_functions_main.h": "c",
+    "eeprom_spi.h": "c",
+    "math.h": "c",
+    "modbus_register_process.h": "c",
+    "modbus_rtu_master.h": "c"
+  },
+  "C_Cpp.errorSquiggles": "disabled",
+  "idf.pythonInstallPath": "F:\\Espressif\\tools\\idf-python\\3.11.2\\python.exe",
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wcast-align",
+    "-Wconversion",
+    "-Wsign-conversion",
+    "-Wnull-dereference"
+  ],
+  "C_Cpp_Runner.msvcWarnings": [
+    "/W4",
+    "/permissive-",
+    "/w14242",
+    "/w14287",
+    "/w14296",
+    "/w14311",
+    "/w14826",
+    "/w44062",
+    "/w44242",
+    "/w14905",
+    "/w14906",
+    "/w14263",
+    "/w44265",
+    "/w14928"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false,
+  "C_Cpp_Runner.useUndefinedSanitizer": false,
+  "C_Cpp_Runner.useLeakSanitizer": false,
+  "C_Cpp_Runner.showCompilationTime": false,
+  "C_Cpp_Runner.useLinkTimeOptimization": false,
+  "C_Cpp_Runner.msvcSecureNoWarnings": false
 }

App/ADS1220/ads1220.c

@@ -12,6 +12,20 @@ long ADS1220RTDGainCorrection = 1;
 long ADS1220TCGainCorrection = 1;
 BOOL ads1220_spi_init_flag = FALSE;
 
+
+// void test1()
+// {
+// 	static uint32_t count = 0;
+//   while(1)
+//   {
+// 		count = 10000;
+// 	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_SET);
+// 	  while(!(count--));
+// 	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_RESET);
+//   }
+// }
+
+
 static void ads1220_cs(cs_state_type state)
 {
 	if (state == CS_L)
@@ -43,7 +57,7 @@ static void fun_ads1220_spi1_init(void)
 		Error_Handler();
 	}
 	ADS1220_CS(GPIO_PIN_RESET);
-	DAC7811_CS(GPIO_PIN_SET);
+	//DAC7811_CS(GPIO_PIN_SET);
 }
 
 // static void spi_write_byte(uint8_t data)
@@ -55,10 +69,10 @@ static void fun_ads1220_spi1_init(void)
 // {
 // 	HAL_SPI_TransmitReceive(&hspi1, pTxData, pRxData, 1, 1000);
 // }
-
+HAL_StatusTypeDef ads1220spi_status_watch;
 static void spi_write_read(uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
 {
-	HAL_SPI_TransmitReceive(&hspi1, pTxData, pRxData, Size, 1000);
+	ads1220spi_status_watch = HAL_SPI_TransmitReceive(&hspi1, pTxData, pRxData, Size, 1000);
 }
 
 static void ads1220_write_regs(uint8_t *writeValues, uint8_t startReg, uint8_t length)
@@ -87,11 +101,11 @@ static void ads1220_read_regs(uint8_t *readValues, uint8_t startReg, uint8_t len
 }
 */
 
-static void ads1220_send_read_data_command(void)
-{
-	uint8_t cmd = ADS1220_RDATA_CMD;
-	spi_write_read(&cmd, RcvData, 1);
-}
+//static void ads1220_send_read_data_command(void)
+//{
+//	uint8_t cmd = ADS1220_RDATA_CMD;
+//	spi_write_read(&cmd, RcvData, 1);
+//}
 
 static void setup_ads1220(uint8_t inputMux, uint8_t opMode,
 						  uint8_t conversionMode, uint8_t dataRate, uint8_t gainLevel, uint8_t pgaBypass,
@@ -208,21 +222,21 @@ if(!Read_DRDY){//当检测到数据可读时
 	intTempSensor:温度传感器模式
 						0：禁用       1：启用
 */
-static void ads1220_init(void)
-{
-	setup_ads1220(
-		ADS1220_MUX_AIN0_AIN1,			// 输入多路复用器配置
-		ADS1220_OP_MODE_NORMAL,			// 工作模式选择
-		ADS1220_CONVERSION_SINGLE_SHOT, // 转换模式
-		ADS1220_DATA_RATE_45SPS,		// 数据速率
-		ADS1220_GAIN_1,					// 增益配置
-		ADS1220_PGA_BYPASS,				// 禁止/启用可编程增益放大器
-		ADS1220_IDAC1_DISABLED,			// 选择IDAC1将路由到的通道
-		ADS1220_IDAC2_DISABLED,			// 选择IDAC2将路由到的通道
-		ADS1220_IDAC_CURRENT_OFF,		// IDAC电流设置
-		ADS1220_VREF_EXT_REF0_PINS,		// 基准电压选择
-		ADS1220_TEMP_SENSOR_OFF);		// 温度传感器
-}
+//static void ads1220_init(void)
+//{
+//	setup_ads1220(
+//		ADS1220_MUX_AIN0_AIN1,			// 输入多路复用器配置
+//		ADS1220_OP_MODE_NORMAL,			// 工作模式选择
+//		ADS1220_CONVERSION_SINGLE_SHOT, // 转换模式
+//		ADS1220_DATA_RATE_45SPS,		// 数据速率
+//		ADS1220_GAIN_1,					// 增益配置
+//		ADS1220_PGA_BYPASS,				// 禁止/启用可编程增益放大器
+//		ADS1220_IDAC1_DISABLED,			// 选择IDAC1将路由到的通道
+//		ADS1220_IDAC2_DISABLED,			// 选择IDAC2将路由到的通道
+//		ADS1220_IDAC_CURRENT_OFF,		// IDAC电流设置
+//		ADS1220_VREF_EXT_REF0_PINS,		// 基准电压选择
+//		ADS1220_TEMP_SENSOR_OFF);		// 温度传感器
+//}
 
 static void ads1220_reset(void)
 {
@@ -236,11 +250,11 @@ static void ads1220_start(void)
 	spi_write_read(&cmd, RcvData, 1);
 }
 
-static void ads1220_powerdown(void)
-{
-	uint8_t cmd = ADS1220_POWERDOWN_CMD;
-	spi_write_read(&cmd, RcvData, 1);
-}
+//static void ads1220_powerdown(void)
+//{
+//	uint8_t cmd = ADS1220_POWERDOWN_CMD;
+//	spi_write_read(&cmd, RcvData, 1);
+//}
 
 static void ads1220_get_conversion_data(float32 *conversionData)
 {
@@ -255,24 +269,25 @@ static void ads1220_get_conversion_data(float32 *conversionData)
 		data ^= 0x00FFFFFF;
 		data += 1;
 	}
-	*conversionData = (float32)data * 2.5f / 8388608;
+	//mv
+	*conversionData = 1000 * (float32)data * 2.5f / 8388608;
 }
 
-static void ads1220_get_rtd_conversion_data_calibrated(volatile long *code)
-{
-	uint8_t outData[3] = {0xff, 0xff, 0xff};
-	uint8_t tempData[3];
+//static void ads1220_get_rtd_conversion_data_calibrated(volatile long *code)
+//{
+//	uint8_t outData[3] = {0xff, 0xff, 0xff};
+//	uint8_t tempData[3];
 
-	spi_write_read(outData, tempData, 3);
+//	spi_write_read(outData, tempData, 3);
 
-	*code = (((long)tempData[0] << 16) + ((long)tempData[1] << 8) + (long)tempData[2]); // combine 3 Bytes of Conversion Data to 24 bit value
-	if (*code & 0x800000)																// check if result is negative
-	{
-		*code ^= 0x00FFFFFF; // invert and make
-		*code += 1;			 // two's complement
-	}
-	*code = (long)((long long)(*code) * ADS1220RTDGainCorrection / 100000); // ADS1220 Gain correction
-}
+//	*code = (((long)tempData[0] << 16) + ((long)tempData[1] << 8) + (long)tempData[2]); // combine 3 Bytes of Conversion Data to 24 bit value
+//	if (*code & 0x800000)																// check if result is negative
+//	{
+//		*code ^= 0x00FFFFFF; // invert and make
+//		*code += 1;			 // two's complement
+//	}
+//	*code = (long)((long long)(*code) * ADS1220RTDGainCorrection / 100000); // ADS1220 Gain correction
+//}
 
 void ads1220_operation(uint8_t channel, float32 *data_pv)
 {
@@ -285,48 +300,48 @@ void ads1220_operation(uint8_t channel, float32 *data_pv)
 
 	ads1220_cs(CS_L);
 	vTaskDelay(10);
-	if (channel == CH2_OUT_CUR)
-	{
-		ads1220_reset();
-		vTaskDelay(5);
-		setup_ads1220(
-			ADS1220_MUX_AIN2_AVSS,			// 输入多路复用器配置
-			ADS1220_OP_MODE_NORMAL,			// 工作模式选择
-			ADS1220_CONVERSION_SINGLE_SHOT, // 转换模式
-			ADS1220_DATA_RATE_45SPS,		// 数据速率
-			ADS1220_GAIN_1,					// 增益配置
-			ADS1220_PGA_BYPASS,				// 禁止/启用可编程增益放大器
-			ADS1220_IDAC1_DISABLED,			// 选择IDAC1将路由到的通道
-			ADS1220_IDAC2_DISABLED,			// 选择IDAC2将路由到的通道
-			ADS1220_IDAC_CURRENT_OFF,		// IDAC电流设置
-			ADS1220_VREF_EXT_REF0_PINS,		// 基准电压选择
-			ADS1220_TEMP_SENSOR_OFF);		// 温度传感器
-		vTaskDelay(5);
-		ads1220_start();
-		vTaskDelay(30);
-		ads1220_get_conversion_data(data_pv);
-	}
-	else if (channel == CH9_IN_TC)
-	{
+	// if (channel == CH2_OUT_CUR)
+	// {
+	// 	ads1220_reset();
+	// 	vTaskDelay(5);
+	// 	setup_ads1220(
+	// 		ADS1220_MUX_AIN2_AVSS,			// 输入多路复用器配置
+	// 		ADS1220_OP_MODE_NORMAL,			// 工作模式选择
+	// 		ADS1220_CONVERSION_SINGLE_SHOT, // 转换模式
+	// 		ADS1220_DATA_RATE_45SPS,		// 数据速率
+	// 		ADS1220_GAIN_1,					// 增益配置
+	// 		ADS1220_PGA_BYPASS,				// 禁止/启用可编程增益放大器
+	// 		ADS1220_IDAC1_DISABLED,			// 选择IDAC1将路由到的通道
+	// 		ADS1220_IDAC2_DISABLED,			// 选择IDAC2将路由到的通道
+	// 		ADS1220_IDAC_CURRENT_OFF,		// IDAC电流设置
+	// 		ADS1220_VREF_EXT_REF0_PINS,		// 基准电压选择
+	// 		ADS1220_TEMP_SENSOR_OFF);		// 温度传感器
+	// 	vTaskDelay(5);
+	// 	ads1220_start();
+	// 	vTaskDelay(30);
+	// 	ads1220_get_conversion_data(data_pv);
+	// }
+	// else if (channel == CH10_IN_TC)
+	// {
 		ads1220_reset();
 		vTaskDelay(5);
 		setup_ads1220(
 			ADS1220_MUX_AIN0_AIN1,			// 输入多路复用器配置
 			ADS1220_OP_MODE_NORMAL,			// 工作模式选择
-			ADS1220_CONVERSION_SINGLE_SHOT, // 转换模式
-			ADS1220_DATA_RATE_45SPS,		// 数据速率
-			ADS1220_GAIN_1,					// 增益配置
+			ADS1220_CONVERSION_SINGLE_SHOT, // 转换模式*
+			ADS1220_DATA_RATE_45SPS,		// 数据速率*
+			ADS1220_GAIN_1,					// 增益配置*
 			ADS1220_PGA_BYPASS,				// 禁止/启用可编程增益放大器
 			ADS1220_IDAC1_DISABLED,			// 选择IDAC1将路由到的通道
 			ADS1220_IDAC2_DISABLED,			// 选择IDAC2将路由到的通道
 			ADS1220_IDAC_CURRENT_OFF,		// IDAC电流设置
-			ADS1220_VREF_EXT_REF0_PINS,		// 基准电压选择
+			ADS1220_VREF_EXT_REF0_PINS,		// 基准电压选择*
 			ADS1220_TEMP_SENSOR_OFF);		// 温度传感器
 		vTaskDelay(5);
 		ads1220_start();
 		vTaskDelay(30);
 		ads1220_get_conversion_data(data_pv);
-	}
+	// }
 	ads1220_cs(CS_H);
 	vTaskDelay(5);
 }

App/ADS1220/ads1220.h

@@ -165,7 +165,7 @@ extern "C"
 
     extern BOOL ads1220_spi_init_flag;
 
-    void ads1220_init(void);
+	void ads1220_init(void);
     void setup_ads1220(uint8_t inputMux, uint8_t opMode,
                        uint8_t conversionMode, uint8_t dataRate, uint8_t gainLevel, uint8_t pgaBypass,
                        uint8_t routeIDAC1, uint8_t routeIDAC2, uint8_t idacCurrent, uint8_t selectVref, uint8_t intTempSensor);

App/APP_WU/Inc/app_screen_main.h

@@ -0,0 +1,131 @@
+#ifndef _APP_SCREEN_MAIN_H_
+#define _APP_SCREEN_MAIN_H_
+
+#include "apps_gather.h"
+
+extern MENU_DATA menu_data;                    //界面参数初始化
+extern PLOT_DATA pltdata;                   //chart绘图参数初始化
+extern uint8_t scr_main_set_flag;
+
+//主界面，ON
+#define IO_ON 1                 
+
+//主界面，OFF
+#define IO_OFF 0                
+
+//主界面，输入模式
+#define IO_INPUT 0              
+
+//主界面，输出模式
+#define IO_OUTPUT 1 
+
+//游标-横线起点1，小数点的宽度与数字不一样，因此分成左右两半
+#define IO_CURSOR_START1 136    
+
+//游标-横线起点2
+#define IO_CURSOR_START2 244    
+
+//游标-数字之间间隔大小
+#define IO_CURSOR_INTERVAL 24   
+
+//游标-y轴坐标值
+#define IO_CURSOR_Y 230
+
+//EEPROM状态监控
+#define EEPROM_MONITOR_ENABLE 1
+
+//符号位，空白
+#define SIGN_NULL 0
+
+//符号位，减号（负数）
+#define SIGN_MINUS 1
+
+//符号位，L，向下溢出
+#define SIGN_L 2
+
+//符号为，H，向上溢出
+#define SIGN_H 3
+
+//菜单数据初始化
+void screen_data_init(void);
+
+//主界面参数初始化
+void main_data_init(void);
+
+//绘图数据初始化
+void plot_data_init(void);
+
+//开机动画
+void scr_init_run(void);
+
+//进度条设置, start[0, end], end[start,100], interval[ms]，结束后返回1
+uint8_t init_set_bar(uint8_t start, uint8_t end, uint16_t interval);
+
+//主界面
+void scr_main_run(void);
+
+//运行时间显示
+void runtime_show(void);            
+
+//电池电量显示
+void battery_show(void);  
+
+//设置游标位置【0000.000】，0~7
+void set_cursor_position(void);
+
+//设置数码管符号位，0->熄灭，1->显示负号
+void set_nixie_cube_sign(uint8_t on2off, uint8_t sg);
+
+//设置数码管显示值：io_slc->输入/输出，pos->第几个数字，num->数值*1000
+//补充说明：pos = 99时，num=[0000000，9999999]；pos = 10时，数值显示为空白。
+void set_nixie_cube(uint8_t io_slc, uint8_t pos, int32_t num);
+
+//RE：按键修改输出值
+void keyset_output(int8_t key_step);
+
+//设置当前的输出值，1000*实际值->(无符号)数组，可直接输入负数
+void set_output_array(int32_t pvo);
+
+//设置输出值：数字显示 + 符号 + 缓存，sto->实际值
+void set_output(float32 sto); 
+
+//获取当前设定的输出值（数组&符号 -> （有符号）实际值）
+float32 get_output_value(void);
+
+//显示当前测量值
+void input_value_show(void);
+
+//输入输出、ON&OFF状态指示
+void io_on2off_status(void);  
+
+//恢复主界面的各项参数显示，用于界面切换（设置界面->主界面）
+void scr_main_recover(void);  
+
+//曲线设置更新
+void scr_main_chart_update(void);
+
+//数值闪烁，数值发生变化后开始闪烁，10秒无动作后闪烁停止，游标移动后恢复前一时刻位置的数值
+void num_twinkle(void);  
+
+//实时曲线绘制
+void plot_drawing(void);    
+
+//设置工作模式和工作模式类型
+void set_working_mode(SIG_FUNCTIONS mode, SIG_FUNCTIONS_TYPE type);
+
+//更新上下限&显示，曲线上下限，数值上下限
+void up2down_update(int16_t low, int16_t up);
+
+//eeprom状态监控
+void eep_status_monitor(void);
+
+//通讯状态标识
+void trans_status_display(void);
+
+
+
+
+
+#endif
+
+

App/APP_WU/Inc/app_screen_modbus.h

@@ -0,0 +1,89 @@
+#ifndef _APP_SCREEN_MODBUS_H_
+#define _APP_SCREEN_MODBUS_H_
+
+#include "apps_gather.h"
+
+typedef enum
+{
+    MOD_CONF_SLAVE_ID = 0,
+    MOD_CONF_START_ADDRESS,
+    MOD_CONF_BYTES,
+    MOD_CONF_TIMEOUT,
+    MOD_CONF_COMMAND,
+    MOD_CONF_REGISTER_NUM,
+    MOD_CONF_CALIBRATION,
+    MOD_CONF_NEXT,
+    MOD_CONF_NONE
+}MOD_CONF_ITEMS;
+
+typedef enum
+{
+    MOD_TRX_DATA = 0,
+    MOD_TRX_PREVIOUS,
+    MOD_TRX_SET,
+    MOD_TRX_SEND,
+    MOD_TRX_NONE
+}MOD_TRX_ITEMS;
+
+//Modbus配置界面，设置右列数值底色
+void config_items_set_color(MOD_CONF_ITEMS cur, uint32_t color);
+
+//Modbus配置界面，选中右列值
+void config_items_check(MOD_CONF_ITEMS cur, MOD_CONF_ITEMS cur_prv);
+
+//Modbus配置界面，弹窗，选中cur，熄灭cur_prv
+void config_window_num_check(uint8_t cur, uint8_t cur_prv);
+
+//Modbus配置界面，弹窗，设定显示内容
+void config_window_num_set(uint8_t pos, uint8_t num);
+
+//Modbus配置界面，更新弹窗内容
+void config_window_update(void);
+
+//Modbus配置界面，弹窗内容转化为数值
+void config_window2value(void);
+
+//打开trx弹窗后，初始化显示内容
+void trx_window_init(void);
+
+//Modbus收发界面，设置选项底色
+void trx_items_set_color(MOD_TRX_ITEMS cur, uint32_t color);
+
+//Modbus收发界面，选中选项
+void trx_items_check(MOD_TRX_ITEMS cur, MOD_TRX_ITEMS cur_prv);
+
+//Modbus收发界面，设置data中32个数字的底色
+void trx_set_window_num_color(uint8_t cur, uint32_t color);
+
+//Modbus收发界面，弹窗，选中数字
+void trx_window_num_check(uint8_t cur, uint8_t cur_prv);
+
+//Modbus收发界面，将弹窗内容转化成数值
+void trx_window_num2val(void);
+
+//按键功能
+void key_functions_modbus(void);
+
+//切换至modbus配置界面后对显示内容进行调整：语言、默认值
+void scr_modbus_config_recover(void);
+
+//切换至trx收发界面后，游标复位，清空数据、tx、rx内容
+void scr_modbus_trx_recover(void);
+
+//任务循环中反复执行的功能
+void screen_modbus_trx_run(void);
+
+extern uint8_t com_switch_cursor;
+extern uint8_t com_switch_cursor_prv;
+extern uint8_t trx_focus;
+extern MOD_CONF_ITEMS mod_mas_conf_cursor;     
+extern MOD_CONF_ITEMS mod_mas_conf_cursor_prv;
+extern uint8_t config_focus;
+extern MOD_TRX_ITEMS mod_mas_trx_cursor;
+extern MOD_TRX_ITEMS mod_mas_trx_cursor_prv;
+extern uint8_t trx_focus;
+extern lv_obj_t *lvobj_window_trx_nums[32];
+
+
+
+#endif

App/APP_WU/Inc/app_screen_setting.h

@@ -0,0 +1,157 @@
+#ifndef _APP_SCREEN_SETTING_H_
+#define _APP_SCREEN_SETTING_H_
+
+#include "apps_gather.h"
+
+extern TABVIEW_DATA tabdata;             
+extern int16_t save_cnt;
+extern int16_t reset_cnt;
+extern int32_t color_table[7];
+extern uint8_t setting_window_num[5];
+
+//页面数量
+#define I0_PAGE_MAX 3
+#define I1_PAGE_MAX 1
+#define I2_PAGE_MAX 1
+#define I3_PAGE_MAX 1
+
+//淡蓝色
+#define COLOR_LIGHT_BLUE_VALUE 0xCAEEFF
+
+//蓝色
+#define COLOR_BLUE_VALUE 0x00B6FF
+
+//深蓝色
+#define COLOR_DARK_BLUE_VALUE 0x000FFF
+
+//黄色
+#define COLOR_YELLOW_VALUE 0xEAE200
+
+//橙色
+#define COLOR_ORANGE_VALUE 0xFD8E10
+
+//绿色
+#define COLOR_GREEN_VALUE 0x00FF4E
+
+//红色
+#define COLOR_RED_VALUE 0xFF0027
+
+//紫色
+#define COLOR_PURPLE_VALUE 0xFF00D4
+
+//黑色
+#define COLOR_BLACK_VALUE 0x000000
+
+//白色
+#define COLOR_WHITE_VALUE 0xffffff
+
+//选项卡未选中时的底色
+#define COLOR_ITEMS_UNCHECKED COLOR_WHITE_VALUE
+
+//选项卡选中时的底色
+#define COLOR_ITEMS_CHECKED COLOR_LIGHT_BLUE_VALUE
+
+//内容未选中时的底色
+#define COLOR_CONTENTS_UNCHECKED COLOR_WHITE_VALUE
+
+//内容选中时的底色
+#define COLOR_CONTENTS_CHECKED COLOR_LIGHT_BLUE_VALUE
+
+//内容焦点后的底色
+#define COLOR_CONTENTS_FOCUSED COLOR_GREEN_VALUE
+
+//通讯子菜单的选项卡
+#define TEXT_HART 0
+#define TEXT_BLE 1
+#define TEXT_MODBUS 2
+#define TEXT_MODBUS_CONFIG 3
+
+//设置菜单数据初始化
+void tab_data_init(void);
+
+//选项卡EEPROM部分数据初始化
+void eeprom_item_data_init(void);
+
+//设置界面选项卡选中：点亮cursor；熄灭cursor_prv
+void setting_items_check(ITEMS cursor, ITEMS cursor_prv);
+
+//当前选项卡内容翻页：显示选项卡 ite 的第 page 页，
+void setting_items_page(ITEMS ite, uint8_t page);
+
+//设置界面选项卡内部内容选中：点亮cursor；熄灭cursor_prv；焦点focus
+void setting_contents_check(uint8_t cursor, uint8_t cursor_prv);
+
+//设置界面选项卡内部内容选中之后，根据键值key_val和步长step修改内容，修改第ite个选项卡的第con个内容
+void setting_contents_modify(ITEMS ite, ITEM_CONTENTS con, int8_t step);
+
+//设置修改项的底色，表示选中和焦点
+void set_contents_color(uint8_t cursor, uint32_t color);
+
+//恢复设置界面的各项参数显示，用于界面切换（主界面->设置界面）
+void scr_setting_recover(void); 
+
+//详细设置界面
+void scr_setting_run(void);
+
+//执行保存功能
+void deal_data_save(void);
+
+//执行复位功能
+void deal_data_reset(void);
+
+//修改选项卡0的文本
+void set_item0_text(ITEM_CONTENTS con);
+
+//修改选项卡1的文本
+void set_item1_text(ITEM_CONTENTS con);
+
+//修改选项卡2的文本
+void set_item2_text(ITEM_CONTENTS con);
+
+//修改选项卡3的文本
+void set_item3_text(ITEM_CONTENTS con);
+
+//修改对象颜色
+void set_obj_color(lv_obj_t * obj, uint8_t color);
+
+//修改选项卡0的值
+void set_item0_value(ITEM_CONTENTS con, int8_t step);
+
+//修改选项卡1的值
+void set_item1_value(ITEM_CONTENTS con, int8_t step);
+
+//修改选项卡2的值
+void set_item2_value(ITEM_CONTENTS con, int8_t step);
+
+//修改选项卡3的值
+void set_item3_value(ITEM_CONTENTS con, int8_t step);
+
+//内容游标 uint8_t -> enum
+ITEM_CONTENTS content_cur_char2enum(ITEMS ite, uint8_t cur_uint8);
+
+//刷新标题和选项卡文本
+void title_item_refresh(void);
+
+//设置通讯子菜单右列值的文本
+void set_communication_text(uint8_t con);
+
+//切换至通讯子菜单
+void communication_select(void);
+
+//修改通讯子菜单的值
+void set_communication_modify(uint8_t con, int8_t step);
+
+//唤出弹窗：电压mV上限、电压mV下限、电阻上限、电阻下限、频率上限、频率下限、热电偶上限、热电偶下限、热电阻上限、热电阻下限
+uint8_t setting_window_display(void);
+
+void setting_val2window(int16_t val);
+
+void setting_window2val(void);
+
+void setting_window_num_check(uint8_t cur, uint8_t cur_prv);
+
+void setting_window_set_num(uint8_t cur);
+
+#endif
+
+

App/APP_WU/Inc/apps_gather.h

@@ -0,0 +1,160 @@
+#ifndef _APPS_GATHER_H_
+#define _APPS_GATHER_H_
+
+/**********************************************Drivers**********************************************/
+#include "main.h"
+#include <string.h>
+#include "gpio.h"
+#include "usart.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timer.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "cmsis_os.h"
+#include "tim.h"
+
+#include "ip5310_i2c.h"
+#include "eeprom_spi.h"
+#include "tm1650.h"
+#include "mux_signal.h"
+#include "JLX240-00301-BN.h"
+#include "ble.h"
+#include "hart.h"
+#include "rn7302.h"
+#include "SIG24130.h"
+
+extern osThreadId task_lcdHandle;
+extern osThreadId task_menuHandle;
+extern uint8_t screen_suspend_flag;
+/**********************************************Drivers**********************************************/
+//
+//
+//
+/**********************************************LVGL**********************************************/
+#include "lvgl.h"                // 它为整个LVGL提供了更完整的头文件引用
+#include "lv_port_disp.h"        // LVGL的显示
+#include "gui_guider.h"          // Gui Guider 生成的界面和控件的声明
+#include "events_init.h"         // Gui Guider 生成的初始化事件、回调函数
+//#include "lv_demo_benchmark.h"
+
+//LVGL相关外部变量
+extern lv_ui  guider_ui;
+extern const lv_img_dsc_t * screen_main_animimg_battery_imgs[6];
+extern const lv_img_dsc_t * screen_main_ani_in_0_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_1_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_2_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_3_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_4_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_5_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_6_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_0_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_1_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_2_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_3_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_4_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_5_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_out_6_imgs[11];
+extern const lv_img_dsc_t * screen_main_ani_in_sign_imgs[4];
+extern const lv_img_dsc_t * screen_main_ani_out_sign_imgs[4];
+
+/**********************************************LVGL**********************************************/
+//
+//
+//
+/**********************************************Functions**********************************************/
+#include "apps_var_def.h"
+#include "app_screen_main.h"
+#include "app_screen_setting.h"
+#include "scr_setting_item_text.h"
+#include "scr_setting_item_value.h"
+#include "key_functions.h"
+#include "scr_setting_text.h"
+#include "app_screen_modbus.h"
+#include "key_functions_main.h"
+#include "key_functions_setting.h"
+#include "key_functions_modbus.h"
+#include "modbus_485.h"
+#include "modbus_rtu.h"
+#include "modbus_rtu_master.h"
+#include "scr_setting_progam_out.h"
+#include "modbus_register_process.h"
+
+extern PHYSICAL_QUANTITY VOL[2];            //电压，VOL[0]-V, VOL[1]-mV
+extern PHYSICAL_QUANTITY CUR;               //电流，mA
+extern PHYSICAL_QUANTITY RES;               //电阻，Ω
+extern PHYSICAL_QUANTITY FRE;               //频率，KHz
+extern PHYSICAL_QUANTITY TC[8];             //热电偶，共8种
+extern PHYSICAL_QUANTITY RTD;               //热电阻
+extern OPERATIONS current_operation;        //当前操作
+extern SYSTEM_STATUS_WATCH system_sts;      //系统状态监控
+extern SIG_TRANSMISSION sig_trans;          //通讯模式
+
+//绝对值计算
+#define MY_ABS(pa) ( ( (pa) >= 0 )?( (pa) ):( 0 - (pa) ) ) 
+
+//在 cubeMX 中配置完成之后再返回此处进行更新
+#define MUX_STACK_SIZE_WORD 128 
+#define LVGL_STACK_SIZE_WORD 768
+#define MENU_STACK_SIZE_WORD 512
+#define RS485_STACK_SIZE_WORD 256
+#define HART_STACK_SIZE_WORD 256
+#define BLE_STACK_SIZE_WORD 256
+#define DEFAULT_STACK_SIZE_WORD 128
+#define MONITOR_STACK_SIZE_WORD 128
+
+#define MUX_TASK_PERIOD 50                  //多通道输入输出任务周期
+#define LVGL_TASK_PERIOD 5                  //LVGL任务周期
+#define MENU_TASK_PERIOD 300                //显示内容设置周期
+#define BLE_TASK_PERIOD 100                 //蓝牙任务周期
+#define HART_TASK_PERIOD 100                //HART任务周期
+#define RS485_TASK_PERIOD MUX_TASK_PERIOD   //485任务周期
+
+//屏幕显示
+void screen_run(void);
+
+//计算a的b次方
+float32 my_power(int a, int b);
+
+//物理量内容初始化
+void physical_quantity_init(void);
+
+//热电偶数据初始化
+void TC_init(void);
+
+//通道选择与切换
+void sig_channel_select(uint8_t io, SIG_FUNCTIONS_TYPE type);
+
+//更新设定值（根据ON\OFF状态）
+void sig_sv_update(void);
+
+//数据转换，mux_signal.pv -> real_value
+float32 mux2real(float32 mux_pv);
+
+//数据转换，real_value -> mux_signal.sv
+float32 real2mux(float32 real_value);
+
+//数据转换，将输入热电偶电压值转换为实际温度值℃
+float32 tcmv2temp(SIG_FUNCTIONS_TYPE type, float32 mv);
+
+//数据转换，将需要模拟的温度值℃转化为热电偶对应的mv
+float32 temp2tcmv(SIG_FUNCTIONS_TYPE type, float32 temp);
+
+//数据转换，热电阻阻值 Ω 转化为温度 ℃
+float32 ohm2temp(float32 ohm);
+
+//数据转换，温度 ℃ 转化为热电阻阻值 Ω
+float32 temp2ohm(float32 temp); 
+
+//初始化打包
+void my_inits_gather(void);
+
+
+
+/**********************************************Functions**********************************************/
+//
+//
+//
+#endif
+
+

App/APP_WU/Inc/apps_var_def.h

@@ -0,0 +1,311 @@
+#ifndef _APPS_VAR_DEF_H_
+#define _APPS_VAR_DEF_H_
+//此文件用于汇总变量类型
+
+#include "stdint.h"
+#include "data_type_def.h"
+
+typedef enum
+{
+    SIG_CURRENT = 0,            //电流
+    SIG_VOLTAGE,                //电压
+    SIG_RESISTANT,              //电阻
+    SIG_FREQUENCE,              //频率
+    SIG_TC,                     //热电偶
+    SIG_RTD                     //热电阻
+}SIG_FUNCTIONS;
+
+typedef enum
+{
+    CURRENT_MA = 0,             //电流mA
+    VOLTAGE_V,                  //电压V
+    VOLTAGE_MV,                 //电压mV
+    RESISTANT_OHM,              //电阻Ω
+    FREQUENCE_KHZ,              //频率KHz
+    TC_K,                       //热电偶K
+    TC_S,                       //热电偶S
+    TC_N,                       //热电偶N
+    TC_B,                       //热电偶B
+    TC_E,                       //热电偶E
+    TC_J,                       //热电偶J
+    TC_R,                       //热电偶R
+    TC_T,                       //热电偶T
+    RTD_DC                      //热电阻摄氏度
+}SIG_FUNCTIONS_TYPE;
+
+typedef struct
+{
+    SIG_FUNCTIONS tag;          //物理量标签
+    SIG_FUNCTIONS_TYPE typ;     //类型
+    int16_t up;                 //上限
+    int16_t low;                //下限
+}PHYSICAL_QUANTITY;
+
+typedef enum
+{
+    SCREEN_INIT = 0,                //起始界面，开机动画
+    SCREEN_MAIN,                    //主界面，主要功能
+    SCREEN_SETTING,                 //设置菜单
+    SCREEN_MODBUS_MASTER_CONFIG,    //modbus主模式参数配置
+    SCREEN_MODBUS_MASTER_TRX        //modbus主模式数据收发
+}SCREENS;
+
+typedef enum
+{
+    MENU_SIMPLYFY_CHINESE = 0,      //简体中文
+    MENU_ENGLISH                    //英文
+}LANGUAGES;
+
+typedef enum
+{
+    OPENNING_ANIME = 0,             //播放开机动画
+    MAIN_FUNCTION,                  //主要功能：输入&输出、曲线显示等
+    SET_ITEM_CHOOSE,                //设置菜单：选项卡选择
+    SET_CONTENT_CHOOSE,             //设置菜单：内容选择
+    SET_CONTENT_MODIFY,             //设置菜单：内容修改
+    SET_WINDOW_MODIFY,              //设置菜单，弹窗，选择与修改内容
+    SET_SHOW_LOG,                   //设置菜单：查看记录
+    SET_COMMUNICATION_SWITCH,       //通信模式切换
+    SET_COMMUNICATION_MODIFY,       //通信模式修改
+    MODBUS_MASTER_CONFIG,           //modbus主站，配置项选择
+    MODBUS_MASTER_CONFIG_MODIFY,    //modbus主站，配置项修改
+    MODBUS_MASTER_TRX,              //modbus主站收发，选项选择
+    MODBUS_MASTER_TRX_MODIFY,       //modbus主站收发，选项修改
+    PROG_OUT_CONFIG_1,              //编程输出配置页面1，输出方式、输出模式、循环次数、下一步
+    PROG_OUT_CONFIG_2,              //阶跃、三角波的参数配置界面
+    PROG_OUT_PROCESSING             //编程输出执行中
+}OPERATIONS;
+
+typedef enum
+{
+    TRANS_NONE = 0,                 //无通讯
+    TRANS_HART_TO_PC,               //HART设备->上位机     
+    TRANS_PC_TO_HART,               //上位机->HART设备
+    TRANS_BLE_TO_PC,                //蓝牙设备->上位机
+    TRANS_PC_TO_BLE,                //上位机->蓝牙设备
+    TRANS_MODBUS_PC_TO_SIG,         //MODBUS，SIG作为从设备，上位机->SIG
+    TRANS_MODBUS_SIG_TO_SLAVE       //MODBUS，SIG作为主设备，SIG->从设备
+}SIG_TRANSMISSION;
+
+typedef struct
+{
+    uint16_t lvgl_stack_consume;            //LVGL任务栈占用
+    uint16_t menu_stack_consume;            //menu任务栈占用
+    uint16_t mux_stack_consume;             //mux任务栈占用
+    uint16_t rs485_stack_consume;           //485任务栈占用
+    uint16_t hart_stack_consume;            //HART任务栈占用
+    uint16_t ble_stack_consume;             //蓝牙任务栈占用
+    uint16_t default_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 mem_consume;                    //内存使用率，0-100
+    uint8_t mem_frag;                       //内存碎片占比，0-100
+    uint8_t mem_consume_max;                //最大内存占用占用，0-100
+    uint8_t eeprom_read_error;              //eeprom读是否出现过错误
+    uint8_t eeprom_write_error;             //eeprom写是否出现过错误
+    uint8_t eeprom_current_status;          //eeprom状态
+    
+}SYSTEM_STATUS_WATCH;
+
+typedef struct
+{
+    //general
+    SCREENS scr_now;                        //当前屏幕，通过按键切换, [0->init, 1->main, 2->setting]
+    int tick_prv;                           //前一个时刻
+    int tick_cur;                           //当前时刻
+    uint8_t menu_reset_flag;                //复位标志，在keil的debug中手动写入
+
+    //screen_init
+    uint8_t scr_init_flag;                  //初始界面标志，是否播放过开机动画
+
+    //screen_main
+    uint8_t runtime_seconds;                //秒          
+    uint8_t runtime_minutes;                //分钟
+    uint8_t runtime_hours;                  //小时
+    char runtime_show[10];                  //存放运行时间转化得到的字符串
+    uint8_t battery_cnt;                    //电池计数
+    uint8_t io_cursor;                      //当前游标位置, [0000,000], 0~6整数表示7个位置
+    uint8_t io_cursor_prv;                  //前一时刻的游标位置
+    uint8_t i_numbers[7];                   //实时显示的字符，输入
+    uint8_t o_numbers[7];                   //实时显示的字符，输出
+    uint8_t io_on2off;                      //ON & OFF
+    uint8_t io_mode;                        //当前工作模式，0输入，1输出
+    SIG_FUNCTIONS input_mode;               //当前的输入模式
+    SIG_FUNCTIONS_TYPE input_mode_type;     //当前输入模式的类型
+    SIG_FUNCTIONS output_mode;              //当前的输出模式
+    SIG_FUNCTIONS_TYPE output_mode_type;    //当前输出模式的类型
+
+    uint8_t sign_flag_in;                   //输入信号符号位标志，0->不显示，1->显示负号
+    uint8_t sign_flag_out;                  //输出信号符号位标志，0->不显示，1->显示负号
+
+    //screen_setting
+   
+}MENU_DATA;
+
+typedef struct
+{
+    //lv_chart_set_range(ui->screen_main_chart_1, LV_CHART_AXIS_PRIMARY_Y, y_pri_low, y_pri_up);
+    uint8_t y_pri_up;                       //纵轴（主）上限，一般不做修改
+    uint8_t y_pri_low;                      //纵轴（主）下限，一般不做修改
+    int16_t yreal_pri_up;                   //实际值y上限
+    int16_t yreal_pri_low;                  //实际值y下限
+
+    //lv_chart_set_range(ui->screen_main_chart_1, LV_CHART_AXIS_SECONDARY_Y, y_scd_low, y_scd_up);
+    uint8_t y_scd_up;                       //纵轴（副）上限，一般不做修改
+    uint8_t y_scd_low;                      //纵轴（副）下限，一般不做修改
+    int16_t yreal_scd_up;                   //实际值y上限
+    int16_t yreal_scd_low;                  //实际值y下限
+
+    //lv_chart_set_next_value(ui->screen_main_chart_1, ui->screen_main_chart_1_0, 1);
+    uint8_t pri_wait_tick;                  //主轴等待滴答数，一段时间没变化后不更新曲线
+    uint8_t y_pri_value;                    //0号曲线的下一个点，主y轴
+    uint8_t y_pri_value_prv;                //前一时刻的点，用于判断是否需要更新内容
+    float32 yreal_pri_value;                //0号曲线的下一个实际值
+
+    //lv_chart_set_next_value(ui->screen_main_chart_1, ui->screen_main_chart_1_1, 1);
+    uint8_t scd_wait_tick;                  //副轴等待滴答数，一段时间没变化后不更新曲线
+    uint8_t y_scd_value;                    //1号曲线的下一个点，副y轴
+    uint8_t y_scd_value_prv;                //前一时刻的点，用于判断是否需要更新内容
+    float32 yreal_scd_value;                //1号曲线的下一个实际值
+    float32 yreal_scd_value_prv;            //前一时刻的点，用于判断是否需要更新内容
+
+}PLOT_DATA;
+
+//设置菜单界面的左列选项卡，从上至下
+typedef enum
+{
+    ITEM_0 = 0,     
+    ITEM_1,
+    ITEM_2,
+    ITEM_3,
+    ITEM_NONE
+}ITEMS;
+
+//设置菜单各个选项卡item的内容
+typedef enum
+{
+    //ITEM_0
+    VOL_UNIT_SET = 0,
+    VOL_UP_SET,
+    VOL_LOW_SET,
+    CURRENT_UP_SET,
+    CURRENT_LOW_SET,
+    RES_UP_SET,
+    RES_LOW_SET,
+    FRE_UP_SET,
+    FRE_LOW_SET,
+    TC_TYPE_SET,
+    TC_UP_SET,
+    TC_LOW_SET,
+    RTD_UP_SET,
+    RTD_LOW_SET,
+    PAGE_PV_ITEM_0,
+
+    //ITEM_1
+    SAMPLE_INTERVAL,
+    PLOT_NUM,
+    INPUT_COLOR,
+    OUTPUT_COLOR,
+    PAGE_PV_ITEM_1,
+
+    //ITEM_2
+    INPUT_LOG,
+    OUTPUT_LOG,
+    COMMUNICATION,
+    PROGRAM_OUTPUT,
+    PAGE_PV_ITEM_2,
+
+    //ITEM_3
+    LIGHT_STATUS,
+    LANGUAGE_SELECT,
+    DATA_SAVE,
+    DATA_RESET,
+    PAGE_PV_ITEM_3,
+
+    //general
+    CONTENT_EMPTY
+}ITEM_CONTENTS;
+
+//主界面chart的曲线备选颜色
+typedef enum
+{
+    COLOR_BLUE = 0,     
+    COLOR_DARK_BLUE,
+    COLOR_YELLOW,
+    COLOR_GREEN,
+    COLOR_RED,
+    COLOR_PURPLE,
+    COLOR_BLACK
+}COLORS;
+
+//SIG在modbus功能中的模式，主或从
+typedef enum
+{
+    SIG_SLAVE = 0,
+    SIG_MASTER
+}SIG_MODBUS_TYPE;
+
+typedef struct
+{
+    ITEMS item_cursor;                      //选项卡游标，后续根据实际需求进行宏定义
+    ITEMS item_cursor_prv;                  //前一时刻的选项卡游标
+    uint8_t item_page;                      //当前页
+    uint8_t item_page_prv;                  //前一页
+    uint8_t content_cursor;                 //内容右侧一列的游标，范围0~5，6个组件之间跳转
+    uint8_t content_cursor_prv;             //前一时刻的内部游标
+    uint8_t content_focus;                  //内容焦点
+    ITEM_CONTENTS current_content;          //当前指向内容
+
+    //ITEMS_0
+    SIG_FUNCTIONS_TYPE item0_page0_vunit;   //电压单位
+    int16_t item0_page0_vup[2];             //电压上限, 0:V，1:mV
+    int16_t item0_page0_vlow[2];            //电压下限, 0:V，1:mV
+    uint8_t item0_page0_cup;                //电流上限
+    uint8_t item0_page0_clow;               //电流下限
+    int16_t item0_page0_rup;                //电阻上限
+    int16_t item0_page1_rlow;               //电阻下限
+    uint8_t item0_page1_fup;                //频率上限
+    uint8_t item0_page1_flow;               //频率下限
+    SIG_FUNCTIONS_TYPE item0_page1_TCtype;  //热电偶类型
+    int16_t item0_page1_TCup[8];            //热电偶上限
+    int16_t item0_page1_TClow[8];           //热电偶下限
+    int16_t item0_page2_RTDup;              //热电阻上限
+    int16_t item0_page2_RTDlow;             //热电阻下限
+
+    //ITEMS_1
+    uint16_t item1_page0_sample_interval;   //采样间隔ms
+    uint8_t item1_page0_plot_num;           //曲线上显示的点数
+    COLORS item1_page0_color_input;         //输出曲线及其图例的颜色
+    COLORS item1_page0_color_output;        //输出曲线及其图例的颜色
+
+    //ITEMS_2
+    char log_time[60][10];                  //输入&输出记录，时间戳
+    float32 input_log_value[60];            //输入记录，实际值
+    SIG_FUNCTIONS_TYPE input_log_unit[60];  //输入记录，单位
+    float32 output_log_value[60];           //输出记录，实际值
+    SIG_FUNCTIONS_TYPE output_log_unit[60]; //输出记录，单位
+    uint8_t hart_enable;                    //HART透传使能
+    uint8_t bluetooth_enable;               //蓝牙透传使能
+    uint8_t modbus_enable;                  //MODBUS使能
+    SIG_MODBUS_TYPE modbus_type;            //SIG在modbus中作为主或从
+    uint8_t modbus_master_send_flag;        //发送标志
+    
+    //ITEMS_3
+    uint8_t item3_page0_lightflag;          //照明状态标志，0熄灭，1开启
+    LANGUAGES item3_page0_language;           //语言类型
+    uint8_t item3_page0_saveflag;           //[0, 1,2 ] -> [未保存，保存中，已保存]
+    uint8_t item3_page0_resetflag;          //[0, 1,2 ] -> [未复位，复位中，已复位]
+
+}TABVIEW_DATA;
+
+#endif

App/APP_WU/Inc/key_functions.h

@@ -0,0 +1,70 @@
+#ifndef _KEY_FUNCTIONS_H_
+#define _KEY_FUNCTIONS_H_
+
+#include "apps_gather.h"
+
+typedef enum
+{
+    KEY_OUT = 0,                //输出
+    KEY_UP,                     //上
+    KEY_MENU,                   //菜单
+    KEY_IN,                     //输入
+    KEY_LEFT,                   //左
+    KEY_OK,                     //OK，确认
+    KEY_RIGHT,                  //右
+    KEY_SWITCH,                 //二级菜单，切换输出&输入类型
+    KEY_SOURCE,                 //闲置，预留
+    KEY_DOWN,                   //下
+    KEY_BACK,                   //返回
+    KEY_NONE,                   //空闲
+    KEY_ALL                     //全选
+}KEYS_TAG;
+
+//tm1650扫描得到的原始键值
+typedef enum
+{
+    KEY_OUT_VAL = 76,
+    KEY_UP_VAL = 84,
+    KEY_MENU_VAL = 68,
+    KEY_IN_VAL = 78,
+    KEY_LEFT_VAL = 77,
+    KEY_OK_VAL = 85,
+    KEY_RIGHT_VAL = 94,
+    KEY_SWITCH_VAL = 69,
+    KEY_SOURCE_VAL = 111,
+    KEY_DOWN_VAL = 86,
+    KEY_BACK_VAL = 70,
+    KEY_NONE_VAL = 0,
+    KEY_ALL_VAL = 250
+}KEYS_VALUE;
+
+typedef enum
+{
+    KEY_STATUS_DISABLE = 0,
+    KEY_STATUS_ENABLE
+}KEYS_STATUS;
+
+typedef struct
+{
+    KEYS_TAG tag;
+    KEYS_VALUE value;
+    KEYS_STATUS status;
+}KEYS;
+
+extern KEYS key_pv;                //当前按键
+extern KEYS_STATUS key_sts[11];    //11个按键的状态，排列顺序与枚举顺序一致
+
+//按键数据类型转换
+void key_char2struct(void);
+
+//按键状态配置
+void key_config(KEYS_TAG key_t, KEYS_STATUS sts);
+
+//按键配置更新
+void key_config_update(OPERATIONS ope);
+
+
+
+#endif
+
+

App/APP_WU/Inc/key_functions_main.h

@@ -0,0 +1,9 @@
+#ifndef _KEY_FUNCTIONS_MAIN_H_
+#define _KEY_FUNCTIONS_MAIN_H_
+
+#include "apps_gather.h"
+
+//按键功能，主界面
+void key_functions_main(void);
+
+#endif

App/APP_WU/Inc/key_functions_modbus.h

@@ -0,0 +1,15 @@
+#ifndef _KEY_FUNCTIONS_MODBUS_H_
+#define _KEY_FUNCTIONS_MODBUS_H_
+
+#include "apps_gather.h"
+
+//Modbus配置界面，弹窗内部游标移动
+void cursor_move(int8_t step);
+
+extern uint8_t window_config_num[4];
+extern uint8_t window_config_cursor; 
+extern uint8_t window_config_cursor_prv;
+extern uint8_t window_trx_focus;
+extern uint8_t window_trx_num[32];
+
+#endif

App/APP_WU/Inc/key_functions_setting.h

@@ -0,0 +1,9 @@
+#ifndef _KEY_FUNCTIONS_SETTING_H_
+#define _KEY_FUNCTIONS_SETTING_H_
+
+#include "apps_gather.h"
+
+//按键功能，详细设置菜单界面
+void key_functions_setting(void); 
+
+#endif

App/APP_WU/Inc/scr_setting_item_text.h

@@ -0,0 +1,10 @@
+#ifndef _SCR_SETTING_ITEM_TEXT_H_
+#define _SCR_SETTING_ITEM_TEXT_H_
+
+#include "apps_gather.h"
+
+
+
+#endif
+
+

App/APP_WU/Inc/scr_setting_item_value.h

@@ -0,0 +1,24 @@
+#ifndef _SCR_SETTING_ITEM_VALUE_H_
+#define _SCR_SETTING_ITEM_VALUE_H_
+
+#include "apps_gather.h"
+
+#define LIGHT_ON HAL_GPIO_WritePin(light_GPIO_Port, light_Pin, GPIO_PIN_SET)
+
+#define LIGHT_OFF HAL_GPIO_WritePin(light_GPIO_Port, light_Pin, GPIO_PIN_RESET)
+
+#define SAMPLE_INTERVAL_MAX 10000
+
+#define PLOT_NUM_MIN 3
+#define PLOT_NUM_MAX 20
+
+//查看输入输出记录，io -> 输入/输出，page -> 指定页码
+void show_IO_log(uint8_t io, uint8_t page);
+
+//显示时间戳、物理量单位、数值
+void show_time_unit_value(lv_obj_t *obj_left, lv_obj_t *obj_right, uint8_t io, uint8_t cur);
+
+
+#endif
+
+

App/APP_WU/Inc/scr_setting_progam_out.h

@@ -0,0 +1,112 @@
+#ifndef _SCR_SETTING_PROGRAM_OUT_H_
+#define _SCR_SETTING_PROGRAM_OUT_H_
+
+#include "apps_gather.h"
+
+//输出方式
+#define PROG_OUT_V 0
+#define PROG_OUT_MA 1
+
+//输出模式
+#define PROG_OUT_STEP 0
+#define PROG_OUT_TRIANGLE 1
+
+//最大循环次数
+#define CIRCULATIONS_MAX 10
+
+//三角波每个周期的间隔数量
+#define TRIANLE_PLOT_INTERVAL_MAX 20
+
+//CONFIG1
+#define CONF1_OUTPUT_UNIT 0
+#define CONF1_OUTPUT_MODE 1
+#define CONF1_CIRCULATIONS 2
+#define CONF1_NEXT 3
+
+//CONFIG2_STEP
+#define CONF2_OUTPUT_MODE 0
+#define CONF2_START_PERCENT 1
+#define CONF2_END_PERCENT 2
+#define CONF2_STEP_PERCENT 3
+#define CONF2_HOLD_TIME 4
+#define CONF2_RISING_PERCENT 5
+#define CONF2_FALLING_PERCENT 6
+#define CONF2_PERIOD 7
+
+typedef enum
+{
+    PROGOUT_WAITING = 0,
+    PROGOUT_START,
+    PROGOUT_RUNNING,
+    PROGOUT_PAUSE,
+    PROGOUT_END
+}PROGRAM_OUT_PROCESS;
+
+typedef struct
+{
+    uint8_t output_unit;            //输出信号的物理量单位，mA、V
+    uint8_t output_mode;            //输出模式，阶跃、三角波
+    uint8_t circulations;           //循环次数，1-10、无穷
+    uint16_t hold_time;             //阶跃保持时间，开始和结束的等待时间
+    uint8_t start_percent;          //起点百分比
+    uint8_t end_percent;            //终点百分比
+    uint8_t step_percent;           //步长百分比
+    uint8_t rising_percent;         //三角波爬升占比
+    uint8_t falling_percent;        //三角波下降占比
+    uint16_t period;                //三角波周期
+
+    PROGRAM_OUT_PROCESS process;    //过程，当前处于哪一步
+    int16_t out_max;                //输出物理量的实际值上限
+    int16_t out_min;                //输出物理量的实际值下限
+    uint8_t out_percent;            //当前输出百分比
+
+    int progout_tick_flag;          //计时标志，1：定时器计时，0：暂停计时    
+    int progout_tick;               //计时计数，正常情况下不会溢出
+}PROGRAM_OUT_DATA;
+
+extern PROGRAM_OUT_DATA progout_data;
+extern uint8_t cursor_conf1;
+extern uint8_t cursor_conf1_prv;
+extern uint8_t cursor_conf2;
+extern uint8_t cursor_conf2_prv;
+
+//初始化相关参数
+void program_out_init(void);
+
+//初始化config1界面
+void program_out_config1(void);
+
+//更新config1右列文本内容
+void text_update_conf1(uint8_t con);
+
+//修改config1右列值
+void val_modify_conf1(int8_t step);
+
+//初始化config2界面
+void program_out_config2(void);
+
+//更新config2右列文本内容
+void text_update_conf2(uint8_t con);
+
+//修改config2右列值
+void val_modify_conf2(int8_t step);
+
+//执行编程输出流程
+void program_out_run(void);
+
+//执行编程输出，阶跃
+void program_out_step(void);
+
+//执行编程输出，三角波
+void program_out_triangle(void);
+
+//置于mux任务内，实时性更强
+void running_process_step(void);
+
+//置于mux任务内，实时性更强
+void running_process_triangle(void);
+
+//百分比转化为数值输出, perc:[0, 100]
+void percent2val_out(float32 perc);
+
+#endif

App/APP_WU/Inc/scr_setting_text.h

@@ -0,0 +1,49 @@
+#ifndef _SCR_SETTING_TEXT_H_
+#define _SCR_SETTING_TEXT_H_
+
+#include "apps_gather.h"
+
+#define TEXT_LENGTH_MAX 20
+#define ITEM_NUM_MAX 4
+#define ITEM0_CONTENT_MAX 14
+#define ITEM1_CONTENT_MAX 4
+#define ITEM2_CONTENT_MAX 4
+#define ITEM2_COMMUNICATION_MAX 4
+#define ITEM2_COMMUNICATION_VALUE_MAX 4
+#define ITEM2_PROGRAM_OUT_CONFIG1_MAX 4
+#define ITEM2_PROGRAM_OUT_CONFIG1_VALUE_MAX 2
+#define ITEM2_PROGRAM_OUT_CONFIG2_MAX 8
+#define ITEM3_CONTENT_MAX 4
+#define ITEM3_CONTENT_VAL_MAX 10
+#define MODBUS_MASTER_CONFIG_ITEM_MAX 8
+#define MODBUS_MASTER_TRX_ITEM_MAX 4
+
+typedef struct
+{
+    char title[TEXT_LENGTH_MAX];
+    char items[ITEM_NUM_MAX][TEXT_LENGTH_MAX];
+    char item_0[ITEM0_CONTENT_MAX][TEXT_LENGTH_MAX];
+    char item_1[ITEM1_CONTENT_MAX][TEXT_LENGTH_MAX];
+    char item_2[ITEM2_CONTENT_MAX][TEXT_LENGTH_MAX];
+    char item_2_com[ITEM2_COMMUNICATION_MAX][TEXT_LENGTH_MAX];
+    char item_2_com_val[ITEM2_COMMUNICATION_VALUE_MAX][TEXT_LENGTH_MAX];
+    char item_3[ITEM3_CONTENT_MAX][TEXT_LENGTH_MAX];
+    char item_3_val[ITEM3_CONTENT_VAL_MAX][TEXT_LENGTH_MAX];
+
+    char modbus_master_title[TEXT_LENGTH_MAX];
+    char modbus_master_item[MODBUS_MASTER_CONFIG_ITEM_MAX][TEXT_LENGTH_MAX];
+    char modbus_master_trx_item[MODBUS_MASTER_TRX_ITEM_MAX][TEXT_LENGTH_MAX];
+    
+    char program_out_config1[ITEM2_PROGRAM_OUT_CONFIG1_MAX][TEXT_LENGTH_MAX];
+    char program_out_config1_val[ITEM2_PROGRAM_OUT_CONFIG1_VALUE_MAX][TEXT_LENGTH_MAX];
+    char program_out_config2[ITEM2_PROGRAM_OUT_CONFIG2_MAX][TEXT_LENGTH_MAX];
+}SETTING_TEXT;
+
+extern SETTING_TEXT text_pack;
+
+//设置界面语言切换
+void setting_laguage_switch(LANGUAGES lan);
+
+#endif
+
+

App/APP_WU/Inc/timer.h

@@ -0,0 +1,27 @@
+#ifndef _TIMER_H_
+#define _TIMER_H_
+
+#include "apps_gather.h"
+
+extern int heart_1000ms_flag;
+extern int heart_1000ms_cnt;
+extern int battery_2000ms_flag;
+extern int battery_2000ms_cnt;
+extern int plot_ms_flag;
+extern int plot_ms_cnt;
+extern int twk_1000ms_flag;
+extern int twk_1000ms_cnt;
+extern int input_500ms_flag;
+extern uint16_t sig2slave_current_tick;
+
+void duty_tim3(void);
+void duty_tim6(void);
+
+void delay_cnt(uint16_t cnt);
+void systick_delay_us(__IO uint32_t delay);
+
+
+
+#endif
+
+

App/APP_WU/Src/app_screen_modbus.c

@@ -0,0 +1,720 @@
+#include "app_screen_modbus.h"
+
+lv_obj_t *lvobj_window_trx_nums[32];
+
+//modbus配置项的游标
+MOD_CONF_ITEMS mod_mas_conf_cursor = MOD_CONF_SLAVE_ID;     
+MOD_CONF_ITEMS mod_mas_conf_cursor_prv = MOD_CONF_NONE;
+uint8_t config_focus = 0;
+
+//modbus收发界面的选项游标
+MOD_TRX_ITEMS mod_mas_trx_cursor = MOD_TRX_PREVIOUS;
+MOD_TRX_ITEMS mod_mas_trx_cursor_prv = MOD_TRX_NONE;
+uint8_t trx_focus = 0;
+
+void config_items_set_color(MOD_CONF_ITEMS cur, uint32_t color)
+{
+    switch (cur)
+    {
+        case MOD_CONF_SLAVE_ID:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_device_addr, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_START_ADDRESS:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_start_addr, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_BYTES:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_bytes, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_TIMEOUT:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_timeout, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_COMMAND:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_cmd, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_REGISTER_NUM:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_register_num, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_CALIBRATION:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_calibration, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_CONF_NEXT:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_next, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void config_items_check(MOD_CONF_ITEMS cur, MOD_CONF_ITEMS cur_prv)
+{
+    uint32_t color = 0;
+    if(config_focus == 1)
+    {
+        color = COLOR_CONTENTS_FOCUSED;
+    }
+    else
+    {
+        color = COLOR_CONTENTS_CHECKED;
+    }
+
+    //点亮cur
+    config_items_set_color(cur, color);
+
+    //熄灭cur——prv
+    config_items_set_color(cur_prv, COLOR_ITEMS_UNCHECKED);
+}
+
+void config_window_num_check(uint8_t cur, uint8_t cur_prv)
+{
+    switch (cur)
+    {
+        case 0:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_0, lv_color_hex(COLOR_CONTENTS_CHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case 1:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_1, lv_color_hex(COLOR_CONTENTS_CHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case 2:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_2, lv_color_hex(COLOR_CONTENTS_CHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case 3:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_3, lv_color_hex(COLOR_CONTENTS_CHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+    
+        default:
+        break;
+    }
+
+    switch (cur_prv)
+    {
+        case 0:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_0, lv_color_hex(COLOR_CONTENTS_UNCHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case 1:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_1, lv_color_hex(COLOR_CONTENTS_UNCHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case 2:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_2, lv_color_hex(COLOR_CONTENTS_UNCHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case 3:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_num_3, lv_color_hex(COLOR_CONTENTS_UNCHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void config_window_num_set(uint8_t pos, uint8_t num)
+{
+    char str_temp[8] = {0};
+
+    if( num < 16 ) 
+    {
+        sprintf(str_temp, "%x", num);
+    }
+    else if (num == 20)
+    {
+        strcpy(str_temp, "0");
+    }
+    else if (num == 21)
+    {
+        strcpy(str_temp, "x");
+    }
+    else
+    {
+        strcpy(str_temp, "-");
+    }
+
+    switch (pos)
+    {
+        case 0:
+        {
+            lv_label_set_text(guider_ui.screen_modbus_config_num_0, str_temp);
+        }
+        break;
+
+        case 1:
+        {
+            lv_label_set_text(guider_ui.screen_modbus_config_num_1, str_temp);
+        }
+        break;
+
+        case 2:
+        {
+            lv_label_set_text(guider_ui.screen_modbus_config_num_2, str_temp);
+        }
+        break;
+
+        case 3:
+        {
+            lv_label_set_text(guider_ui.screen_modbus_config_num_3, str_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void config_window_update(void)
+{
+    switch (mod_mas_conf_cursor)
+    {
+        case MOD_CONF_SLAVE_ID:
+        {
+            //前两位显示“0x”，游标从3开始，2-3
+            window_config_num[0] = 20;
+            window_config_num[1] = 21;
+            window_config_num[2] = mod_master.target_id >> 4;
+            window_config_num[3] = mod_master.target_id & 0x0F;
+            for(uint8_t i = 0; i < 4; i++)
+            {
+                config_window_num_set(i, window_config_num[i]);
+            }
+            window_config_cursor = 3;
+            window_config_cursor_prv = 99;
+            config_window_num_check(window_config_cursor, window_config_cursor_prv);
+
+            lv_obj_clear_flag(guider_ui.screen_modbus_config_window_config, LV_OBJ_FLAG_HIDDEN);
+        }
+        break;
+
+        case MOD_CONF_START_ADDRESS:
+        {
+            //游标从3开始，0-3
+            window_config_num[0] = 0x000F & (mod_master.start_address >> 12);
+            window_config_num[1] = 0x000F & (mod_master.start_address >> 8);
+            window_config_num[2] = 0x000F & (mod_master.start_address >> 4);
+            window_config_num[3] = 0x000F & (mod_master.start_address );
+            for(uint8_t i = 0; i < 4; i++)
+            {
+                config_window_num_set(i, window_config_num[i]);
+            }
+            window_config_cursor = 3;
+            window_config_cursor_prv = 99;
+            config_window_num_check(window_config_cursor, window_config_cursor_prv);
+
+            lv_obj_clear_flag(guider_ui.screen_modbus_config_window_config, LV_OBJ_FLAG_HIDDEN);
+        }
+        break;
+
+        case MOD_CONF_COMMAND:
+        {
+            //前两位显示“0x”，游标从3开始，2-3
+            window_config_num[0] = 20;
+            window_config_num[1] = 21;
+            window_config_num[2] = mod_master.command_code >> 4;
+            window_config_num[3] = mod_master.command_code & 0x0F;
+            for(uint8_t i = 0; i < 4; i++)
+            {
+                config_window_num_set(i, window_config_num[i]);
+            }
+            window_config_cursor = 3;
+            window_config_cursor_prv = 99;
+            config_window_num_check(window_config_cursor, window_config_cursor_prv);
+
+            lv_obj_clear_flag(guider_ui.screen_modbus_config_window_config, LV_OBJ_FLAG_HIDDEN);
+        }
+        break;
+
+        case MOD_CONF_REGISTER_NUM:
+        {
+            //第一位显示“0”，游标从1开始，1-3
+            window_config_num[0] = 0;
+            window_config_num[1] = mod_master.register_num / 100;
+            window_config_num[2] = (mod_master.register_num / 10) % 10;
+            window_config_num[3] = mod_master.register_num % 10;
+            for(uint8_t i = 0; i < 4; i++)
+            {
+                config_window_num_set(i, window_config_num[i]);
+            }
+            window_config_cursor = 3;
+            window_config_cursor_prv = 99;
+            config_window_num_check(window_config_cursor, window_config_cursor_prv);
+
+            lv_obj_clear_flag(guider_ui.screen_modbus_config_window_config, LV_OBJ_FLAG_HIDDEN);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void config_window2value(void)
+{
+    char str_temp[16];
+
+    switch (mod_mas_conf_cursor)
+    {
+        case MOD_CONF_SLAVE_ID:
+        {
+            mod_master.target_id = window_config_num[2] & 0x0F;
+            mod_master.target_id <<= 4;
+            mod_master.target_id += window_config_num[3] & 0x0F;
+
+            sprintf(str_temp, "0x%02x", mod_master.target_id);
+            lv_label_set_text(guider_ui.screen_modbus_config_value_device_addr, str_temp);
+        }
+        break;
+
+        case MOD_CONF_START_ADDRESS:
+        {
+            mod_master.start_address = window_config_num[0] & 0x0F;
+            mod_master.start_address <<= 4;
+            mod_master.start_address += window_config_num[1] & 0x0F;
+            mod_master.start_address <<= 4;
+            mod_master.start_address += window_config_num[2] & 0x0F;
+            mod_master.start_address <<= 4;
+            mod_master.start_address += window_config_num[3] & 0x0F;
+
+            sprintf(str_temp, "0x%04x", mod_master.start_address);
+            lv_label_set_text(guider_ui.screen_modbus_config_value_start_addr, str_temp);
+        }
+        break;
+
+        case MOD_CONF_COMMAND:
+        {
+            mod_master.command_code= window_config_num[2];
+            mod_master.command_code <<= 4;
+            mod_master.command_code += window_config_num[3];
+
+            sprintf(str_temp, "0x%02x", mod_master.command_code);
+            lv_label_set_text(guider_ui.screen_modbus_config_value_cmd, str_temp);
+        }
+        break;
+
+        case MOD_CONF_REGISTER_NUM:
+        {
+            mod_master.register_num = window_config_num[1]*100 + window_config_num[2]*10 + window_config_num[3];
+
+            sprintf(str_temp, "%d", mod_master.register_num);
+            lv_label_set_text(guider_ui.screen_modbus_config_value_register_num, str_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//打开trx弹窗后，初始化显示内容
+void trx_window_init(void)
+{
+    //界面切换时会删除下列对象，因此每次打开弹窗时都应该执行下列操作
+    lvobj_window_trx_nums[0] = guider_ui.screen_modbus_trx_num_00;
+    lvobj_window_trx_nums[1] = guider_ui.screen_modbus_trx_num_01;
+    lvobj_window_trx_nums[2] = guider_ui.screen_modbus_trx_num_02;
+    lvobj_window_trx_nums[3] = guider_ui.screen_modbus_trx_num_03;
+    lvobj_window_trx_nums[4] = guider_ui.screen_modbus_trx_num_04;
+    lvobj_window_trx_nums[5] = guider_ui.screen_modbus_trx_num_05;
+    lvobj_window_trx_nums[6] = guider_ui.screen_modbus_trx_num_06;
+    lvobj_window_trx_nums[7] = guider_ui.screen_modbus_trx_num_07;
+    lvobj_window_trx_nums[8] = guider_ui.screen_modbus_trx_num_10;
+    lvobj_window_trx_nums[9] = guider_ui.screen_modbus_trx_num_11;
+    lvobj_window_trx_nums[10] = guider_ui.screen_modbus_trx_num_12;
+    lvobj_window_trx_nums[11] = guider_ui.screen_modbus_trx_num_13;
+    lvobj_window_trx_nums[12] = guider_ui.screen_modbus_trx_num_14;
+    lvobj_window_trx_nums[13] = guider_ui.screen_modbus_trx_num_15;
+    lvobj_window_trx_nums[14] = guider_ui.screen_modbus_trx_num_16;
+    lvobj_window_trx_nums[15] = guider_ui.screen_modbus_trx_num_17;
+    lvobj_window_trx_nums[16] = guider_ui.screen_modbus_trx_num_20;
+    lvobj_window_trx_nums[17] = guider_ui.screen_modbus_trx_num_21;
+    lvobj_window_trx_nums[18] = guider_ui.screen_modbus_trx_num_22;
+    lvobj_window_trx_nums[19] = guider_ui.screen_modbus_trx_num_23;
+    lvobj_window_trx_nums[20] = guider_ui.screen_modbus_trx_num_24;
+    lvobj_window_trx_nums[21] = guider_ui.screen_modbus_trx_num_25;
+    lvobj_window_trx_nums[22] = guider_ui.screen_modbus_trx_num_26;
+    lvobj_window_trx_nums[23] = guider_ui.screen_modbus_trx_num_27;
+    lvobj_window_trx_nums[24] = guider_ui.screen_modbus_trx_num_30;
+    lvobj_window_trx_nums[25] = guider_ui.screen_modbus_trx_num_31;
+    lvobj_window_trx_nums[26] = guider_ui.screen_modbus_trx_num_32;
+    lvobj_window_trx_nums[27] = guider_ui.screen_modbus_trx_num_33;
+    lvobj_window_trx_nums[28] = guider_ui.screen_modbus_trx_num_34;
+    lvobj_window_trx_nums[29] = guider_ui.screen_modbus_trx_num_35;
+    lvobj_window_trx_nums[30] = guider_ui.screen_modbus_trx_num_36;
+    lvobj_window_trx_nums[31] = guider_ui.screen_modbus_trx_num_37;
+
+    char str_temp[8];
+    for(uint8_t i = 0; i < 32; i++)
+    {
+        if(window_trx_num[i] == 16)
+        {
+            lv_label_set_text(lvobj_window_trx_nums[i], "-");
+        }
+        else
+        {
+            sprintf(str_temp, "%x", window_trx_num[i]);
+            lv_label_set_text(lvobj_window_trx_nums[i], str_temp);
+        }
+    }
+    
+}
+
+void trx_items_set_color(MOD_TRX_ITEMS cur, uint32_t color)
+{
+    switch (cur)
+    {
+        case MOD_TRX_DATA:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_value_Data, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_TRX_PREVIOUS:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_label_previous, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_TRX_SET:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_label_set, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+
+        case MOD_TRX_SEND:
+        {
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_label_send, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void trx_items_check(MOD_TRX_ITEMS cur, MOD_TRX_ITEMS cur_prv)
+{
+    uint32_t color = 0;
+    if(trx_focus == 1)
+    {
+        color = COLOR_CONTENTS_FOCUSED;
+    }
+    else
+    {
+        color = COLOR_CONTENTS_CHECKED;
+    }
+
+    //点亮cur
+    trx_items_set_color(cur, color);
+
+    //熄灭cur——prv
+    trx_items_set_color(cur_prv, COLOR_ITEMS_UNCHECKED);
+}
+
+void trx_set_window_num_color(uint8_t cur, uint32_t color)
+{
+    //设备底色的接口函数数据类型不一样，用lvobj_window_trx_nums[i]循环会进入硬件错误中断
+
+    switch (cur)
+    {
+        case 0:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_00, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 1:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_01, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 2:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_02, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 3:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_03, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 4:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_04, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 5:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_05, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 6:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_06, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 7:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_07, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 8:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_10, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 9:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_11, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 10:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_12, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 11:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_13, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 12:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_14, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 13:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_15, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 14:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_16, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 15:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_17, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 16:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_20, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 17:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_21, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 18:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_22, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 19:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_23, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 20:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_24, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 21:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_25, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 22:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_26, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 23:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_27, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 24:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_30, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 25:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_31, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 26:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_32, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 27:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_33, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 28:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_34, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 29:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_35, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 30:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_36, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+
+        case 31:
+            lv_obj_set_style_bg_color(guider_ui.screen_modbus_trx_num_37, lv_color_hex(color), LV_PART_MAIN|LV_STATE_DEFAULT);
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void trx_window_num_check(uint8_t cur, uint8_t cur_prv)
+{
+    if(window_trx_focus == 1)
+    {
+        trx_set_window_num_color(cur, COLOR_CONTENTS_FOCUSED);
+    }
+    else
+    {
+        trx_set_window_num_color(cur, COLOR_CONTENTS_CHECKED);
+    }
+
+    trx_set_window_num_color(cur_prv, COLOR_CONTENTS_UNCHECKED);
+}
+
+void trx_window_num2val(void)
+{
+    //初次打开trx界面的弹窗时，所有的位置均为“-”。
+    //从左往右，从上往下，以第一个出现的“-”作为终止位
+    uint8_t val_len = 0;
+    char str0[10] = {0};
+    char str_temp[150] = {0};
+
+    //从第0个开始，寻找终止位
+    for(uint8_t i = 0; i < 32; i++)
+    {
+        //[0,15]为十六进制单字符，16规定为“-”
+        if( window_trx_num[i] == 16 )
+        {
+            if( i % 2 )
+            {   //[][][]...[x,-]，“-”在奇数位，置零
+                window_trx_num[i] = 0;
+                val_len = (i+1)/2;
+            }
+            else
+            {
+                val_len = i/2;
+            }
+            
+            for(uint8_t j = 0; j < val_len; j++)
+            {
+                mod_master.data_tx_value[j] = window_trx_num[2*j];
+                mod_master.data_tx_value[j] <<= 4;
+                mod_master.data_tx_value[j] += window_trx_num[2*j + 1]&0x0F;
+            }
+
+            break;
+        }
+    }
+
+    //在Data窗格内显示mod_master.data_tx_value
+    for(uint8_t k = 0; k < val_len; k++)
+    {
+        sprintf(str0, "%02x ", mod_master.data_tx_value[k]);
+        strcat(str_temp, str0);
+    }
+    lv_label_set_text(guider_ui.screen_modbus_trx_value_Data, str_temp);
+}
+
+void scr_modbus_config_recover(void)
+{
+    //标题
+    lv_label_set_text(guider_ui.screen_modbus_config_label_title, text_pack.modbus_master_title);
+
+    //左列名称
+    lv_label_set_text(guider_ui.screen_modbus_config_label_device_addr, text_pack.modbus_master_item[0]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_start_addr, text_pack.modbus_master_item[1]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_bytes, text_pack.modbus_master_item[2]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_timeout, text_pack.modbus_master_item[3]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_cmd, text_pack.modbus_master_item[4]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_register_num, text_pack.modbus_master_item[5]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_calibration, text_pack.modbus_master_item[6]);
+    lv_label_set_text(guider_ui.screen_modbus_config_label_next, text_pack.modbus_master_item[7]);
+
+    char str_temp[16];
+    //右列值
+    sprintf(str_temp, "0x%02x", mod_master.target_id);
+    lv_label_set_text(guider_ui.screen_modbus_config_value_device_addr, str_temp);
+    sprintf(str_temp, "0x%04x", mod_master.start_address);
+    lv_label_set_text(guider_ui.screen_modbus_config_value_start_addr, str_temp);
+    sprintf(str_temp, "%d", mod_master.byte_num);
+    lv_label_set_text(guider_ui.screen_modbus_config_value_bytes, str_temp);
+    sprintf(str_temp, "%d", mod_master.timeout);
+    lv_label_set_text(guider_ui.screen_modbus_config_value_timeout, str_temp);
+    sprintf(str_temp, "0x%02x", mod_master.command_code);
+    lv_label_set_text(guider_ui.screen_modbus_config_value_cmd, str_temp);
+    sprintf(str_temp, "%d", mod_master.register_num);
+    lv_label_set_text(guider_ui.screen_modbus_config_value_register_num, str_temp);
+    //lv_label_set_text(guider_ui.screen_modbus_config_value_calibration, );
+    //lv_label_set_text(guider_ui.screen_modbus_config_value_next, );
+
+    //配置项的游标
+    mod_mas_conf_cursor = MOD_CONF_SLAVE_ID;        
+    mod_mas_conf_cursor_prv = MOD_CONF_NONE;
+    config_items_check(mod_mas_conf_cursor, mod_mas_conf_cursor_prv);
+}
+
+void scr_modbus_trx_recover(void)
+{
+    //根据当前语言，刷新标题
+    lv_label_set_text(guider_ui.screen_modbus_trx_label_Data, text_pack.modbus_master_trx_item[0]);
+    lv_label_set_text(guider_ui.screen_modbus_trx_label_previous, text_pack.modbus_master_trx_item[1]);
+    lv_label_set_text(guider_ui.screen_modbus_trx_label_set, text_pack.modbus_master_trx_item[2]);
+    lv_label_set_text(guider_ui.screen_modbus_trx_label_send, text_pack.modbus_master_trx_item[3]);
+
+    //清空数据、发送、接收框
+    lv_label_set_text(guider_ui.screen_modbus_trx_value_Data,"");
+    lv_label_set_text(guider_ui.screen_modbus_trx_value_Tx,"");
+    lv_label_set_text(guider_ui.screen_modbus_trx_value_Rx,"");
+
+    mod_mas_trx_cursor = MOD_TRX_PREVIOUS;
+    mod_mas_trx_cursor_prv = MOD_TRX_NONE;
+    trx_items_check(mod_mas_trx_cursor, mod_mas_trx_cursor_prv);
+}
+
+uint8_t trx_focus_cnt = 0;
+void screen_modbus_trx_run(void)
+{
+    //mobus收发界面，ok按下焦点后，亮一段时间后恢复原色
+    if(trx_focus)
+    {
+        trx_focus_cnt++;
+        if(trx_focus_cnt >= 2)
+        {
+            trx_focus_cnt = 0;
+            trx_focus = 0;
+            trx_items_check(mod_mas_trx_cursor, MOD_TRX_NONE);
+        }
+    }
+}

App/APP_WU/Src/apps_gather.c

@@ -0,0 +1,869 @@
+#include "apps_gather.h"    //用于头文件打包汇总，函数声明和变量定义
+// lv_conf.h { line:282->CPU&FPS; line:289->MEM used }
+
+OPERATIONS current_operation;
+PHYSICAL_QUANTITY VOL[2];                   //电压，VOL[0]-V, VOL[1]-mV
+PHYSICAL_QUANTITY CUR;                      //电流，mA
+PHYSICAL_QUANTITY RES;                      //电阻，Ω
+PHYSICAL_QUANTITY FRE;                      //频率，KHz
+PHYSICAL_QUANTITY TC[8];                    //热电偶，共8种
+PHYSICAL_QUANTITY RTD;                      //热电阻
+SYSTEM_STATUS_WATCH system_sts;             //系统状态监控
+SIG_TRANSMISSION sig_trans = TRANS_NONE;    //通讯模式
+
+// 热电偶真值表，电压mV
+// 行：[0,7]->[K, S, N, B, E, J, R, T]，列：[0,10]->[mV_Tmin,...,mV_Tmax](均分成10个间隔，11个端点)
+static float32 TC_TABLE_MV[8][11] = 
+{
+    {-6.458, -3.734, 2.354, 9.061, 15.849, 22.819, 29.757, 36.484, 42.980, 49.130, 54.886},
+    {-0.236, 0.888, 2.451, 4.184, 6.034, 7.992, 10.063, 12.228, 14.421, 16.611, 18.693},
+    {-4.345, -2.672, 1.174, 5.946, 11.428, 17.323, 23.428, 29.592, 35.714, 41.713, 47.513},
+    {0.000, 0.144, 0.647, 1.483, 2.625, 4.041, 5.702, 7.567, 9.593, 11.708, 13.820},
+    {-9.835, -7.021, -0.925, 7.066, 16.269, 26.154, 36.358, 46.624, 56.764, 66.705, 76.373},
+    {-8.095, -3.300, 3.757, 11.501, 19.311, 27.113, 35.230, 44.010, 52.996, 61.415, 69.553},
+    {-0.226, 0.895, 2.538, 4.417, 6.472, 8.685, 11.052, 13.549, 16.097, 18.654, 21.101},
+    {-6.258, -5.650, -4.324, -2.444, -0.077, 2.687, 5.812, 9.235, 12.912, 16.802, 20.872}
+};
+
+//热电偶真值表，温度℃
+// 行：[0,7]->[K, S, N, B, E, J, R, T]，列：[0,10]->[Tmin,...,Tmax](均分成10个间隔，11个端点)
+static float32 TC_TABLE_TEMP[8][11] =
+{
+    {-270.0, -105.8, 58.4, 222.6, 386.8, 551.0, 715.2, 879.4, 1043.6, 1207.8, 1372.0},
+    {-50.0, 131.8, 313.6, 495.4, 677.2, 859.0, 1040.8, 1222.6, 1404.4, 1586.2, 1768.0},
+    {-270.0, -113.0, 44.0, 201.0, 358.0, 515.0, 672.0, 829.0, 986.0, 1143.0, 1300.0},
+    {0.0, 182.0, 364.0, 546.0, 728.0, 910.0, 1092.0, 1274.0, 1456.0, 1638.0, 1820.0},
+    {-270.0, -143.0, -16.0, 111.0, 238.0, 365.0, 492.0, 619.0, 746.0, 873.0, 1000.0},
+    {-210.0, -69.0, 72.0, 213.0, 354.0, 495.0, 636.0, 777.0, 918.0, 1059.0, 1200.0},
+    {-50.0, 131.8, 313.6, 495.4, 677.2, 859.0, 1040.8, 1222.6, 1404.4, 1586.2, 1768.0},
+    {-270.0, -203.0, -136.0, -69.0, -2.0, 65.0, 132.0, 199.0, 266.0, 333.0, 400.0}
+};                                    
+
+//热电阻真值表，温度℃
+static float32 RTD_TABLE_TEMP[11] = {-200, -114, -28, 58, 144, 230, 316, 402, 488, 574, 660};
+
+//热电阻真值表，电阻Ω
+static float32 RTD_TABLE_OHM[11] = {18.52, 54.97, 89.01, 122.47, 155.08, 186.84, 217.74, 247.78, 276.97, 305.31, 332.79};
+
+//热电偶数据初始化
+void TC_init(void)
+{
+    //热电偶K
+    TC[0].tag = SIG_TC;
+    TC[0].typ = TC_K;
+    TC[0].low = TC_TABLE_TEMP[0][0];
+    TC[0].up = TC_TABLE_TEMP[0][10];
+
+    //热电偶S
+    TC[1].tag = SIG_TC;
+    TC[1].typ = TC_S;
+    TC[1].low = TC_TABLE_TEMP[1][0];
+    TC[1].up = TC_TABLE_TEMP[1][10];
+
+    //热电偶N
+    TC[2].tag = SIG_TC;
+    TC[2].typ = TC_N;
+    TC[2].low = TC_TABLE_TEMP[2][0];
+    TC[2].up = TC_TABLE_TEMP[2][10];
+
+    //热电偶B
+    TC[3].tag = SIG_TC;
+    TC[3].typ = TC_B;
+    TC[3].low = TC_TABLE_TEMP[3][0];;
+    TC[3].up = TC_TABLE_TEMP[3][10];;
+
+    //热电偶E
+    TC[4].tag = SIG_TC;
+    TC[4].typ = TC_E;
+    TC[4].low = TC_TABLE_TEMP[4][0];
+    TC[4].up = TC_TABLE_TEMP[4][10];
+
+    //热电偶J
+    TC[5].tag = SIG_TC;
+    TC[5].typ = TC_J;
+    TC[5].low = TC_TABLE_TEMP[5][0];
+    TC[5].up = TC_TABLE_TEMP[5][10];
+
+    //热电偶R
+    TC[6].tag = SIG_TC;
+    TC[6].typ = TC_R;
+    TC[6].low = TC_TABLE_TEMP[6][0];
+    TC[6].up = TC_TABLE_TEMP[6][10];
+
+    //热电偶T
+    TC[7].tag = SIG_TC;
+    TC[7].typ = TC_T;
+    TC[7].low = TC_TABLE_TEMP[7][0];
+    TC[7].up = TC_TABLE_TEMP[7][10];
+}
+
+//物理量内容初始化
+//底层数据，无法通过按键&菜单修改，用户使用时，仅修改tabdata里的变量
+void physical_quantity_init(void)
+{
+    VOL[0].tag = SIG_VOLTAGE;
+    VOL[0].typ = VOLTAGE_V;
+    VOL[0].low = 0;
+    VOL[0].up = 30;
+
+    VOL[1].tag = SIG_VOLTAGE;
+    VOL[1].typ = VOLTAGE_MV;
+    VOL[1].low = -2500;
+    VOL[1].up = 2500;
+
+    CUR.tag = SIG_CURRENT;
+    CUR.typ = CURRENT_MA;
+    CUR.low = 0;
+    CUR.up = 25;
+
+    RES.tag = SIG_RESISTANT;
+    RES.typ = RESISTANT_OHM;
+    RES.low = 0;
+    RES.up = 4000;
+
+    FRE.tag = SIG_FREQUENCE;
+    FRE.typ = FREQUENCE_KHZ;
+    FRE.low = 0;
+    FRE.up = 100;
+
+    TC_init();
+
+    RTD.tag = SIG_RTD;
+    RTD.typ = RTD_DC;
+    RTD.low = RTD_TABLE_TEMP[0];
+    RTD.up = RTD_TABLE_TEMP[10];
+}
+
+void screen_run(void)
+{
+    if(menu_data.scr_init_flag == 0)
+    {
+        //未播放过开机动画的情况下，播放开机动画
+        scr_init_run();                     
+    }
+    else
+    {
+        //播放过开机动画之后，跳转至指定界面
+        switch (menu_data.scr_now)
+        {
+            case SCREEN_MAIN:
+            {
+                scr_main_run();             //主界面显示
+                key_functions_main();       //主界面的按键功能
+            }
+            break;
+        
+            case SCREEN_SETTING:
+            {
+                scr_setting_run();          //设置界面
+                key_functions_setting();    //设置界面的按键功能
+            }
+            break;
+
+            case SCREEN_MODBUS_MASTER_CONFIG:
+            {
+                key_functions_modbus();
+            }
+            break;
+
+            case SCREEN_MODBUS_MASTER_TRX:
+            {
+                screen_modbus_trx_run();
+                key_functions_modbus();
+            }
+            break;
+            
+            default:
+            break;
+        }
+    }
+}
+
+//通道选择与切换
+void sig_channel_select(uint8_t io, SIG_FUNCTIONS_TYPE type)
+{
+    switch (io)
+    {
+        case IO_INPUT:
+        {
+            switch (type)
+            {
+                case CURRENT_MA:
+                {
+                    mux_signal.channel = CH8_IN_CUR;
+                }
+                break;
+
+                case VOLTAGE_V:
+                {
+                    mux_signal.channel = CH6_IN_VOL;
+                }
+                break;
+
+                case VOLTAGE_MV:
+                {
+                    mux_signal.channel = CH7_IN_MVOL;
+                }
+                break;
+
+                case RESISTANT_OHM:
+                {
+                    //与热电阻一致
+                    mux_signal.channel = CH10_IN_RTD;
+                }
+                break;
+
+                case FREQUENCE_KHZ:
+                {
+                    mux_signal.channel = CH9_IN_FRE;
+                }
+                break;
+
+                case TC_K:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_S:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_N:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_B:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_E:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_J:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_R:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case TC_T:
+                {
+                    mux_signal.channel = CH11_IN_TC;
+                }
+                break;
+
+                case RTD_DC:
+                {
+                    mux_signal.channel = CH10_IN_RTD;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case IO_OUTPUT:
+        {
+            switch (type)
+            {
+                case CURRENT_MA:
+                {
+                    mux_signal.channel = CH2_OUT_CUR;
+                }
+                break;
+
+                case VOLTAGE_V:
+                {
+                    mux_signal.channel = CH0_OUT_VOL_V;
+                }
+                break;
+
+                case VOLTAGE_MV:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case RESISTANT_OHM:
+                {
+                    mux_signal.channel = CH4_OUT_RES;
+                }
+                break;
+
+                case FREQUENCE_KHZ:
+                {
+                    mux_signal.channel = CH3_OUT_FRE;
+                }
+                break;
+
+                case TC_K:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_S:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_N:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_B:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_E:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_J:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_R:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case TC_T:
+                {
+                    mux_signal.channel = CH1_OUT_VOL_MV;
+                }
+                break;
+
+                case RTD_DC:
+                {
+                    mux_signal.channel = CH4_OUT_RES;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//更新设定值（根据ON\OFF状态）
+// float32 flt_test = 0, flt_test_rev = 0;
+// uint32_t uit_test = 0;
+// uint16_t uit_test_l = 0, uit_test_h = 0;
+void sig_sv_update(void)
+{
+    if(progout_data.process == PROGOUT_WAITING)
+    {
+        //按键修改屏幕上的设定值 -> 将屏幕上的值转化成实际值 -> 实际值再转化成mux输入值
+        switch (menu_data.io_on2off)
+        {
+            case IO_ON:
+            {
+                mux_signal.data_sv = real2mux( get_output_value() );
+            }
+            break;
+
+            case IO_OFF:
+            {
+                mux_signal.data_sv = 0;
+            }
+            break;
+        
+            default:
+            break;
+        }
+    }
+    else
+    {
+        program_out_run();
+        set_output( mux2real(mux_signal.data_sv) );
+    }
+
+    //本地控制的情况下，保持寄存器的值跟随设定值变化
+    if(get_coil_val(COIL_ADDR_HOLD_SV_CTRL) == 0)
+    {
+        HoldReg[HOLD_ADDR_MUX_SV_H] = ( (uint32_t)mux2real(mux_signal.data_sv) ) >> 16;
+        HoldReg[HOLD_ADDR_MUX_SV_L] = ( (uint32_t)mux2real(mux_signal.data_sv) ) & 0x0000FFFF;
+    }
+
+    //手动输入flt_test，拆分成高低位之后重新拼接成flt_test_rev，验证前后是否一致
+    // memcpy(&uit_test, &flt_test, 4);
+    // uit_test_h = uit_test >> 16;
+    // uit_test_l = uit_test & 0x0000FFFF;
+    // uit_test = (uit_test_h << 16) + uit_test_l;
+    // memcpy(&flt_test_rev, &uit_test, 4);
+}
+
+//数据转换，将输入热电偶电压值转换为实际温度值℃
+float32 tcmv2temp(SIG_FUNCTIONS_TYPE type, float32 mv)
+{
+    float32 result_temp = 0;
+    uint8_t typ = 0, i = 0;
+    typ = (uint8_t)type;
+    typ -= 5;       //[5,12]->[0,7]
+
+    float32 mv_left = 0, mv_right = 0;
+    float32 temp_left = 0, temp_right = 0;
+
+    for(i = 0; i < 10; i++)
+    {
+        if( ( TC_TABLE_MV[typ][i] <= mv )&&( mv < TC_TABLE_MV[typ][i + 1] ) )
+        {
+            mv_left = TC_TABLE_MV[typ][i];
+            mv_right = TC_TABLE_MV[typ][i + 1];
+            temp_left = TC_TABLE_TEMP[typ][i];
+            temp_right = TC_TABLE_TEMP[typ][i + 1];
+
+            result_temp = temp_left + ( temp_right - temp_left )*\
+            ( mv - mv_left )/( mv_right - mv_left);
+
+            return result_temp;
+        }
+    }
+
+    //ERROR
+    return -999;
+}
+
+//数据转换，将需要模拟的温度值℃转化为热电偶对应的mv
+float32 temp2tcmv(SIG_FUNCTIONS_TYPE type, float32 temp)
+{
+    float32 result_mv = 0;
+    uint8_t typ = 0, i = 0;
+    typ = (uint8_t)type;
+    typ -= 5;       //[5,12]->[0,7]
+
+    float32 mv_left = 0, mv_right = 0;
+    float32 temp_left = 0, temp_right = 0;
+
+    for(i = 0; i < 10; i++)
+    {
+        if( ( TC_TABLE_TEMP[typ][i] <= temp )&&( temp < TC_TABLE_TEMP[typ][i + 1] ) )
+        {
+            mv_left = TC_TABLE_MV[typ][i];
+            mv_right = TC_TABLE_MV[typ][i + 1];
+            temp_left = TC_TABLE_TEMP[typ][i];
+            temp_right = TC_TABLE_TEMP[typ][i + 1];
+
+            result_mv = mv_left + ( mv_right - mv_left )*\
+            ( temp - temp_left )/( temp_right - temp_left);
+
+            return result_mv;
+        }
+    }
+
+    //ERROR
+    return -999;
+}
+
+//数据转换，mux_signal.pv -> real_value
+float32 mux2real(float32 mux_pv)
+{
+    float32 result = 0;
+    SIG_FUNCTIONS mode;
+    SIG_FUNCTIONS_TYPE type;
+
+    switch (menu_data.io_mode)
+    {
+        case IO_INPUT:
+        {
+            mode = menu_data.input_mode;
+            type = menu_data.input_mode_type;
+        }
+        break;
+
+        case IO_OUTPUT:
+        {
+            mode = menu_data.output_mode;
+            type = menu_data.output_mode_type;
+        }
+        break;
+    
+        default:
+        break;
+    }
+    
+    switch (mode)
+    {
+        //电压
+        case SIG_VOLTAGE:       
+        {
+            switch (type)
+            {
+                // mV 输入已处理，无需乘以1000
+                case VOLTAGE_MV:
+                {
+                    result = mux_pv;
+                }
+                break;
+
+                //1:1
+                case VOLTAGE_V:
+                {
+                    result = mux_pv;
+                }
+                break;
+            
+                default:
+                break;
+            }
+            
+        }
+        break;
+
+        //电流
+        case SIG_CURRENT:       
+        {
+            switch (type)
+            {
+                //1:1
+                case CURRENT_MA:
+                {
+                    result = mux_pv;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        //电阻
+        case SIG_RESISTANT:     
+        {
+            switch (type)
+            {
+                case RESISTANT_OHM:
+                {
+                    result = mux_pv;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        //频率
+        case SIG_FREQUENCE:     
+        {
+            switch (type)
+            {
+                case FREQUENCE_KHZ:
+                {
+                    //Hz -> KHz
+                    result = mux_pv / 1000;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        //热电偶
+        case SIG_TC:            
+        {
+            result = tcmv2temp(type, mux_pv);
+        }
+        break;
+
+        //热电阻
+        case SIG_RTD:           
+        {
+            switch (type)
+            {
+                case RTD_DC:
+                {
+                    result = ohm2temp(mux_pv);
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+
+    return result;
+}
+
+//数据转换，real_value -> mux_signal.sv
+//float32 r2m_test_in = 0, r2m_test_out = 0;
+float32 real2mux(float32 real_value)
+{
+    float32 result = 0;
+
+    SIG_FUNCTIONS mode;
+    SIG_FUNCTIONS_TYPE type;
+
+    switch (menu_data.io_mode)
+    {
+        case IO_INPUT:
+        {
+            mode = menu_data.input_mode;
+            type = menu_data.input_mode_type;
+        }
+        break;
+
+        case IO_OUTPUT:
+        {
+            mode = menu_data.output_mode;
+            type = menu_data.output_mode_type;
+        }
+        break;
+    
+        default:
+        break;
+    }
+    
+    switch (mode)
+    {
+        //电压
+        case SIG_VOLTAGE:       
+        {
+            switch (type)
+            {
+                //[-2500mV, 2500mV] -> [-2.5V, 2.5V]
+                case VOLTAGE_MV:
+                {
+                    result = real_value / (float32)1000;
+                }
+                break;
+
+                //1:1
+                case VOLTAGE_V:
+                {
+                    result = real_value;
+                }
+                break;
+            
+                default:
+                break;
+            }
+            
+        }
+        break;
+
+        //电流
+        case SIG_CURRENT:       
+        {
+            switch (type)
+            {
+                //1:1
+                case CURRENT_MA:
+                {
+                    result = real_value;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        //电阻
+        case SIG_RESISTANT:     
+        {
+            switch (type)
+            {
+                case RESISTANT_OHM:
+                {
+                    result = real_value;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        //频率
+        case SIG_FREQUENCE:     
+        {
+            switch (type)
+            {
+                case FREQUENCE_KHZ:
+                {
+                    //KHz -> Hz
+                    result = real_value * 1000;
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        //热电偶
+        case SIG_TC:            
+        {
+            result = temp2tcmv(type, real_value);
+            //r2m_test_out = temp2tcmv(type, r2m_test_in);
+        }
+        break;
+
+        //热电阻
+        case SIG_RTD:           
+        {
+            switch (type)
+            {
+                case RTD_DC:
+                {
+                    result = temp2ohm(real_value);
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+    
+    return result;
+}
+
+//数据转换，热电阻阻值 Ω 转化为温度 ℃
+float32 ohm2temp(float32 ohm)
+{
+    float32 result = 0;
+
+    for(uint8_t i = 0;i < 10; i++)
+    {
+        if( ( RTD_TABLE_OHM[i] <= ohm ) && ( ohm <= RTD_TABLE_OHM[i + 1] ) )
+        {
+            result = RTD_TABLE_TEMP[i] + ( RTD_TABLE_TEMP[i + 1] - RTD_TABLE_TEMP[i] ) *\
+            ( ( ohm - RTD_TABLE_OHM[i] ) / ( RTD_TABLE_OHM[i + 1] - RTD_TABLE_OHM[i] ) );
+
+            return result;
+        }
+    }
+
+    return 0;
+}
+
+//数据转换，温度 ℃ 转化为热电阻阻值 Ω
+float32 temp2ohm(float32 temp)
+{
+    float32 result = 0;
+
+    for(uint8_t i = 0;i < 10; i++)
+    {
+        if( ( RTD_TABLE_TEMP[i] <= temp ) && ( temp <= RTD_TABLE_TEMP[i + 1] ) )
+        {
+            result = RTD_TABLE_OHM[i] + ( RTD_TABLE_OHM[i + 1] - RTD_TABLE_OHM[i] ) *\
+            ( ( temp - RTD_TABLE_TEMP[i] ) / ( RTD_TABLE_TEMP[i + 1] - RTD_TABLE_TEMP[i] ) );
+
+            return result;
+        }
+    }
+
+    return 0;
+}
+
+//计算a的b次方
+float32 my_power(int a, int b)
+{
+    if(a == 0) return 0;
+    if(b == 0) return 1;
+
+    float32 result = 1;
+    
+    if( b > 0 )
+    {
+        for(uint8_t i = 0; i < b; i++)
+        {
+            result *= a;
+        }
+    }
+    else
+    {
+        for(uint8_t i = 0; i < (-b); i++)
+        {
+            result /= (float32)a;
+        }
+    }
+    return result;
+}
+
+//初始化打包
+void my_inits_gather(void)
+{
+    //HART复位关闭
+    HART_RESET(GPIO_PIN_SET);
+    //HART默认接收
+    HART_RTS(RTS_OFF);
+
+    //eeprom
+    eeprom_spi_init();
+
+    //按键扫描
+    tm1650_init(&hi2c1);
+
+    //LVGL
+    lv_init();                              // LVGL 初始化
+    lv_port_disp_init();                    // 注册LVGL的显示任务初始化
+    // lv_demo_benchmark();                 //lv_conf.h, line:761
+    setup_ui(&guider_ui);                   // 初始化UI，设置与加载初始界面
+    events_init(&guider_ui);                // 初始化事件
+
+    //MODBUS主站初始化
+    modbus_rtu_master_init();
+
+    //编程输出参数初始化
+    program_out_init();
+}
+
+
+
+
+
+
+
+

App/APP_WU/Src/apps_var_def.c

@@ -0,0 +1,2 @@
+#include "apps_var_def.h"
+

App/APP_WU/Src/key_functions.c

@@ -0,0 +1,413 @@
+#include "key_functions.h"
+
+KEYS key_pv;                //当前按键
+KEYS_STATUS key_sts[11] = {KEY_STATUS_DISABLE};    //11个按键的状态，排列顺序与枚举顺序一致
+
+//按键数据类型转换
+void key_char2struct(void)
+{
+    key_pv.value = (KEYS_VALUE)key;
+
+    switch (key_pv.value)
+    {
+        case KEY_OUT_VAL:
+        {
+            key_pv.tag = KEY_OUT;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_UP_VAL:
+        {
+            key_pv.tag = KEY_UP;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_MENU_VAL:
+        {
+            key_pv.tag = KEY_MENU;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_IN_VAL:
+        {
+            key_pv.tag = KEY_IN;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_LEFT_VAL:
+        {
+            key_pv.tag = KEY_LEFT;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_OK_VAL:
+        {
+            key_pv.tag = KEY_OK;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_RIGHT_VAL:
+        {
+            key_pv.tag = KEY_RIGHT;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_SWITCH_VAL:
+        {
+            key_pv.tag = KEY_SWITCH;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_SOURCE_VAL:
+        {
+            key_pv.tag = KEY_SOURCE;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_DOWN_VAL:
+        {
+            key_pv.tag = KEY_DOWN;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_BACK_VAL:
+        {
+            key_pv.tag = KEY_BACK;
+            key_pv.status = key_sts[key_pv.tag];
+        }
+        break;
+
+        case KEY_NONE_VAL:
+        {
+            key_pv.tag = KEY_NONE;
+            key_pv.status = KEY_STATUS_DISABLE;
+        }
+        break;
+
+        case KEY_ALL_VAL:
+        {
+            key_pv.tag = KEY_ALL;
+            key_pv.status = KEY_STATUS_DISABLE;
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//按键状态配置
+void key_config(KEYS_TAG key_t, KEYS_STATUS sts)
+{
+    if(key_t != KEY_ALL)
+    {
+        key_sts[key_t] = sts;
+    }
+    else
+    {
+        for (uint8_t i = 0; i < 11; i++)
+        {
+            key_sts[i] = sts;
+        }
+    }
+}
+
+//按键配置更新
+void key_config_update(OPERATIONS ope)
+{
+    switch (ope)
+    {
+        case OPENNING_ANIME:
+        {
+            key_config(KEY_ALL, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case MAIN_FUNCTION:
+        {
+            key_config(KEY_ALL, KEY_STATUS_ENABLE);
+        }
+        break;
+
+        case SET_ITEM_CHOOSE:
+        {
+            //使能：上、下、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_LEFT, KEY_STATUS_DISABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case SET_CONTENT_CHOOSE:
+        {
+            //使能：上、下、左、右、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case SET_CONTENT_MODIFY:
+        {
+            //使能：左、右、返回
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_UP, KEY_STATUS_DISABLE);
+            key_config(KEY_DOWN, KEY_STATUS_DISABLE);
+            key_config(KEY_OK, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case SET_WINDOW_MODIFY:
+        {
+            //使能：上、下、左、右、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_OK, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case SET_SHOW_LOG:
+        {
+            //使能：左、右、返回
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_UP, KEY_STATUS_DISABLE);
+            key_config(KEY_DOWN, KEY_STATUS_DISABLE);
+            key_config(KEY_OK, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case SET_COMMUNICATION_SWITCH:
+        {
+            //使能：上、下、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_LEFT, KEY_STATUS_DISABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case SET_COMMUNICATION_MODIFY:
+        {
+            //使能：左、右、返回
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_UP, KEY_STATUS_DISABLE);
+            key_config(KEY_DOWN, KEY_STATUS_DISABLE);
+            key_config(KEY_OK, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case MODBUS_MASTER_CONFIG:
+        {
+            //使能：上、下、左、右、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case MODBUS_MASTER_CONFIG_MODIFY:
+        {
+            //使能：上、下、左、右、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+        
+        case MODBUS_MASTER_TRX:
+        {
+            //使能：上、下、左、右、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case MODBUS_MASTER_TRX_MODIFY:
+        {
+            //使能：上、下、左、右、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case PROG_OUT_CONFIG_1:
+        {
+            //使能：上、下、左、右、确认（OK）、返回
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case PROG_OUT_CONFIG_2:
+        {
+            //使能：上、下、左、右、确认（OK）、返回、OUT
+            key_config(KEY_UP, KEY_STATUS_ENABLE);
+            key_config(KEY_DOWN, KEY_STATUS_ENABLE);
+            key_config(KEY_LEFT, KEY_STATUS_ENABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_ENABLE);
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+            key_config(KEY_OUT, KEY_STATUS_ENABLE);
+
+            //不使能其他按键
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+
+        case PROG_OUT_PROCESSING:
+        {
+            //使能：确认（OK）、返回
+            key_config(KEY_OK, KEY_STATUS_ENABLE);
+            key_config(KEY_BACK, KEY_STATUS_ENABLE);
+            
+            //不使能其他按键
+            key_config(KEY_UP, KEY_STATUS_DISABLE);
+            key_config(KEY_DOWN, KEY_STATUS_DISABLE);
+            key_config(KEY_LEFT, KEY_STATUS_DISABLE);
+            key_config(KEY_RIGHT, KEY_STATUS_DISABLE);
+            key_config(KEY_OUT, KEY_STATUS_DISABLE);
+            key_config(KEY_IN, KEY_STATUS_DISABLE);
+            key_config(KEY_SOURCE, KEY_STATUS_DISABLE);
+            key_config(KEY_MENU, KEY_STATUS_DISABLE);
+            key_config(KEY_SWITCH, KEY_STATUS_DISABLE);
+        }
+        break;
+     
+        default:
+        break;
+    }
+}
+
+

App/APP_WU/Src/key_functions_main.c

@@ -0,0 +1,437 @@
+#include "key_functions_main.h"
+
+//KEY_MAIN
+void key_functions_main(void)       
+{
+    if( key_pv.status == KEY_STATUS_DISABLE ) return;
+
+    uint8_t cursor_temp = 0;        //临时游标，替代枚举变量进行加减运算
+
+    switch (key_pv.tag)
+    {
+        case KEY_OUT:
+        {
+            key = 0;
+            key_char2struct();
+
+            //交替按下 in 和 out 时，只改变输入/输出，连续按同一个键的时候才改变类型
+            if(menu_data.io_mode == IO_INPUT)
+            {
+                menu_data.io_mode = IO_OUTPUT;
+                menu_data.output_mode = menu_data.input_mode;
+
+                io_on2off_status();     //更新状态指示
+            }
+            else
+            {
+                cursor_temp = (uint8_t)menu_data.output_mode;
+                cursor_temp = (cursor_temp >= 5)?(0):(cursor_temp + 1);
+                menu_data.output_mode = (SIG_FUNCTIONS)cursor_temp;
+            }
+            
+            switch (menu_data.output_mode)
+            {
+                case SIG_VOLTAGE:       //电压
+                {
+                    menu_data.output_mode_type = VOLTAGE_V;
+                    set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                }
+                break;
+
+                case SIG_CURRENT:       //电流
+                {
+                    menu_data.output_mode_type = CURRENT_MA;
+                    set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                }
+                break;
+
+                case SIG_RESISTANT:     //电阻
+                {
+                    menu_data.output_mode_type = RESISTANT_OHM;
+                    set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                }
+                break;
+
+                case SIG_FREQUENCE:     //频率
+                {
+                    menu_data.output_mode_type = FREQUENCE_KHZ;
+                    set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                }
+                break;
+
+                case SIG_TC:            //热电偶
+                {
+                    menu_data.output_mode_type = TC_K;
+                    set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                }
+                break;
+
+                case SIG_RTD:           //热电阻
+                {
+                    menu_data.output_mode_type = RTD_DC;
+                    set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_UP:
+        {
+            key = 0;
+            key_char2struct();
+
+            if(menu_data.io_mode == IO_INPUT)
+            {
+                return;
+            }
+            
+            keyset_output(1);
+        }
+        break;
+
+        case KEY_MENU:
+        {
+            key = 0;
+            key_char2struct();
+
+            //加载菜单界面
+            scr_setting_recover();
+            lv_scr_load(guider_ui.screen_setting);
+            lv_obj_clear_flag(guider_ui.screen_setting, LV_OBJ_FLAG_HIDDEN);
+
+            //隐藏主界面对象
+            lv_obj_add_flag(guider_ui.screen_main, LV_OBJ_FLAG_HIDDEN);
+
+            menu_data.scr_now = SCREEN_SETTING;   //当前界面为详细设置菜单
+            set_coil_val(COIL_ADDR_SCREEN_SWITCH, 1);
+        }
+        break;
+
+        case KEY_IN:
+        {
+            key = 0;
+            key_char2struct();
+
+            if(menu_data.io_mode == IO_OUTPUT)
+            {
+                menu_data.io_mode = IO_INPUT;
+
+                //继承之前的输出类型
+                menu_data.input_mode = menu_data.output_mode;
+
+                io_on2off_status();     //更新状态指示
+            }
+            else
+            {
+                //枚举类型不能直接运算，于是使用临时变量cursor_temp
+                cursor_temp = (uint8_t)menu_data.input_mode;
+                cursor_temp = (cursor_temp >= 5)?(0):(cursor_temp + 1);
+                menu_data.input_mode = (SIG_FUNCTIONS)cursor_temp;
+            }
+
+            switch (menu_data.input_mode)
+            {
+                case SIG_VOLTAGE:       //电压
+                {
+                    menu_data.input_mode_type = VOLTAGE_V;
+                    set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                }
+                break;
+
+                case SIG_CURRENT:       //电流
+                {
+                    menu_data.input_mode_type = CURRENT_MA;
+                    set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                }
+                break;
+
+                case SIG_RESISTANT:     //电阻
+                {
+                    menu_data.input_mode_type = RESISTANT_OHM;
+                    set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                }
+                break;
+
+                case SIG_FREQUENCE:     //频率
+                {
+                    menu_data.input_mode_type = FREQUENCE_KHZ;
+                    set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                }
+                break;
+
+                case SIG_TC:            //热电偶
+                {
+                    menu_data.input_mode_type = TC_K;
+                    set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                }
+                break;
+
+                case SIG_RTD:           //热电阻
+                {
+                    menu_data.input_mode_type = RTD_DC;
+                    set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_LEFT:
+        {
+            key = 0;
+            key_char2struct();
+
+            if(menu_data.io_mode == IO_INPUT)
+            {
+                return;
+            }
+
+            menu_data.io_cursor_prv = menu_data.io_cursor;
+            menu_data.io_cursor = (menu_data.io_cursor <= 0)?(6):(menu_data.io_cursor - 1);
+            set_cursor_position();
+
+        }
+        break;
+
+        case KEY_OK:
+        {
+            key = 0;
+            key_char2struct();
+
+            //主界面用OK键控制开关ON&OFF
+            if(menu_data.io_on2off == IO_ON)
+            {
+                menu_data.io_on2off = IO_OFF;
+                set_coil_val(COIL_ADDR_ON_OFF, IO_OFF);
+
+                //编程输出时暂停计数
+                if(progout_data.process == PROGOUT_RUNNING) 
+                {
+                    progout_data.process = PROGOUT_PAUSE;
+                    progout_data.progout_tick_flag = 0;
+                }
+            }
+            else
+            {
+                menu_data.io_on2off = IO_ON;
+                set_coil_val(COIL_ADDR_ON_OFF, IO_ON);
+
+                //编程输出时继续计数
+                if(progout_data.process == PROGOUT_PAUSE)
+                {
+                    progout_data.process = PROGOUT_RUNNING;
+                    progout_data.progout_tick_flag = 1;
+                }
+            }
+            
+            io_on2off_status();     //更新ON/OFF/IN/OUT状态指示
+        }
+        break;
+
+        case KEY_RIGHT:
+        {
+            key = 0;
+            key_char2struct();
+            if(menu_data.io_mode == IO_INPUT)
+            {
+                return;
+            }
+
+            menu_data.io_cursor_prv = menu_data.io_cursor;
+            menu_data.io_cursor = (menu_data.io_cursor >= 6)?(0):(menu_data.io_cursor + 1);
+            set_cursor_position();
+        }
+        break;
+
+        case KEY_SWITCH:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (menu_data.io_mode)                 //输入、输出模式切换
+            {
+                case IO_OUTPUT:
+                {
+                    switch (menu_data.output_mode)     //功能切换
+                    {
+                        case SIG_CURRENT:
+                        {
+                            menu_data.output_mode_type = CURRENT_MA;
+                            set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                        }
+                        break;
+
+                        case SIG_RESISTANT:     //电阻
+                        {
+                            menu_data.output_mode_type = RESISTANT_OHM;
+                            set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                        }
+                        break;
+
+                        case SIG_VOLTAGE:
+                        {
+                            cursor_temp = (uint8_t)menu_data.output_mode_type;
+                            cursor_temp = (cursor_temp == 1)?(2):(1);
+                            menu_data.output_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
+
+                            set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                        }
+                        break;
+
+                        case SIG_FREQUENCE:     //频率
+                        {
+                            menu_data.output_mode_type = FREQUENCE_KHZ;
+                            set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                        }
+                        break;
+
+                        case SIG_TC:            //热电偶
+                        {
+                            cursor_temp = (uint8_t)menu_data.output_mode_type;
+                            cursor_temp = (cursor_temp >= 12)?(5):(cursor_temp + 1);
+                            menu_data.output_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
+
+                            set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                        }
+                        break;
+
+                        case SIG_RTD:           //热电阻
+                        {
+                            menu_data.output_mode_type = RTD_DC;
+                            set_working_mode(menu_data.output_mode, menu_data.output_mode_type);
+                        }
+                        break;
+                    
+                        default:
+                        break;
+                    }
+                }
+                break;
+
+                case IO_INPUT:
+                {
+                    switch (menu_data.input_mode)
+                    {
+                        case SIG_CURRENT:
+                        {
+                            menu_data.input_mode_type = CURRENT_MA;
+                            set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                        }
+                        break;
+
+                        case SIG_VOLTAGE:
+                        {
+                            cursor_temp = (uint8_t)menu_data.input_mode_type;
+                            cursor_temp = (cursor_temp == 1)?(2):(1);
+                            menu_data.input_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
+
+                            set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                        }
+                        break;
+
+                        case SIG_RESISTANT:     //电阻
+                        {
+                            menu_data.input_mode_type = RESISTANT_OHM;
+                            set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                        }
+                        break;
+
+                        case SIG_FREQUENCE:     //频率
+                        {
+                            menu_data.input_mode_type = FREQUENCE_KHZ;
+                            set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                        }
+                        break;
+
+                        case SIG_TC:            //热电偶
+                        {
+                            cursor_temp = (uint8_t)menu_data.input_mode_type;
+                            cursor_temp = (cursor_temp >= 12)?(5):(cursor_temp + 1);
+                            menu_data.input_mode_type = (SIG_FUNCTIONS_TYPE)cursor_temp;
+
+                            set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                        }
+                        break;
+
+                        case SIG_RTD:           //热电阻
+                        {
+                            menu_data.input_mode_type = RTD_DC;
+                            set_working_mode(menu_data.input_mode, menu_data.input_mode_type);
+                        }
+                        break;
+                    
+                        default:
+                        break;
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_SOURCE:
+        {
+            //电源开关靠硬件电路实现，此处可做预留
+            key = 0;
+            key_char2struct();
+        }
+        break;
+
+        case KEY_DOWN:
+        {
+            key = 0;
+            key_char2struct();
+            if(menu_data.io_mode == IO_INPUT)
+            {
+                return;
+            }
+            
+            keyset_output(-1);
+        }
+        break;
+
+        case KEY_BACK:      
+        {
+            key = 0;
+            key_char2struct();
+
+            if(current_operation == PROG_OUT_PROCESSING)
+            {
+                progout_data.process = PROGOUT_END;
+                progout_data.progout_tick_flag = 0;
+                progout_data.progout_tick = 2500;
+            }
+        }
+        break;
+
+        case KEY_ALL:      //闲置，预留
+        {
+            key = 0;
+            key_char2struct();
+        }
+        break;
+
+        case KEY_NONE:      //闲置，预留
+        {
+        }
+        break;
+    
+        default:
+        {
+            key = 0;
+            key_char2struct();
+        }
+        break;
+    }
+}
+

App/APP_WU/Src/key_functions_modbus.c

@@ -0,0 +1,833 @@
+#include "key_functions_modbus.h"
+
+uint8_t mod_trx_set_flag = 0;               //trx的屏幕是否加载过
+uint8_t window_config_cursor = 0;           //弹窗游标位置
+uint8_t window_config_cursor_prv = 0;       //前一时刻的游标位置
+uint8_t window_config_num[4] = {0};         //配置窗口内的四个数字
+
+uint8_t window_trx_num[32] = {0};           //收发界面data窗口内的32个数字，范围[0,16]，其中[0,15]为十六进制单字符，16定义为“-”
+uint8_t window_trx_cursor = 0;
+uint8_t window_trx_cursor_prv = 0;
+uint8_t window_trx_focus = 0;       //收发界面data窗口内的焦点
+
+void cursor_move(int8_t step)
+{
+    switch (mod_mas_conf_cursor)
+    {
+        case MOD_CONF_SLAVE_ID:
+        {
+            window_config_cursor_prv = window_config_cursor;
+            window_config_cursor = 3*(window_config_cursor == 2) + 2*(window_config_cursor == 3);
+        }
+        break;
+
+        case MOD_CONF_START_ADDRESS:
+        {
+            window_config_cursor_prv = window_config_cursor;
+            window_config_cursor += step;
+            if(window_config_cursor > 200)
+            { 
+                window_config_cursor = 3;
+            }
+            else if (window_config_cursor > 3)
+            {
+                window_config_cursor = 0;
+            }
+        }
+        break;
+
+        case MOD_CONF_COMMAND:
+        {
+            window_config_cursor_prv = window_config_cursor;
+            window_config_cursor = 3*(window_config_cursor == 2) + 2*(window_config_cursor == 3);
+        }
+        break;
+
+        case MOD_CONF_REGISTER_NUM:
+        {
+            window_config_cursor_prv = window_config_cursor;
+            window_config_cursor += step;
+            if(window_config_cursor < 1)
+            { 
+                window_config_cursor = 3;
+            }
+            else if (window_config_cursor > 3)
+            {
+                window_config_cursor = 1;
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+
+    config_window_num_check(window_config_cursor, window_config_cursor_prv);
+}
+
+void key_functions_modbus(void)
+{
+    if( key_pv.status == KEY_STATUS_DISABLE ) return;
+
+    uint8_t calculate_temp = 0;     //临时变量，替代枚举变量进行计算
+    char str_temp[16];
+
+    switch (key_pv.tag)
+    {
+        case KEY_UP:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (current_operation)
+            {
+                case MODBUS_MASTER_CONFIG:
+                {
+                    mod_mas_conf_cursor_prv = mod_mas_conf_cursor;
+
+                    calculate_temp = (uint8_t)mod_mas_conf_cursor;
+                    if(calculate_temp == 0)
+                    {
+                        calculate_temp = 7;
+                    }
+                    else
+                    {
+                        calculate_temp -= 1;
+                    }
+                    mod_mas_conf_cursor = (MOD_CONF_ITEMS)calculate_temp;
+
+                    config_items_check(mod_mas_conf_cursor, mod_mas_conf_cursor_prv);
+                }
+                break;
+
+                case MODBUS_MASTER_CONFIG_MODIFY:
+                {
+                    if( (mod_mas_conf_cursor == MOD_CONF_SLAVE_ID)||(mod_mas_conf_cursor == MOD_CONF_START_ADDRESS)||(mod_mas_conf_cursor == MOD_CONF_COMMAND) )
+                    {
+                        window_config_num[window_config_cursor] += 1;
+                        if(window_config_num[window_config_cursor] >= 16) window_config_num[window_config_cursor] = 0;
+
+                        config_window_num_set(window_config_cursor, window_config_num[window_config_cursor]);
+                    }
+                    else if (mod_mas_conf_cursor == MOD_CONF_REGISTER_NUM)
+                    {
+                        window_config_num[window_config_cursor] += 1;
+                        if(window_config_num[window_config_cursor] >= 10) window_config_num[window_config_cursor] = 0;
+
+                        config_window_num_set(window_config_cursor, window_config_num[window_config_cursor]);
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX:
+                {
+                    if(mod_mas_trx_cursor)
+                    {
+                        mod_mas_trx_cursor_prv = mod_mas_trx_cursor; 
+                        mod_mas_trx_cursor = MOD_TRX_DATA;
+
+                        trx_items_check(mod_mas_trx_cursor, mod_mas_trx_cursor_prv);
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX_MODIFY:
+                {
+                    if(window_trx_focus == 0)
+                    {
+                        window_trx_cursor_prv = window_trx_cursor;
+                        window_trx_cursor -= 8;
+                        if( window_trx_cursor > 200 ) window_trx_cursor += 32;
+
+                        trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+                    }
+                    else
+                    {
+                        window_trx_num[window_trx_cursor] += 1;
+                        if(window_trx_num[window_trx_cursor] > 16) window_trx_num[window_trx_cursor] = 0;
+                        
+                        if(window_trx_num[window_trx_cursor] != 16)
+                        {
+                            sprintf(str_temp, "%x", window_trx_num[window_trx_cursor]);
+                            lv_label_set_text(lvobj_window_trx_nums[window_trx_cursor], str_temp);
+                        }
+                        else
+                        {
+                            lv_label_set_text(lvobj_window_trx_nums[window_trx_cursor], "-");
+                        }
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_DOWN:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (current_operation)
+            {
+                case MODBUS_MASTER_CONFIG:
+                {
+                   mod_mas_conf_cursor_prv = mod_mas_conf_cursor;
+
+                    calculate_temp = (uint8_t)mod_mas_conf_cursor;
+                    if(calculate_temp == 7)
+                    {
+                        calculate_temp = 0;
+                    }
+                    else
+                    {
+                        calculate_temp += 1;
+                    }
+                    mod_mas_conf_cursor = (MOD_CONF_ITEMS)calculate_temp;
+
+                    config_items_check(mod_mas_conf_cursor, mod_mas_conf_cursor_prv);
+                }
+                break;
+
+                case MODBUS_MASTER_CONFIG_MODIFY:
+                {
+                    if( (mod_mas_conf_cursor == MOD_CONF_SLAVE_ID)||(mod_mas_conf_cursor == MOD_CONF_START_ADDRESS)||(mod_mas_conf_cursor == MOD_CONF_COMMAND) )
+                    {
+                        window_config_num[window_config_cursor] -= 1;
+                        if(window_config_num[window_config_cursor] > 200) window_config_num[window_config_cursor] = 15;
+
+                        config_window_num_set(window_config_cursor, window_config_num[window_config_cursor]);
+                    }
+                    else if (mod_mas_conf_cursor == MOD_CONF_REGISTER_NUM)
+                    {
+                        window_config_num[window_config_cursor] -= 1;
+                        if(window_config_num[window_config_cursor] > 200) window_config_num[window_config_cursor] = 9;
+
+                        config_window_num_set(window_config_cursor, window_config_num[window_config_cursor]);
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX:
+                {
+                    if(!mod_mas_trx_cursor)
+                    {
+                        mod_mas_trx_cursor_prv = mod_mas_trx_cursor; 
+                        mod_mas_trx_cursor = MOD_TRX_PREVIOUS;
+
+                        trx_items_check(mod_mas_trx_cursor, mod_mas_trx_cursor_prv);
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX_MODIFY:
+                {
+                    if(window_trx_focus == 0)
+                    {
+                        window_trx_cursor_prv = window_trx_cursor;
+                        window_trx_cursor += 8;
+                        if( window_trx_cursor > 31 ) window_trx_cursor -= 32;
+
+                        trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+                    }
+                    else
+                    {
+                        window_trx_num[window_trx_cursor] -= 1;
+                        if(window_trx_num[window_trx_cursor] >= 200) window_trx_num[window_trx_cursor] = 16;
+                        
+                        if(window_trx_num[window_trx_cursor] != 16)
+                        {
+                            sprintf(str_temp, "%x", window_trx_num[window_trx_cursor]);
+                            lv_label_set_text(lvobj_window_trx_nums[window_trx_cursor], str_temp);
+                        }
+                        else
+                        {
+                            lv_label_set_text(lvobj_window_trx_nums[window_trx_cursor], "-");
+                        }
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_LEFT:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (current_operation)
+            {
+                case MODBUS_MASTER_CONFIG:
+                {
+                    mod_mas_conf_cursor_prv = mod_mas_conf_cursor;
+
+                    calculate_temp = (uint8_t)mod_mas_conf_cursor;
+                    calculate_temp -= 4;
+                    if(calculate_temp > 200)
+                    {
+                        calculate_temp = (uint8_t)mod_mas_conf_cursor_prv + 4;
+                    }
+                    mod_mas_conf_cursor = (MOD_CONF_ITEMS)calculate_temp;
+
+                    config_items_check(mod_mas_conf_cursor, mod_mas_conf_cursor_prv);
+                }
+                break;
+
+                case MODBUS_MASTER_CONFIG_MODIFY:
+                {
+                    switch (mod_mas_conf_cursor)
+                    {
+                        case MOD_CONF_SLAVE_ID:
+                        {}
+                        //break;
+
+                        case MOD_CONF_START_ADDRESS:
+                        {}
+                        //break;
+
+                        case MOD_CONF_COMMAND:
+                        {}
+                        //break;
+
+                        case MOD_CONF_REGISTER_NUM:
+                        {
+                            cursor_move(-1);
+                        }
+                        break;
+
+                        case MOD_CONF_BYTES:
+                        {
+                            mod_master.byte_num -= 1;
+                            if( mod_master.byte_num > 200) mod_master.byte_num = 16;
+
+                            sprintf(str_temp, "< %d >", mod_master.byte_num);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_bytes, str_temp);
+                        }
+                        break;
+
+                        case MOD_CONF_TIMEOUT:
+                        {
+                            mod_master.timeout -= 100;
+                            if( mod_master.timeout > 60000) mod_master.timeout = 10000;
+
+                            sprintf(str_temp, "< %d >", mod_master.timeout);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_timeout, str_temp);
+                        }
+                        break;
+                    
+                        default:
+                        break;
+                    }
+                    
+                }
+                break;
+
+                case MODBUS_MASTER_TRX:
+                {
+                    if(mod_mas_trx_cursor)
+                    {
+                        mod_mas_trx_cursor_prv = mod_mas_trx_cursor;
+                        
+                        calculate_temp = (uint8_t)mod_mas_trx_cursor;
+                        calculate_temp -= 1;
+                        if(calculate_temp == 0) calculate_temp = 3;
+                        mod_mas_trx_cursor = (MOD_TRX_ITEMS)calculate_temp;
+
+                        trx_items_check(mod_mas_trx_cursor, mod_mas_trx_cursor_prv);
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX_MODIFY:
+                {
+                    if(window_trx_focus == 0)
+                    {
+                        window_trx_cursor_prv = window_trx_cursor;
+                        window_trx_cursor -= 1;
+                        if( window_trx_cursor > 200 ) window_trx_cursor = 31;
+
+                        trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_RIGHT:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (current_operation)
+            {
+                case MODBUS_MASTER_CONFIG:
+                {
+                    mod_mas_conf_cursor_prv = mod_mas_conf_cursor;
+
+                    calculate_temp = (uint8_t)mod_mas_conf_cursor;
+                    calculate_temp += 4;
+                    if(calculate_temp > 7)
+                    {
+                        calculate_temp = (uint8_t)mod_mas_conf_cursor_prv - 4;
+                    }
+                    mod_mas_conf_cursor = (MOD_CONF_ITEMS)calculate_temp;
+
+                    config_items_check(mod_mas_conf_cursor, mod_mas_conf_cursor_prv);
+                }
+                break;
+
+                case MODBUS_MASTER_CONFIG_MODIFY:
+                {
+                    switch (mod_mas_conf_cursor)
+                    {
+                        case MOD_CONF_SLAVE_ID:
+                        {}
+                        //break;
+
+                        case MOD_CONF_START_ADDRESS:
+                        {}
+                        //break;
+
+                        case MOD_CONF_COMMAND:
+                        {}
+                        //break;
+
+                        case MOD_CONF_REGISTER_NUM:
+                        {
+                            cursor_move(1);
+                        }
+                        break;
+
+                        case MOD_CONF_BYTES:
+                        {
+                            mod_master.byte_num += 1;
+                            if( mod_master.byte_num > 16) mod_master.byte_num = 0;
+
+                            sprintf(str_temp, "< %d >", mod_master.byte_num);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_bytes, str_temp);
+                        }
+                        break;
+
+                        case MOD_CONF_TIMEOUT:
+                        {
+                            mod_master.timeout += 100;
+                            if( mod_master.timeout > 10000) mod_master.timeout = 0;
+
+                            sprintf(str_temp, "< %d >", mod_master.timeout);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_timeout, str_temp);
+                        }
+                        break;
+                    
+                        default:
+                        break;
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX:
+                {
+                    if(mod_mas_trx_cursor)
+                    {
+                        mod_mas_trx_cursor_prv = mod_mas_trx_cursor;
+                        
+                        calculate_temp = (uint8_t)mod_mas_trx_cursor;
+                        calculate_temp += 1;
+                        if(calculate_temp > 3) calculate_temp = 1;
+                        mod_mas_trx_cursor = (MOD_TRX_ITEMS)calculate_temp;
+
+                        trx_items_check(mod_mas_trx_cursor, mod_mas_trx_cursor_prv);
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_TRX_MODIFY:
+                {
+                    if(window_trx_focus == 0)
+                    {
+                        window_trx_cursor_prv = window_trx_cursor;
+                        window_trx_cursor += 1;
+                        if( window_trx_cursor > 31 ) window_trx_cursor = 0;
+
+                        trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_OK:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (current_operation)
+            {
+                case MODBUS_MASTER_CONFIG:
+                {
+                    switch(mod_mas_conf_cursor)
+                    {
+                        case MOD_CONF_SLAVE_ID:
+                        {
+                            config_window_update();
+                            current_operation = MODBUS_MASTER_CONFIG_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_START_ADDRESS:
+                        {
+                            config_window_update();
+                            current_operation = MODBUS_MASTER_CONFIG_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_BYTES:
+                        {
+                            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_bytes, lv_color_hex(COLOR_CONTENTS_FOCUSED), LV_PART_MAIN|LV_STATE_DEFAULT);
+                            sprintf(str_temp, "< %d >", mod_master.byte_num);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_bytes, str_temp);
+                            current_operation = MODBUS_MASTER_CONFIG_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_TIMEOUT:
+                        {
+                            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_timeout, lv_color_hex(COLOR_CONTENTS_FOCUSED), LV_PART_MAIN|LV_STATE_DEFAULT);
+                            sprintf(str_temp, "< %d >", mod_master.timeout);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_timeout, str_temp);
+                            current_operation = MODBUS_MASTER_CONFIG_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_COMMAND:
+                        {
+                            config_window_update();   
+                            current_operation = MODBUS_MASTER_CONFIG_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_REGISTER_NUM:
+                        {
+                            config_window_update(); 
+                            current_operation = MODBUS_MASTER_CONFIG_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_CALIBRATION:
+                        {}
+                        break;
+
+                        case MOD_CONF_NEXT:
+                        {
+                            if(!mod_trx_set_flag)
+                            {
+                                mod_trx_set_flag = 1;
+                                setup_scr_screen_modbus_trx(&guider_ui);
+                                delay_cnt(200);                                 //不加延时有概率卡死
+                            }
+                            //加载trx界面
+                            scr_modbus_trx_recover();
+                            lv_scr_load(guider_ui.screen_modbus_trx); 
+                            lv_obj_clear_flag(guider_ui.screen_modbus_trx, LV_OBJ_FLAG_HIDDEN); 
+
+                            menu_data.scr_now = SCREEN_MODBUS_MASTER_TRX;
+                            
+                            //隐藏配置界面，熄灭当前游标
+                            lv_obj_add_flag(guider_ui.screen_modbus_config, LV_OBJ_FLAG_HIDDEN);
+                            config_items_check(MOD_CONF_NONE, mod_mas_conf_cursor);
+
+                            current_operation = MODBUS_MASTER_TRX;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_CONF_NONE:
+                        {}
+                        break;
+                    
+                        default:
+                        break;
+                    }
+                }
+                break;
+
+                case MODBUS_MASTER_CONFIG_MODIFY:
+                {
+                }
+                break;
+
+                case MODBUS_MASTER_TRX:
+                {
+                    switch (mod_mas_trx_cursor)
+                    {
+                        case MOD_TRX_DATA:
+                        {
+                            lv_obj_clear_flag(guider_ui.screen_modbus_trx_window_data, LV_OBJ_FLAG_HIDDEN);
+
+                            trx_window_init();
+
+                            window_trx_cursor = 0;
+                            window_trx_cursor_prv = 99;
+                            trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+
+                            current_operation = MODBUS_MASTER_TRX_MODIFY;
+                            key_config_update(current_operation);
+                        }
+                        break;
+
+                        case MOD_TRX_PREVIOUS:
+                        {
+                            key = KEY_BACK_VAL;
+                            key_char2struct();
+                        }
+                        break;
+
+                        case MOD_TRX_SET:
+                        {
+                            trx_focus = 1;
+                            trx_items_check(mod_mas_trx_cursor, MOD_TRX_NONE);
+
+                            modbus_rtu_master_load();
+                            switch (mod_master.tx_error_message)
+                            {
+                                case TX_ERROR_WRONG_CMD:
+                                {
+                                    lv_label_set_text(guider_ui.screen_modbus_trx_value_Tx, "EEROR: Wrong Command");
+                                }
+                                break;
+
+                                case TX_ERROR_COIL_NUM:
+                                {
+                                    lv_label_set_text(guider_ui.screen_modbus_trx_value_Tx, "EEROR: Wrong Coil Num");
+                                }
+                                break;
+
+                                case TX_ERROR_HOLDREG_NUM:
+                                {
+                                    lv_label_set_text(guider_ui.screen_modbus_trx_value_Tx, "EEROR: Wrong HoldReg Num");
+                                }
+                                break;
+
+                                case TX_ERROR_NONE:
+                                {
+                                    char str0[10] = {0};
+                                    char str_temp[256] = {0};
+                                    for(uint8_t i = 0; i < mod_master.data_tx_len; i++)
+                                    {
+                                        sprintf(str0, "%02x ", mod_master.data_tx[i]);
+                                        strcat(str_temp, str0);
+                                    }
+                                    lv_label_set_text(guider_ui.screen_modbus_trx_value_Tx, str_temp);
+                                }
+                                break;
+                            
+                                default:
+                                break;
+                            }
+                        }
+                        break;
+
+                        case MOD_TRX_SEND:
+                        {
+                            trx_focus = 1;
+                            trx_items_check(mod_mas_trx_cursor, MOD_TRX_NONE);
+
+                            modbus_rtu_master_send();
+                        }
+                        break;
+                    
+                        default:
+                        break;
+                    }
+                    
+                }
+                break;
+
+                case MODBUS_MASTER_TRX_MODIFY:
+                {
+                    window_trx_focus = 1;
+                    trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case KEY_BACK:
+        {
+            key = 0;
+            key_char2struct();
+
+            switch (current_operation)
+            {
+                case MODBUS_MASTER_CONFIG:
+                {
+                    //直接删除收发界面的内容
+                    if(mod_trx_set_flag)
+                    {   
+                        //加载过的情况下才能删除，否则会进入硬件错误中断    
+                        mod_trx_set_flag = 0;
+                        lv_obj_del(guider_ui.screen_modbus_trx);
+                    }
+
+                    //加载设置界面的内容
+                    setup_scr_screen_setting(&guider_ui);
+                    scr_setting_recover();
+                    delay_cnt(200);                                 //不加延时有概率卡死
+                    
+                    lv_scr_load(guider_ui.screen_setting);          //加载菜单界面
+
+                    //异步删除modbus配置的相关内容，释放内存
+                    lv_obj_del_async(guider_ui.screen_modbus_config);
+
+                    menu_data.scr_now = SCREEN_SETTING;
+                    set_coil_val(COIL_ADDR_SCREEN_SWITCH, 1);
+   
+                    //进入拓展功能选项卡
+                    tabdata.item_cursor = ITEM_2;
+                    tabdata.item_cursor_prv = ITEM_0;
+                    setting_items_check(tabdata.item_cursor, tabdata.item_cursor_prv);
+
+                    //进入通讯选择
+                    tabdata.content_focus = 0;
+                    lv_obj_set_style_bg_color(guider_ui.screen_setting_label_21, lv_color_hex(COLOR_ITEMS_UNCHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+                    communication_select();
+                    current_operation = SET_COMMUNICATION_SWITCH;
+                    key_config_update(current_operation);
+                    
+                }
+                break;
+
+                case MODBUS_MASTER_CONFIG_MODIFY:
+                {
+                    switch (mod_mas_conf_cursor)
+                    {
+                        case MOD_CONF_SLAVE_ID:
+                        {}
+                        //break;
+
+                        case MOD_CONF_START_ADDRESS:
+                        {}
+                        //break;
+
+                        case MOD_CONF_COMMAND:
+                        {}
+                        //break;
+
+                        case MOD_CONF_REGISTER_NUM:
+                        {
+                            lv_obj_add_flag(guider_ui.screen_modbus_config_window_config, LV_OBJ_FLAG_HIDDEN);
+                            config_window_num_check(99, window_config_cursor);
+                            window_config_cursor = 0;
+                            window_config_cursor_prv = 99;
+
+                            config_window2value();
+                            memset(window_config_num, 0, 4);
+                        }
+                        break;
+
+                        case MOD_CONF_BYTES:
+                        {
+                            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_bytes, lv_color_hex(COLOR_CONTENTS_CHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+                            sprintf(str_temp, "%d", mod_master.byte_num);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_bytes, str_temp);
+                        }
+                        break;
+
+                        case MOD_CONF_TIMEOUT:
+                        {
+                            lv_obj_set_style_bg_color(guider_ui.screen_modbus_config_value_timeout, lv_color_hex(COLOR_CONTENTS_CHECKED), LV_PART_MAIN|LV_STATE_DEFAULT);
+                            sprintf(str_temp, "%d", mod_master.timeout);
+                            lv_label_set_text(guider_ui.screen_modbus_config_value_timeout, str_temp);
+                        }
+                        break;
+                    
+                        default:
+                        break;
+                    }
+
+                    current_operation = MODBUS_MASTER_CONFIG;
+                    key_config_update(current_operation);
+                }
+                break;
+
+                case MODBUS_MASTER_TRX:
+                {
+                    //加载配置界面
+                    scr_modbus_config_recover();
+                    lv_scr_load(guider_ui.screen_modbus_config);
+                    lv_obj_clear_flag(guider_ui.screen_modbus_config, LV_OBJ_FLAG_HIDDEN);
+
+                    menu_data.scr_now = SCREEN_MODBUS_MASTER_CONFIG;
+
+                    //隐藏trx界面
+                    lv_obj_add_flag(guider_ui.screen_modbus_trx, LV_OBJ_FLAG_HIDDEN);
+
+                    //熄灭当前游标
+                    trx_items_check(MOD_TRX_NONE, mod_mas_trx_cursor);
+
+                    current_operation = MODBUS_MASTER_CONFIG;
+                    key_config_update(current_operation);
+                }
+                break;
+
+                case MODBUS_MASTER_TRX_MODIFY:
+                {
+                    if(window_trx_focus == 1)
+                    {
+                        //存在焦点的情况下，熄灭焦点
+                        window_trx_focus = 0;
+                        trx_window_num_check(window_trx_cursor, window_trx_cursor_prv);
+                    }
+                    else
+                    {
+                        //不存在焦点的情况下，关闭弹窗、熄灭游标、数值转换，返回trx界面
+                        lv_obj_add_flag(guider_ui.screen_modbus_trx_window_data, LV_OBJ_FLAG_HIDDEN);
+
+                        trx_window_num_check(99, window_trx_cursor);
+                        window_trx_cursor = 0;
+                        window_trx_cursor_prv = 99;
+
+                        //窗口内容转换为数值
+                        trx_window_num2val();
+
+                        current_operation = MODBUS_MASTER_TRX;
+                        key_config_update(current_operation);
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+

App/APP_WU/Src/scr_setting_item_text.c

@@ -0,0 +1,729 @@
+#include "scr_setting_item_text.h"
+//该部分代码用于修改选项卡内部，右侧一列的文本
+
+//修改选项卡0的文本
+void set_item0_text(ITEM_CONTENTS con)
+{
+    char str_temp[16] = {0};
+    uint8_t enum_temp = 0;
+
+    switch (con)
+    {
+        case VOL_UNIT_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                if(tabdata.item0_page0_vunit == VOLTAGE_V)
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_01, "V");
+                }
+                else if(tabdata.item0_page0_vunit == VOLTAGE_MV)
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_01, "mV");
+                }
+            }
+            else
+            {
+                if(tabdata.item0_page0_vunit == VOLTAGE_V)
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_01, "< V >");
+                }
+                else if(tabdata.item0_page0_vunit == VOLTAGE_MV)
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_01, "< mV >");
+                }
+            }
+        }
+        break;
+
+        case VOL_UP_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                if(tabdata.item0_page0_vunit == VOLTAGE_V)
+                {
+                    sprintf(str_temp,"%d",tabdata.item0_page0_vup[0]);
+                }
+                else if(tabdata.item0_page0_vunit == VOLTAGE_MV)
+                {
+                    sprintf(str_temp,"%d",tabdata.item0_page0_vup[1]);
+                }
+            }
+            else
+            {
+                if(tabdata.item0_page0_vunit == VOLTAGE_V)
+                {
+                    sprintf(str_temp,"< %d >",tabdata.item0_page0_vup[0]);
+                }
+                else if(tabdata.item0_page0_vunit == VOLTAGE_MV)
+                {
+                    sprintf(str_temp,"< %d >",tabdata.item0_page0_vup[1]);
+                }
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+        }
+        break;
+
+        case VOL_LOW_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                if(tabdata.item0_page0_vunit == VOLTAGE_V)
+                {
+                    sprintf(str_temp,"%d",tabdata.item0_page0_vlow[0]);
+                }
+                else if(tabdata.item0_page0_vunit == VOLTAGE_MV)
+                {
+                    sprintf(str_temp,"%d",tabdata.item0_page0_vlow[1]);
+                }
+            }
+            else
+            {
+                if(tabdata.item0_page0_vunit == VOLTAGE_V)
+                {
+                    sprintf(str_temp,"< %d >",tabdata.item0_page0_vlow[0]);
+                }
+                else if(tabdata.item0_page0_vunit == VOLTAGE_MV)
+                {
+                    sprintf(str_temp,"< %d >",tabdata.item0_page0_vlow[1]);
+                }
+            }
+            
+            lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+        }
+        break;
+
+        case CURRENT_UP_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page0_cup);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page0_cup);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_31, str_temp);
+        }
+        break;
+
+        case CURRENT_LOW_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page0_clow);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page0_clow);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_41, str_temp);
+        }
+        break;
+
+        case RES_UP_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page0_rup);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page0_rup);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_51, str_temp);
+        }
+        break;
+
+        case RES_LOW_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page1_rlow);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page1_rlow);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_01, str_temp);
+        }
+        break;
+
+        case FRE_UP_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page1_fup);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page1_fup);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+        }
+        break;
+
+        case FRE_LOW_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page1_flow);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page1_flow);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+        }
+        break;
+
+        case TC_TYPE_SET:
+        {
+            switch (tabdata.item0_page1_TCtype)
+            {
+                case TC_K:
+                { 
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "K ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< K ℃ >");
+                    }
+                }
+                break;
+
+                case TC_S:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "S ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< S ℃ >");
+                    }
+                }
+                break;
+
+                case TC_N:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "N ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< N ℃ >");
+                    }
+                }
+                break;
+
+                case TC_B:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "B ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< B ℃ >");
+                    }
+                }
+                break;
+
+                case TC_E:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "E ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< E ℃ >");
+                    }
+                }
+                break;
+
+                case TC_J:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "J ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< J ℃ >");
+                    }
+                }
+                break;
+
+                case TC_R:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "R ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< R ℃ >");
+                    }
+                }
+                break;
+
+                case TC_T:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "T ℃");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, "< T ℃ >");
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+            
+        }
+        break;
+
+        case TC_UP_SET:
+        {
+            enum_temp = (uint8_t)tabdata.item0_page1_TCtype;
+            enum_temp -= 5;
+
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page1_TCup[enum_temp]);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page1_TCup[enum_temp]);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_41, str_temp);
+        }
+        break;
+
+        case TC_LOW_SET:
+        {
+            enum_temp = (uint8_t)tabdata.item0_page1_TCtype;
+            enum_temp -= 5;
+
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page1_TClow[enum_temp]);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page1_TClow[enum_temp]);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_51, str_temp);
+        }
+        break;
+
+        case RTD_UP_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page2_RTDup);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >",tabdata.item0_page2_RTDup);
+            }
+
+            lv_label_set_text(guider_ui.screen_setting_label_01, str_temp);
+        }
+        break;
+
+        case RTD_LOW_SET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d",tabdata.item0_page2_RTDlow);
+            }
+            else
+            {sprintf(str_temp,"< %d >",tabdata.item0_page2_RTDlow);}
+
+            lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+        }
+        break;
+
+        case PAGE_PV_ITEM_0:
+        {
+            sprintf(str_temp,"< %d/%d >",tabdata.item_page, I0_PAGE_MAX);
+            lv_label_set_text(guider_ui.screen_setting_label_page, str_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+
+//修改选项卡1的文本
+void set_item1_text(ITEM_CONTENTS con)
+{
+    char str_temp[16] = {0};
+
+    switch (con)
+    {
+        case SAMPLE_INTERVAL:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d", tabdata.item1_page0_sample_interval);
+                lv_label_set_text(guider_ui.screen_setting_label_01, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >", tabdata.item1_page0_sample_interval);
+                lv_label_set_text(guider_ui.screen_setting_label_01, str_temp);
+            }
+        }
+        break;
+
+        case PLOT_NUM:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp,"%d", tabdata.item1_page0_plot_num);
+                lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp,"< %d >", tabdata.item1_page0_plot_num);
+                lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+            }
+        }
+        break;
+
+        case INPUT_COLOR:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                lv_label_set_text(guider_ui.screen_setting_label_21, "===");
+            }
+            else
+            {
+                lv_label_set_text(guider_ui.screen_setting_label_21, "<===>");
+                set_contents_color(2, 0x000000);
+            }
+
+            set_obj_color(guider_ui.screen_setting_label_21, tabdata.item1_page0_color_input);
+        }
+        break;
+
+        case OUTPUT_COLOR:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                lv_label_set_text(guider_ui.screen_setting_label_31, "===");
+            }
+            else
+            {
+                lv_label_set_text(guider_ui.screen_setting_label_31, "<===>");
+                set_contents_color(3, 0x000000);
+            }
+            set_obj_color(guider_ui.screen_setting_label_31, tabdata.item1_page0_color_output);
+        }
+        break;
+
+        case PAGE_PV_ITEM_1:
+        {
+            sprintf(str_temp,"< %d/%d >",tabdata.item_page, I1_PAGE_MAX);
+            lv_label_set_text(guider_ui.screen_setting_label_page, str_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//修改选项卡2的文本
+void set_item2_text(ITEM_CONTENTS con)
+{
+    char str_temp[16] = {0};
+
+    switch (con)
+    {
+        case INPUT_LOG:
+        {
+            lv_label_set_text(guider_ui.screen_setting_label_01, ">");
+        }
+        break;
+
+        case OUTPUT_LOG:
+        {
+            lv_label_set_text(guider_ui.screen_setting_label_11, ">");
+        }
+        break;
+
+        case COMMUNICATION:
+        {
+            lv_label_set_text(guider_ui.screen_setting_label_21, ">");
+        }
+        break;
+
+        case PROGRAM_OUTPUT:
+        {
+            lv_label_set_text(guider_ui.screen_setting_label_31, ">");
+        }
+        break;
+
+        case PAGE_PV_ITEM_2:
+        {
+            sprintf(str_temp,"< %d/%d >",tabdata.item_page, I2_PAGE_MAX);
+            lv_label_set_text(guider_ui.screen_setting_label_page, str_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//修改选项卡3的文本
+void set_item3_text(ITEM_CONTENTS con)
+{
+    char str_temp[32] = {0};
+
+    switch (con)
+    {
+        case LIGHT_STATUS:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                if(tabdata.item3_page0_lightflag)
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_01, text_pack.item_3_val[0]);
+                }
+                else
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_01, text_pack.item_3_val[1]);
+                }
+            }
+            else
+            {
+                if(tabdata.item3_page0_lightflag)
+                {
+                    sprintf(str_temp,"< %s >",text_pack.item_3_val[0]);
+                }
+                else
+                {
+                    sprintf(str_temp,"< %s >",text_pack.item_3_val[1]);
+                }
+                
+                lv_label_set_text(guider_ui.screen_setting_label_01, str_temp);
+            }
+        }
+        break;
+
+        case LANGUAGE_SELECT:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                switch (tabdata.item3_page0_language)
+                {
+                    case MENU_SIMPLYFY_CHINESE:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_11, text_pack.item_3_val[2]);
+                    }
+                    break;
+
+                    case MENU_ENGLISH:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_11, text_pack.item_3_val[3]);
+                    }
+                    break;
+                
+                    default:
+                    break;
+                }
+            }
+            else
+            {
+                switch (tabdata.item3_page0_language)
+                {
+                    case MENU_SIMPLYFY_CHINESE:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[2]);
+                        lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+
+                        //切换语言后，更新本页的其他文本
+                        setting_laguage_switch(MENU_SIMPLYFY_CHINESE);
+                        title_item_refresh();
+                    }
+                    break;
+
+                    case MENU_ENGLISH:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[3]);
+                        lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+
+                        //切换语言后，更新本页的其他文本
+                        setting_laguage_switch(MENU_ENGLISH);
+                        title_item_refresh();
+                    }
+                    break;
+                
+                    default:
+                    break;
+                }
+            }
+        }
+        break;
+
+        case DATA_SAVE:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                switch (tabdata.item3_page0_saveflag)
+                {
+                    case 0:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_21, text_pack.item_3_val[4]);
+                    }
+                    break;
+
+                    case 1:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_21, text_pack.item_3_val[5]);
+                    }
+                    break;
+
+                    case 2:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_21, text_pack.item_3_val[6]);
+                    }
+                    break;
+                
+                    default:
+                    break;
+                }
+            }
+            else
+            {
+                switch (tabdata.item3_page0_saveflag)
+                {
+                    case 0:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[4]);
+                    }
+                    break;
+
+                    case 1:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[5]);
+                    }
+                    break;
+
+                    case 2:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[6]);
+                    }
+                    break;
+                
+                    default:
+                    break;
+                }
+
+                lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+            }
+        }
+        break;
+
+        case DATA_RESET:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                switch (tabdata.item3_page0_resetflag)
+                {
+                    case 0:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, text_pack.item_3_val[7]);
+                    }
+                    break;
+
+                    case 1:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, text_pack.item_3_val[8]);
+                    }
+                    break;
+
+                    case 2:
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_31, text_pack.item_3_val[9]);
+                    }
+                    break;
+                
+                    default:
+                    break;
+                }
+            }
+            else
+            {
+                switch (tabdata.item3_page0_resetflag)
+                {
+                    case 0:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[7]);
+                    }
+                    break;
+
+                    case 1:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[8]);
+                    }
+                    break;
+
+                    case 2:
+                    {
+                        sprintf(str_temp,"< %s >",text_pack.item_3_val[9]);
+                    }
+                    break;
+                
+                    default:
+                    break;
+                }
+
+                lv_label_set_text(guider_ui.screen_setting_label_31, str_temp);
+            }
+        }
+        break;
+
+        case PAGE_PV_ITEM_3:
+        {
+            sprintf(str_temp,"< %d/%d >",tabdata.item_page, I3_PAGE_MAX);
+            lv_label_set_text(guider_ui.screen_setting_label_page, str_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//修改对象颜色
+void set_obj_color(lv_obj_t * obj, uint8_t color)
+{
+    lv_obj_set_style_text_color(obj, lv_color_hex(color_table[color]), LV_PART_MAIN|LV_STATE_DEFAULT);
+}
+
+

App/APP_WU/Src/scr_setting_item_value.c

@@ -0,0 +1,680 @@
+#include "scr_setting_item_value.h"
+//该部分代码用于修改选项卡内部，右侧一列的值
+
+//修改选项卡0的值
+void set_item0_value(ITEM_CONTENTS con, int8_t step)
+{
+    uint8_t enum_temp = 0;
+
+    switch (con)
+    {
+        case VOL_UNIT_SET:
+        {
+            if( tabdata.item0_page0_vunit == VOLTAGE_V )
+            {
+                tabdata.item0_page0_vunit = VOLTAGE_MV;
+            }
+            else
+            {
+                tabdata.item0_page0_vunit = VOLTAGE_V;
+            }
+
+            //修改单位后，更新上下限
+            set_item0_text(VOL_UP_SET);
+            set_item0_text(VOL_LOW_SET);
+        }
+        break;
+
+        case VOL_UP_SET:
+        {
+            if( tabdata.item0_page0_vunit == VOLTAGE_V )
+            {
+                tabdata.item0_page0_vup[0] = tabdata.item0_page0_vup[0] + step;
+
+                //上下限幅
+                if(tabdata.item0_page0_vup[0] > VOL[0].up) tabdata.item0_page0_vup[0] = VOL[0].up;
+                if(tabdata.item0_page0_vup[0] < VOL[0].low) tabdata.item0_page0_vup[0] = VOL[0].low;
+
+                //防止自相矛盾
+                if(tabdata.item0_page0_vup[0] < tabdata.item0_page0_vlow[0]) tabdata.item0_page0_vup[0] = tabdata.item0_page0_vlow[0];
+            }
+            else
+            {
+                tabdata.item0_page0_vup[1] = tabdata.item0_page0_vup[1] + step;
+
+                //上下限幅
+                if(tabdata.item0_page0_vup[1] > VOL[1].up) tabdata.item0_page0_vup[1] = VOL[1].up;
+                if(tabdata.item0_page0_vup[1] < VOL[1].low) tabdata.item0_page0_vup[1] = VOL[1].low;
+
+                //防止自相矛盾
+                if(tabdata.item0_page0_vup[1] < tabdata.item0_page0_vlow[1]) tabdata.item0_page0_vup[1] = tabdata.item0_page0_vlow[1];
+            }
+        }
+        break;
+
+        case VOL_LOW_SET:
+        {
+            if( tabdata.item0_page0_vunit == VOLTAGE_V )
+            {
+                tabdata.item0_page0_vlow[0] = tabdata.item0_page0_vlow[0] + step;
+
+                //上下限幅
+                if(tabdata.item0_page0_vlow[0] > VOL[0].up) tabdata.item0_page0_vlow[0] = VOL[0].up;
+                if(tabdata.item0_page0_vlow[0] < VOL[0].low) tabdata.item0_page0_vlow[0] = VOL[0].low;
+
+                //防止自相矛盾
+                if(tabdata.item0_page0_vlow[0] > tabdata.item0_page0_vup[0]) tabdata.item0_page0_vlow[0] = tabdata.item0_page0_vup[0];
+            }
+            else
+            {
+                tabdata.item0_page0_vlow[1] = tabdata.item0_page0_vlow[1] + step;
+
+                //上下限幅
+                if(tabdata.item0_page0_vlow[1] > VOL[1].up) tabdata.item0_page0_vlow[1] = VOL[1].up;
+                if(tabdata.item0_page0_vlow[1] < VOL[1].low) tabdata.item0_page0_vlow[1] = VOL[1].low;
+
+                //防止自相矛盾
+                if(tabdata.item0_page0_vlow[1] > tabdata.item0_page0_vup[1]) tabdata.item0_page0_vlow[1] = tabdata.item0_page0_vup[1];
+            }
+        }
+        break;
+
+        case CURRENT_UP_SET:
+        {
+            tabdata.item0_page0_cup = tabdata.item0_page0_cup + step;
+
+            //上下限幅
+            if(tabdata.item0_page0_cup > CUR.up) tabdata.item0_page0_cup = CUR.up;
+            if(tabdata.item0_page0_cup < CUR.low) tabdata.item0_page0_cup = CUR.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page0_cup < tabdata.item0_page0_clow) tabdata.item0_page0_cup = tabdata.item0_page0_clow;
+        }
+        break;
+
+        case CURRENT_LOW_SET:
+        {
+            tabdata.item0_page0_clow = tabdata.item0_page0_clow + step;
+
+            //上下限幅
+            if(tabdata.item0_page0_clow > CUR.up) tabdata.item0_page0_clow = CUR.up;
+            if(tabdata.item0_page0_clow < CUR.low) tabdata.item0_page0_clow = CUR.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page0_clow > tabdata.item0_page0_cup) tabdata.item0_page0_clow = tabdata.item0_page0_cup;
+        }
+        break;
+
+        case RES_UP_SET:
+        {
+            tabdata.item0_page0_rup = tabdata.item0_page0_rup + step;
+
+            //上下限幅
+            if(tabdata.item0_page0_rup > RES.up) tabdata.item0_page0_rup = RES.up;
+            if(tabdata.item0_page0_rup < RES.low) tabdata.item0_page0_rup = RES.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page0_rup < tabdata.item0_page1_rlow) tabdata.item0_page0_rup = tabdata.item0_page1_rlow;
+        }
+        break;
+
+        case RES_LOW_SET:
+        {
+            tabdata.item0_page1_rlow = tabdata.item0_page1_rlow + step;
+
+            //上下限幅
+            if(tabdata.item0_page1_rlow > RES.up) tabdata.item0_page1_rlow = RES.up;
+            if(tabdata.item0_page1_rlow < RES.low) tabdata.item0_page1_rlow = RES.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page1_rlow > tabdata.item0_page0_rup) tabdata.item0_page1_rlow = tabdata.item0_page0_rup;
+        }
+        break;
+
+        case FRE_UP_SET:
+        {
+            tabdata.item0_page1_fup = tabdata.item0_page1_fup + step;
+
+            //上下限幅
+            if(tabdata.item0_page1_fup > FRE.up) tabdata.item0_page1_fup = FRE.up;
+            if(tabdata.item0_page1_fup < FRE.low) tabdata.item0_page1_fup = FRE.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page1_fup < tabdata.item0_page1_flow) tabdata.item0_page1_fup = tabdata.item0_page1_flow;
+        }
+        break;
+
+        case FRE_LOW_SET:
+        {
+            tabdata.item0_page1_flow = tabdata.item0_page1_flow + step;
+
+            //上下限幅
+            if(tabdata.item0_page1_flow > FRE.up) tabdata.item0_page1_flow = FRE.up;
+            if(tabdata.item0_page1_flow < FRE.low) tabdata.item0_page1_flow = FRE.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page1_flow > tabdata.item0_page1_fup) tabdata.item0_page1_flow = tabdata.item0_page1_fup;
+        }
+        break;
+
+        case TC_TYPE_SET:
+        {
+            enum_temp = (uint8_t)tabdata.item0_page1_TCtype;
+            enum_temp = enum_temp + step;
+            if(enum_temp > 12) enum_temp = 5;
+            if(enum_temp < 5) enum_temp = 12;
+            tabdata.item0_page1_TCtype = (SIG_FUNCTIONS_TYPE)enum_temp;
+
+            //修改单位后，更新上下限
+            set_item0_text(TC_UP_SET);
+            set_item0_text(TC_LOW_SET);
+        }
+        break;
+
+        case TC_UP_SET:
+        {
+            enum_temp = (uint8_t)tabdata.item0_page1_TCtype;
+            enum_temp -= 5;
+         
+            tabdata.item0_page1_TCup[enum_temp]= tabdata.item0_page1_TCup[enum_temp] + step;
+
+            //上下限幅
+            if(tabdata.item0_page1_TCup[enum_temp] > TC[enum_temp].up) tabdata.item0_page1_TCup[enum_temp] = TC[enum_temp].up;
+            if(tabdata.item0_page1_TCup[enum_temp] < TC[enum_temp].low) tabdata.item0_page1_TCup[enum_temp] = TC[enum_temp].low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page1_TCup[enum_temp] < tabdata.item0_page1_TClow[enum_temp]) tabdata.item0_page1_TCup[enum_temp] = tabdata.item0_page1_TClow[enum_temp];
+        }
+        break;
+
+        case TC_LOW_SET:
+        {
+            enum_temp = (uint8_t)tabdata.item0_page1_TCtype;
+            enum_temp -= 5;
+         
+            tabdata.item0_page1_TClow[enum_temp]= tabdata.item0_page1_TClow[enum_temp] + step;
+
+            //上下限幅
+            if(tabdata.item0_page1_TClow[enum_temp] > TC[enum_temp].up) tabdata.item0_page1_TClow[enum_temp] = TC[enum_temp].up;
+            if(tabdata.item0_page1_TClow[enum_temp] < TC[enum_temp].low) tabdata.item0_page1_TClow[enum_temp] = TC[enum_temp].low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page1_TClow[enum_temp] > tabdata.item0_page1_TCup[enum_temp]) tabdata.item0_page1_TClow[enum_temp] = tabdata.item0_page1_TCup[enum_temp];
+        }
+        break;
+
+        case RTD_UP_SET:
+        {
+            tabdata.item0_page2_RTDup = tabdata.item0_page2_RTDup + step;
+
+            //上下限幅
+            if(tabdata.item0_page2_RTDup > RTD.up) tabdata.item0_page2_RTDup = RTD.up;
+            if(tabdata.item0_page2_RTDup < RTD.low) tabdata.item0_page2_RTDup = RTD.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page2_RTDup < tabdata.item0_page2_RTDlow) tabdata.item0_page2_RTDup = tabdata.item0_page2_RTDlow;
+        }
+        break;
+
+        case RTD_LOW_SET:
+        {
+            tabdata.item0_page2_RTDlow = tabdata.item0_page2_RTDlow + step;
+
+            //上下限幅
+            if(tabdata.item0_page2_RTDlow > RTD.up) tabdata.item0_page2_RTDlow = RTD.up;
+            if(tabdata.item0_page2_RTDlow < RTD.low) tabdata.item0_page2_RTDlow = RTD.low;
+
+            //防止自相矛盾
+            if(tabdata.item0_page2_RTDlow > tabdata.item0_page2_RTDup) tabdata.item0_page2_RTDlow = tabdata.item0_page2_RTDup;
+        }
+        break;
+
+        default:
+        break;
+    }
+}
+
+
+//修改选项卡1的值
+int16_t save_cnt = 0;
+int16_t reset_cnt = 0;
+void set_item1_value(ITEM_CONTENTS con, int8_t step)
+{
+    uint8_t val_temp = 0;
+    uint8_t val_start = 0;
+    uint8_t val_end = 0;
+
+    switch (con)
+    {
+        case SAMPLE_INTERVAL:
+        {
+            tabdata.item1_page0_sample_interval += step * 100;
+            if( tabdata.item1_page0_sample_interval > SAMPLE_INTERVAL_MAX ) tabdata.item1_page0_sample_interval = SAMPLE_INTERVAL_MAX;
+            if( tabdata.item1_page0_sample_interval < MENU_TASK_PERIOD ) tabdata.item1_page0_sample_interval = MENU_TASK_PERIOD;
+
+            HoldReg[HOLD_ADDR_SAMPLE_INTERVAL] = tabdata.item1_page0_sample_interval;
+        }
+        break;
+
+        case PLOT_NUM:
+        {
+            tabdata.item1_page0_plot_num += step;
+            if( tabdata.item1_page0_plot_num > PLOT_NUM_MAX ) tabdata.item1_page0_plot_num = PLOT_NUM_MAX;
+            if( tabdata.item1_page0_plot_num < PLOT_NUM_MIN ) tabdata.item1_page0_plot_num = PLOT_NUM_MIN;
+
+            HoldReg[HOLD_ADDR_PLOT_COUNTS] = 0x00FF & tabdata.item1_page0_plot_num;
+        }
+        break;
+
+        case INPUT_COLOR:
+        {
+            val_start = (uint8_t)COLOR_BLUE;
+            val_end = (uint8_t)COLOR_PURPLE;
+            val_temp = (uint8_t)tabdata.item1_page0_color_input;
+            val_temp += step;
+
+            if( val_temp > val_end ) 
+            {
+                if( val_temp < 200)
+                {
+                    val_temp = val_start;
+                }
+                else
+                {
+                    val_temp = val_end;
+                }
+            }
+            if( val_temp < val_start ) val_temp = val_end;
+
+            tabdata.item1_page0_color_input = (COLORS)val_temp;
+            HoldReg[HOLD_ADDR_INPUT_COLOR] = 0x00FF & (uint8_t)tabdata.item1_page0_color_input;
+        }
+        break;
+
+        case OUTPUT_COLOR:
+        {
+            val_start = (uint8_t)COLOR_BLUE;
+            val_end = (uint8_t)COLOR_PURPLE;
+            val_temp = (uint8_t)tabdata.item1_page0_color_output;
+            val_temp += step;
+
+            if( val_temp > val_end ) 
+            {
+                if( val_temp < 200)
+                {
+                    val_temp = val_start;
+                }
+                else
+                {
+                    val_temp = val_end;
+                }
+            }
+            if( val_temp < val_start ) val_temp = val_end;
+
+            tabdata.item1_page0_color_output = (COLORS)val_temp;
+            HoldReg[HOLD_ADDR_OUTPUT_COLOR] = 0x00FF & (uint8_t)tabdata.item1_page0_color_output;
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//修改选项卡2的值
+void set_item2_value(ITEM_CONTENTS con, int8_t step)
+{
+    switch (con)
+    {
+        default:
+        break;
+    }
+}
+
+//修改选项卡3的值
+void set_item3_value(ITEM_CONTENTS con, int8_t step)
+{
+    uint8_t val_temp = 0;
+    uint8_t val_start = 0;
+    uint8_t val_end = 0;
+
+    switch (con)
+    {
+        case LIGHT_STATUS:
+        {
+            if(tabdata.item3_page0_lightflag)
+            {
+                tabdata.item3_page0_lightflag = 0;
+                LIGHT_OFF;
+
+                //D1位置0
+                //CoilState[0] &= 0xFD;
+                set_coil_val(COIL_ADDR_LIGHT, 0);
+            }
+            else
+            {
+                tabdata.item3_page0_lightflag = 1;
+                LIGHT_ON;
+                
+                //D1位置1
+                CoilState[0] |= 0x02;
+                set_coil_val(COIL_ADDR_LIGHT, 1);
+            }
+        }
+        break;
+
+        case LANGUAGE_SELECT:
+        {
+            val_start = (uint8_t)MENU_SIMPLYFY_CHINESE;
+            val_end = (uint8_t)MENU_ENGLISH;
+            val_temp = (uint8_t)tabdata.item3_page0_language;
+            val_temp += step;
+
+            if( val_temp > val_end ) 
+            {
+                if(val_temp < 200)
+                {
+                    val_temp = val_start;
+                }
+                else
+                {
+                    val_temp = val_end;
+                }
+            }
+
+            if( val_temp < val_start ) val_temp = val_end;
+
+            tabdata.item3_page0_language = (LANGUAGES)val_temp;
+            HoldReg[HOLD_ADDR_LANGUAGE] = 0x00FF & (uint8_t)tabdata.item3_page0_language;
+
+            if(tabdata.item3_page0_saveflag == 2) tabdata.item3_page0_saveflag = 0;
+            if(tabdata.item3_page0_resetflag == 2) tabdata.item3_page0_resetflag = 0;
+
+        }
+        break;
+
+        case DATA_SAVE:
+        {
+            if(tabdata.item3_page0_saveflag == 0)
+            {
+                tabdata.item3_page0_saveflag = 1;
+
+                save_cnt = 0;
+            }
+        }
+        break;
+
+        case DATA_RESET:
+        {
+            if(tabdata.item3_page0_resetflag == 0)
+            {
+                tabdata.item3_page0_resetflag = 1;
+                
+                reset_cnt = 0;
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+//查看输入输出记录，io -> 输入/输出，page -> 指定页码
+void show_IO_log(uint8_t io, uint8_t page)
+{
+    if( (page > 10) || (page < 1) )
+    {
+        return;
+    }
+
+    //启用所需组件
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_50, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_50, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_51, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_51, LV_OBJ_FLAG_HIDDEN); };
+    
+    uint8_t cur = 0;
+    cur = (page - 1)*6; 
+    char str[16];
+
+    //1秒1条记录，60秒才能填满，填满之前时间戳以“---”代替
+    if(tabdata.log_time[cur][2] == 0)
+    {
+        //第1条时间为空，后面5*2条也为空
+        lv_label_set_text(guider_ui.screen_setting_label_00, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_10, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_20, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_30, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_40, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_50, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_01, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_11, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_21, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_31, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_41, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_51, "---");
+    }
+    else if(tabdata.log_time[cur + 1][2] == 0)
+    {
+        show_time_unit_value(guider_ui.screen_setting_label_00, guider_ui.screen_setting_label_01, io, cur);
+
+        //第2条时间为空，后面4*2条也为空
+        lv_label_set_text(guider_ui.screen_setting_label_10, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_20, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_30, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_40, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_50, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_11, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_21, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_31, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_41, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_51, "---");
+    }
+    else if(tabdata.log_time[cur + 2][2] == 0)
+    {
+        show_time_unit_value(guider_ui.screen_setting_label_00, guider_ui.screen_setting_label_01, io, cur);
+        show_time_unit_value(guider_ui.screen_setting_label_10, guider_ui.screen_setting_label_11, io, cur + 1);
+
+        //第3条时间为空，后面3*2条也为空
+        lv_label_set_text(guider_ui.screen_setting_label_20, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_30, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_40, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_50, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_21, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_31, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_41, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_51, "---");
+    }
+    else if(tabdata.log_time[cur + 3][2] == 0)
+    {
+        show_time_unit_value(guider_ui.screen_setting_label_00, guider_ui.screen_setting_label_01, io, cur);
+        show_time_unit_value(guider_ui.screen_setting_label_10, guider_ui.screen_setting_label_11, io, cur + 1);
+        show_time_unit_value(guider_ui.screen_setting_label_20, guider_ui.screen_setting_label_21, io, cur + 2);
+
+        //第4条时间为空，后面2*2条也为空
+        lv_label_set_text(guider_ui.screen_setting_label_30, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_40, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_50, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_31, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_41, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_51, "---");
+    }
+    else if(tabdata.log_time[cur + 4][2] == 0)
+    {
+        show_time_unit_value(guider_ui.screen_setting_label_00, guider_ui.screen_setting_label_01, io, cur);
+        show_time_unit_value(guider_ui.screen_setting_label_10, guider_ui.screen_setting_label_11, io, cur + 1);
+        show_time_unit_value(guider_ui.screen_setting_label_20, guider_ui.screen_setting_label_21, io, cur + 2);
+        show_time_unit_value(guider_ui.screen_setting_label_30, guider_ui.screen_setting_label_31, io, cur + 3);
+
+        //第5条时间为空，后面1*2条也为空
+        lv_label_set_text(guider_ui.screen_setting_label_40, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_50, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_41, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_51, "---");
+    }
+    else if(tabdata.log_time[cur + 5][2] == 0)
+    {
+        show_time_unit_value(guider_ui.screen_setting_label_00, guider_ui.screen_setting_label_01, io, cur);
+        show_time_unit_value(guider_ui.screen_setting_label_10, guider_ui.screen_setting_label_11, io, cur + 1);
+        show_time_unit_value(guider_ui.screen_setting_label_20, guider_ui.screen_setting_label_21, io, cur + 2);
+        show_time_unit_value(guider_ui.screen_setting_label_30, guider_ui.screen_setting_label_31, io, cur + 3);
+        show_time_unit_value(guider_ui.screen_setting_label_40, guider_ui.screen_setting_label_41, io, cur + 4);
+
+        //第6条时间为空
+        lv_label_set_text(guider_ui.screen_setting_label_50, "---");
+        lv_label_set_text(guider_ui.screen_setting_label_51, "---");
+    }
+    else
+    {
+        //6条数据时间均不为空
+        show_time_unit_value(guider_ui.screen_setting_label_00, guider_ui.screen_setting_label_01, io, cur);
+        show_time_unit_value(guider_ui.screen_setting_label_10, guider_ui.screen_setting_label_11, io, cur + 1);
+        show_time_unit_value(guider_ui.screen_setting_label_20, guider_ui.screen_setting_label_21, io, cur + 2);
+        show_time_unit_value(guider_ui.screen_setting_label_30, guider_ui.screen_setting_label_31, io, cur + 3);
+        show_time_unit_value(guider_ui.screen_setting_label_40, guider_ui.screen_setting_label_41, io, cur + 4);
+        show_time_unit_value(guider_ui.screen_setting_label_50, guider_ui.screen_setting_label_51, io, cur + 5);
+    }
+
+    sprintf(str,"< %d/%d >", page, 10);
+    lv_label_set_text(guider_ui.screen_setting_label_page, str);
+}
+
+//显示时间戳、物理量单位、数值
+void show_time_unit_value(lv_obj_t *obj_left, lv_obj_t *obj_right, uint8_t io, uint8_t cur)
+{
+    char str_temp[16];
+    char str_temp_val[16];
+    SIG_FUNCTIONS_TYPE unit;
+
+    switch (io)
+    {
+        case IO_INPUT:
+        {
+            //数值
+            sprintf(str_temp_val, "%.3f", tabdata.input_log_value[cur]);
+
+            unit = tabdata.input_log_unit[cur];
+        }
+        break;
+
+        case IO_OUTPUT:
+        {
+            //数值
+            sprintf(str_temp_val, "%.3f", tabdata.output_log_value[cur]);
+
+            unit = tabdata.output_log_unit[cur];
+        }
+        break;
+
+        default:
+        break;
+    }
+
+    //时间、物理量单位
+    switch (unit)
+    {
+        case VOLTAGE_MV:
+        {
+            sprintf(str_temp,"%s mV",tabdata.log_time[cur]);
+        }
+        break;
+
+        case VOLTAGE_V:
+        {
+            sprintf(str_temp,"%s V",tabdata.log_time[cur]);
+        }
+        break;
+
+        case CURRENT_MA:
+        {
+            sprintf(str_temp,"%s mA",tabdata.log_time[cur]);
+        }
+        break;
+
+        case RESISTANT_OHM:
+        {
+            sprintf(str_temp,"%s Ω",tabdata.log_time[cur]);
+        }
+        break;
+
+        case FREQUENCE_KHZ:
+        {
+            sprintf(str_temp,"%s KHz",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_K:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_S:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_N:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_B:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_E:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_J:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_R:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case TC_T:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+
+        case RTD_DC:
+        {
+            sprintf(str_temp,"%s ℃",tabdata.log_time[cur]);
+        }
+        break;
+    
+        default:
+        break;
+    }
+
+    //左列：时间、物理量单位
+    lv_label_set_text(obj_left, str_temp);
+
+    //右列：数值
+    lv_label_set_text(obj_right, str_temp_val);
+}
+
+

App/APP_WU/Src/scr_setting_progam_out.c

@@ -0,0 +1,891 @@
+#include "scr_setting_progam_out.h"
+
+PROGRAM_OUT_DATA progout_data;
+uint8_t cursor_conf1 = 0;
+uint8_t cursor_conf1_prv = 99;
+uint8_t cursor_conf2 = 0;
+uint8_t cursor_conf2_prv = 99;
+
+void program_out_init(void)
+{
+    progout_data.output_unit = PROG_OUT_MA;
+    progout_data.output_mode = PROG_OUT_STEP;
+    progout_data.circulations = 3;
+    progout_data.hold_time = 3000;
+    progout_data.start_percent = 0;
+    progout_data.end_percent = 100;
+    progout_data.step_percent = 25;
+    progout_data.rising_percent = 100;
+    progout_data.falling_percent = 0;
+    progout_data.period = 5000;
+    progout_data.process = PROGOUT_WAITING;
+    progout_data.progout_tick = 0;
+    progout_data.progout_tick_flag = 0;
+}
+
+void program_out_config1(void)
+{
+    //启用所需组件
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN); };
+    if( lv_obj_has_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN); };
+
+    //隐藏多余组件
+    lv_obj_add_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(guider_ui.screen_setting_label_50, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(guider_ui.screen_setting_label_51, LV_OBJ_FLAG_HIDDEN);
+
+    //显示左列文本
+    lv_label_set_text(guider_ui.screen_setting_label_00, text_pack.program_out_config1[0]);
+    lv_label_set_text(guider_ui.screen_setting_label_10, text_pack.program_out_config1[1]);
+    lv_label_set_text(guider_ui.screen_setting_label_20, text_pack.program_out_config1[2]);
+    lv_label_set_text(guider_ui.screen_setting_label_30, text_pack.program_out_config1[3]);
+
+    //显示右列值
+    text_update_conf1(CONF1_OUTPUT_UNIT);
+    text_update_conf1(CONF1_OUTPUT_MODE);
+    text_update_conf1(CONF1_CIRCULATIONS);
+    lv_label_set_text(guider_ui.screen_setting_label_31, ">");
+
+    //初始化游标
+    cursor_conf1 = 0;
+    cursor_conf1_prv = 99;
+    setting_contents_check(cursor_conf1, cursor_conf1_prv);
+}
+
+void val_modify_conf1(int8_t step)
+{
+    switch(cursor_conf1)
+    {
+        case CONF1_OUTPUT_UNIT:
+        {
+            progout_data.output_unit += step;
+            if( (1 < progout_data.output_unit)&&(progout_data.output_unit < 200) ) progout_data.output_unit = 0;
+            if( progout_data.output_unit > 200 ) progout_data.output_unit = 1;
+        }
+        break;
+
+        case CONF1_OUTPUT_MODE:
+        {
+            progout_data.output_mode += step;
+            if( (1 < progout_data.output_mode)&&(progout_data.output_mode < 200) ) progout_data.output_mode = 0;
+            if( progout_data.output_mode > 200 ) progout_data.output_mode = 1;
+        }
+        break;
+
+        case CONF1_CIRCULATIONS:
+        {
+            progout_data.circulations += step;
+            if( (11 < progout_data.circulations)&&(progout_data.circulations < 200) ) progout_data.circulations = 1;
+            if( progout_data.circulations < 1 ) progout_data.circulations = 11;
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void text_update_conf1(uint8_t con)
+{
+    char str_temp[20] = {0};
+
+    switch (con)
+    {
+        case CONF1_OUTPUT_UNIT:
+        {
+            switch (progout_data.output_unit)
+            {
+                case PROG_OUT_V:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_01, "V");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_01, "< V >");
+                    }
+                }
+                break;
+
+                case PROG_OUT_MA:
+                {
+                    if(tabdata.content_focus == 0)
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_01, "mA");
+                    }
+                    else
+                    {
+                        lv_label_set_text(guider_ui.screen_setting_label_01, "< mA >");
+                    }
+                }
+                break;
+            
+                default:
+                break;
+            }
+        }
+        break;
+
+        case CONF1_OUTPUT_MODE:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                lv_label_set_text(guider_ui.screen_setting_label_11, text_pack.program_out_config1_val[progout_data.output_mode]);
+            }
+            else
+            {
+                sprintf(str_temp, "< %s >", text_pack.program_out_config1_val[progout_data.output_mode]);
+                lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+            }
+        }
+        break;
+
+        case CONF1_CIRCULATIONS:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                if(progout_data.circulations <= CIRCULATIONS_MAX )
+                {
+                    sprintf(str_temp, "%d", progout_data.circulations);
+                    lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+                }
+                else
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_21, "∞");
+                }
+            }
+            else
+            {
+                if(progout_data.circulations <= CIRCULATIONS_MAX )
+                {
+                    sprintf(str_temp, "< %d >", progout_data.circulations);
+                    lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+                }
+                else
+                {
+                    lv_label_set_text(guider_ui.screen_setting_label_21, "< ∞ >");
+                }
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void program_out_config2(void)
+{
+    switch (progout_data.output_mode)
+    {
+        case PROG_OUT_STEP:
+        {
+            //启用所需组件
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN); };
+
+            //隐藏多余组件
+            lv_obj_add_flag(guider_ui.screen_setting_label_50, LV_OBJ_FLAG_HIDDEN);
+            lv_obj_add_flag(guider_ui.screen_setting_label_51, LV_OBJ_FLAG_HIDDEN);
+
+            //显示左列文本
+            lv_label_set_text(guider_ui.screen_setting_label_00, text_pack.program_out_config2[0]);
+            lv_label_set_text(guider_ui.screen_setting_label_10, text_pack.program_out_config2[2]);
+            lv_label_set_text(guider_ui.screen_setting_label_20, text_pack.program_out_config2[3]);
+            lv_label_set_text(guider_ui.screen_setting_label_30, text_pack.program_out_config2[4]);
+            lv_label_set_text(guider_ui.screen_setting_label_40, text_pack.program_out_config2[1]);
+
+            //显示右列值
+            text_update_conf2(CONF2_OUTPUT_MODE);
+            text_update_conf2(CONF2_START_PERCENT);
+            text_update_conf2(CONF2_END_PERCENT);
+            text_update_conf2(CONF2_STEP_PERCENT);
+            text_update_conf2(CONF2_HOLD_TIME);
+
+            //初始化游标
+            cursor_conf2 = 1;
+            cursor_conf2_prv = 99;
+            setting_contents_check(cursor_conf2, cursor_conf2_prv);
+        }
+        break;
+
+        case PROG_OUT_TRIANGLE:
+        {
+            //启用所需组件
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_00, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_01, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_10, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_11, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_20, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_21, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_30, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_31, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_40, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_41, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_50, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_50, LV_OBJ_FLAG_HIDDEN); };
+            if( lv_obj_has_flag(guider_ui.screen_setting_label_51, LV_OBJ_FLAG_HIDDEN) ) { lv_obj_clear_flag(guider_ui.screen_setting_label_51, LV_OBJ_FLAG_HIDDEN); };
+
+            //显示左列文本
+            lv_label_set_text(guider_ui.screen_setting_label_00, text_pack.program_out_config2[0]);
+            lv_label_set_text(guider_ui.screen_setting_label_10, text_pack.program_out_config2[2]);
+            lv_label_set_text(guider_ui.screen_setting_label_20, text_pack.program_out_config2[3]);
+            lv_label_set_text(guider_ui.screen_setting_label_30, text_pack.program_out_config2[5]);
+            lv_label_set_text(guider_ui.screen_setting_label_40, text_pack.program_out_config2[6]);
+            lv_label_set_text(guider_ui.screen_setting_label_50, text_pack.program_out_config2[7]);
+
+            //显示右列值
+            text_update_conf2(CONF2_OUTPUT_MODE);
+            text_update_conf2(CONF2_START_PERCENT);
+            text_update_conf2(CONF2_END_PERCENT);
+            text_update_conf2(CONF2_RISING_PERCENT);
+            text_update_conf2(CONF2_FALLING_PERCENT);
+            text_update_conf2(CONF2_PERIOD);
+
+            //初始化游标
+            cursor_conf2 = 1;
+            cursor_conf2_prv = 99;
+            setting_contents_check(cursor_conf2, cursor_conf2_prv);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void text_update_conf2(uint8_t con)
+{
+    char str_temp[20] = {0};
+
+    switch (con)
+    {
+        case CONF2_OUTPUT_MODE:
+        {
+            lv_label_set_text(guider_ui.screen_setting_label_01, text_pack.program_out_config1_val[progout_data.output_mode]);
+        }
+        break;
+
+        case CONF2_START_PERCENT:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d%%", progout_data.start_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d%% >", progout_data.start_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_11, str_temp);
+            }
+        }
+        break;
+
+        case CONF2_END_PERCENT:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d%%", progout_data.end_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d%% >", progout_data.end_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_21, str_temp);
+            }
+        }
+        break;
+
+        case CONF2_STEP_PERCENT:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d%%", progout_data.step_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_31, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d%% >", progout_data.step_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_31, str_temp);
+            }
+        }
+        break;
+
+        case CONF2_HOLD_TIME:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d", progout_data.hold_time);
+                lv_label_set_text(guider_ui.screen_setting_label_41, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d >", progout_data.hold_time);
+                lv_label_set_text(guider_ui.screen_setting_label_41, str_temp);
+            }
+        }
+        break;
+
+        case CONF2_RISING_PERCENT:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d%%", progout_data.rising_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_31, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d%% >", progout_data.rising_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_31, str_temp);
+            }
+        }
+        break;
+
+        case CONF2_FALLING_PERCENT:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d%%", progout_data.falling_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_41, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d%% >", progout_data.falling_percent);
+                lv_label_set_text(guider_ui.screen_setting_label_41, str_temp);
+            }
+        }
+        break;
+
+        case CONF2_PERIOD:
+        {
+            if(tabdata.content_focus == 0)
+            {
+                sprintf(str_temp, "%d", progout_data.period);
+                lv_label_set_text(guider_ui.screen_setting_label_51, str_temp);
+            }
+            else
+            {
+                sprintf(str_temp, "< %d >", progout_data.period);
+                lv_label_set_text(guider_ui.screen_setting_label_51, str_temp);
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void val_modify_conf2(int8_t step)
+{
+    uint8_t cur_temp = 0;
+
+    //阶跃和三角波的枚举类型存在交叉
+    if( (progout_data.output_mode == PROG_OUT_STEP)||(cursor_conf2 <= 2) )
+    {
+        cur_temp = cursor_conf2;
+    }
+    else
+    {
+        cur_temp = cursor_conf2 + 2;
+    }
+
+    switch(cur_temp)
+    {
+        //0~95
+        case CONF2_START_PERCENT:
+        {
+            progout_data.start_percent += step;
+            if(progout_data.start_percent > 200) progout_data.start_percent = 0; 
+            if( (progout_data.end_percent - 5) <= progout_data.start_percent ) 
+                progout_data.start_percent = progout_data.end_percent - 5;
+
+            text_update_conf2(cur_temp);
+
+            if(progout_data.output_mode == PROG_OUT_STEP)
+            {
+                //起点与终点的间隔较小时，步长同步变化
+                if(progout_data.step_percent > (progout_data.end_percent - progout_data.start_percent)) 
+                    progout_data.step_percent = progout_data.end_percent - progout_data.start_percent;
+                tabdata.content_focus = 0;
+                text_update_conf2(CONF2_STEP_PERCENT);
+                tabdata.content_focus = 1;
+            }
+        }
+        break;
+
+        //5~100
+        case CONF2_END_PERCENT:
+        {
+            progout_data.end_percent += step;
+            if(progout_data.end_percent > 100) progout_data.end_percent = 100; 
+            if( (progout_data.end_percent - 5) <= progout_data.start_percent ) 
+                progout_data.end_percent = progout_data.start_percent + 5;
+
+            text_update_conf2(cur_temp);
+
+            if(progout_data.output_mode == PROG_OUT_STEP)
+            {
+                //起点与终点的间隔较小时，步长同步变化
+                if(progout_data.step_percent > (progout_data.end_percent - progout_data.start_percent)) 
+                    progout_data.step_percent = progout_data.end_percent - progout_data.start_percent;
+                tabdata.content_focus = 0;
+                text_update_conf2(CONF2_STEP_PERCENT);
+                tabdata.content_focus = 1;
+            }
+        }
+        break;
+
+        case CONF2_STEP_PERCENT:
+        {
+            progout_data.step_percent += step;
+            if(progout_data.step_percent < 5) progout_data.step_percent = 5;
+            if(progout_data.step_percent > (progout_data.end_percent - progout_data.start_percent)) 
+                progout_data.step_percent = progout_data.end_percent - progout_data.start_percent;
+
+            text_update_conf2(cur_temp);
+        }
+        break;
+
+        case CONF2_HOLD_TIME:
+        {
+            if( step > 0 )
+            {
+                progout_data.hold_time += 500;
+            }
+            else
+            {
+                progout_data.hold_time -= 500;
+            }
+            if(progout_data.hold_time < 500) progout_data.hold_time = 500;
+            if(progout_data.hold_time > 30000) progout_data.hold_time = 30000;
+
+            text_update_conf2(cur_temp);
+        }
+        break;
+
+        case CONF2_RISING_PERCENT:
+        {
+            progout_data.rising_percent += step;
+            if( progout_data.rising_percent > 200 ) progout_data.rising_percent = 0;
+            if( progout_data.rising_percent > 100 ) progout_data.rising_percent = 100;
+            
+            text_update_conf2(CONF2_RISING_PERCENT);
+
+            //下降占比同步更新
+            progout_data.falling_percent = 100 - progout_data.rising_percent;
+            tabdata.content_focus = 0;
+            text_update_conf2(CONF2_FALLING_PERCENT);
+            tabdata.content_focus = 1;
+        }
+        break;
+
+        case CONF2_FALLING_PERCENT:
+        {
+            progout_data.falling_percent += step;
+            if( progout_data.falling_percent > 200 ) progout_data.falling_percent = 0;
+            if( progout_data.falling_percent > 100 ) progout_data.falling_percent = 100;
+            
+            text_update_conf2(CONF2_FALLING_PERCENT);
+
+            //上升占比同步更新
+            progout_data.rising_percent = 100 - progout_data.falling_percent;
+            tabdata.content_focus = 0;
+            text_update_conf2(CONF2_RISING_PERCENT);
+            tabdata.content_focus = 1;
+        }
+        break;
+
+        case CONF2_PERIOD:
+        {
+            if( step > 0 )
+            {
+                progout_data.period += 500;
+            }
+            else
+            {
+                progout_data.period -= 500;
+            }
+            if(progout_data.period < 1000) progout_data.period = 1000;
+            if(progout_data.period > 10000) progout_data.period = 10000;
+
+            text_update_conf2(cur_temp);
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void program_out_run(void)
+{
+    switch (progout_data.output_mode)
+    {
+        case PROG_OUT_STEP:
+        {
+            program_out_step();
+        }
+        break;
+
+        case PROG_OUT_TRIANGLE:
+        {
+            program_out_triangle();
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void percent2val_out(float32 perc)
+{
+    if( (perc < 0)||(perc > 100) ) return;
+
+    mux_signal.data_sv = perc / (float32)100 * (progout_data.out_max - progout_data.out_min) + progout_data.out_min;
+    mux_signal.data_sv = real2mux(mux_signal.data_sv);
+}
+
+int8_t step_dir = 0;
+uint8_t cir_times = 0;
+void program_out_step(void)
+{
+    switch (progout_data.process)
+    {
+        case PROGOUT_START:
+        {
+            if( progout_data.progout_tick_flag == 0 )
+            {
+                //计时开始
+                progout_data.progout_tick_flag = 1;
+                progout_data.progout_tick = 0;
+
+                progout_data.out_percent = progout_data.start_percent;
+                percent2val_out(progout_data.out_percent);
+                step_dir = 1;
+            }
+            else
+            {
+                //到达起点%后等待一段时间
+                if(progout_data.progout_tick >= 3000)
+                {
+                    //计时结束
+                    progout_data.progout_tick_flag = 0;
+                    progout_data.progout_tick = 0;
+
+                    progout_data.process = PROGOUT_RUNNING;
+                }
+            }
+        }
+        break;
+
+        case PROGOUT_RUNNING:
+        {
+            //迁移至mux任务内
+        }
+        break;
+
+        case PROGOUT_PAUSE:
+        {}
+        break;
+
+        case PROGOUT_END:
+        {
+            if( progout_data.progout_tick_flag == 0 )
+            {
+                progout_data.progout_tick_flag = 1;
+
+                //相关参数清零
+                step_dir = 0;
+                cir_times = 0;
+            }
+            else
+            {
+                //等待3秒后返回config2界面
+                if(progout_data.progout_tick >= 3000)
+                {
+                    //计时结束
+                    progout_data.progout_tick_flag = 0;
+                    progout_data.progout_tick = 0;
+
+                    //输出关闭、清零
+                    menu_data.io_on2off = IO_OFF;
+                    mux_signal.data_sv = 0;
+
+                    //加载菜单界面
+                    lv_scr_load(guider_ui.screen_setting);
+                    scr_setting_recover();
+                    lv_obj_clear_flag(guider_ui.screen_setting, LV_OBJ_FLAG_HIDDEN);
+
+                    //隐藏主界面对象
+                    lv_obj_add_flag(guider_ui.screen_main, LV_OBJ_FLAG_HIDDEN);
+
+                    //当前界面为详细设置菜单，切换至ITEM2
+                    menu_data.scr_now = SCREEN_SETTING;  
+                    set_coil_val(COIL_ADDR_SCREEN_SWITCH, 1); 
+                    tabdata.item_cursor_prv = ITEM_0;
+                    tabdata.item_cursor = ITEM_2;
+                    setting_items_check(tabdata.item_cursor, tabdata.item_cursor_prv);
+
+                    //返回config2界面
+                    program_out_config2();
+                    current_operation = PROG_OUT_CONFIG_2;
+                    key_config_update(current_operation);
+
+                    progout_data.process = PROGOUT_WAITING;
+                }
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void running_process_step(void)
+{
+    if(progout_data.progout_tick_flag == 0)
+    {
+        //计时开始
+        progout_data.progout_tick_flag = 1;
+        progout_data.progout_tick = 0;
+
+        progout_data.out_percent += step_dir * progout_data.step_percent;
+
+        if(progout_data.out_percent <= progout_data.start_percent)
+        {
+            //向下触底后本次循环结束
+            progout_data.out_percent = progout_data.start_percent;
+            step_dir = 1;
+
+            cir_times++;
+            if( progout_data.circulations < 11 ) 
+            {
+                //循环次数达到目标后，跳转至终止步骤
+                if(cir_times >= progout_data.circulations)
+                {
+                    progout_data.process = PROGOUT_END;
+                    progout_data.progout_tick_flag = 0;
+                    progout_data.progout_tick = 0;
+                }
+            }
+            else
+            {
+                //无限循环
+                cir_times = 0;
+            }
+        }
+        else if(progout_data.out_percent >= progout_data.end_percent)
+        {
+            //向上触顶后反向
+            progout_data.out_percent = progout_data.end_percent;
+            step_dir = -1;
+        }
+        percent2val_out(progout_data.out_percent);
+    }
+    else
+    {
+        if( progout_data.progout_tick >= progout_data.hold_time )
+        {
+            //计时结束
+            progout_data.progout_tick_flag = 0;
+            progout_data.progout_tick = 0;
+        }
+    }
+}
+
+uint8_t tri_interval = 0;       //控制周期，调整输出的时间间隔
+uint8_t tri_step_up = 0;        //上升阶段每次变化的步长
+uint8_t tri_step_down = 0;      //下降阶段每次变化的步长
+uint8_t tri_up2down = 0;        //上升和下降的分界点，第几个间隔
+void program_out_triangle(void)
+{
+    switch (progout_data.process)
+    {
+        case PROGOUT_START:
+        {
+            if( progout_data.progout_tick_flag == 0 )
+            {
+                //计时开始
+                progout_data.progout_tick_flag = 1;
+                progout_data.progout_tick = 0;
+
+                progout_data.out_percent = progout_data.start_percent;
+                percent2val_out(progout_data.out_percent);
+
+                //初始方向、控制间隔、上升&下降的分界点、上升&下降各自的步长
+                step_dir = 1;
+                tri_interval = progout_data.period / TRIANLE_PLOT_INTERVAL_MAX;
+                tri_up2down = ( (float32)progout_data.rising_percent/(float32)100 ) * TRIANLE_PLOT_INTERVAL_MAX;
+                if( tri_up2down == 0 )
+                {
+                    tri_step_up = progout_data.end_percent - progout_data.start_percent;
+                    tri_step_down = (progout_data.end_percent - progout_data.start_percent)/TRIANLE_PLOT_INTERVAL_MAX;
+                }
+                else if( tri_up2down == TRIANLE_PLOT_INTERVAL_MAX)
+                {
+                    tri_step_up = (progout_data.end_percent - progout_data.start_percent)/TRIANLE_PLOT_INTERVAL_MAX;
+                    tri_step_down = progout_data.end_percent - progout_data.start_percent;
+                }
+                else
+                {
+                    tri_step_up = (progout_data.end_percent - progout_data.start_percent)/tri_up2down;
+                    tri_step_down = (progout_data.end_percent - progout_data.start_percent)/(TRIANLE_PLOT_INTERVAL_MAX - tri_up2down);
+                }
+            }
+            else
+            {
+                //到达起点%后等待一段时间
+                if(progout_data.progout_tick >= 3000)
+                {
+                    //计时结束
+                    progout_data.progout_tick_flag = 0;
+                    progout_data.progout_tick = 0;
+
+                    progout_data.process = PROGOUT_RUNNING;
+                }
+            }
+        }
+        break;
+
+        case PROGOUT_RUNNING:
+        {
+            //迁移至mux任务内
+        }
+        break;
+
+        case PROGOUT_PAUSE:
+        {}
+        break;
+
+        case PROGOUT_END:
+        {
+            if( progout_data.progout_tick_flag == 0 )
+            {
+                progout_data.progout_tick_flag = 1;
+
+                //相关参数清零
+                step_dir = 0;
+                cir_times = 0;
+                tri_interval = 0;      
+                tri_step_up = 0;       
+                tri_step_down = 0;    
+                tri_up2down = 0;        
+            }
+            else
+            {
+                //等待3秒后返回config2界面
+                if(progout_data.progout_tick >= 3000)
+                {
+                    //计时结束
+                    progout_data.progout_tick_flag = 0;
+                    progout_data.progout_tick = 0;
+
+                    //输出关闭、清零
+                    menu_data.io_on2off = IO_OFF;
+                    mux_signal.data_sv = 0;
+
+                    //加载菜单界面
+                    lv_scr_load(guider_ui.screen_setting);
+                    scr_setting_recover();
+                    lv_obj_clear_flag(guider_ui.screen_setting, LV_OBJ_FLAG_HIDDEN);
+
+                    //隐藏主界面对象
+                    lv_obj_add_flag(guider_ui.screen_main, LV_OBJ_FLAG_HIDDEN);
+
+                    menu_data.scr_now = SCREEN_SETTING;   //当前界面为详细设置菜单
+                    set_coil_val(COIL_ADDR_SCREEN_SWITCH, 1); 
+
+                    tabdata.item_cursor_prv = ITEM_0;
+                    tabdata.item_cursor = ITEM_2;
+                    setting_items_check(tabdata.item_cursor, tabdata.item_cursor_prv);
+
+                    //返回config2界面
+                    program_out_config2();
+                    current_operation = PROG_OUT_CONFIG_2;
+                    key_config_update(current_operation);
+
+                    progout_data.process = PROGOUT_WAITING;
+                }
+            }
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void running_process_triangle(void)
+{
+    if( progout_data.progout_tick_flag == 0 )
+    {
+        //计时开始
+        progout_data.progout_tick_flag = 1;
+        progout_data.progout_tick = 0;
+
+        if(step_dir == 1)
+        {
+            progout_data.out_percent += tri_step_up;
+            if(progout_data.out_percent >= progout_data.end_percent) 
+            {
+                progout_data.out_percent = progout_data.end_percent;
+                step_dir = -1;
+            } 
+        }
+        else if(step_dir == -1)
+        {
+            progout_data.out_percent -= tri_step_down;
+            if( (progout_data.out_percent <= progout_data.start_percent)||(progout_data.out_percent > 101) ) 
+            {
+                progout_data.out_percent = progout_data.start_percent;
+
+                cir_times++;
+                step_dir = 1;
+                if( progout_data.circulations < 11 ) 
+                {
+                    //循环次数达到目标后，跳转至终止步骤
+                    if(cir_times >= progout_data.circulations) 
+                    {
+                        progout_data.process = PROGOUT_END;
+                        progout_data.progout_tick_flag = 0;
+                        progout_data.progout_tick = 0;
+                    }
+                }
+                else
+                {
+                    //无限循环
+                    cir_times = 0;
+                }
+            }
+        }
+        percent2val_out(progout_data.out_percent); 
+    }
+    else
+    {
+        if(progout_data.progout_tick >= tri_interval)
+        {
+            //计时结束
+            progout_data.progout_tick_flag = 0;
+            progout_data.progout_tick = 0;
+        }
+    }
+}
+

App/APP_WU/Src/scr_setting_text.c

@@ -0,0 +1,344 @@
+#include "scr_setting_text.h"
+
+SETTING_TEXT text_pack;
+
+//内容：设置界面，标题
+//语言：中文、英文
+static char title_text_chinese[TEXT_LENGTH_MAX] = "详细设置";
+static char title_text_english[TEXT_LENGTH_MAX] = "Detailed Setting";
+
+
+//内容：设置界面，选项卡
+//语言：中文、英文
+static char items_text_chinese[ITEM_NUM_MAX][TEXT_LENGTH_MAX] = 
+{
+    "量程设置",
+    "曲线设置",
+    "拓展功能",
+    "系统设置"
+};
+static char items_text_english[ITEM_NUM_MAX][TEXT_LENGTH_MAX] = 
+{
+    "Range",
+    "Chart",
+    "Extra",
+    "System"
+};
+
+
+//内容：设置界面，选项卡0的内容，左列文本
+//语言：中文、英文
+static char item0_contents_text_chinese[ITEM0_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "电压单位",
+    "电压上限",
+    "电压下限",
+    "电流上限 mA",
+    "电流下限 mA",
+    "电阻上限 Ω", 
+
+    "电阻下限 Ω",
+    "频率上限 KHz",
+    "频率下限 KHz",
+    "热电偶类型",
+    "热电偶上限℃",
+    "热电偶下限℃",
+
+    "热电阻上限℃",
+    "热电阻下限℃"
+};
+static char item0_contents_text_english[ITEM0_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "Volt unit",
+    "Volt max",
+    "Volt min",
+    "Cur max mA",
+    "Cur min mA",
+    "Res max Ω", 
+
+    "Res min Ω",
+    "Fre max KHz",
+    "Fre min KHz",
+    "TC type",
+    "TC max ℃",
+    "TC min ℃",
+
+    "RTD max ℃",
+    "RTD min ℃"
+};
+
+
+//内容：设置界面，选项卡1的内容，左列文本
+//语言：中文、英文
+static char item1_contents_text_chinese[ITEM1_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "采样间隔",
+    "描点数量",
+    "颜色-输入",
+    "颜色-输出"
+};
+static char item1_contents_text_english[ITEM1_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "Plot gap",
+    "plop count",
+    "Color-input",
+    "Color-output"
+};
+
+
+//内容：设置界面，选项卡2的内容，左列文本
+//语言：中文、英文
+static char item2_contents_text_chinese[ITEM2_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "输入记录",
+    "输出记录",
+    "通讯",
+    "编程输出"
+};
+static char item2_contents_text_english[ITEM2_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "Input log",
+    "Output log",
+    "Interaction",
+    "Progam out"
+};
+
+
+//内容：设置界面，选项卡2的通讯子菜单，左列文本和右列的值
+//语言：中文、英文
+static char item2_communication_switch_chinese[ITEM2_COMMUNICATION_MAX][TEXT_LENGTH_MAX] =
+{
+    "HART通讯",
+    "蓝牙通讯",
+    "Modbus通讯",
+    "--配置"
+};
+static char item2_communication_switch_english[ITEM2_COMMUNICATION_MAX][TEXT_LENGTH_MAX] =
+{
+    "HART",
+    "BLE",
+    "Modbus",
+    "--Config"
+};
+static char item2_communication_switch_value_chinese[ITEM2_COMMUNICATION_VALUE_MAX][TEXT_LENGTH_MAX] =
+{
+    "开",
+    "关",
+    "主",
+    "从"
+};
+static char item2_communication_switch_value_english[ITEM2_COMMUNICATION_VALUE_MAX][TEXT_LENGTH_MAX] =
+{
+    "ON",
+    "OFF",
+    "Master",
+    "Slave"
+};
+
+
+//内容：设置界面，选项卡2的编程输出子菜单，左列文本和右列的值
+//语言：中文、英文
+static char item2_program_out_config1_chinese[ITEM2_PROGRAM_OUT_CONFIG1_MAX][TEXT_LENGTH_MAX] = 
+{
+    "输出方式",
+    "输出模式",
+    "循环次数",
+    "下一步"
+};
+static char item2_program_out_config1_english[ITEM2_PROGRAM_OUT_CONFIG1_MAX][TEXT_LENGTH_MAX] = 
+{
+    "Output unit",
+    "Output mode",
+    "Circulation",
+    "Next"
+};
+static char item2_program_out_config1_value_chinese[ITEM2_PROGRAM_OUT_CONFIG1_VALUE_MAX][TEXT_LENGTH_MAX] = 
+{
+    "阶跃",
+    "三角波"
+};
+static char item2_program_out_config1_value_english[ITEM2_PROGRAM_OUT_CONFIG1_VALUE_MAX][TEXT_LENGTH_MAX] = 
+{
+    "Step",
+    "Triangle"
+};
+static char item2_program_out_config2_chinese[ITEM2_PROGRAM_OUT_CONFIG2_MAX][TEXT_LENGTH_MAX] =
+{
+    "输出模式",
+    "保持时间",
+    "起点",
+    "终点",
+    "步长",
+    "上升占比",
+    "下降占比",
+    "周期"
+};
+static char item2_program_out_config2_english[ITEM2_PROGRAM_OUT_CONFIG2_MAX][TEXT_LENGTH_MAX] =
+{
+    "Output Mode",
+    "Hold time",
+    "Start",
+    "End",
+    "Step Size",
+    "Rising",
+    "Falling",
+    "Period"
+};
+
+
+//内容：设置界面，选项卡3的内容，左列文本和右列的值
+//语言：中文、英文
+static char item3_contents_text_chinese[ITEM3_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "照明",
+    "语言",
+    "配置保存",
+    "配置复位"
+};
+static char item3_contents_text_english[ITEM3_CONTENT_MAX][TEXT_LENGTH_MAX] =
+{
+    "Lighting",
+    "Language",
+    "Config save",
+    "Config reset"
+};
+static char item3_contents_value_chinese[ITEM3_CONTENT_VAL_MAX][TEXT_LENGTH_MAX] =
+{
+    "开",
+    "关",
+    "简体中文",
+    "English",
+    "未保存",
+    "保存中",
+    "已保存",
+    "未复位",
+    "复位中",
+    "已复位",
+};
+static char item3_contents_value_english[ITEM3_CONTENT_VAL_MAX][TEXT_LENGTH_MAX] =
+{
+    "ON",
+    "OFF",
+    "简体中文",
+    "English",
+    "No save",
+    "saving",
+    "saved",
+    "No reset",
+    "resetting",
+    "已复位",
+};
+
+
+//内容：Modbus主站配置界面，标题
+//语言：中文、英文
+static char modbus_master_config_title_chinese[TEXT_LENGTH_MAX] =
+{
+    "Modbus 主设备"
+};
+
+static char modbus_master_config_title_english[TEXT_LENGTH_MAX] =
+{
+    "Modbus Master"
+};
+
+
+//内容：Modbus主站配置界面，左列文本
+//语言：中文、英文
+static char modbus_master_config_item_chinese[MODBUS_MASTER_CONFIG_ITEM_MAX][TEXT_LENGTH_MAX] =
+{
+    "从设备地址",
+    "起始地址",
+    "字节数",
+    "超时时间",
+    "命令字",
+    "寄存器数量",
+    "校验",
+    "下一步"
+};
+static char modbus_master_config_item_english[MODBUS_MASTER_CONFIG_ITEM_MAX][TEXT_LENGTH_MAX] =
+{
+    "Slave id",
+    "Start addr",
+    "Bytes num",
+    "Timeout",
+    "Command",
+    "Register",
+    "Calibrate",
+    "Next"
+};
+
+
+//内容：Modbus主站收发界面，标题文本
+//语言：中文、英文
+static char modbus_master_trx_item_chinese[MODBUS_MASTER_TRX_ITEM_MAX][TEXT_LENGTH_MAX] =
+{
+    "(HEX)数据",
+    "上一步",
+    "设置",
+    "发送"
+};
+static char modbus_master_trx_item_english[MODBUS_MASTER_TRX_ITEM_MAX][TEXT_LENGTH_MAX] =
+{
+    "(HEX)Data",
+    "Previous",
+    "Set",
+    "Send"
+};
+
+
+//语言切换
+void setting_laguage_switch(LANGUAGES lan)
+{
+    switch (lan)
+    {
+        case MENU_SIMPLYFY_CHINESE:
+        {
+            memcpy(text_pack.title, title_text_chinese, sizeof(text_pack.title)) ;
+            memcpy(text_pack.items, items_text_chinese, sizeof(text_pack.items)) ;
+            memcpy(text_pack.item_0, item0_contents_text_chinese, sizeof(text_pack.item_0)) ;
+            memcpy(text_pack.item_1, item1_contents_text_chinese, sizeof(text_pack.item_1)) ;
+            memcpy(text_pack.item_2, item2_contents_text_chinese, sizeof(text_pack.item_2)) ;
+            memcpy(text_pack.item_2_com, item2_communication_switch_chinese, sizeof(text_pack.item_2_com));
+            memcpy(text_pack.item_2_com_val, item2_communication_switch_value_chinese, sizeof(text_pack.item_2_com_val));
+            memcpy(text_pack.item_3, item3_contents_text_chinese, sizeof(text_pack.item_3)) ;
+            memcpy(text_pack.item_3_val, item3_contents_value_chinese, sizeof(text_pack.item_3_val)) ;
+
+            memcpy(text_pack.modbus_master_title, modbus_master_config_title_chinese, sizeof(text_pack.modbus_master_title));
+            memcpy(text_pack.modbus_master_item, modbus_master_config_item_chinese, sizeof(text_pack.modbus_master_item));
+            memcpy(text_pack.modbus_master_trx_item, modbus_master_trx_item_chinese, sizeof(text_pack.modbus_master_trx_item));
+
+            memcpy(text_pack.program_out_config1, item2_program_out_config1_chinese, sizeof(text_pack.program_out_config1));
+            memcpy(text_pack.program_out_config1_val, item2_program_out_config1_value_chinese, sizeof(text_pack.program_out_config1_val));
+            memcpy(text_pack.program_out_config2, item2_program_out_config2_chinese, sizeof(text_pack.program_out_config2));
+        }
+        break;
+
+        case MENU_ENGLISH:
+        {
+            memcpy(text_pack.title, title_text_english, sizeof(text_pack.title)) ;
+            memcpy(text_pack.items, items_text_english, sizeof(text_pack.items)) ;
+            memcpy(text_pack.item_0, item0_contents_text_english, sizeof(text_pack.item_0)) ;
+            memcpy(text_pack.item_1, item1_contents_text_english, sizeof(text_pack.item_1)) ;
+            memcpy(text_pack.item_2, item2_contents_text_english, sizeof(text_pack.item_2)) ;
+            memcpy(text_pack.item_2_com, item2_communication_switch_english, sizeof(text_pack.item_2_com));
+            memcpy(text_pack.item_2_com_val, item2_communication_switch_value_english, sizeof(text_pack.item_2_com_val));
+            memcpy(text_pack.item_3, item3_contents_text_english, sizeof(text_pack.item_3)) ;
+            memcpy(text_pack.item_3_val, item3_contents_value_english, sizeof(text_pack.item_3_val)) ;
+
+            memcpy(text_pack.modbus_master_title, modbus_master_config_title_english, sizeof(text_pack.modbus_master_title));
+            memcpy(text_pack.modbus_master_item, modbus_master_config_item_english, sizeof(text_pack.modbus_master_item));
+            memcpy(text_pack.modbus_master_trx_item, modbus_master_trx_item_english, sizeof(text_pack.modbus_master_trx_item));
+
+            memcpy(text_pack.program_out_config1, item2_program_out_config1_english, sizeof(text_pack.program_out_config1));
+            memcpy(text_pack.program_out_config1_val, item2_program_out_config1_value_english, sizeof(text_pack.program_out_config1_val));
+            memcpy(text_pack.program_out_config2, item2_program_out_config2_english, sizeof(text_pack.program_out_config2));
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+

App/APP_WU/Src/timer.c

@@ -0,0 +1,205 @@
+#include "timer.h"
+
+int heart_1000ms_flag = 0;
+int heart_1000ms_cnt = 0;
+int battery_2000ms_flag = 0;
+int battery_2000ms_cnt = 0;
+int plot_ms_flag = 0;
+int plot_ms_cnt = 0;
+int twk_1000ms_flag = 0;
+int twk_1000ms_cnt = 0;
+int input_500ms_flag = 0;
+int input_500ms_cnt = 0;
+uint16_t sig2slave_current_tick = 0;
+
+void duty_tim3(void)
+{
+    freq_signal.over_cnt++;
+}
+
+void duty_tim6(void)
+{
+    //lv_tick_inc(1);
+    
+    heart_1000ms_cnt++;
+    if( heart_1000ms_cnt >= 1000)
+    {
+      heart_1000ms_cnt = 0;
+      heart_1000ms_flag = 1;
+    }
+
+    battery_2000ms_cnt++;
+    if( battery_2000ms_cnt >= 2000)
+    {
+      battery_2000ms_cnt = 0;
+      battery_2000ms_flag = 1;
+    }
+
+    plot_ms_cnt++;
+    if( plot_ms_cnt >= tabdata.item1_page0_sample_interval)
+    {
+      plot_ms_cnt = 0;
+      plot_ms_flag = 1;
+    }
+
+    twk_1000ms_cnt++;
+    if( twk_1000ms_cnt >= 1000)
+    {
+      twk_1000ms_cnt = 0;
+      twk_1000ms_flag = 1;
+    }
+
+    input_500ms_cnt++;
+    if( input_500ms_cnt >= 500)
+    {
+      input_500ms_cnt = 0;
+      input_500ms_flag = 1;
+    }
+
+    if(progout_data.progout_tick_flag == 1)
+    {
+      progout_data.progout_tick++;
+    }
+
+    //发送完成 或者 已经接收到一部分数据之后开始计时
+    if( (sig2slave_step == 1)||(mod_master.tx_flag == TX_OK) )
+    {
+      sig2slave_current_tick++;
+      mod_master.rx_error_message = RX_ERROR_NONE;
+
+      if(sig2slave_current_tick > mod_master.timeout)
+      {
+        if(sig2slave_step == 0)
+        {
+          //进入此处说明发送成功后未收到任何数据
+          mod_master.rx_error_message = RX_ERROR_TIMEOUT;
+          mod_master.tx_flag = TX_NONE;
+        }
+
+        HAL_UART_DMAStop(&huart2);
+        __HAL_UART_CLEAR_IDLEFLAG(&huart2);
+    
+        sig2slave_current_tick = 0;
+        sig2slave_step = 2;                       //无论是哪个阶段出现超时，均跳转至step2
+        scom2_rs485.rx_flag = TRUE;
+        sig_trans = TRANS_MODBUS_SIG_TO_SLAVE;    //发送回调中会修改成none，因此在这里重新赋值（接收超时也属于接收的一种结果）
+      }
+    }
+}
+
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
+{
+  //记录发送完成的时间点
+  st_flag = TRANSPARENT_TRANSMIT_END;
+
+  //发送完成后将相关数组清零
+  if(huart == &huart1)
+  {
+    //HART重新使能接收
+    HART_RTS(RTS_OFF);
+    
+    memset(scom1_hart.tx_buff, 0, scom1_hart.tx_len);
+    scom1_hart.tx_len = 0;
+
+    //PC--->SIG--->HART，重新开启485的DMA
+    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+  }
+  else if(huart == &huart2)
+  {
+    memset(scom2_rs485.tx_buff, 0, scom2_rs485.tx_len);
+    scom2_rs485.tx_len = 0;
+
+    //开启对应的DMA
+    switch (sig_trans)
+    {
+      case TRANS_HART_TO_PC:
+      {
+        HAL_UART_Receive_DMA(&huart1, scom1_hart.rx_buff, BUFFER_SIZE);
+      }
+      break;
+
+      case TRANS_BLE_TO_PC:
+      {
+        HAL_UART_Receive_DMA(&huart6, scom6_ble.rx_buff, BUFFER_SIZE);
+      }
+      break;
+
+      case TRANS_MODBUS_PC_TO_SIG:
+      {
+        HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+      }
+      break;
+
+      case TRANS_MODBUS_SIG_TO_SLAVE:
+      {
+        mod_master.tx_flag = TX_OK;
+        HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+        sig2slave_current_tick = 0;
+      }
+      break;
+    
+      default:
+      break;
+    }
+  }
+  else if(huart == &huart6)
+  {
+    memset(scom6_ble.tx_buff, 0, scom6_ble.tx_len);
+    scom6_ble.tx_len = 0;
+
+    //PC--->SIG--->BLE，重新开启485的DMA
+    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+  }
+
+  //通讯模式清空，等待下一次接收
+  sig_trans = TRANS_NONE;
+
+  //如果显示任务被挂起，则在此处释放（无DMA的情况）
+  if(screen_suspend_flag)
+  {
+    xTaskResumeFromISR(task_lcdHandle);
+    xTaskResumeFromISR(task_menuHandle);
+    screen_suspend_flag = 0;
+  }
+}
+
+void delay_cnt(uint16_t cnt)
+{
+  while(cnt > 0)
+  {
+    cnt--;
+  }
+}
+
+#define CPU_FREQUENCY_MHZ    165.888		// STM32时钟主频
+void systick_delay_us(__IO uint32_t delay)
+{
+    int last, curr, val;
+    int temp;
+
+    while (delay != 0)
+    {
+        temp = delay > 900 ? 900 : delay;
+        last = SysTick->VAL;
+        curr = last - CPU_FREQUENCY_MHZ * temp;
+        if (curr >= 0)
+        {
+            do
+            {
+                val = SysTick->VAL;
+            }
+            while ((val < last) && (val >= curr));
+        }
+        else
+        {
+            curr += CPU_FREQUENCY_MHZ * 1000;
+            do
+            {
+                val = SysTick->VAL;
+            }
+            while ((val <= last) || (val > curr));
+        }
+        delay -= temp;
+    }
+}
+

App/BLE/ble.c

@@ -13,3 +13,155 @@ void ble_send(UART_HandleTypeDef *huart, uint8_t *data)
 {
     usart_printf(huart, (char *)data);
 }
+
+int8_t write_ble_id(char *id)
+{
+    if(!id) return -1;
+
+    char str_id[50] = {0};
+
+    sprintf(str_id,"AT+NAME=%s\r\n",id);
+    usart_printf(&huart6, str_id);
+    return 1;
+}
+
+void write_ble_cmd(char *cmd)
+{
+    if(!cmd) return;
+
+    usart_printf(&huart6, cmd);
+}
+
+uint8_t ble_init_step = 0;
+uint8_t ble_cnt = 0;
+uint8_t ble_init(void)
+{
+    uint8_t result = 0;
+
+    switch (ble_init_step)
+    {
+        case 0:
+        {
+            if(ble_cnt == 0)
+            {
+                char ble_id[9];
+                strcpy (ble_id, "00000001");
+
+                write_ble_id(ble_id);   //修改蓝牙名称
+                ble_cnt++;
+            }
+            else
+            {
+                ble_cnt++;
+                if( (ble_cnt * BLE_TASK_PERIOD) > 500)
+                {
+                    ble_cnt = 0;
+                    ble_init_step++;
+                }
+            }
+        }
+        break;
+
+        case 1:
+        {
+            if(ble_cnt == 0)
+            {
+                write_ble_cmd("AT+UUIDS=FFF0\r\n");     //主服务通道
+
+                ble_cnt++;
+            }
+            else
+            {
+                ble_cnt++;
+                if( (ble_cnt * BLE_TASK_PERIOD) > 500)
+                {
+                    ble_cnt = 0;
+                    ble_init_step++;
+                }
+            }
+        }
+        break;
+
+        case 2:
+        {
+            if(ble_cnt == 0)
+            {
+                write_ble_cmd("AT+UUIDN=FFF1\r\n");     //读通道FFF1
+
+                ble_cnt++;
+            }
+            else
+            {
+                ble_cnt++;
+                if( (ble_cnt * BLE_TASK_PERIOD) > 500)
+                {
+                    ble_cnt = 0;
+                    ble_init_step++;
+                }
+            }
+        }
+        break;
+
+        case 3:
+        {
+            if(ble_cnt == 0)
+            {
+                write_ble_cmd("AT+UUIDW=FFF2\r\n");     //写通道FFF2
+
+                ble_cnt++;
+            }
+            else
+            {
+                ble_cnt++;
+                if( (ble_cnt * BLE_TASK_PERIOD) > 500)
+                {
+                    ble_cnt = 0;
+                    ble_init_step++;
+                }
+            }
+        }
+        break;
+
+        case 4:
+        {
+            if(ble_cnt == 0)
+            {
+                write_ble_cmd("AT+REBOOT=1\r\n");       //重启
+
+                ble_cnt++;
+            }
+            else
+            {
+                ble_cnt++;
+                if( (ble_cnt * BLE_TASK_PERIOD) > 1000)
+                {
+                    ble_cnt = 0;
+                    ble_init_step++;
+                }
+            }
+        }
+        break;
+
+        case 5:
+        {
+            //清空缓存区（蓝牙配置时收获的响应）
+            memset(scom6_ble.rx_buff, 0, sizeof(scom6_ble.rx_buff));
+            scom6_ble.rx_len = 0;
+            
+            ble_init_step++;
+        }
+        break;
+
+        case 6:
+        {
+            result = 1;
+        }
+        break;
+
+        default:
+        break;
+    }
+
+    return result;
+}
+

App/BLE/ble.h

@@ -1,8 +1,20 @@
-#ifndef __BLE_H
-#define __BLE_H
+#ifndef _BLE_H_
+#define _BLE_H_
+
 #include "usart.h"
 #include "data_type_def.h"
+#include "apps_gather.h"
+
 void ble_send(UART_HandleTypeDef *huart, uint8_t *data);
 
+//DEVICE <---SIG---> PC
+//将来自设备的BLUETOOTH数据装载至com485_tx，将comblue_tx的数据发送至设备
+void transparent_bluetooth(st_scom *scom);
+
+int8_t write_ble_id(char *id);
+
+void write_ble_cmd(char *cmd);
+
+uint8_t ble_init(void);
 
 #endif

App/DAC7811/dac7811.c

@@ -35,7 +35,7 @@ void fun_dac7811_spi1_init()
         Error_Handler();
     }
     ADS1220_CS(GPIO_PIN_SET);
-    DAC7811_CS(GPIO_PIN_SET);
+    //DAC7811_CS(GPIO_PIN_SET);
 }
 
 void fun_dac7811_operate(float32 *data_sv)
@@ -57,8 +57,8 @@ void fun_dac7811_operate(float32 *data_sv)
     }
     else
     {
-        DAC7811_CS(GPIO_PIN_RESET);
+        //DAC7811_CS(GPIO_PIN_RESET);
         HAL_SPI_Transmit(&hspi1, (uint8_t *)(&reg_data), 1, 1000);
-        DAC7811_CS(GPIO_PIN_SET);
+        //DAC7811_CS(GPIO_PIN_SET);
     }
 }

App/DAC8552/dac8552.c

@@ -63,10 +63,10 @@ void dac8552_operation(float32 *data1, float32 *data2)
     if (data1 != NULL)
     {
         // 4~20mA输出
-        if (*data1 > 20.0f)
-            *data1 = 20.0f;
-        else if (*data1 < 4.0f)
-            *data1 = 4.0f;
+        if (*data1 > 25.0f)
+            *data1 = 25.0f;
+        else if (*data1 < 0.0f)
+            *data1 = 0.0f;
         temp = (*data1) * 100.0f;
         data = (uint16_t)(65535.0f * temp / 2500.0f);
         set_dac8552_channel_value(&dac8552, LD_CH_B, SEL_BUF_B, PD_NONE, data);

App/EEPROM/eeprom_spi.c

@@ -0,0 +1,998 @@
+#include "eeprom_spi.h"
+
+//使用方法：
+// uint8_t eep_tx = 0x72;
+// uint8_t eep_rx = 0;
+// uint8_t eep_addr[3];
+// uint8_t eep_test_flag = 0;
+// uint8_t eep_status = 0;
+
+// if(eep_test_flag == 0)
+// {
+//     eep_test_flag = 1;
+
+//     eep_addr[0] = 0x00;
+//     eep_addr[1] = 0x00;
+//     eep_addr[2] = 0x00;
+//     eeprom_writedata(eep_addr, eep_tx);
+
+//     eep_rx = eeprom_readdata(eep_addr);
+//	}
+//	结果：eep_rx = 0x72
+
+void eeprom_spi_init(void)
+{
+    EEPROM_CS_H;    // CS 初始化高（手册中描述：S拉低时片选）
+    EEPROM_SCLK_L;  // CLK 初始化低
+    EEPROM_WR_H;    // 不使用硬件保护
+}
+
+void eeprom_spi_writebyte(uint8_t wrt_data)
+{
+    uint8_t i = 0;
+	uint8_t temp = 0;
+	for(i = 0; i < 8; i++)
+	{
+		temp = ((wrt_data&0x80)==0x80)? 1:0;
+
+		wrt_data = wrt_data << 1;
+
+		EEPROM_SCLK_L; //CPOL=0
+
+		if(temp)
+		{
+			EEPROM_MOSI_H;
+		}
+		else
+		{
+			EEPROM_MOSI_L;
+		}
+
+		systick_delay_us(10);       // 空等待
+
+		EEPROM_SCLK_H; //CPHA=0
+
+		systick_delay_us(10);       // 空等待
+	}
+
+	EEPROM_SCLK_L; 
+}
+
+uint8_t eeprom_spi_readbyte(void)
+{
+    uint8_t i = 0;
+	uint8_t read_data = 0xFF;
+	for(i = 0; i < 8; i++) 
+	{
+		read_data = read_data << 1;
+
+		EEPROM_SCLK_L;
+
+		systick_delay_us(10);       // 空等待
+
+		EEPROM_SCLK_H;
+
+		systick_delay_us(10);       // 空等待
+		
+		if(EEPROM_MISO) 
+		{
+			read_data = read_data + 1; 
+		} 
+	}
+	EEPROM_SCLK_L;
+	
+	return read_data;
+}
+
+uint8_t SPI_WriteReadByte(uint8_t data)
+{
+	uint16_t bit_ctr;
+   	for(bit_ctr=0;bit_ctr<8;bit_ctr++) 
+   	{
+		if(data & 0x80) 
+		{
+			EEPROM_MOSI_H;
+		} 		        
+		else 
+		{
+			EEPROM_MOSI_L;
+		}
+		
+		data = (data << 1);           
+		EEPROM_SCLK_H; 
+		systick_delay_us(5);       // 空等待
+		if(EEPROM_MISO)
+		{
+			data |= 0x01;
+		} 
+		EEPROM_SCLK_L; 
+		systick_delay_us(5);       // 空等待       		 
+   	}
+
+	return(data); 
+}
+
+void eeprom_writedata(int32_t addr_long, uint8_t txd)
+{
+	uint8_t write_en_flag = 0;
+	uint8_t ee_status = 0;
+	uint8_t addr[3];
+	addr[0] = addr_long >> 16;
+	addr[1] = addr_long >> 8;
+	addr[2] = addr_long;
+
+	int16_t wait_max = 0;
+	do
+	{
+		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 = eeprom_spi_readbyte();
+		delay_cnt(10);
+		EEPROM_CS_H;
+
+		write_en_flag = ee_status & 0x03;
+
+		wait_max++;
+		if(wait_max > 500)
+		{
+			system_sts.eeprom_write_error = 1;
+			return;
+		}
+
+	} while (write_en_flag != 0x02);
+
+	EEPROM_CS_L;
+	delay_cnt(10);
+	eeprom_spi_writebyte(WRITE_MEMORY);
+	eeprom_spi_writebyte(addr[0]);
+	eeprom_spi_writebyte(addr[1]);
+	eeprom_spi_writebyte(addr[2]);
+	eeprom_spi_writebyte(txd);
+	delay_cnt(10);
+	EEPROM_CS_H;
+
+}
+
+uint8_t eeprom_readdata(int32_t addr_long)
+{
+	uint8_t rxd = 0;
+	uint8_t write_en_flag = 0;
+	uint8_t ee_status = 0;
+	uint8_t addr[3];
+	addr[0] = addr_long >> 16;
+	addr[1] = addr_long >> 8;
+	addr[2] = addr_long ;
+
+	int16_t wait_max = 0;
+	do
+	{
+		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 = eeprom_spi_readbyte();
+		delay_cnt(10);
+		EEPROM_CS_H;
+
+		write_en_flag = ee_status & 0x01;
+
+		wait_max++;
+		if(wait_max > 500)
+		{
+			system_sts.eeprom_read_error = 1;
+			return 0;
+		}
+
+	} while (write_en_flag);
+	
+	EEPROM_CS_L;
+	delay_cnt(10);
+	eeprom_spi_writebyte(READ_MEMORY);
+	eeprom_spi_writebyte(addr[0]);
+	eeprom_spi_writebyte(addr[1]);
+	eeprom_spi_writebyte(addr[2]);
+	rxd = eeprom_spi_readbyte();
+	delay_cnt(10);
+	EEPROM_CS_H;
+
+	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)
+{
+	TABVIEW_DATA tab_temp;
+	memcpy(&tab_temp, &tabdata, sizeof(TABVIEW_DATA));
+
+	eeprom_dataread();
+
+	if( (tab_temp.item0_page0_vup[0] != tabdata.item0_page0_vup[0])||(tab_temp.item0_page0_vlow[0] != tabdata.item0_page0_vlow[0])||\
+	(tab_temp.item0_page0_vup[1] != tabdata.item0_page0_vup[1])||(tab_temp.item0_page0_vlow[1] != tabdata.item0_page0_vlow[1]) )
+	{
+		tabdata.item0_page0_vup[0] = tab_temp.item0_page0_vup[0];
+		tabdata.item0_page0_vlow[0] = tab_temp.item0_page0_vlow[0];
+		tabdata.item0_page0_vup[1] = tab_temp.item0_page0_vup[1];
+		tabdata.item0_page0_vlow[1] = tab_temp.item0_page0_vlow[1];
+
+		eeprom_datasave_single(0);
+	}
+
+	if( (tab_temp.item0_page0_cup != tabdata.item0_page0_cup)||(tab_temp.item0_page0_clow != tabdata.item0_page0_clow) )
+	{
+		tabdata.item0_page0_cup = tab_temp.item0_page0_cup;
+		tabdata.item0_page0_clow = tab_temp.item0_page0_clow;
+
+		eeprom_datasave_single(1);
+	}
+
+	if( (tab_temp.item0_page0_rup != tabdata.item0_page0_rup)||(tab_temp.item0_page1_rlow != tabdata.item0_page1_rlow) )
+	{
+		tabdata.item0_page0_rup = tab_temp.item0_page0_rup;
+		tabdata.item0_page1_rlow = tab_temp.item0_page1_rlow;
+		
+		eeprom_datasave_single(2);
+	}
+
+	if( (tab_temp.item0_page1_fup != tabdata.item0_page1_fup)||(tab_temp.item0_page1_flow != tabdata.item0_page1_flow) )
+	{
+		tabdata.item0_page1_fup = tab_temp.item0_page1_fup;
+		tabdata.item0_page1_flow = tab_temp.item0_page1_flow;
+
+		eeprom_datasave_single(3);
+	}
+
+	for(uint8_t i = 0 ; i < 8; i++)
+	{
+		if( (tab_temp.item0_page1_TCup[i] != tabdata.item0_page1_TCup[i])||(tab_temp.item0_page1_TClow[i] != tabdata.item0_page1_TClow[i]) )
+		{
+			tabdata.item0_page1_TCup[i] = tab_temp.item0_page1_TCup[i];
+			tabdata.item0_page1_TClow[i] = tab_temp.item0_page1_TClow[i];
+
+			eeprom_datasave_single( i + 4 );
+		}
+	}
+
+	if( (tab_temp.item0_page2_RTDup != tabdata.item0_page2_RTDup)||(tab_temp.item0_page2_RTDlow != tabdata.item0_page2_RTDlow) )
+	{
+		tabdata.item0_page2_RTDup = tab_temp.item0_page2_RTDup;
+		tabdata.item0_page2_RTDlow = tab_temp.item0_page2_RTDlow;
+
+		eeprom_datasave_single(12);
+	}
+
+	if(tab_temp.item1_page0_sample_interval != tabdata.item1_page0_sample_interval)
+	{
+		tabdata.item1_page0_sample_interval = tab_temp.item1_page0_sample_interval;
+
+		eeprom_datasave_single(13);
+	}
+
+	if(tab_temp.item1_page0_plot_num != tabdata.item1_page0_plot_num)
+	{
+		tabdata.item1_page0_plot_num = tab_temp.item1_page0_plot_num;
+
+		eeprom_datasave_single(14);
+	}
+
+	if(tab_temp.item1_page0_color_input != tabdata.item1_page0_color_input)
+	{
+		tabdata.item1_page0_color_input = tab_temp.item1_page0_color_input;
+
+		eeprom_datasave_single(15);
+	}
+
+	if(tab_temp.item1_page0_color_output != tabdata.item1_page0_color_output)
+	{
+		tabdata.item1_page0_color_output = tab_temp.item1_page0_color_output;
+
+		eeprom_datasave_single(16);
+	}
+
+	if(tab_temp.item3_page0_language != tabdata.item3_page0_language)
+	{
+		tabdata.item3_page0_language = tab_temp.item3_page0_language;
+
+		eeprom_datasave_single(17);
+	}
+}
+
+#endif
+
+void eeprom_datasave_single(uint8_t tag)
+{
+	uint8_t temp_h = 0, temp_l = 0;
+
+	switch (tag)
+	{
+		case 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);
+			
+			//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);
+		}
+		break;
+
+		case 1:
+		{
+			//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);
+		}
+		break;
+
+		case 2:
+		{
+			//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);
+		}
+		break;
+
+		case 3:
+		{
+			//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);
+		}
+		break;
+
+		case 4:
+		{
+			//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);
+		}
+		break;
+
+		case 5:
+		{
+			//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);
+		}
+		break;
+
+		case 6:
+		{
+			//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);
+		}
+		break;
+
+		case 7:
+		{
+			//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);
+		}
+		break;
+
+		case 8:
+		{
+			//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);
+		}
+		break;
+
+		case 9:
+		{
+			//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);
+		}
+		break;
+
+		case 10:
+		{
+			//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);
+		}
+		break;
+
+		case 11:
+		{
+			//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);
+		}
+		break;
+
+		case 12:
+		{
+			//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);
+		}
+		break;
+
+		case 13:
+		{
+			//采样间隔
+			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);
+		}
+		break;
+
+		case 14:
+		{
+			//描点数量
+			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);
+		}
+		break;
+
+		case 15:
+		{
+			//输入曲线颜色
+			temp_h = ((uint8_t)tabdata.item1_page0_color_input) >> 8;
+			temp_l = ((uint8_t)tabdata.item1_page0_color_input) & 0xFF;
+			eeprom_writedata(INPUT_COLOR_ADDR, temp_h);
+			eeprom_writedata(INPUT_COLOR_ADDR + 8, temp_l);
+		}
+		break;
+
+		case 16:
+		{
+			//输出曲线颜色
+			temp_h = ((uint8_t)tabdata.item1_page0_color_output) >> 8;
+			temp_l = ((uint8_t)tabdata.item1_page0_color_output) & 0xFF;
+			eeprom_writedata(OUTPUT_COLOR_ADDR, temp_h);
+			eeprom_writedata(OUTPUT_COLOR_ADDR + 8, temp_l);
+		}
+		break;
+
+		case 17:
+		{
+			//语言选择
+			temp_h = ((uint8_t)tabdata.item3_page0_language) >> 8;
+			temp_l = ((uint8_t)tabdata.item3_page0_language) & 0xFF;
+			eeprom_writedata(LANGUAGE_SELECT_ADDR, temp_h);
+			eeprom_writedata(LANGUAGE_SELECT_ADDR + 8, temp_l);
+		}
+		break;
+
+		default:
+		break;
+	}
+}
+
+//开机上电后读取参数
+void eeprom_dataread(void)
+{
+	uint8_t temp_h = 0, temp_l = 0;
+
+	//VOL V
+	temp_h = eeprom_readdata(VOL_V_UP_ADDR);
+	temp_l = eeprom_readdata(VOL_V_UP_ADDR + 8);
+	tabdata.item0_page0_vup[0] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(VOL_V_LOW_ADDR);
+	temp_l = eeprom_readdata(VOL_V_LOW_ADDR + 8);
+	tabdata.item0_page0_vlow[0] = ( temp_h << 8 ) + temp_l;
+
+	//出现错误后，提前返回
+	if(system_sts.eeprom_read_error) return;
+
+	//VOL mV
+	temp_h = eeprom_readdata(VOL_MV_UP_ADDR);
+	temp_l = eeprom_readdata(VOL_MV_UP_ADDR + 8);
+	tabdata.item0_page0_vup[1] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(VOL_MV_LOW_ADDR);
+	temp_l = eeprom_readdata(VOL_MV_LOW_ADDR + 8);
+	tabdata.item0_page0_vlow[1] = ( temp_h << 8 ) + temp_l;
+
+	//CUR
+	//temp_h = eeprom_readdata(CUR_UP_ADDR);
+	temp_l = eeprom_readdata(CUR_UP_ADDR + 8);
+	tabdata.item0_page0_cup = temp_l;
+
+	//temp_h = eeprom_readdata(CUR_LOW_ADDR);
+	temp_l = eeprom_readdata(CUR_LOW_ADDR + 8);
+	tabdata.item0_page0_clow = temp_l;
+
+	//RES
+	temp_h = eeprom_readdata(RES_UP_ADDR);
+	temp_l = eeprom_readdata(RES_UP_ADDR + 8);
+	tabdata.item0_page0_rup = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(RES_LOW_ADDR);
+	temp_l = eeprom_readdata(RES_LOW_ADDR + 8);
+	tabdata.item0_page1_rlow = ( temp_h << 8 ) + temp_l;
+
+	//FRE
+	//temp_h = eeprom_readdata(FRE_UP_ADDR);
+	temp_l = eeprom_readdata(FRE_UP_ADDR + 8);
+	tabdata.item0_page1_fup = temp_l;
+
+	//temp_h = eeprom_readdata(FRE_LOW_ADDR);
+	temp_l = eeprom_readdata(FRE_LOW_ADDR + 8);
+	tabdata.item0_page1_flow = temp_l;
+
+	//TC K
+	temp_h = eeprom_readdata(TC_K_UP_ADDR);
+	temp_l = eeprom_readdata(TC_K_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[0] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_K_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_K_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[0] = ( temp_h << 8 ) + temp_l;
+
+	//TC S
+	temp_h = eeprom_readdata(TC_S_UP_ADDR);
+	temp_l = eeprom_readdata(TC_S_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[1] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_S_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_S_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[1] = ( temp_h << 8 ) + temp_l;
+
+	//TC N
+	temp_h = eeprom_readdata(TC_N_UP_ADDR);
+	temp_l = eeprom_readdata(TC_N_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[2] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_N_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_N_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[2] = ( temp_h << 8 ) + temp_l;
+
+	//TC B
+	temp_h = eeprom_readdata(TC_B_UP_ADDR);
+	temp_l = eeprom_readdata(TC_B_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[3] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_B_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_B_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[3] = ( temp_h << 8 ) + temp_l;
+
+	//TC E
+	temp_h = eeprom_readdata(TC_E_UP_ADDR);
+	temp_l = eeprom_readdata(TC_E_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[4] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_E_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_E_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[4] = ( temp_h << 8 ) + temp_l;
+
+	//TC J
+	temp_h = eeprom_readdata(TC_J_UP_ADDR);
+	temp_l = eeprom_readdata(TC_J_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[5] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_J_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_J_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[5] = ( temp_h << 8 ) + temp_l;
+
+	//TC R
+	temp_h = eeprom_readdata(TC_R_UP_ADDR);
+	temp_l = eeprom_readdata(TC_R_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[6] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_R_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_R_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[6] = ( temp_h << 8 ) + temp_l;
+
+	//TC T
+	temp_h = eeprom_readdata(TC_T_UP_ADDR);
+	temp_l = eeprom_readdata(TC_T_UP_ADDR + 8);
+	tabdata.item0_page1_TCup[7] = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(TC_T_LOW_ADDR);
+	temp_l = eeprom_readdata(TC_T_LOW_ADDR + 8);
+	tabdata.item0_page1_TClow[7] = ( temp_h << 8 ) + temp_l;
+
+	//RTD
+	temp_h = eeprom_readdata(RTD_UP_ADDR);
+	temp_l = eeprom_readdata(RTD_UP_ADDR + 8);
+	tabdata.item0_page2_RTDup = ( temp_h << 8 ) + temp_l;
+
+	temp_h = eeprom_readdata(RTD_LOW_ADDR);
+	temp_l = eeprom_readdata(RTD_LOW_ADDR + 8);
+	tabdata.item0_page2_RTDlow = ( temp_h << 8 ) + temp_l;
+
+	//采样间隔
+	temp_h = eeprom_readdata(SAMPLE_INTERVAL_ADDR);
+	temp_l = eeprom_readdata(SAMPLE_INTERVAL_ADDR + 8);
+	tabdata.item1_page0_sample_interval = ( temp_h << 8 ) + temp_l;
+
+	//描点数量
+	temp_h = eeprom_readdata(PLOT_COUNT_ADDR);
+	temp_l = eeprom_readdata(PLOT_COUNT_ADDR + 8);
+	tabdata.item1_page0_plot_num = ( temp_h << 8 ) + temp_l;
+
+	//输入曲线颜色
+	temp_h = eeprom_readdata(INPUT_COLOR_ADDR);
+	temp_l = eeprom_readdata(INPUT_COLOR_ADDR + 8);
+	tabdata.item1_page0_color_input = (COLORS)( ( temp_h << 8 ) + temp_l );
+
+	//输出曲线颜色
+	temp_h = eeprom_readdata(OUTPUT_COLOR_ADDR);
+	temp_l = eeprom_readdata(OUTPUT_COLOR_ADDR + 8);
+	tabdata.item1_page0_color_output = (COLORS)( ( temp_h << 8 ) + temp_l );
+
+	//语言选择
+	temp_h = eeprom_readdata(LANGUAGE_SELECT_ADDR);
+	temp_l = eeprom_readdata(LANGUAGE_SELECT_ADDR + 8);
+	tabdata.item3_page0_language = (LANGUAGES)( ( temp_h << 8 ) + temp_l );
+}
+
+//判断EEPROM内是否已存在数据
+uint8_t eeprom_device_check(void)
+{
+	uint8_t device_status_h = 0, device_status_l = 0;
+	int dev_sts = 0;
+
+	device_status_h = eeprom_readdata(DEVICE_CHECK);
+	device_status_l = eeprom_readdata(DEVICE_CHECK + 8);
+	dev_sts = (device_status_h << 8) + device_status_l;
+
+	if(dev_sts != 0xAAAA)
+	{
+		tabdata.item0_page0_vup[0] = VOL[0].up;        //电压V上限
+        tabdata.item0_page0_vlow[0] = VOL[0].low;      //电压V下限
+        tabdata.item0_page0_vup[1] = VOL[1].up;        //电压mV上限
+        tabdata.item0_page0_vlow[1] = VOL[1].low;      //电压mV下限
+        tabdata.item0_page0_cup = CUR.up;              //电流上限
+        tabdata.item0_page0_clow = CUR.low;            //电流下限
+        tabdata.item0_page0_rup = RES.up;              //电阻上限
+        tabdata.item0_page1_rlow = RES.low;            //电阻下限
+        tabdata.item0_page1_fup = FRE.up;              //频率上限
+        tabdata.item0_page1_flow = FRE.low;            //频率下限            
+        tabdata.item0_page1_TCup[0] = TC[0].up;        //TCK上限
+        tabdata.item0_page1_TClow[0] = TC[0].low;      //TCK下限
+        tabdata.item0_page1_TCup[1] = TC[1].up;        //TCS上限
+        tabdata.item0_page1_TClow[1] = TC[1].low;      //TCS下限
+        tabdata.item0_page1_TCup[2] = TC[2].up;        //TCN上限
+        tabdata.item0_page1_TClow[2] = TC[2].low;      //TCN下限
+        tabdata.item0_page1_TCup[3] = TC[3].up;        //TCB上限
+        tabdata.item0_page1_TClow[3] = TC[3].low;      //TCB下限
+        tabdata.item0_page1_TCup[4] = TC[4].up;        //TCE上限
+        tabdata.item0_page1_TClow[4] = TC[4].low;      //TCE下限
+        tabdata.item0_page1_TCup[5] = TC[5].up;        //TCJ上限
+        tabdata.item0_page1_TClow[5] = TC[5].low;      //TCJ下限
+        tabdata.item0_page1_TCup[6] = TC[6].up;        //TCR上限
+        tabdata.item0_page1_TClow[6] = TC[6].low;      //TCR下限
+        tabdata.item0_page1_TCup[7] = TC[7].up;        //TCT上限
+        tabdata.item0_page1_TClow[7] = TC[7].low;      //TCT下限
+        tabdata.item0_page2_RTDup = RTD.up;            //RTD上限
+        tabdata.item0_page2_RTDlow = RTD.low;          //RTD下限
+		tabdata.item1_page0_sample_interval = 1500;
+		tabdata.item1_page0_plot_num = 5;
+		tabdata.item1_page0_color_input = COLOR_YELLOW;
+		tabdata.item1_page0_color_output = COLOR_BLUE;
+		tabdata.item3_page0_language = MENU_SIMPLYFY_CHINESE;
+		
+		//eeprom_datasave();
+		eeprom_datasave_changed();
+
+		eeprom_writedata(DEVICE_CHECK, 0xAA);
+		eeprom_writedata(DEVICE_CHECK + 8, 0xAA);
+		
+		return 0;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+
+
+

App/EEPROM/eeprom_spi.h

@@ -0,0 +1,177 @@
+#ifndef _EEPROM_SPI_H_
+#define _EEPROM_SPI_H_
+
+#include "apps_gather.h"
+
+//模拟SPI, CS->PB9, WR->PD6, SCLK->PB3, MOSI->PB5, MISO->PB4 
+
+//CS->PB9
+#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)
+
+//WR->PD6
+#define EEPROM_WR_H HAL_GPIO_WritePin(EEPROM_WR_GPIO_Port, EEPROM_WR_Pin, GPIO_PIN_SET)
+#define EEPROM_WR_L HAL_GPIO_WritePin(EEPROM_WR_GPIO_Port, EEPROM_WR_Pin, GPIO_PIN_RESET)
+
+//SCLK->PB3
+#define EEPROM_SCLK_H HAL_GPIO_WritePin(EEPROM_SCLK_GPIO_Port, EEPROM_SCLK_Pin, GPIO_PIN_SET)
+#define EEPROM_SCLK_L HAL_GPIO_WritePin(EEPROM_SCLK_GPIO_Port, EEPROM_SCLK_Pin, GPIO_PIN_RESET)
+
+//MOSI->PB5
+#define EEPROM_MOSI_H HAL_GPIO_WritePin(EEPROM_MOSI_GPIO_Port, EEPROM_MOSI_Pin, GPIO_PIN_SET)
+#define EEPROM_MOSI_L HAL_GPIO_WritePin(EEPROM_MOSI_GPIO_Port, EEPROM_MOSI_Pin, GPIO_PIN_RESET)
+
+//MISO->PB4 
+#define EEPROM_MISO HAL_GPIO_ReadPin(EEPROM_MISO_GPIO_Port, EEPROM_MISO_Pin)
+
+//eeprom cmd
+#define WRITE_ENABLE 0x06
+#define WRITE_DISABLE 0x04
+#define WRITE_MEMORY 0x02
+#define READ_MEMORY 0x03
+#define READ_STATUS 0x05
+
+//my address
+//{
+    //0x7D0 - 0x7E0(2000 - 2016)，标记后写入0xAAAA（连续16位“1”“0”交替）
+    #define DEVICE_CHECK 0x0007D0
+    #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
+
+    //电压V下限，tag：0，EE_START_ADDR + 1*EE_INTERVAL
+    #define VOL_V_LOW_ADDR (VOL_V_UP_ADDR + EE_INTERVAL)
+
+    //电压mV上限，tag：0，EE_START_ADDR + 2*EE_INTERVAL
+    #define VOL_MV_UP_ADDR (VOL_V_LOW_ADDR + EE_INTERVAL)
+
+    //电压mV下限，tag：0，EE_START_ADDR + 3*EE_INTERVAL
+    #define VOL_MV_LOW_ADDR (VOL_MV_UP_ADDR + EE_INTERVAL)
+
+    //电流上限，tag：1，EE_START_ADDR + 4*EE_INTERVAL
+    #define CUR_UP_ADDR (VOL_MV_LOW_ADDR + EE_INTERVAL)
+
+    //电流下限，tag：1，EE_START_ADDR + 5*EE_INTERVAL
+    #define CUR_LOW_ADDR (CUR_UP_ADDR + EE_INTERVAL)
+
+    //电阻上限，tag：2，EE_START_ADDR + 6*EE_INTERVAL
+    #define RES_UP_ADDR (CUR_LOW_ADDR + EE_INTERVAL)
+
+    //电阻下限，tag：2，EE_START_ADDR + 7*EE_INTERVAL
+    #define RES_LOW_ADDR (RES_UP_ADDR + EE_INTERVAL)
+
+    //频率上限，tag：3，EE_START_ADDR + 8*EE_INTERVAL
+    #define FRE_UP_ADDR (RES_LOW_ADDR + EE_INTERVAL)
+
+    //频率下限，tag：3，EE_START_ADDR + 9*EE_INTERVAL
+    #define FRE_LOW_ADDR (FRE_UP_ADDR + EE_INTERVAL)
+
+    //TC_K上限，tag：4，EE_START_ADDR + 10*EE_INTERVAL
+    #define TC_K_UP_ADDR (FRE_LOW_ADDR + EE_INTERVAL)
+
+    //TC_K下限，tag：4，EE_START_ADDR + 11*EE_INTERVAL
+    #define TC_K_LOW_ADDR (TC_K_UP_ADDR + EE_INTERVAL)
+
+    //TC_S上限，tag：5，EE_START_ADDR + 12*EE_INTERVAL
+    #define TC_S_UP_ADDR (TC_K_LOW_ADDR + EE_INTERVAL)
+
+    //TC_S下限，tag：5，EE_START_ADDR + 13*EE_INTERVAL
+    #define TC_S_LOW_ADDR (TC_S_UP_ADDR + EE_INTERVAL)
+
+    //TC_N上限，tag：6，EE_START_ADDR + 14*EE_INTERVAL
+    #define TC_N_UP_ADDR (TC_S_LOW_ADDR + EE_INTERVAL)
+
+    //TC_N下限，tag：6，EE_START_ADDR + 15*EE_INTERVAL
+    #define TC_N_LOW_ADDR (TC_N_UP_ADDR + EE_INTERVAL)
+
+    //TC_B上限，tag：7，EE_START_ADDR + 16*EE_INTERVAL
+    #define TC_B_UP_ADDR (TC_N_LOW_ADDR + EE_INTERVAL)
+
+    //TC_B下限，tag：7，EE_START_ADDR + 17*EE_INTERVAL
+    #define TC_B_LOW_ADDR (TC_B_UP_ADDR + EE_INTERVAL)
+
+    //TC_E上限，tag：8，EE_START_ADDR + 18*EE_INTERVAL
+    #define TC_E_UP_ADDR (TC_B_LOW_ADDR + EE_INTERVAL)
+
+    //TC_E下限，tag：8，EE_START_ADDR + 19*EE_INTERVAL
+    #define TC_E_LOW_ADDR (TC_E_UP_ADDR + EE_INTERVAL)
+
+    //TC_J上限，tag：9，EE_START_ADDR + 20*EE_INTERVAL
+    #define TC_J_UP_ADDR (TC_E_LOW_ADDR + EE_INTERVAL)
+
+    //TC_J下限，tag：9，EE_START_ADDR + 21*EE_INTERVAL
+    #define TC_J_LOW_ADDR (TC_J_UP_ADDR + 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_writebyte(uint8_t wrt_data);
+uint8_t SPI_WriteReadByte(uint8_t data);
+uint8_t eeprom_spi_readbyte(void);
+void eeprom_writedata(int32_t addr_long, uint8_t txd);
+uint8_t eeprom_readdata(int32_t addr_long);
+
+//开机上电后读取参数
+void eeprom_dataread(void);
+
+//判断EEPROM内是否已存在数据
+uint8_t eeprom_device_check(void);
+
+//保存指定数据
+void eeprom_datasave_single(uint8_t tag);
+
+#if DATA_SAVE_ALL
+
+//存储参数，全部
+void eeprom_datasave(void);
+
+#else
+
+//保存修改过的数据
+void eeprom_datasave_changed(void);
+
+#endif
+
+
+
+#endif
+
+

App/HART/hart.c

@@ -4,6 +4,7 @@
 #include "task.h"
 #include "hart.h"
 #include "gpio.h"
+#include "apps_gather.h"
 
 void hart_send(UART_HandleTypeDef *huart, uint8_t *data)
 {
@@ -41,10 +42,15 @@ void hart_communicate(st_scom *scom)
     if (scom->tx_flag == TRUE)
     {
         scom->tx_flag = FALSE;
+
         HART_RTS(RTS_ON);
-        vTaskDelay(5);
+        vTaskDelay(15);
+
         memcpy(scom->tx_buff, hart_data_test, sizeof(hart_data_test));
         hart_send(&huart1, scom->tx_buff);
+        
         HART_RTS(RTS_OFF);
     }
 }
+
+

App/HART/hart.h

@@ -1,5 +1,5 @@
-#ifndef __HART_H
-#define __HART_H
+#ifndef _HART_H_
+#define _HART_H_
 #include "usart.h"
 #include "data_type_def.h"
 
@@ -8,4 +8,9 @@
 
 void hart_send(UART_HandleTypeDef *huart, uint8_t *data);
 void hart_communicate(st_scom *scom);
+
+//DEVICE <---SIG---> PC
+//将来自设备的HART数据装载至com485_tx，将comhart_tx的HART数据发送至设备
+void transparent_hart(st_scom *scom);
+
 #endif

App/IP5310/ip5310_i2c.c

@@ -0,0 +1,40 @@
+/*
+ * @Author: wujunchao wujunchao@wuxismart.com
+ * @Date: 2025-03-17 13:35:30
+ * @LastEditors: wujunchao wujunchao@wuxismart.com
+ * @LastEditTime: 2025-03-24 17:35:57
+ * @FilePath: \signal_generator\App\APP_WU\Src\ip5310_i2c.c
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+#include "ip5310_i2c.h"
+
+uint8_t rx_data = 0;
+uint8_t tx_data = 0;
+
+uint8_t bat_cpa;
+uint8_t charge_flag = 0;
+uint8_t charging_flag = 0;
+
+//I2C读取电池电量
+void read_battery(void)
+{
+    //读取当前电量，5个档位
+    tx_data = BATTERY_CAPACITY;
+    HAL_I2C_Master_Transmit(&hi2c3, WRITE_CMD, &tx_data, 1, 0xff);
+    HAL_I2C_Master_Receive(&hi2c3, READ_CMD, &rx_data, 1, 0xff);
+    bat_cpa = (rx_data >> 4);
+
+    //电池充电是否开始，type-C是否接入电源
+    tx_data = CHARGE_FLAG;
+    HAL_I2C_Master_Transmit(&hi2c3, WRITE_CMD, &tx_data, 1, 0xff);
+    HAL_I2C_Master_Receive(&hi2c3, READ_CMD, &rx_data, 1, 0xff);
+    charge_flag = (rx_data & 0x08)>>3;
+
+    //电池充电是否结束，type-C可能还处于连接状态
+    tx_data = CHARGING_FLAG;
+    HAL_I2C_Master_Transmit(&hi2c3, WRITE_CMD, &tx_data, 1, 0xff);
+    HAL_I2C_Master_Receive(&hi2c3, READ_CMD, &rx_data, 1, 0xff);
+    charging_flag = (rx_data & 0x08)>>3;
+}
+
+

App/IP5310/ip5310_i2c.h

@@ -0,0 +1,41 @@
+#ifndef _IP5310_I2C_H_
+#define _IP5310_I2C_H_
+
+#include "apps_gather.h"
+
+extern uint8_t bat_cpa;
+extern uint8_t charge_flag;
+extern uint8_t charging_flag;
+
+//电芯电量寄存器
+//bits [4~7]->[0000, 0001, 0011, 0111, 1111]->[<3%, 3~25%, 25~50%, 50~75%, >75%]
+#define BATTERY_CAPACITY 0x74
+
+//[3]bit, 1：充电开启, 0：充电关闭
+#define CHARGE_FLAG 0x70
+
+//[3]bit, 1：充电结束, 0：充电中
+#define CHARGING_FLAG 0x71
+
+//读命令
+#define READ_CMD 0xEB
+
+//写命令
+#define WRITE_CMD 0xEA
+
+#define BAT_CAP_3 0
+#define BAT_CAP_3_25 1
+#define BAT_CAP_25_50 3
+#define BAT_CAP_50_75 7
+#define BAT_CAP_75 15
+#define BAT_CAP_CHARGING 20
+
+//I2C读取电池电量
+void read_battery(void);
+
+
+
+
+#endif
+
+

App/LCD/JLX240-00301-BN.c

@@ -8,7 +8,7 @@
 // LCM resolution:240x320,
 // driver IC:ST7789V,
 
-#include <chinese_code.h>
+//#include <chinese_code.h>
 
 typedef struct
 {
@@ -72,7 +72,7 @@ void transfer_data(uint8_t data1)
     CS_SET();             // CS0 = 1;
 }
 
-// 杩炲啓2锟???瀛楄妭锛堝嵆16浣嶏級鏁版嵁鍒癓CD妯″潡
+//连写2个字节（即16位）数据到LCD模块
 void transfer_data_16(uint16_t data_16bit)
 {
     transfer_data(data_16bit >> 8);
@@ -110,6 +110,8 @@ repeat:
         ;
 }
 
+//uint8_t cmd_test1 = 0x00;
+uint8_t cmd_test2 = 0xA0;
 void lcd_initial()
 {
     RST_RESET(); // reset = 0;
@@ -118,13 +120,12 @@ void lcd_initial()
     delay(200);
 
     //------------------------------display and color format setting--------------------------------//
-    transfer_command(0x36); // 琛屾壂鎻忛『搴忓強RGB锛屽垪锟???鎻忛『搴忥紝锟???锟???/绔栨斁
-    transfer_data(0x00);
-    transfer_data(0x48);
+    transfer_command(0x36);     //行扫描顺序及RGB，列扫描顺序，横放/竖放 
+    transfer_data(cmd_test2);       
 
-    transfer_command(0xB6); // 鏄剧ず鍔熻兘璁剧疆锛氬垪/锟??? 鏄剧ず椤哄簭
+    transfer_command(0xB6);     //显示功能设置：列/行 显示顺序
     transfer_data(0x0A);
-    transfer_data(0x82); // 鏀瑰彉SOURCE绾跨殑鏂瑰悜锟???0xa2锛氬乏鍒板彸锟???0x82锛氬彸鍒板乏
+    transfer_data(0x82);        //改变SOURCE线的方向：0xa2：左到右，0x82：右到左
 
     transfer_command(0x3a); // 256K 16bit/pixel
     transfer_data(0x05);
@@ -186,26 +187,26 @@ void lcd_initial()
     transfer_data(0x1b);
     transfer_data(0x1e);
 
-    transfer_command(0x11); // 閫€鍑虹潯锟???
+    transfer_command(0x11); //退出睡眠
     delay(200);
-    transfer_command(0x29); // 鎵撳紑鏄剧ず
+    transfer_command(0x29); //打开显示
 }
 
-// 瀹氫箟绐楀彛鍧愭爣锛氬紑濮嬪潗鏍囷紙XS,YS)浠ュ強绐楀彛澶у皬锛坸_total,y_total)
+//定义窗口坐标：开始坐标（XS,YS)以及窗口大小（x_total,y_total)
 void lcd_address(int XS, int YS, int x_total, int y_total)
 {
     int XE, YE;
     XE = XS + x_total - 1;
     YE = YS + y_total - 1;
-    transfer_command(0x2a); // 璁剧疆X寮€濮嬪強缁撴潫鐨勫湴鍧€
-    transfer_data_16(XS);   // X寮€濮嬪湴鍧€(16浣嶏級
-    transfer_data_16(XE);   // X缁撴潫鍦板潃(16浣嶏級
+    transfer_command(0x2a); // 设置X开始及结束的地址
+    transfer_data_16(XS);   // X开始地址(16位）
+    transfer_data_16(XE);   // X结束地址(16位）
 
-    transfer_command(0x2b); // 璁剧疆Y寮€濮嬪強缁撴潫鐨勫湴鍧€
-    transfer_data_16(YS);   // Y寮€濮嬪湴鍧€(16浣嶏級
-    transfer_data_16(YE);   // Y缁撴潫鍦板潃(16浣嶏級
+    transfer_command(0x2b); // 设置Y开始及结束的地址
+    transfer_data_16(YS);   // Y开始地址(16位）
+    transfer_data_16(YE);   // Y结束地址(16位）
 
-    transfer_command(0x2c); // 鍐欐暟锟???寮€锟???
+    transfer_command(0x2c); // 写数据开始
 }
 
 void mono_transfer_data_16(int mono_data, int font_color, int back_color)
@@ -215,17 +216,17 @@ void mono_transfer_data_16(int mono_data, int font_color, int back_color)
     {
         if (mono_data & 0x80)
         {
-            transfer_data_16(font_color); // 褰撴暟锟???锟???1鏃讹紝鏄剧ず瀛椾綋棰滆壊
+            transfer_data_16(font_color); //当数据是1时，显示字体颜色
         }
         else
         {
-            transfer_data_16(back_color); // 褰撴暟锟???锟???0鏃讹紝鏄剧ず搴曡壊
+            transfer_data_16(back_color); //当数据是0时，显示底色
         }
         mono_data <<= 1;
     }
 }
 
-// 鍏ㄥ睆鏄剧ず涓€绉嶏拷?锟借壊
+//全屏显示一种颜色
 void display_color(int color_data)
 {
     int i, j;
@@ -239,10 +240,11 @@ void display_color(int color_data)
     }
 }
 
+
 void display_black(void)
 {
     int i, j, k;
-    transfer_command(0x2c); // 鍐欐暟锟???寮€锟???
+    transfer_command(0x2c); // 写数据开始
     for (i = 0; i < 240; i++)
     {
         transfer_data_16(0xffff);
@@ -268,7 +270,8 @@ void display_black(void)
     }
 }
 
-// 鏄剧ず8x16鐐归樀鐨勫瓧绗︿覆
+#if 0
+//显示8x16点阵的字符串
 void disp_string_8x16(int x, int y, const char *text, int font_color, int back_color)
 {
     int i = 0, j, k;
@@ -295,11 +298,11 @@ void display_string_16x16(int x, int y, const char *text, int font_color, int ba
     uchar i, j, k;
     uint address;
     j = 0;
-    while (text[j] != '\0') //'\0' 瀛楋拷?锟戒覆缁撴潫鏍囧織
+    while (text[j] != '\0')  //'\0' 字符串结束标志
     {
         i = 0;
         address = 1;
-        while (Chinese_horizontal_text_16x16[i] > 0x7e) // >0x7f鍗筹拷?锟芥槑涓嶆槸ASCII鐮佸瓧锟???
+        while (Chinese_horizontal_text_16x16[i] > 0x7e) // >0x7f即说明不是ASCII码字符
         {
             if (Chinese_horizontal_text_16x16[i] == text[j])
             {
@@ -317,7 +320,7 @@ void display_string_16x16(int x, int y, const char *text, int font_color, int ba
             x += 16;
         }
 
-        if (address != 1) // 鏄剧ず姹夊瓧
+        if (address != 1) // 显示汉字  
         {
             lcd_address(x, y, 16, 16);
             for (i = 0; i < 2; i++)
@@ -330,7 +333,7 @@ void display_string_16x16(int x, int y, const char *text, int font_color, int ba
             }
             j += 2;
         }
-        else // 鏄剧ず绌虹櫧瀛楋拷??
+        else //显示空白字符
         {
             lcd_address(x, y, 16, 16);
             for (i = 0; i < 2; i++)
@@ -346,7 +349,7 @@ void display_string_16x16(int x, int y, const char *text, int font_color, int ba
     }
 }
 
-// 鏄剧ず32x32鐐归樀鐨勫崟鑹茬殑鍥惧儚
+//显示32x32点阵的单色的图像
 void disp_32x32(int x, int y, const char *dp, int font_color, int back_color)
 {
     int i, j;
@@ -361,22 +364,25 @@ void disp_32x32(int x, int y, const char *dp, int font_color, int back_color)
     }
 }
 
-// 鏄剧ず涓€骞呭僵锟???
+//显示一幅彩图
 void display_image(int x, int y, const uchar *dp)
 {
-    uchar i, j, k = 0;
+    uchar i, j;
     lcd_address(x, y, 120, 160);
     for (i = 0; i < 120; i++)
     {
         for (j = 0; j < 160; j++)
         {
-            transfer_data(*dp); // 浼犱竴锟???鍍忕礌鐨勫浘鐗囨暟锟???鐨勯珮锟???
+            transfer_data(*dp); //传一个像素的图片数据的高位 
             dp++;
-            transfer_data(*dp); // 浼犱竴锟???鍍忕礌鐨勫浘鐗囨暟锟???鐨勪綆锟???
+            transfer_data(*dp); //传一个像素的图片数据的低位
             dp++;
         }
     }
 }
+
+
+
 void lcd_menu(void)
 {
     static uint8_t init_flag = 0;
@@ -396,3 +402,8 @@ void lcd_menu(void)
     sprintf(content, "AO:ch[%02d] vol[%2.4f]V.", mux_signal.channel, mux_signal.data_sv / 1000.0f);
     disp_string_8x16(10, 70, content, white, blue);
 }
+
+#endif
+
+
+

App/LCD/JLX240-00301-BN.h

@@ -1,13 +1,13 @@
 /*
  * @Author: DaMingSY zxm5337@163.com
  * @Date: 2024-08-29 10:34:51
- * @LastEditors: DaMingSY zxm5337@163.com
- * @LastEditTime: 2024-09-05 15:12:35
+ * @LastEditors: wujunchao wujunchao@wuxismart.com
+ * @LastEditTime: 2024-12-25 10:14:46
  * @FilePath: \signal_generator\App\LCD\JLX240-00301-BN.h
  * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
  */
-#ifndef __JLX240X320_H
-#define __JLX240X320_H
+#ifndef _JLX240X320_H_
+#define _JLX240X320_H_
 #include "data_type_def.h"
 
 #define CS_SET() HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_SET)
@@ -44,4 +44,8 @@ typedef union
 void lcd_initial(void);
 
 void lcd_menu(void);
+
+void lcd_address(int XS, int YS, int x_total, int y_total);
+void transfer_data_16(uint16_t data_16bit);
+
 #endif

App/LCD/JLX240-00303-BN-P.c

@@ -1,434 +0,0 @@
-// LCM resolution:240x320,
-// driver IC:ST7789V,
-
-#include <chinese_code.h>
-
-// 液晶屏IC所需要的信号线的接口定义
-/*
-sbit DC0 = P3 ^ 4;
-sbit WR0 = P3 ^ 0;
-sbit RD0 = P3 ^ 1;
-sbit CS0 = P3 ^ 5;
-sbit reset = P3 ^ 3;
-sbit IM1 = P3 ^ 6;
-sbit IM2 = P3 ^ 7;
-sbit key = P2 ^ 0; // P2.0口与GND之间接一个按键
-*/
-
-
-#pragma pack(push,1)
- 
-typedef struct ST_TEST
-{
-	unsigned char	ucA:1;
-	unsigned char	ucB:1;
-	unsigned char	ucC:1;
-	unsigned char	ucD:1;
-	unsigned char	ucE:1;
-	unsigned char	ucF:1;
-	unsigned char	ucG:1;
-	unsigned char	ucH:1;
-} ST_TEST;
-#pragma pack(pop)
-
-
-union data_port
-{
-	uint8_t data;
-	#pragma pack(push,1)
-	struct
-	{
-		uint8_t bit0 : 1;
-		uint8_t bit1 : 1;
-		uint8_t bit2 : 1;
-		uint8_t bit3 : 1;
-		uint8_t bit4 : 1;
-		uint8_t bit5 : 1;
-		uint8_t bit6 : 1;
-		uint8_t bit7 : 1;
-	} bit;
-	#pragma pack(pop)
-}
-
-transfer_command(int com1)
-{
-	CS0 = 0;
-	DC0 = 0;
-	RD0 = 1;
-	P1 = com1;
-	WR0 = 0;
-	delay_us(1);
-	WR0 = 1;
-	CS0 = 1;
-}
-
-void transfer_data(int data1)
-{
-	CS0 = 0;
-	DC0 = 1;
-	RD0 = 1;
-	P1 = data1;
-	WR0 = 0;
-	WR0 = 1;
-	CS0 = 1;
-}
-
-// 连写2个字节（即16位）数据到LCD模块
-void transfer_data_16(uint data_16bit)
-{
-	transfer_data(data_16bit >> 8);
-	transfer_data(data_16bit);
-}
-
-void delay(long i)
-{
-	int j, k;
-	for (j = 0; j < i; j++)
-		for (k = 0; k < 110; k++)
-			;
-}
-
-void delay_us(long i)
-{
-	int j, k;
-	for (j = 0; j < i; j++)
-		;
-	for (k = 0; k < 1; k++)
-		;
-}
-
-void Switch()
-{
-repeat:
-	if (key == 1)
-		goto repeat;
-	else
-		delay(1000);
-	if (key)
-		goto repeat;
-	else
-		;
-}
-
-void lcd_initial()
-{
-	reset = 0;
-	delay(200);
-	reset = 1;
-	delay(200);
-	//************* Start Initial Sequence **********//
-
-	//------------------------------display and color format setting--------------------------------//
-	transfer_command(0x36); // 行扫描顺序及RGB，列扫描顺序，横放/竖放
-	transfer_data(0x00);
-	transfer_data(0x48);
-
-	transfer_command(0xB6); // 显示功能设置：列/行 显示顺序
-	transfer_data(0x0A);
-	transfer_data(0x82); // 改变SOURCE线的方向：0xa2：左到右，0x82：右到左
-
-	transfer_command(0x3a); // 256K 16bit/pixel
-	transfer_data(0x05);
-	//--------------------------------ST7789V Frame rate setting----------------------------------//
-	transfer_command(0xb2);
-	transfer_data(0x0c);
-	transfer_data(0x0c);
-	transfer_data(0x00);
-	transfer_data(0x33);
-	transfer_data(0x33);
-	transfer_command(0xb7);
-	transfer_data(0x35);
-	//---------------------------------ST7789V Power setting--------------------------------------//
-	transfer_command(0xbb);
-	transfer_data(0x28);
-	transfer_command(0xc0);
-	transfer_data(0x2c);
-	transfer_command(0xc2);
-	transfer_data(0x01);
-	transfer_command(0xc3);
-	transfer_data(0x10);
-	transfer_command(0xc4);
-	transfer_data(0x20);
-	transfer_command(0xc6);
-	transfer_data(0x0f);
-	transfer_command(0xd0);
-	transfer_data(0xa4);
-	transfer_data(0xa1);
-	//--------------------------------ST7789V gamma setting---------------------------------------//
-	transfer_command(0xe0);
-	transfer_data(0xd0);
-	transfer_data(0x00);
-	transfer_data(0x02);
-	transfer_data(0x07);
-	transfer_data(0x0a);
-	transfer_data(0x28);
-	transfer_data(0x32);
-	transfer_data(0x44);
-	transfer_data(0x42);
-	transfer_data(0x06);
-	transfer_data(0x0e);
-	transfer_data(0x12);
-	transfer_data(0x14);
-	transfer_data(0x17);
-
-	transfer_command(0xe1);
-	transfer_data(0xd0);
-	transfer_data(0x00);
-	transfer_data(0x02);
-	transfer_data(0x07);
-	transfer_data(0x0a);
-	transfer_data(0x28);
-	transfer_data(0x31);
-	transfer_data(0x54);
-	transfer_data(0x47);
-	transfer_data(0x0e);
-	transfer_data(0x1c);
-	transfer_data(0x17);
-	transfer_data(0x1b);
-	transfer_data(0x1e);
-
-	transfer_command(0x11); // 退出睡眠
-	delay(200);
-	transfer_command(0x29); // 打开显示
-}
-
-// 定义窗口坐标：开始坐标（XS,YS)以及窗口大小（x_total,y_total)
-void lcd_address(int XS, int YS, int x_total, int y_total)
-{
-	int XE, YE;
-	XE = XS + x_total - 1;
-	YE = YS + y_total - 1;
-	transfer_command(0x2a); // 设置X开始及结束的地址
-	transfer_data_16(XS);	// X开始地址(16位）
-	transfer_data_16(XE);	// X结束地址(16位）
-
-	transfer_command(0x2b); // 设置Y开始及结束的地址
-	transfer_data_16(YS);	// Y开始地址(16位）
-	transfer_data_16(YE);	// Y结束地址(16位）
-
-	transfer_command(0x2c); // 写数据开始
-}
-
-void mono_transfer_data_16(int mono_data, int font_color, int back_color)
-{
-	int i;
-	for (i = 0; i < 8; i++)
-	{
-		if (mono_data & 0x80)
-		{
-			transfer_data_16(font_color); // 当数据是1时，显示字体颜色
-		}
-		else
-		{
-			transfer_data_16(back_color); // 当数据是0时，显示底色
-		}
-		mono_data <<= 1;
-	}
-}
-
-// 全屏显示一种颜色
-void display_color(int color_data)
-{
-	int i, j;
-	lcd_address(0, 0, 240, 320);
-	for (i = 0; i < 240; i++)
-	{
-		for (j = 0; j < 320; j++)
-		{
-			transfer_data_16(color_data);
-		}
-	}
-}
-
-void display_black(void)
-{
-	int i, j, k;
-	transfer_command(0x2c); // 写数据开始
-	for (i = 0; i < 240; i++)
-	{
-		transfer_data_16(0xffff);
-	}
-	for (i = 0; i < 318; i++)
-	{
-		for (k = 0; k < 1; k++)
-		{
-			transfer_data_16(0xffff);
-		}
-		for (j = 0; j < 238; j++)
-		{
-			transfer_data_16(0x0000);
-		}
-		for (k = 0; k < 1; k++)
-		{
-			transfer_data_16(0xffff);
-		}
-	}
-	for (i = 0; i < 320; i++)
-	{
-		transfer_data_16(0xffff);
-	}
-}
-
-// 显示8x16点阵的字符串
-void disp_string_8x16(int x, int y, char *text, int font_color, int back_color)
-{
-	int i = 0, j, k;
-	while (text[i] > 0x00)
-	{
-		if ((text[i] >= 0x20) && (text[i] <= 0x7e))
-		{
-			j = text[i] - 0x20;
-			lcd_address(x, y, 8, 16);
-			for (k = 0; k < 16; k++)
-			{
-				mono_transfer_data_16(ascii_table_8x16[j * 16 + k], font_color, back_color); //?a??"ascii_table_8x16[]"?a??êy×é?ú"ASCII_TABLE_5X8_8X16_horizontal.h"à?
-			}
-			x += 8;
-			i++;
-		}
-		else
-			i++;
-	}
-}
-
-void display_string_16x16(int x, int y, uchar *text, int font_color, int back_color)
-{
-	uchar i, j, k;
-	uint address;
-	j = 0;
-	while (text[j] != '\0') //'\0' 字符串结束标志
-	{
-		i = 0;
-		address = 1;
-		while (Chinese_horizontal_text_16x16[i] > 0x7e) // >0x7f即说明不是ASCII码字符
-		{
-			if (Chinese_horizontal_text_16x16[i] == text[j])
-			{
-				if (Chinese_horizontal_text_16x16[i + 1] == text[j + 1])
-				{
-					address = i * 16;
-					break;
-				}
-			}
-			i += 2;
-		}
-		if (y > 320)
-		{
-			y = 0;
-			x += 16;
-		}
-
-		if (address != 1) // 显示汉字
-		{
-			lcd_address(x, y, 16, 16);
-			for (i = 0; i < 2; i++)
-			{
-				for (k = 0; k < 16; k++)
-				{
-					mono_transfer_data_16(Chinese_horizontal_code_16x16[address], font_color, back_color);
-					address++;
-				}
-			}
-			j += 2;
-		}
-		else // 显示空白字符
-		{
-			lcd_address(x, y, 16, 16);
-			for (i = 0; i < 2; i++)
-			{
-				for (k = 0; k < 16; k++)
-				{
-					mono_transfer_data_16(0x00, font_color, back_color);
-				}
-			}
-			j += 2;
-		}
-		x = x + 16;
-	}
-}
-
-// 显示32x32点阵的单色的图像
-void disp_32x32(int x, int y, char *dp, int font_color, int back_color)
-{
-	int i, j;
-	lcd_address(x, y, 32, 32);
-	for (i = 0; i < 32; i++)
-	{
-		for (j = 0; j < 4; j++)
-		{
-			mono_transfer_data_16(*dp, font_color, back_color);
-			dp++;
-		}
-	}
-}
-
-// 显示一幅彩图
-void display_image(int x, int y, uchar *dp)
-{
-	uchar i, j, k = 0;
-	lcd_address(x, y, 120, 160);
-	for (i = 0; i < 120; i++)
-	{
-		for (j = 0; j < 160; j++)
-		{
-			transfer_data(*dp); // 传一个像素的图片数据的高位
-			dp++;
-			transfer_data(*dp); // 传一个像素的图片数据的低位
-			dp++;
-		}
-	}
-}
-
-void main(void)
-{
-	P1M1 = 0x00;
-	P1M0 = 0x00; // P1配置为准双向
-	P2M1 = 0x00;
-	P2M0 = 0x00; // P2配置为准双向
-	P3M1 = 0x00;
-	P3M0 = 0x00; // P3配置为准双向
-	IM1 = 0;	 // IM1=0、IM2=0并行接口；IM1=1、IM2=1串行接口
-	IM2 = 0;
-	lcd_initial();
-	while (1)
-	{
-		display_color(blue);
-		disp_32x32(40 + 32 * 0, 8, jing_32x32, white, blue);
-		disp_32x32(40 + 32 * 1, 8, lian_32x32, white, blue);
-		disp_32x32(40 + 32 * 2, 8, xun_32x32, white, blue);
-		disp_32x32(40 + 32 * 3, 8, dian_32x32, white, blue);
-		disp_32x32(40 + 32 * 4, 8, zi_32x32, white, blue);
-
-		display_string_16x16(24, 56, "深圳市晶联讯电子有限公司", white, blue);
-		display_string_16x16(48, 88, "型号", white, blue);
-		disp_string_8x16(80, 88, ":JLX240-00303-BN", white, blue);
-		display_string_16x16(48, 120, "视窗", white, blue);
-		disp_string_8x16(80, 120, ":36.7x48.9mm", white, blue);
-		display_string_16x16(48, 152, "驱动", white, blue);
-		disp_string_8x16(80, 152, "IC:ST7789V", white, blue);
-
-		display_string_16x16(0, 184, "经营宗旨：制造高品质产品及服务", white, blue);
-		display_string_16x16(0, 216, "质量方针：客户至上，质量保证", white, blue);
-		display_string_16x16(79, 236, "持续改进，服务到位", white, blue);
-		display_string_16x16(0, 270, "经营目标：做最好的液晶模块厂家", white, blue);
-		display_string_16x16(79, 292, "做客户信得过的企业", white, blue);
-		Switch();
-
-		display_image(0, 0, pic1);
-		display_image(120, 0, pic1);
-		display_image(0, 160, pic1);
-		display_image(120, 160, pic1);
-		Switch();
-
-		display_color(0xf800);
-		Switch();
-		display_color(0x07e0);
-		Switch();
-		display_color(0x001f);
-		Switch();
-		display_black();
-		Switch();
-		display_color(0xffff);
-		Switch();
-	}
-}

App/LCD/JLX240-00303-BN-S.c

@@ -1,397 +0,0 @@
-//LCM resolution:240x320,
-//driver IC:ST7789V,
-
-#include <STC15F2K60S2.H>
-#include <chinese_code.h>
-
-//液晶屏IC所需要的信号线的接口定义
-sbit cs1=P3^5;	
-sbit reset=P3^3;
-sbit rs=P3^0;
-sbit sclk=P3^4;
-sbit sid=P3^2;
-sbit IM1=P3^6;
-sbit IM2=P3^7;
-sbit key=P2^0;		 //P2.0口与GND之间接一个按键
-
-/*写指令到LCD模块*/
-void transfer_command(int data1)   
-{
-	char i;
-	cs1=0;
-	rs=0;
-	for(i=0;i<8;i++)
-	{
-		sclk=0;
-		if(data1&0x80) sid=1;
-		else sid=0;
-		sclk=1;
-		data1=data1<<=1;
-	}
-	cs1=1;
-}
-
-/*写数据到LCD模块*/
-void transfer_data(int data1)
-{
-	char i;
-	cs1=0;
-	rs=1;
-	for(i=0;i<8;i++)
-	{
-		sclk=0;
-		if(data1&0x80) sid=1;
-		else sid=0;
-		sclk=1;
-		data1=data1<<=1;
-	}
-	cs1=1;
-}
-
-//连写2个字节（即16位）数据到LCD模块
-void transfer_data_16(uint data_16bit)
-{
-	transfer_data(data_16bit>>8);
-	transfer_data(data_16bit);
-}
-
-void delay(long i)
-{
-	int j,k;
-	for(j=0;j<i;j++)
-	for(k=0;k<110;k++);
-}  
-
-void Switch()
-{
- repeat:
-	if (key==1) goto repeat;
-	else delay(1000);
-	if (key) goto repeat;
-	else ;
-}
-
-void lcd_initial()
-{
-	reset=0;
-	delay(200);
-	reset=1;
-	delay(200);
-//************* Start Initial Sequence **********// 
-
-//------------------------------display and color format setting--------------------------------//
-	transfer_command(0x36);     //行扫描顺序及RGB，列扫描顺序，横放/竖放 
-	transfer_data(0x00);
-	transfer_data(0x48);
-	
-	transfer_command(0xB6);    	//显示功能设置：列/行 显示顺序
-	transfer_data(0x0A);    
-	transfer_data(0x82);    	//改变SOURCE线的方向：0xa2：左到右，0x82：右到左
-	
-	transfer_command(0x3a);     //256K 16bit/pixel
-	transfer_data(0x05);
-//--------------------------------ST7789V Frame rate setting----------------------------------//
-	transfer_command(0xb2);
-	transfer_data(0x0c);
-	transfer_data(0x0c);
-	transfer_data(0x00);
-	transfer_data(0x33);
-	transfer_data(0x33);
-	transfer_command(0xb7);
-	transfer_data(0x35);
-//---------------------------------ST7789V Power setting--------------------------------------//
-	transfer_command(0xbb);
-	transfer_data(0x28);
-	transfer_command(0xc0);
-	transfer_data(0x2c);
-	transfer_command(0xc2);
-	transfer_data(0x01);
-	transfer_command(0xc3);
-	transfer_data(0x10);
-	transfer_command(0xc4);
-	transfer_data(0x20);
-	transfer_command(0xc6);
-	transfer_data(0x0f);
-	transfer_command(0xd0);
-	transfer_data(0xa4);
-	transfer_data(0xa1);
-//--------------------------------ST7789V gamma setting---------------------------------------//
-	transfer_command(0xe0);
-	transfer_data(0xd0);
-	transfer_data(0x00);
-	transfer_data(0x02);
-	transfer_data(0x07);
-	transfer_data(0x0a);
-	transfer_data(0x28);
-	transfer_data(0x32);
-	transfer_data(0x44);
-	transfer_data(0x42);
-	transfer_data(0x06);
-	transfer_data(0x0e);
-	transfer_data(0x12);
-	transfer_data(0x14);
-	transfer_data(0x17);
-	
-	transfer_command(0xe1);
-	transfer_data(0xd0);
-	transfer_data(0x00);
-	transfer_data(0x02);
-	transfer_data(0x07);
-	transfer_data(0x0a);
-	transfer_data(0x28);
-	transfer_data(0x31);
-	transfer_data(0x54);
-	transfer_data(0x47);
-	transfer_data(0x0e);
-	transfer_data(0x1c);
-	transfer_data(0x17);
-	transfer_data(0x1b);
-	transfer_data(0x1e);
-	
-	transfer_command(0x11);    //退出睡眠
-	delay(200);
-	transfer_command(0x29);    //打开显示
-}
-
-//定义窗口坐标：开始坐标（XS,YS)以及窗口大小（x_total,y_total)
-void lcd_address(int XS,int YS,int x_total,int y_total)
-{
-	int XE,YE; 
-	XE=XS+x_total-1;
-	YE=YS+y_total-1;	
-	transfer_command(0x2a);		// 设置X开始及结束的地址
-	transfer_data_16(XS);	// X开始地址(16位）
-	transfer_data_16(XE);	// X结束地址(16位）
-			
-	transfer_command(0x2b);		// 设置Y开始及结束的地址
-	transfer_data_16(YS);	// Y开始地址(16位）
-	transfer_data_16(YE);	// Y结束地址(16位）
-
-	transfer_command(0x2c);	    // 写数据开始
-}
-
-void mono_transfer_data_16(int mono_data,int font_color,int back_color)
-{
-	int i;
-	for(i=0;i<8;i++)
-	{
-	 	if(mono_data&0x80)
-		{
-			transfer_data_16(font_color);	//当数据是1时，显示字体颜色
-		}
-		else
-		{
-			transfer_data_16(back_color);	//当数据是0时，显示底色
-		}
-		mono_data<<=1;
-	}
-}
-
-
-//全屏显示一种颜色
-void display_color(int color_data)
-{  
-	int i,j;
-	lcd_address(0,0,240,320);
-	for(i=0;i<240;i++)
-	{
-		for(j=0;j<320;j++)
-		{
-			transfer_data_16(color_data);		  
-		}
-	}
-}
-
-void display_black(void)
-{  
-	int i,j,k;
-	transfer_command(0x2c); 	    // 写数据开始
-	for(i=0;i<240;i++)
-	{
-		transfer_data_16(0xffff);
-	}
-	for(i=0;i<318;i++)
-	{
-		for(k=0;k<1;k++)
-		{
-			transfer_data_16(0xffff);
-		}
-		for(j=0;j<238;j++)
-		{
-			transfer_data_16(0x0000);
-		}
-		for(k=0;k<1;k++)
-		{ 
-			transfer_data_16(0xffff);
-		}
-	}
-	for(i=0;i<320;i++)
-	{
-		transfer_data_16(0xffff);
-	}
-}
-
-//显示8x16点阵的字符串
-void disp_string_8x16(int x,int y,char *text,int font_color,int back_color)
-{
-	int i=0,j,k;
-	while(text[i]>0x00)
-	{	
-		if((text[i]>=0x20)&&(text[i]<=0x7e))
-		{
-			j=text[i]-0x20;
-			lcd_address(x,y,8,16);
-			for(k=0;k<16;k++)
-			{
-				mono_transfer_data_16(ascii_table_8x16[j*16+k],font_color,back_color);	  //?a??"ascii_table_8x16[]"?a??êy×é?ú"ASCII_TABLE_5X8_8X16_horizontal.h"à?
-			}
-			x+=8;
-			i++;
-		}
-		else
-		i++;
-	}
-}
-
-void display_string_16x16(int x,int y,uchar *text,int font_color,int back_color)
-{
-	uchar i,j,k;
-	uint address; 
-	j = 0;
-	while(text[j] != '\0')                                //'\0' 字符串结束标志
-	{
-		i = 0;
-		address = 1;
-		while(Chinese_horizontal_text_16x16[i] > 0x7e)	  // >0x7f即说明不是ASCII码字符
-		{
-			if(Chinese_horizontal_text_16x16[i] == text[j])
-			{
-				if(Chinese_horizontal_text_16x16[i + 1] == text[j + 1])
-				{
-					address = i * 16;
-					break;
-				}
-			}
-			i += 2;            
-		} 
-		if(y > 320)
-		{
-			y=0;	
-			x+=16;
-		}	
-
-		if(address != 1)// 显示汉字                   
-		{
-			lcd_address(x,y,16,16); 
-			for(i=0;i<2;i++)
-			{				
-				for(k = 0; k <16; k++)               
-				{								
-				mono_transfer_data_16(Chinese_horizontal_code_16x16[address],font_color,back_color);
-				address++;
-				}
-			}
-			j+=2;        
-		}
-		else              //显示空白字符            
-		{
-			lcd_address(x,y,16,16);
-			for(i = 0; i <2; i++)
-			{			
-			for(k = 0; k < 16; k++)               
-			{
-			mono_transfer_data_16(0x00,font_color,back_color);   
-			}
-			}
-			j+=2;
-		}       
-		x=x+16;
-	}
-}
-
-
-//显示32x32点阵的单色的图像
-void disp_32x32(int x,int y,char *dp,int font_color,int back_color)
-{
-	int i,j;
-	lcd_address(x,y,32,32); 
-	for(i=0;i<32;i++)
-	{
-		for(j=0;j<4;j++)
-		{
-			mono_transfer_data_16(*dp,font_color,back_color);
-			dp++;
-		}
-	}
-}
-
-//显示一幅彩图
-void display_image(int x,int y,uchar *dp)
-{
-	uchar i,j,k=0;
-	lcd_address(x,y,120,160);
-	for(i=0;i<120;i++)
-	{
-		for(j=0;j<160;j++)
-		{
-			transfer_data(*dp);			//传一个像素的图片数据的高位 
-			dp++;
-			transfer_data(*dp);			//传一个像素的图片数据的低位
-			dp++;
-		}
-	}
-}
-
-void main(void)
-{ 
-  P1M1=0x00;
-	P1M0=0x00;   //P1配置为准双向
-	P2M1=0x00;
-	P2M0=0x00;   //P2配置为准双向
-	P3M1=0x00;
-	P3M0=0x00;   //P3配置为准双向	  	
-	IM1=1; //IM1=0、IM2=0并行接口；IM1=1、IM2=1串行接口
-	IM2=1;
-	lcd_initial(); 
-	while(1)
-	{
-		display_color(blue);
-		disp_32x32(40+32*0,8,jing_32x32,white,blue);
-		disp_32x32(40+32*1,8,lian_32x32,white,blue);
-		disp_32x32(40+32*2,8,xun_32x32,white,blue);
-		disp_32x32(40+32*3,8,dian_32x32,white,blue);
-		disp_32x32(40+32*4,8,zi_32x32,white,blue);
-		
-		display_string_16x16(24,56,"深圳市晶联讯电子有限公司",white,blue);	
-		display_string_16x16(48,88,"型号",white,blue);
-		disp_string_8x16(80,88,":JLX240-00303-BN",white,blue);
-		display_string_16x16(48,120,"视窗",white,blue);
-		disp_string_8x16(80,120,":36.7x48.9mm",white,blue);
-		display_string_16x16(48,152,"驱动",white,blue);
-		disp_string_8x16(80,152,"IC:ST7789V",white,blue);
-		
-		display_string_16x16(0,184,"经营宗旨：制造高品质产品及服务",white,blue);
-		display_string_16x16(0,216,"质量方针：客户至上，质量保证",white,blue);
-		display_string_16x16(79,236,"持续改进，服务到位",white,blue);
-		display_string_16x16(0,270,"经营目标：做最好的液晶模块厂家",white,blue);
-		display_string_16x16(79,292,"做客户信得过的企业",white,blue);
-		Switch();
-		
-		display_image(0,0,pic1);
-		display_image(120,0,pic1);
-		display_image(0,160,pic1);
-		display_image(120,160,pic1);
-		Switch();
-		
-		display_color(0xf800);
-		Switch();
-		display_color(0x07e0);
-		Switch();
-		display_color(0x001f);
-		Switch();
-		display_black();
-		Switch();
-		display_color(0xffff);
-		Switch();
-	}
-}

App/MODBUS/Inc/modbus_485.h

@@ -0,0 +1,47 @@
+#ifndef _MODBUS_485_H_
+#define _MODBUS_485_H_
+
+#include "apps_gather.h"
+
+typedef enum
+{
+    TRANSPARENT_WAIT = 0,
+    TRANSPARENT_RECIEVE_START,
+    TRANSPARENT_RECIEVE_FINISHED,
+    TRANSPARENT_TRANSMIT_END
+}TRANS_PROCESS;
+
+extern uint32_t tick_start;
+extern uint32_t tick_middle;
+extern uint32_t tick_end;
+//extern uint32_t trans_log_rx;
+extern uint32_t trans_log_tx;
+extern uint8_t sig2slave_step;
+extern TRANS_PROCESS st_flag;
+
+void parse_scom_485(st_scom *scom);
+
+//透传，DMA发送，与发送回调组合使用
+void transparent_tim(void);
+
+void trans_hart2pc(void);
+
+void trans_pc2hart(void);
+
+void trans_ble2pc(void);
+
+void trans_pc2ble(void);
+
+void trans_modbus_pc2sig(void);
+
+//SIG作为主设备，向外发送数据之后，等待从机应答，持续一段时间（超时时间）无数据后停止接收，并对收到的数据进行解析
+void trans_modbus_sig2slave(void);
+
+//DMA接收只有半满中断、空闲中断和完成（溢出）中断，因此用以下函数尝试进行捕获
+//该函数放置于TIM2的中断内，1ms为周期，尝试捕获前3帧
+void trans_start_capture(void);
+
+uint8_t trans_enable_check(st_scom *scom);
+
+
+#endif

App/MODBUS/Inc/modbus_register_process.h

@@ -0,0 +1,108 @@
+#ifndef _MODBUS_REGISTER_PROCESS_H_
+#define _MODBUS_REGISTER_PROCESS_H_
+
+#include "apps_gather.h"
+
+//自定义线圈寄存器地址
+#define COIL_ADDR_ON_OFF 0x00
+#define COIL_ADDR_LIGHT 0x01
+#define COIL_ADDR_CONFIG_SAVE 0x02
+#define COIL_ADDR_CONFIG_RESET 0x03
+#define COIL_ADDR_SCREEN_SWITCH 0x04
+#define COIL_ADDR_HOLD_SV_CTRL 0x05
+#define COIL_ADDR_HOLD_SV_ENSURE 0x06
+
+//自定义离散状态寄存器地址
+
+//自定义保持寄存器地址
+#define HOLD_ADDR_SET_WORK_MODE 0x00
+#define HOLD_ADDR_MUX_SV_L 0x01
+#define HOLD_ADDR_MUX_SV_H 0x02
+#define HOLD_ADDR_PHY_UNIT 0x03
+#define HOLD_ADDR_PHY_UP 0x04
+#define HOLD_ADDR_PHY_LOW 0x05
+#define HOLD_ADDR_SAMPLE_INTERVAL 0x06
+#define HOLD_ADDR_PLOT_COUNTS 0x07
+#define HOLD_ADDR_INPUT_COLOR 0x08
+#define HOLD_ADDR_OUTPUT_COLOR 0x09
+#define HOLD_ADDR_LANGUAGE 0x0A
+
+//自定义输入寄存器地址
+#define INPUT_ADDR_BATTERY 0x00
+#define INPUT_ADDR_RUNTIME_SECOND 0x01
+#define INPUT_ADDR_RUNTIME_HOUR 0x02
+#define INPUT_ADDR_MUX_PV_L 0x03
+#define INPUT_ADDR_MUX_PV_H 0x04
+
+//处理modbus寄存器值的更新与写入
+void modbus_registers_update(void);
+
+//线圈寄存器，读写
+void modbus_reg_update_coil(void);
+
+//设置线圈寄存器，输入参数：地址、标志位
+void set_coil_val(uint8_t addr, uint8_t bit_val);
+
+//获取线圈值，应对上位机修改线圈的情况
+uint8_t get_coil_val(uint8_t addr);
+
+//线圈寄存器，处理主界面的ON&OFF事件
+void coil_deal_ON2OFF(void);
+
+//线圈寄存器，处理照明事件
+void coil_deal_light(void);
+
+//线圈寄存器，处理配置保存事件
+void coil_deal_save(void);
+
+//线圈寄存器，处理配置复位事件
+void coil_deal_reset(void);
+
+//线圈寄存器，处理主界面<->设置界面的屏幕切换事件
+void coil_deal_screen_switch(void);
+
+//离散输入寄存器，上位机只读
+void modbus_reg_update_dis(void);
+
+//保持寄存器，读写
+void modbus_reg_update_hold(void);
+
+//保持寄存器，处理工作模式切换的事件
+void hold_deal_set_work_mode(void);
+
+//保持寄存器，处理设定值更改的事件
+void hold_deal_muxsv(void);
+
+//保持寄存器，处理量程修改事件，先选择需要修改的物理量
+void hold_deal_range_type(void);
+
+//保持寄存器，处理量程修改事件，修改当前选择的物理量的量程上限
+void hold_deal_range_max(void);
+
+//保持寄存器，处理量程修改事件，修改当前选择的物理量的量程下限
+void hold_deal_range_min(void);
+
+//保持寄存器，处理采样间隔修改事件
+void hold_deal_sample_interval(void);
+
+//保持寄存器，处理描点数量修改事件
+void hold_deal_plot_counts(void);
+
+//保持寄存器，处理输入曲线&图例颜色修改事件
+void hold_deal_color_input(void);
+
+//保持寄存器，处理输出曲线&图例颜色修改事件
+void hold_deal_color_output(void);
+
+//保持寄存器，处理语言选择事件
+void hold_deal_language_select(void);
+
+//输入寄存器，上位机只读
+void modbus_reg_update_input(void);
+
+
+
+
+#endif
+
+

App/MODBUS/Inc/modbus_rtu.h

@@ -0,0 +1,93 @@
+#ifndef _MODBUS_RTU_H_
+#define _MODBUS_RTU_H_
+
+#include "apps_gather.h"
+
+/*--------------------------------- 宏定义 -----------------------------------*/
+//功能码
+#define ReadCoilState       	0x01         //读取线圈状态
+#define ReadDisInputState		0x02         //读取输入状态
+#define ReadHoldReg        		0x03         //读取保持寄存器
+#define ReadInputReg       		0x04         //读取输入寄存器
+#define WriteSingleCoil    		0x05         //写单个线圈寄存器
+#define WriteSingleReg      	0x06         //写单个保持寄存器
+#define WriteMultiCoil      	0x0F         //写多个线圈寄存器
+#define WriteMultiReg       	0x10         //写多个保持寄存器
+
+#define COIL_ADD_MIN       		0x00
+#define COIL_ADD_MAX       		0x0F
+#define MAX_COIL_NUM       		((COIL_ADD_MAX) - (COIL_ADD_MIN) + 1)
+
+#define DIS_ADD_MIN       		0x00
+#define DIS_ADD_MAX       		0x0F
+#define MAX_DIS_NUM       		((DIS_ADD_MAX) - (DIS_ADD_MIN) + 1)
+
+#define INPUT_REG_ADD_MIN       0x00
+#define INPUT_REG_ADD_MAX       0x0F
+#define MAX_INPUT_REG_NUM       ((INPUT_REG_ADD_MAX) - (INPUT_REG_ADD_MIN) + 1)
+
+#define HOLD_REG_ADD_MIN        0x00
+#define HOLD_REG_ADD_MAX        0x0F
+#define MAX_HOLD_REG_NUM        ((HOLD_REG_ADD_MAX) - (HOLD_REG_ADD_MIN) + 1)
+
+#define BROADCAST_ADDRESS   	0x00
+#define LOCAL_ADDRESS       	0x01
+
+#define MAKEWORD(a,b)      		((uint16_t)(((uint8_t)(a)) | ((uint16_t)((uint8_t)(b))) << 8))
+
+ #define MAX_SIZE				255
+
+typedef enum
+{
+    MB_EX_NONE = 0x00,
+    MB_EX_ILLEGAL_FUNCTION = 0x01,
+    MB_EX_ILLEGAL_DATA_ADDRESS = 0x02,
+    MB_EX_ILLEGAL_DATA_VALUE = 0x03,
+    MB_EX_SLAVE_DEVICE_FAILURE = 0x04,
+    MB_EX_ACKNOWLEDGE = 0x05,
+    MB_EX_SLAVE_BUSY = 0x06,
+    MB_EX_MEMORY_PARITY_ERROR = 0x08,
+    MB_EX_GATEWAY_PATH_FAILED = 0x0A,
+    MB_EX_GATEWAY_TGT_FAILED = 0x0B
+} eMBException;
+
+typedef union var_reg
+{
+   uint16_t    SamData [MAX_INPUT_REG_NUM];         // 采样数据
+   uint16_t    InputReg[MAX_INPUT_REG_NUM];         // Reg 与 SamData
+}Var_Reg;
+
+
+extern uint8_t  CoilState[(MAX_COIL_NUM + 7) / 8];
+extern uint8_t  DisState [(MAX_DIS_NUM + 7) / 8];
+extern uint16_t InputReg[MAX_INPUT_REG_NUM];
+extern uint16_t HoldReg[MAX_HOLD_REG_NUM];
+extern Var_Reg  SamVarReg;
+extern eMBException ex_message;
+
+//MODBUS_RTU
+void modbus_analysis_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void modbus_process_rtu(void);
+void readcoilstate_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void readdisinputstate_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void readholdreg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void readinputreg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void writesinglereg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void writemultireg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void writesinglecoil_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void writemulticoil_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen);
+void modbus_errfunction_rtu(uint8_t uCmdCode, uint8_t uErrorCode);
+
+//MODBUD
+uint16_t ModbusCRC16(uint8_t *ptr, uint16_t len);
+void GetOneCoilVal(uint16_t wCoilAddr, uint8_t *pCoilVal);
+void GetOneDisInputVal(uint16_t wDisInputAddr, uint8_t *pDisInputVal);
+uint16_t GetHoldRegData(uint16_t RegAdd);
+uint16_t GetInputRegData(uint16_t RegAdd);
+void WriteHoldRegData(uint16_t wRegAddr, uint16_t RegData);
+void WriteOneCoilData(uint16_t wRegAddr, uint16_t RegData);
+
+
+#endif
+
+

App/MODBUS/Inc/modbus_rtu_master.h

@@ -0,0 +1,76 @@
+#ifndef _MODBUS_RTU_MASTER_H_
+#define _MODBUS_RTU_MASTER_H_
+
+#include "apps_gather.h"
+#include "modbus_rtu.h"
+
+#define TX_BUFF_MAX 32
+#define TX_DATA_MAX 16
+#define RX_BUFF_MAX 128
+
+#define TX_NONE 0x00           //没有需要发送的数据
+#define TX_WAITING 0x01        //数据准备完成，等待发送
+#define TX_OK 0x02             //发送完成
+
+#define RX_NONE 0x00           //没有接收到数据
+#define RX_WAITING 0x01        //等待接收
+#define RX_OK 0x02             //接收完成
+
+typedef enum
+{
+    RX_ERROR_NONE = 0,      //数据接收未出现错误
+    RX_ERROR_TIMEOUT,       //接收数据超时
+    RX_ERROR_OVERFLOW,      //接收到的数据超出缓存区
+    RX_ERROR_WRONG_ID,      //接收到的设备ID与目标ID不符
+    RX_ERROR_WRONG_LENGTH,  //数据长度不符
+    RX_ERROR_INVALID_CMD,   //命令字无效，不存在
+    RX_EEROR_WRONG_CMD,     //应答的命令字与发送的不符
+    RX_ERROR_WRONG_DATA,    //应答的数据与写入的不符
+    RX_ERROR_WRONG_NUM      //应答的寄存器数量与发送的不符
+}ERROR_NESSAGE_RX;
+
+typedef enum
+{
+    TX_ERROR_NONE = 0,      //数据发送未出现错误
+    TX_ERROR_WRONG_CMD,     //命令字错误
+    TX_ERROR_COIL_NUM,      //写多个线圈时，线圈数量或字节数错误
+    TX_ERROR_HOLDREG_NUM    //写保持寄存器时，寄存器数量或字节数错误
+}ERROR_NESSAGE_TX;
+
+typedef struct
+{
+    uint8_t target_id;                      //目标ID，从设备识别号、地址
+    uint8_t command_code;                   //命令字
+    uint16_t start_address;                 //起始地址
+    uint16_t register_num;                  //线圈、寄存器数量
+    uint16_t crc16;                         //MODBUS_CRC16校验码
+    uint8_t byte_num;                       //需要写入的线圈、保持寄存器字节数
+    uint8_t data_tx_value[TX_DATA_MAX];     //需要写入的数值,8位
+    uint8_t data_tx[TX_BUFF_MAX];           //存放完整的发送数据报
+    uint8_t data_rx[RX_BUFF_MAX];           //存放完整的接收数据报
+    uint8_t data_tx_len;                    //发送的数据报长度
+    uint8_t data_rx_len;                    //接收到的数据报长度
+    ERROR_NESSAGE_RX rx_error_message;      //接收过程中的错误信息
+    ERROR_NESSAGE_TX tx_error_message;      //发送过程中的错误信息
+    uint16_t timeout;                       //超时、等待时间
+    uint8_t rx_flag;                        //接收标志位
+    uint8_t tx_flag;                        //发送标志位
+
+    char result_display[200];                //在显示屏上显示读取到的结果
+}MODBUS_MASTER;
+
+extern MODBUS_MASTER mod_master;
+
+void modbus_rtu_master_init(void);
+
+void modbus_rtu_master_load(void);
+
+void modbus_rtu_master_send(void);
+
+void modbus_rtu_master_analysis(void);
+
+void modbus_rtu_master_data_process(void);
+
+#endif
+
+

App/MODBUS/Src/modbus_485.c

@@ -0,0 +1,360 @@
+#include "modbus_485.h"
+
+uint32_t tick_start = 0;
+uint32_t tick_middle = 0;
+uint32_t tick_end = 0;
+//uint32_t trans_log_rx = 0;
+uint32_t trans_log_tx = 0;
+TRANS_PROCESS st_flag = TRANSPARENT_WAIT;
+
+
+void parse_scom_485(st_scom *scom)
+{
+    if ((scom == &scom2_rs485) && (scom->rx_flag == TRUE))
+    {
+        scom->rx_flag = FALSE;
+        if ((scom->rx_buff[0] == 0xff) && (scom->rx_buff[1] == 0xff) && (scom->rx_buff[scom->rx_len - 1] == 0xaa))
+        {
+            vTaskDelay(10);
+            HAL_UART_Transmit(&huart2, scom->rx_buff, scom->rx_len, 0xFFFF);
+        }
+        scom->rx_len = 0;
+    }
+}
+
+void transparent_tim(void)
+{
+    switch (sig_trans)
+    {
+        case TRANS_NONE:
+        {}
+        break;
+
+        case TRANS_HART_TO_PC:
+        {
+            trans_hart2pc();
+        }
+        break;
+
+        case TRANS_PC_TO_HART:
+        {
+            trans_pc2hart();
+        }
+        break;
+
+        case TRANS_BLE_TO_PC:
+        {
+            trans_ble2pc();
+        }
+        break;
+
+        case TRANS_PC_TO_BLE:
+        {
+            trans_pc2ble();
+        }
+        break;
+
+        case TRANS_MODBUS_PC_TO_SIG:
+        {
+            trans_modbus_pc2sig();
+        }
+        break;
+
+        case TRANS_MODBUS_SIG_TO_SLAVE:
+        {
+            trans_modbus_sig2slave();
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+void trans_hart2pc(void)
+{
+    //来自HART设备的数据是否接收完成
+    if (scom1_hart.rx_flag == TRUE)
+    {
+        scom1_hart.rx_flag = FALSE;
+        
+        //接收到的数据是否符合HART数据报，符合则写入485的tx，准备发送至上位机
+        // if ((scom1_hart.rx_buff[0] == 0xff) && (scom1_hart.rx_buff[1] == 0xff) && (scom1_hart.rx_buff[scom1_hart.rx_len - 1] == 0xAA))
+        // {
+        if ((scom1_hart.rx_buff[0] == 0xff) && (scom1_hart.rx_buff[1] == 0xff))
+        {
+            memcpy(scom2_rs485.tx_buff, scom1_hart.rx_buff, scom1_hart.rx_len);
+            scom2_rs485.tx_len = scom1_hart.rx_len;
+            scom2_rs485.tx_flag = TRUE;
+        }
+
+        if(scom2_rs485.tx_flag == TRUE) 
+        {
+            scom2_rs485.tx_flag = FALSE;
+
+            //将数据发送至上位机
+            HAL_UART_Transmit_DMA(&huart2, scom2_rs485.tx_buff, scom2_rs485.tx_len);
+        }
+
+        //清空缓存区，等待新的数据
+        memset(scom1_hart.rx_buff, 0, scom1_hart.rx_len);
+        scom1_hart.rx_len = 0;
+    }
+}
+
+void trans_pc2hart(void)
+{
+    if (scom2_rs485.rx_flag == TRUE)
+    {
+        scom2_rs485.rx_flag = FALSE;
+
+        // if ((scom2_rs485.rx_buff[0] == 0xff) && (scom2_rs485.rx_buff[1] == 0xff) && (scom2_rs485.rx_buff[scom2_rs485.rx_len - 1] == 0xaa))
+        // {
+        if ( (scom2_rs485.rx_buff[0] == 0xff) && (scom2_rs485.rx_buff[1] == 0xff) )
+        {
+            //接收到的数据是否符合HART数据报，符合则写入HART的tx，准备发送至HART设备
+            memcpy(scom1_hart.tx_buff, scom2_rs485.rx_buff, scom2_rs485.rx_len);
+            scom1_hart.tx_len = scom2_rs485.rx_len;
+            scom1_hart.tx_flag = TRUE;
+        }
+
+        //来自上位机的数据是否准备完毕
+        if (scom1_hart.tx_flag == TRUE)
+        {
+            scom1_hart.tx_flag = FALSE;
+            HART_RTS(RTS_ON);
+
+            systick_delay_us(10000);
+
+            //将tx中的数据发送至HART设备
+            HAL_UART_Transmit_DMA(&huart1, scom1_hart.tx_buff, scom1_hart.tx_len);
+        }
+
+        //清空缓存区，等待新的数据
+        memset(scom2_rs485.rx_buff, 0, scom2_rs485.rx_len);
+        scom2_rs485.rx_len = 0;
+    }
+}
+
+void trans_ble2pc(void)
+{
+    if( ble_init() == 0 ) return;
+
+    if (scom6_ble.rx_flag == TRUE)
+    {
+        scom6_ble.rx_flag = FALSE;
+
+        //将接收到的数据存入485的tx，准备发送至上位机
+        memcpy(scom2_rs485.tx_buff, scom6_ble.rx_buff, scom6_ble.rx_len);
+        scom2_rs485.tx_len = scom6_ble.rx_len;
+        scom2_rs485.tx_flag = TRUE;
+
+        if(scom2_rs485.tx_flag == TRUE) 
+        {
+            scom2_rs485.tx_flag = FALSE;
+
+            //将数据发送至上位机
+            HAL_UART_Transmit_DMA(&huart2, scom2_rs485.tx_buff, scom2_rs485.tx_len);
+        }
+
+        //清空缓存区，等待新的数据
+        memset(scom6_ble.rx_buff, 0, scom6_ble.rx_len);
+        scom6_ble.rx_len = 0;
+    }
+}
+
+void trans_pc2ble(void)
+{
+    if (scom2_rs485.rx_flag == TRUE)
+    {
+        scom2_rs485.rx_flag = FALSE;
+
+        //将接收到的数据存入BLE的tx，准备发送至蓝牙设备
+        memcpy(scom6_ble.tx_buff, scom2_rs485.rx_buff, scom2_rs485.rx_len);
+        scom6_ble.tx_len = scom2_rs485.rx_len;
+        scom6_ble.tx_flag = TRUE;
+
+        //来自上位机的数据是否准备完毕
+        if (scom6_ble.tx_flag == TRUE)
+        {
+            scom6_ble.tx_flag = FALSE;
+
+            //将tx中的数据发送至蓝牙设备
+            HAL_UART_Transmit_DMA(&huart6, scom6_ble.tx_buff, scom6_ble.tx_len);
+        }
+
+        //清空缓存区，等待新的数据
+        memset(scom2_rs485.rx_buff, 0, scom2_rs485.rx_len);
+        scom2_rs485.rx_len = 0;
+    }
+}
+
+void trans_modbus_pc2sig(void)
+{
+    if (scom2_rs485.rx_flag == TRUE)
+    {
+        scom2_rs485.rx_flag = FALSE;
+
+        modbus_process_rtu();
+
+        if(scom2_rs485.tx_flag == TRUE) 
+        {
+            scom2_rs485.tx_flag = FALSE;
+
+            //将数据发送至上位机
+            HAL_UART_Transmit_DMA(&huart2, scom2_rs485.tx_buff, scom2_rs485.tx_len);
+        }
+
+        //清空缓存区，等待新的数据
+        memset(scom2_rs485.rx_buff, 0, scom2_rs485.rx_len);
+        scom2_rs485.rx_len = 0;
+    }
+}
+
+uint8_t sig2slave_step = 0;
+uint8_t sig2slave_data_length_total = 0;
+uint8_t buffer_size_temp = BUFFER_SIZE;
+void trans_modbus_sig2slave(void)
+{
+    if (scom2_rs485.rx_flag == TRUE)
+    {
+        scom2_rs485.rx_flag = FALSE;
+
+        switch (sig2slave_step)
+        {
+            case 0:
+            {
+                //进入此处说明已经接收完成一部分数据，重新开始超时计时，发送标志复位
+                mod_master.tx_flag = TX_NONE;
+                sig2slave_current_tick = 0;
+
+                //记录第一次接收到的数据长度
+                sig2slave_data_length_total = scom2_rs485.rx_len;
+ 
+                if(scom2_rs485.rx_len < BUFFER_SIZE)
+                {
+                    //修改剩余buff长度，继续接收
+                    buffer_size_temp -= scom2_rs485.rx_len;
+                    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff + sig2slave_data_length_total, buffer_size_temp);
+                }
+                sig2slave_step++;
+            }
+            break;
+
+            case 1:
+            {
+                //超时时间内再次收到数据，重新开始超时计时
+                sig2slave_current_tick = 0;
+
+                //本次收到的数据长度
+                uint8_t sig2slave_data_length_temp = buffer_size_temp - __HAL_DMA_GET_COUNTER(huart2.hdmarx);
+
+                //累计收到的数据长度
+                sig2slave_data_length_total += sig2slave_data_length_temp;
+                scom2_rs485.rx_len = sig2slave_data_length_total;
+
+                if(scom2_rs485.rx_len < BUFFER_SIZE)
+                {
+                    //继续接收
+                    buffer_size_temp -= sig2slave_data_length_temp;
+                    HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff + sig2slave_data_length_total, buffer_size_temp);
+                }
+            }
+            break;
+
+            case 2:
+            {
+                if(mod_master.rx_error_message != RX_ERROR_TIMEOUT)
+                {
+                    //进入此处说明收到了数据，并且超时计时期间内未收到新的数据
+                    modbus_rtu_master_analysis();
+                }
+                else
+                {
+                    strcpy(mod_master.result_display, "ERROR: TIMEOUT");
+                }
+                //在屏幕上显示 mod_master.result_display 字符串
+                lv_label_set_text(guider_ui.screen_modbus_trx_value_Rx, mod_master.result_display);
+
+                //数据传输状态复位
+                sig2slave_step = 0;
+                sig_trans = TRANS_NONE;
+
+                //数据处理完成后，情况接收数据
+                memset(scom2_rs485.rx_buff, 0, scom2_rs485.rx_len);
+                scom2_rs485.rx_len = 0;
+
+                //DMA连续接收参数复位
+                sig2slave_data_length_total = 0;
+                buffer_size_temp = BUFFER_SIZE;
+
+                HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+            }
+            break;
+        
+            default:
+            break;
+        }
+    }
+}
+
+uint8_t trans_enable_check(st_scom *scom)
+{
+    uint8_t result = 0;
+
+    if( scom == &scom1_hart )
+    {
+        if(tabdata.hart_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_HART_TO_PC;
+
+            return result;
+        }
+    }
+    else if( scom == &scom6_ble )
+    {
+        if(tabdata.bluetooth_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_BLE_TO_PC;
+
+            return result;
+        }
+    }
+    else if( scom == &scom2_rs485 )
+    {
+        if(tabdata.hart_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_PC_TO_HART;
+
+            return result;
+        }
+        else if(tabdata.bluetooth_enable)
+        {
+            result = 1;
+            sig_trans = TRANS_PC_TO_BLE;
+
+            return result;
+        }
+        else if(tabdata.modbus_enable)
+        {
+            if(tabdata.modbus_type == SIG_SLAVE)
+            {
+                sig_trans = TRANS_MODBUS_PC_TO_SIG;
+            }
+            else
+            {
+                sig_trans = TRANS_MODBUS_SIG_TO_SLAVE;
+            }
+            result = 1;
+
+            return result;
+        }
+    }
+
+    return result;
+}
+
+

App/MODBUS/Src/modbus_register_process.c

@@ -0,0 +1,776 @@
+#include "modbus_register_process.h"
+
+//处理modbus寄存器值的更新与写入
+void modbus_registers_update(void)
+{
+    //线圈寄存器
+    modbus_reg_update_coil();
+
+    //离散状态寄存器
+    modbus_reg_update_dis();
+
+    //保持寄存器
+    modbus_reg_update_hold();
+
+    //输入寄存器
+    modbus_reg_update_input();
+}
+
+//线圈寄存器，读写
+void modbus_reg_update_coil(void)
+{
+    //主界面的ON&OFF控制
+    coil_deal_ON2OFF();
+
+    //照明控制
+    coil_deal_light();
+    
+    //配置保存
+    coil_deal_save();
+
+    //配置复位
+    coil_deal_reset();
+
+    //屏幕切换：主界面<->设置界面
+    coil_deal_screen_switch();
+}
+
+void set_coil_val(uint8_t addr, uint8_t bit_val)
+{
+    if( (addr > COIL_ADD_MAX)||(bit_val > 1) ) return;
+    addr -= COIL_ADD_MIN;
+    if( addr > 200 ) return;
+
+    uint8_t pcoil = addr / 8;   //数组的第几个元素, 0-7
+    uint8_t pbit = addr % 8;    //元素的第几位, 0-7
+    uint8_t fac = 0;            //辅助计算的因子
+
+    switch (bit_val)
+    {
+        case 0:
+        {
+            fac = ~(1 << pbit);
+            CoilState[pcoil] &= fac; 
+        }
+        break;
+
+        case 1:
+        {
+            fac = 1 << pbit;
+            CoilState[pcoil] |= fac; 
+        }
+        break;
+    
+        default:
+        break;
+    }
+}
+
+uint8_t get_coil_val(uint8_t addr)
+{
+    if( addr > COIL_ADD_MAX ) return 99;
+    addr -= COIL_ADD_MIN;
+    if( addr > 200 ) return 99;
+
+    uint8_t result = 0;
+    uint8_t pcoil = addr / 8;   //数组的第几个元素, 0-7
+    uint8_t pbit = addr % 8;    //元素的第几位, 0-7
+
+    result = 0x01 & (CoilState[pcoil] >> pbit);
+
+    return result;
+}
+
+void coil_deal_ON2OFF(void)
+{
+    if( (get_coil_val(COIL_ADDR_ON_OFF) != menu_data.io_on2off)&&(get_coil_val(COIL_ADDR_ON_OFF) < 2) )
+    {
+        //进入此处说明线圈寄存器的值被上位机修改
+        if( menu_data.scr_now == SCREEN_MAIN )
+        {
+            //只有在主界面时，修改内容才生效
+            menu_data.io_on2off = get_coil_val(COIL_ADDR_ON_OFF);
+            io_on2off_status(); 
+        }
+        else
+        {
+            //拒绝修改内容
+            set_coil_val(COIL_ADDR_ON_OFF, menu_data.io_on2off); 
+        }
+    }
+}
+
+void coil_deal_light(void)
+{
+    if( (get_coil_val(COIL_ADDR_LIGHT) != tabdata.item3_page0_lightflag)&&(get_coil_val(COIL_ADDR_LIGHT) < 2) )
+    {
+        //进入此处说明线圈寄存器的值被上位机修改
+        tabdata.item3_page0_lightflag = get_coil_val(COIL_ADDR_LIGHT);
+        if(tabdata.item3_page0_lightflag) 
+        {
+            LIGHT_ON;
+        }
+        else
+        {
+            LIGHT_OFF;
+        }
+
+        //如果当前页面存在该内容，则更新文本
+        if( (menu_data.scr_now == SCREEN_SETTING)&&(tabdata.item_cursor == ITEM_3) ) set_item3_text(LIGHT_STATUS);
+    }
+}
+
+void coil_deal_save(void)
+{
+    if( (get_coil_val(COIL_ADDR_CONFIG_SAVE) == 1)&&(tabdata.item3_page0_saveflag == 0) )
+    {
+        if( (menu_data.scr_now == SCREEN_SETTING)&&(tabdata.item3_page0_resetflag != 1) )
+        {
+            //当前处于设置界面，并且未处于重置过程中，执行保存
+            tabdata.item3_page0_saveflag = 1;
+        }
+        else
+        {
+            //拒绝修改
+            set_coil_val(COIL_ADDR_CONFIG_SAVE, 0);
+        }        
+    }
+}
+
+void coil_deal_reset(void)
+{
+    if( (get_coil_val(COIL_ADDR_CONFIG_RESET) == 1)&&(tabdata.item3_page0_resetflag == 0) )
+    {
+        if( (menu_data.scr_now == SCREEN_SETTING)&&(tabdata.item3_page0_saveflag != 1) )
+        {
+            //当前处于设置界面，并且未处于保存过程中，执行复位
+            tabdata.item3_page0_resetflag = 1;
+        }
+        else
+        {
+            //拒绝修改
+            set_coil_val(COIL_ADDR_CONFIG_RESET, 0);
+        } 
+    }
+}
+
+void coil_deal_screen_switch(void)
+{
+    if( get_coil_val(COIL_ADDR_SCREEN_SWITCH) != ( (uint8_t)menu_data.scr_now - 1 ) )
+    {
+        switch (menu_data.scr_now)
+        {
+            case SCREEN_INIT:
+            {
+                //拒绝修改，开机动画视作主界面
+                set_coil_val(COIL_ADDR_SCREEN_SWITCH, 0);
+            }
+            break;
+
+            case SCREEN_MAIN:
+            {
+                //切换至设置界面;
+                scr_setting_recover();
+                lv_scr_load(guider_ui.screen_setting);
+                lv_obj_clear_flag(guider_ui.screen_setting, LV_OBJ_FLAG_HIDDEN);
+
+                //隐藏主界面对象
+                lv_obj_add_flag(guider_ui.screen_main, LV_OBJ_FLAG_HIDDEN);
+
+                menu_data.scr_now = SCREEN_SETTING;   
+                set_coil_val(COIL_ADDR_SCREEN_SWITCH, 1);
+            }
+            break;
+
+            case SCREEN_SETTING:
+            {
+                //切换至主界面;
+                if(!scr_main_set_flag)
+                {
+                    scr_main_set_flag = 1;
+                    setup_scr_screen_main(&guider_ui);
+                    delay_cnt(200);                   
+                }
+                scr_main_recover();
+                lv_scr_load(guider_ui.screen_main);
+                lv_obj_clear_flag(guider_ui.screen_main, LV_OBJ_FLAG_HIDDEN);
+
+                //隐藏设置界面对象
+                lv_obj_add_flag(guider_ui.screen_setting, LV_OBJ_FLAG_HIDDEN);
+
+                menu_data.scr_now = SCREEN_MAIN;
+                set_coil_val(COIL_ADDR_SCREEN_SWITCH, 0); 
+            }
+            break;
+        
+            default:
+            {
+                //拒绝修改，其他界面视作设置界面
+                set_coil_val(COIL_ADDR_SCREEN_SWITCH, 1);
+            }
+            break;
+        }
+    }
+}
+
+//离散输入寄存器，上位机只读
+void modbus_reg_update_dis(void)
+{}
+
+//保持寄存器，读写
+void modbus_reg_update_hold(void)
+{
+    //保持寄存器，处理工作模式的修改事件
+    hold_deal_set_work_mode();
+
+    //保持寄存器，处理mux输出设定值的修改事件
+    hold_deal_muxsv();
+
+    //保持寄存器，量程类型选择
+    hold_deal_range_type();
+
+    //保持寄存器，处理量程上限的修改事件
+    hold_deal_range_max();
+
+    //保持寄存器，处理量程下限的修改事件
+    hold_deal_range_min();
+
+    //保持寄存器，处理采样间隔修改事件
+    hold_deal_sample_interval();
+
+    //保持寄存器，处理描点数量的修改事件
+    hold_deal_plot_counts();
+
+    //保持寄存器，处理输入曲线&图例颜色修改事件
+    hold_deal_color_input();
+
+    //保持寄存器，处理输出曲线&图例颜色修改事件
+    hold_deal_color_output();
+
+    //保持寄存器，处理语言选择事件
+    hold_deal_language_select();
+}
+
+void hold_deal_set_work_mode(void)
+{
+    //计算当前工作模式的对应编码（参照Modbus寄存器配置表excel文件）
+    uint16_t work_mode_pv = (menu_data.io_mode == IO_INPUT)*( (uint16_t)menu_data.input_mode_type + 1 ) + \
+                            (menu_data.io_mode == IO_OUTPUT)*( (uint16_t)menu_data.output_mode_type + 15 );
+
+    //工作模式符合编码的情况下，发生改变才执行以下操作
+    if( (HoldReg[HOLD_ADDR_SET_WORK_MODE] != work_mode_pv)&&(0 < HoldReg[HOLD_ADDR_SET_WORK_MODE])&&(HoldReg[HOLD_ADDR_SET_WORK_MODE] <= 28) )
+    {
+        //只有在主界面才接受修改
+        if(menu_data.scr_now == SCREEN_MAIN)
+        {
+            SIG_FUNCTIONS iom;
+            SIG_FUNCTIONS_TYPE iomt;
+
+            //根据编码值倒推工作模式与工作模式的类型
+            iomt = (SIG_FUNCTIONS_TYPE)( HoldReg[HOLD_ADDR_SET_WORK_MODE] - 1 - 14 * (HoldReg[HOLD_ADDR_SET_WORK_MODE] > 14) );
+            switch (iomt)
+            {
+                case 0:
+                    iom = SIG_CURRENT;
+                break;
+
+                case 1:
+                {}
+                //break;
+
+                case 2:
+                    iom = SIG_VOLTAGE;
+                break;
+
+                case 3:
+                    iom = SIG_RESISTANT;
+                break;
+
+                case 4:
+                    iom = SIG_FREQUENCE;
+                break;
+
+                case 13:
+                    iom = SIG_RTD;
+                break;
+            
+                default:
+                    iom = SIG_TC;
+                break;
+            }
+
+            if(HoldReg[HOLD_ADDR_SET_WORK_MODE] > 14)
+            {
+                menu_data.io_mode = IO_OUTPUT;
+                menu_data.output_mode = iom;
+                menu_data.output_mode_type = iomt;
+            }
+            else
+            {
+                menu_data.io_mode = IO_INPUT;
+                menu_data.input_mode = iom;
+                menu_data.input_mode_type = iomt;
+            }
+            set_working_mode(iom, iomt);
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_SET_WORK_MODE] = work_mode_pv;
+        }
+    }
+}
+
+void hold_deal_muxsv(void)
+{
+    //上位机控制的情况下，设定值跟随保持寄存器的值变化
+    uint32_t hold_temp = (HoldReg[HOLD_ADDR_MUX_SV_H] << 16) + HoldReg[HOLD_ADDR_MUX_SV_L];
+    float32 real_hold = 0;
+    memcpy(&real_hold, &hold_temp, 4);
+
+    if( (real2mux(real_hold) != mux_signal.data_sv)&&get_coil_val(COIL_ADDR_HOLD_SV_CTRL)&&get_coil_val(COIL_ADDR_HOLD_SV_ENSURE) )
+    {
+        if( (menu_data.scr_now == SCREEN_MAIN)&&(pltdata.yreal_pri_low <= real_hold)&&(real_hold <= pltdata.yreal_pri_up) )
+        {
+            set_output(real_hold);
+        }
+        else
+        {
+            //拒绝修改
+            uint32_t mcpy_temp = 0;
+            float32 muxpv_temp = mux2real(mux_signal.data_sv);
+            memcpy(&mcpy_temp, &muxpv_temp, 4);
+            HoldReg[HOLD_ADDR_MUX_SV_H] = mcpy_temp >> 16;
+            HoldReg[HOLD_ADDR_MUX_SV_L] = mcpy_temp & 0x0000FFFF;
+        }
+
+        //设定一次后清零，等待下次设定
+        set_coil_val(COIL_ADDR_HOLD_SV_ENSURE, 0);
+    }
+}
+
+int16_t rg_max = 0, rg_min = 0;
+uint16_t range_max_prv = 0, range_min_prv = 0;  
+uint16_t phyunit_prv = 0;
+uint8_t *p8low = 0, *p8up = 0, *p8low_prv = 0, *p8up_prv = 0;
+int16_t *p16low = 0, *p16up = 0, *p16low_prv = 0, *p16up_prv = 0;
+void hold_deal_range_type(void)
+{
+    //发生变化时才执行以下操作
+    if( HoldReg[HOLD_ADDR_PHY_UNIT] == phyunit_prv ) return;
+    phyunit_prv = HoldReg[HOLD_ADDR_PHY_UNIT];
+    range_max_prv = 0;
+    range_min_prv = 0;
+
+    //选择指定物理量之后，更新上限和下限的寄存器值
+    switch (HoldReg[HOLD_ADDR_PHY_UNIT])
+    {
+        case 1:
+        {
+            HoldReg[HOLD_ADDR_PHY_LOW] = 0x00FF & tabdata.item0_page0_clow;
+            HoldReg[HOLD_ADDR_PHY_UP] = 0x00FF & tabdata.item0_page0_cup;
+            rg_max = CUR.up;
+            rg_min = CUR.low;
+            p8low = &tabdata.item0_page0_clow;
+            p8up = &tabdata.item0_page0_cup;
+        }
+        break;
+
+        case 2:
+        {
+            memcpy(HoldReg + HOLD_ADDR_PHY_LOW, &tabdata.item0_page0_vlow[0], 2);
+            memcpy(HoldReg + HOLD_ADDR_PHY_UP, &tabdata.item0_page0_vup[0], 2);
+            rg_max = VOL[0].up;
+            rg_min = VOL[0].low;
+            p16low = &tabdata.item0_page0_vlow[0];
+            p16up = &tabdata.item0_page0_vup[0];
+        }
+        break;
+
+        case 3:
+        {
+            memcpy(HoldReg + HOLD_ADDR_PHY_LOW, &tabdata.item0_page0_vlow[1], 2);
+            memcpy(HoldReg + HOLD_ADDR_PHY_UP, &tabdata.item0_page0_vup[1], 2);
+            rg_max = VOL[1].up;
+            rg_min = VOL[1].low;
+            p16low = &tabdata.item0_page0_vlow[1];
+            p16up = &tabdata.item0_page0_vup[1];
+        }
+        break;
+
+        case 4:
+        {
+            memcpy(HoldReg + HOLD_ADDR_PHY_LOW, &tabdata.item0_page1_rlow, 2);
+            memcpy(HoldReg + HOLD_ADDR_PHY_UP, &tabdata.item0_page0_rup, 2);
+            rg_max = RES.up;
+            rg_min = RES.low;
+            p16low = &tabdata.item0_page1_rlow;
+            p16up = &tabdata.item0_page0_rup;
+        }
+        break;
+
+        case 5:
+        {
+            HoldReg[HOLD_ADDR_PHY_LOW] = 0x00FF & tabdata.item0_page1_flow;
+            HoldReg[HOLD_ADDR_PHY_UP] = 0x00FF & tabdata.item0_page1_fup;
+            rg_max = FRE.up;
+            rg_min = FRE.low;
+            p8low = &tabdata.item0_page1_flow;
+            p8up = &tabdata.item0_page1_fup;
+        }
+        break;
+
+        case 6:
+        {}
+        //break;
+
+        case 7:
+        {}
+        //break;
+
+        case 8:
+        {}
+        //break;
+
+        case 9:
+        {}
+        //break;
+
+        case 10:
+        {}
+        //break;
+
+        case 11:
+        {}
+        //break;
+
+        case 12:
+        {}
+        //break;
+
+        case 13:
+        {
+            uint8_t p_temp = HoldReg[HOLD_ADDR_PHY_UNIT] - 6;
+
+            memcpy(HoldReg + HOLD_ADDR_PHY_LOW, &tabdata.item0_page1_TClow[p_temp], 2);
+            memcpy(HoldReg + HOLD_ADDR_PHY_UP, &tabdata.item0_page1_TCup[p_temp], 2);
+            rg_max = TC[p_temp].up;
+            rg_min = TC[p_temp].low;
+            p16low = &tabdata.item0_page1_TClow[p_temp];
+            p16up = &tabdata.item0_page1_TCup[p_temp];
+        }
+        break;
+
+        case 14:
+        {
+            memcpy(HoldReg + HOLD_ADDR_PHY_LOW, &tabdata.item0_page2_RTDlow, 2);
+            memcpy(HoldReg + HOLD_ADDR_PHY_UP, &tabdata.item0_page2_RTDup, 2);
+            rg_max = RTD.up;
+            rg_min = RTD.low;
+            p16low = &tabdata.item0_page2_RTDlow;
+            p16up = &tabdata.item0_page2_RTDup;
+        }
+        break;
+    
+        default:
+        {
+            HoldReg[HOLD_ADDR_PHY_UNIT] = 0;
+            HoldReg[HOLD_ADDR_PHY_LOW] = 0;
+            HoldReg[HOLD_ADDR_PHY_UP] = 0;
+            rg_max = 0;
+            rg_min = 0;
+            *p8low = 0;
+            *p8up = 0; 
+            *p16low = 0;
+            *p16up = 0; 
+        }
+        break;
+    }
+}
+
+void hold_deal_range_max(void)
+{
+    //发生改变才执行（只需判断是否变化，不用处理符号）
+    if(range_max_prv == HoldReg[HOLD_ADDR_PHY_UP]) 
+    {
+        //处理 当前选中的物理量在本地进行了修改 的情况
+        if(*p8up != *p8up_prv)
+        {
+            *p8up_prv = *p8up;
+            HoldReg[HOLD_ADDR_PHY_UP] = 0x00FF & (*p8up); 
+        }
+        else if(*p16up != *p16up_prv)
+        {
+            *p16up_prv = *p16up;
+            memcpy(HoldReg + HOLD_ADDR_PHY_UP, p16up, 2);
+        }
+        return;
+    }
+    range_max_prv = HoldReg[HOLD_ADDR_PHY_UP];
+
+    //数据类型不同，电流mA(0-25)和频率KHz(0-100)的数据类型时uint8，其他都是int16
+    //*p8指向了需要修改的uint8，*p16指向了需要修改的int16
+    if( (HoldReg[HOLD_ADDR_PHY_UNIT] == 1)|(HoldReg[HOLD_ADDR_PHY_UNIT] == 5) )
+    {
+        if( (!p8up)|(!p8low) ) return;
+
+        uint8_t hold_temp8 = 0x00FF & HoldReg[HOLD_ADDR_PHY_UP];
+        if( (*p8low <= hold_temp8)&&(hold_temp8 <= (uint8_t)rg_max) ) 
+        {
+            *p8up = hold_temp8;
+            *p8up_prv = *p8up;
+
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                SIG_FUNCTIONS_TYPE typ = (SIG_FUNCTIONS_TYPE)(menu_data.input_mode_type*(!menu_data.io_mode) + menu_data.output_mode_type*menu_data.io_mode);
+                if( typ == (HoldReg[HOLD_ADDR_PHY_UNIT] - 1) )
+                {
+                    up2down_update(*p8low, *p8up);
+                }
+            }
+            else if(menu_data.scr_now == SCREEN_SETTING)
+            {
+                setting_items_page(ITEM_0, 1);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_PHY_UP] = range_max_prv;
+        }
+    }
+    else
+    {
+        if( (!p16up)|(!p16low) ) return;
+
+        int16_t hold_temp16 = 0;
+
+        memcpy(&hold_temp16, HoldReg + HOLD_ADDR_PHY_UP, 2);
+        if( (*p16low <= hold_temp16)&&(hold_temp16 <= rg_max) ) 
+        {
+            *p16up = hold_temp16;
+            *p16up_prv = *p16up;
+
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                SIG_FUNCTIONS_TYPE typ = (SIG_FUNCTIONS_TYPE)(menu_data.input_mode_type*(!menu_data.io_mode) + menu_data.output_mode_type*menu_data.io_mode);
+                if( typ == (HoldReg[HOLD_ADDR_PHY_UNIT] - 1) )
+                {
+                    up2down_update(*p16low, *p16up);
+                }
+            }
+            else if(menu_data.scr_now == SCREEN_SETTING)
+            {
+                setting_items_page(ITEM_0, 1);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_PHY_UP] = range_max_prv;
+        }
+    }
+}
+
+void hold_deal_range_min(void)
+{
+    //发生改变才执行（只需判断是否变化，不用处理符号）
+    if(range_min_prv == HoldReg[HOLD_ADDR_PHY_LOW])
+    {
+        //处理 当前选中的物理量在本地进行了修改 的情况
+        if(*p8low != *p8low_prv)
+        {
+            *p8low_prv = *p8low;
+            HoldReg[HOLD_ADDR_PHY_LOW] = 0x00FF & (*p8low); 
+        }
+        else if(*p16low != *p16low_prv)
+        {
+            *p16low_prv = *p16low;
+            memcpy(HoldReg + HOLD_ADDR_PHY_LOW, p16low, 2);
+        }
+        return;
+    }
+    range_min_prv = HoldReg[HOLD_ADDR_PHY_LOW];
+
+    if( (HoldReg[HOLD_ADDR_PHY_UNIT] == 1)|(HoldReg[HOLD_ADDR_PHY_UNIT] == 5) )
+    {
+        if( (!p8up)|(!p8low) ) return;
+
+        uint8_t hold_temp8 = 0x00FF & HoldReg[HOLD_ADDR_PHY_LOW];
+        if( ((uint8_t)rg_min <= hold_temp8)&&(hold_temp8 <= *p8up) ) 
+        {
+            *p8low = hold_temp8;
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                SIG_FUNCTIONS_TYPE typ = (SIG_FUNCTIONS_TYPE)(menu_data.input_mode_type*(!menu_data.io_mode) + menu_data.output_mode_type*menu_data.io_mode);
+                if( typ == (HoldReg[HOLD_ADDR_PHY_UNIT] - 1) )
+                {
+                    up2down_update(*p8low, *p8up);
+                }
+            }
+            else if(menu_data.scr_now == SCREEN_SETTING)
+            {
+                setting_items_page(ITEM_0, 1);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_PHY_LOW] = range_min_prv;
+        }
+    }
+    else
+    {
+        if( (!p16up)|(!p16low) ) return;
+
+        int16_t hold_temp16 = 0;
+
+        memcpy(&hold_temp16, HoldReg + HOLD_ADDR_PHY_LOW, 2);
+        if( (rg_min <= hold_temp16)&&(hold_temp16 <= *p16up) ) 
+        {
+            *p16low = hold_temp16;
+
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                SIG_FUNCTIONS_TYPE typ = (SIG_FUNCTIONS_TYPE)(menu_data.input_mode_type*(!menu_data.io_mode) + menu_data.output_mode_type*menu_data.io_mode);
+                if( typ == (HoldReg[HOLD_ADDR_PHY_UNIT] - 1) )
+                {
+                    up2down_update(*p16low, *p16up);
+                }
+            }
+            else if(menu_data.scr_now == SCREEN_SETTING)
+            {
+                setting_items_page(ITEM_0, 1);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_PHY_LOW] = range_min_prv;
+        }
+    }
+}
+
+//保持寄存器，处理采样间隔修改事件
+void hold_deal_sample_interval(void)
+{
+    if( HoldReg[HOLD_ADDR_SAMPLE_INTERVAL] != tabdata.item1_page0_sample_interval )
+    {
+        if( (MENU_TASK_PERIOD <= HoldReg[HOLD_ADDR_SAMPLE_INTERVAL])&&(HoldReg[HOLD_ADDR_SAMPLE_INTERVAL] <= SAMPLE_INTERVAL_MAX) )
+        {
+            tabdata.item1_page0_sample_interval = HoldReg[HOLD_ADDR_SAMPLE_INTERVAL];
+
+            if( (menu_data.scr_now == SCREEN_SETTING)&&(tabdata.item_cursor == ITEM_1) ) set_item1_text(SAMPLE_INTERVAL);
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_SAMPLE_INTERVAL] = tabdata.item1_page0_sample_interval;
+        }
+    }
+}
+
+//保持寄存器，处理描点数量修改事件
+void hold_deal_plot_counts(void)
+{
+    if( HoldReg[HOLD_ADDR_PLOT_COUNTS] != (0x00FF & tabdata.item1_page0_plot_num) )
+    {
+        if( (PLOT_NUM_MIN <= HoldReg[HOLD_ADDR_PLOT_COUNTS])&&(HoldReg[HOLD_ADDR_PLOT_COUNTS] <= PLOT_NUM_MAX) )
+        {
+            tabdata.item1_page0_plot_num = 0x00FF & HoldReg[HOLD_ADDR_PLOT_COUNTS];
+
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                //更新显示模式，强制归零后自动恢复显示值（曲线只有在显示值变化时才刷新，于是在此处手动发生变化）
+                scr_main_chart_update();
+                pltdata.y_pri_value = 0;
+                pltdata.y_scd_value = 0;
+            }
+            else if(menu_data.scr_now == SCREEN_SETTING)
+            {
+                set_item1_text(PLOT_NUM);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_PLOT_COUNTS] = 0x00FF & tabdata.item1_page0_plot_num;
+        }
+    }
+}
+
+//保持寄存器，处理输入曲线&图例颜色修改事件
+void hold_deal_color_input(void)
+{
+    if( HoldReg[HOLD_ADDR_INPUT_COLOR] != (0x00FF & (uint8_t)tabdata.item1_page0_color_input) )
+    {
+        if( HoldReg[HOLD_ADDR_INPUT_COLOR] <= 5 )
+        {
+            tabdata.item1_page0_color_input = (COLORS)HoldReg[HOLD_ADDR_INPUT_COLOR];
+
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                scr_main_chart_update();
+            }
+            else if( (menu_data.scr_now == SCREEN_SETTING)&&(tabdata.item_cursor == ITEM_1) )
+            {
+                set_obj_color(guider_ui.screen_setting_label_21, tabdata.item1_page0_color_input);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_INPUT_COLOR] = 0x00FF & (uint8_t)tabdata.item1_page0_color_input;
+        }
+    }
+}
+
+//保持寄存器，处理输出曲线&图例颜色修改事件
+void hold_deal_color_output(void)
+{
+    if( HoldReg[HOLD_ADDR_OUTPUT_COLOR] != (0x00FF & (uint8_t)tabdata.item1_page0_color_output) )
+    {
+        if( HoldReg[HOLD_ADDR_OUTPUT_COLOR] <= 5 )
+        {
+            tabdata.item1_page0_color_output = (COLORS)HoldReg[HOLD_ADDR_OUTPUT_COLOR];
+
+            if(menu_data.scr_now == SCREEN_MAIN)
+            {
+                scr_main_chart_update();
+            }
+            else if( (menu_data.scr_now == SCREEN_SETTING)&&(tabdata.item_cursor == ITEM_1) )
+            {
+                set_obj_color(guider_ui.screen_setting_label_31, tabdata.item1_page0_color_output);
+            }
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_OUTPUT_COLOR] = 0x00FF & (uint8_t)tabdata.item1_page0_color_output;
+        }
+    }
+}
+
+//保持寄存器，处理语言选择事件
+void hold_deal_language_select(void)
+{
+    if( HoldReg[HOLD_ADDR_LANGUAGE] != (0x00FF & (uint8_t)tabdata.item3_page0_language) )
+    {
+        if( HoldReg[HOLD_ADDR_LANGUAGE] <= 1 )
+        {
+            tabdata.item3_page0_language = (LANGUAGES)HoldReg[HOLD_ADDR_LANGUAGE];
+
+            setting_laguage_switch(tabdata.item3_page0_language);
+        }
+        else
+        {
+            //拒绝修改
+            HoldReg[HOLD_ADDR_LANGUAGE] = 0x00FF & (uint8_t)tabdata.item3_page0_language;
+        }
+    }
+}
+
+//输入寄存器，上位机只读
+void modbus_reg_update_input(void)
+{}
+

App/MODBUS/Src/modbus_rtu.c

@@ -0,0 +1,764 @@
+#include "modbus_rtu.h"
+
+uint8_t  CoilState[(MAX_COIL_NUM + 7) / 8] = {0};		//线圈寄存器
+uint8_t  DisState[(MAX_DIS_NUM + 7) / 8] = {0};		    //离散量寄存器
+uint16_t InputReg[MAX_INPUT_REG_NUM] = {0};			    //输入寄存器
+uint16_t HoldReg[MAX_HOLD_REG_NUM] = {0};               //保持寄存器
+
+Var_Reg  SamVarReg;
+eMBException ex_message = MB_EX_NONE;                                           //从设备返回的异常信息
+
+/*******************************************************************************
+函数名称 ： Modbus_Analysis
+功    能 ： CRC校验
+参    数 ： ptr--校验数组指针  len--校验数据长度
+返 回 值 ： CRC校验码，双字节
+*******************************************************************************/
+void modbus_analysis_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint8_t  uSlaveAdd, uCmdCode;
+
+    if((upRxdbuf == NULL) || (wRxdLen < 2))  return;
+
+    uSlaveAdd    = upRxdbuf[0];
+    uCmdCode     = upRxdbuf[1];
+
+    // 从机地址为本机地址或者是广播帧
+    if((uSlaveAdd == LOCAL_ADDRESS) || (uSlaveAdd == BROADCAST_ADDRESS))
+    {
+      switch(uCmdCode)
+      {
+			case ReadCoilState:
+				readcoilstate_rtu(upRxdbuf + 2, wRxdLen - 2);             // 读线圈状态
+				break;
+
+			case ReadDisInputState:
+				readdisinputstate_rtu(upRxdbuf + 2, wRxdLen - 2);         // 读离散输入状态
+				break;
+			
+			case ReadHoldReg:
+				readholdreg_rtu(upRxdbuf + 2, wRxdLen - 2);               // 读取保持寄存器
+				break;
+			
+			case ReadInputReg:
+				readinputreg_rtu(upRxdbuf + 2, wRxdLen - 2);              // 读取输入寄存器
+				break;
+			
+			case WriteSingleReg:
+				writesinglereg_rtu(upRxdbuf + 2, wRxdLen - 2);            // 写单个寄存器
+				break;
+
+			case WriteMultiCoil:
+				writemulticoil_rtu(upRxdbuf + 2, wRxdLen - 2);            // 写多个线圈
+				break;
+			
+			case WriteMultiReg:
+				writemultireg_rtu(upRxdbuf + 2, wRxdLen - 2);             // 写多个寄存器
+				break;
+
+			case WriteSingleCoil:
+				writesinglecoil_rtu(upRxdbuf + 2, wRxdLen - 2);           // 写单个线圈
+				break;
+
+			default:
+				modbus_errfunction_rtu(upRxdbuf[1], 0x01);                    // 错误码处理
+				break;
+        }
+    }
+}
+
+void modbus_process_rtu(void)
+{
+    uint8_t  *pFrame;
+    uint16_t wFrameLen = 0;
+    uint16_t wFrameCRC, wCalCRC;
+
+    pFrame = scom2_rs485.rx_buff;    	// 接收数据起始地址
+    wFrameLen = scom2_rs485.rx_len;   	// 接收数据长度
+
+    if(wFrameLen < 2) return;    		// 数据长度不是有效值
+
+    // 获取接收数据帧中的校验和
+    wFrameCRC = MAKEWORD(pFrame[wFrameLen - 2], pFrame[wFrameLen - 1]);
+    // 计算接收到的数据的校验和
+    wCalCRC   = ModbusCRC16(pFrame, wFrameLen - 2);
+    if(wFrameCRC != wCalCRC) return;
+
+    modbus_analysis_rtu(scom2_rs485.rx_buff, scom2_rs485.rx_len);// 协议处理
+}
+
+/*******************************************************************************
+函数名称 ： ReadCoilStateFUNC
+功    能 ： 功能码:0x01,读取线圈
+参    数 ： 无
+返 回 值 ： 无
+*发送:[硬件地址][01][线圈起始地址高][线圈起始地址低][线圈数量高][线圈数量低][CRC低][CRC高]
+*返回:[硬件地址][01][字节长度][线圈值][线圈值][线圈值][CRC低][CRC高]
+*******************************************************************************/
+void readcoilstate_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+	uint16_t wCoilStartAddr,wCoilNum,wTotalCoilNum,CRC16Temp;
+    uint8_t  i,k,uCommIndexNum = 0,uByteCount,uCoilVal,uErrorCode,uExit = 0;
+	uint8_t  upTxdbuf[MAX_SIZE] = {0};
+
+    wCoilStartAddr  = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取线圈起始地址
+    wCoilNum        = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取线圈个数
+
+	if((wCoilNum >= 0x0001) || (wCoilNum <= MAX_COIL_NUM))
+	{
+		if(((wCoilStartAddr <= COIL_ADD_MAX)) &&
+			(wCoilNum + wCoilStartAddr <= COIL_ADD_MAX + 1))//(wCoilStartAddr >= COIL_ADD_MIN) && 
+		{
+			uByteCount = (wCoilNum + 7) / 8;    //返回数据字节个数
+	
+			upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = ReadCoilState;
+			upTxdbuf[uCommIndexNum ++] = uByteCount;
+			
+			wTotalCoilNum = 0;
+            for(k = 0; k < uByteCount; k++)
+			{
+				upTxdbuf[uCommIndexNum] = 0;
+				for(i = 0; i < 8; i++)
+				{
+					GetOneCoilVal(wCoilStartAddr + wTotalCoilNum,&uCoilVal);
+					upTxdbuf[uCommIndexNum] |= uCoilVal << i;
+ 
+					wTotalCoilNum ++;
+					if(wTotalCoilNum >= wCoilNum)
+					{
+						 uExit = 1;
+						 break;
+					}
+				}
+				
+				uCommIndexNum ++;
+				
+				if(uExit == 1)
+				{
+					break;
+				}
+			}
+
+            CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+			
+			return;
+		}
+		else
+		{
+			uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+		}
+	}
+	else 
+	{
+		 uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+	}
+
+    modbus_errfunction_rtu(ReadCoilState, uErrorCode);
+    return;
+}
+
+/*******************************************************************************
+函数名称 ： ReadDisInputStateFUNC
+功    能 ： 功能码:0x02,读取离散量
+参    数 ： 无
+返 回 值 ： 无
+*发送:[硬件地址][02][离散量起始地址高][离散量起始地址低][离散量数量高][离散量数量低][CRC低][CRC高]
+*返回:[硬件地址][02][字节长度][离散量值][离散量值][离散量值][CRC低][CRC高]
+*******************************************************************************/
+void readdisinputstate_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint16_t wDisStartAddr,wDisNum,wTotalDisNum,CRC16Temp;
+    uint8_t  i,k,uCommIndexNum = 0,uByteCount,uDisVal,uErrorCode,uExit = 0;
+	uint8_t  upTxdbuf[MAX_SIZE];
+
+    wDisStartAddr  = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取离散量起始地址
+    wDisNum        = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取离散量个数
+
+	if((wDisNum >= 0x0001) || (wDisNum <= MAX_DIS_NUM))
+	{
+		if(((wDisStartAddr <= DIS_ADD_MAX)) &&
+			(wDisNum + wDisStartAddr <= DIS_ADD_MAX + 1))//(wDisStartAddr >= DIS_ADD_MIN) && 
+		{
+			uByteCount = (wDisNum + 7) / 8;    //返回数据字节个数
+	
+			upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = ReadDisInputState;
+			upTxdbuf[uCommIndexNum ++] = uByteCount;
+			
+			wTotalDisNum = 0;
+            for(k = 0; k < uByteCount; k++)
+			{
+				upTxdbuf[uCommIndexNum] = 0;
+				for(i = 0; i < 8; i++)
+				{
+					GetOneDisInputVal(wDisStartAddr + wTotalDisNum,&uDisVal);
+					upTxdbuf[uCommIndexNum] |= uDisVal << i;
+ 
+					wTotalDisNum ++;
+					if(wTotalDisNum >= wDisNum)
+					{
+						 uExit = 1;
+						 break;
+					}
+				}
+				
+				uCommIndexNum ++;
+				
+				if(uExit == 1)
+				{
+					break;
+				}
+			}
+
+            CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+			
+			return;
+		}
+		else
+		{
+			uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+		}
+	}
+	else 
+	{
+		 uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+	}
+
+    modbus_errfunction_rtu(ReadDisInputState, uErrorCode);
+    return;	
+}
+
+/*******************************************************************************
+函数名称 ： ReadHoldRegFUNC
+功    能 ： 功能码:0x03,读取保持寄存器
+参    数 ： 无
+返 回 值 ： 无
+*发送:[硬件地址][03][起始地址高][起始地址低][总寄存器数高][总寄存器数低][CRC低][CRC高]
+*返回:[硬件地址][03][字节数][寄存器0高][寄存器0低][寄存器1高][寄存器1低][寄存器n高][寄存器n低][CRC低][CRC高]
+*******************************************************************************/
+void readholdreg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint16_t wRegStartAdd, wRegLen, i, wRegValue, CRC16Temp;
+    uint8_t  uErrorCode, uCommIndexNum = 0;
+    uint8_t  upTxdbuf[MAX_SIZE];
+
+    if(upRxdbuf == NULL)  return;
+
+    wRegStartAdd = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取寄存器起始地址
+    wRegLen      = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取读取寄存器长度
+
+    if((wRegLen >= 0x01) && (wRegLen <= MAX_HOLD_REG_NUM))
+    {
+        if(((wRegStartAdd <= HOLD_REG_ADD_MAX)) &&
+                (((wRegStartAdd + wRegLen) >= HOLD_REG_ADD_MIN) && ((wRegStartAdd + wRegLen) <= HOLD_REG_ADD_MAX + 1)))//(wRegStartAdd >= HOLD_REG_ADD_MIN) && 
+        {
+            upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = ReadHoldReg;
+            upTxdbuf[uCommIndexNum ++] = wRegLen * 2;
+
+            for(i = 0; i < wRegLen; i++)
+            {
+                //获取16位数据并返回
+                wRegValue = GetHoldRegData(wRegStartAdd + i);
+                upTxdbuf[uCommIndexNum ++] = (uint8_t)(wRegValue >> 8);
+                upTxdbuf[uCommIndexNum ++] = (uint8_t)(wRegValue & 0xFF);
+            }
+
+            CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF); // crc16低字节在前
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);   // crc16高字节在后
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+
+            return;
+        }
+        else
+        {
+            uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+        }
+    }
+    else
+    {
+        uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+    }
+    modbus_errfunction_rtu(ReadHoldReg, uErrorCode);
+    return;
+}
+
+/*******************************************************************************
+函数名称 ： ReadInputRegFUNC
+功    能 ： 功能码:0x04,读取输入寄存器
+参    数 ： 无
+返 回 值 ： 无
+*发送:[硬件地址][04][起始地址高][起始地址低][总寄存器数高][总寄存器数低][    CRC低   ][     CRC高  ]
+*返回:[硬件地址][04][  字节数  ][寄存器0高 ][  寄存器0低 ][  寄存器1高 ][  寄存器1低 ][  寄存器n高 ][  寄存器n低 ][  CRC低 ][  CRC高 ]
+*******************************************************************************/
+void readinputreg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint16_t wRegStartAdd, wRegLen, i, wRegValue, CRC16Temp;
+    uint8_t  uErrorCode, uCommIndexNum = 0;
+	uint8_t  upTxdbuf[MAX_SIZE];
+   
+    if(upRxdbuf == NULL)  return;
+
+    wRegStartAdd = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取寄存器起始地址
+    wRegLen      = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取读取寄存器长度
+
+    if((wRegLen >= 0x01) && (wRegLen <= MAX_INPUT_REG_NUM))
+    {
+        if(((wRegStartAdd <= INPUT_REG_ADD_MAX)) &&
+           ((wRegStartAdd + wRegLen) <= INPUT_REG_ADD_MAX + 1))//(wRegStartAdd >= INPUT_REG_ADD_MIN) && 
+        {
+            upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = ReadInputReg;
+            upTxdbuf[uCommIndexNum ++] = wRegLen * 2;
+
+            for(i = 0; i < wRegLen; i++)
+            {
+                //获取16位数据并返回
+                wRegValue = GetInputRegData(wRegStartAdd + i);
+                upTxdbuf[uCommIndexNum ++] = (uint8_t)(wRegValue >> 8);
+                upTxdbuf[uCommIndexNum ++] = (uint8_t)(wRegValue & 0xFF);
+            }
+
+            CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF); // crc16低字节在前
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);   // crc16高字节在后
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+
+            return;
+        }
+        else
+        {
+            uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+        }
+    }
+    else
+    {
+        uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+    }
+    modbus_errfunction_rtu(ReadInputReg, uErrorCode);
+    return;
+}
+
+/*******************************************************************************
+函数名称 ： WriteSingleRegFUNC
+功    能 ： 功能码:0x06 预设(写)单寄存器
+参    数 ： 无
+返 回 值 ： 无
+*发送:[硬件地址][06][寄存器地址高][寄存器地址低][寄存器值高][寄存器值低][CRC低][CRC高]
+*返回:[硬件地址][06][寄存器地址高][寄存器地址低][寄存器值高][寄存器值低][CRC低][CRC高]
+*******************************************************************************/
+void writesinglereg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint16_t wRegAddr, wRegValue, CRC16Temp;
+    uint8_t  uCommIndexNum = 0, uErrorCode;
+    uint8_t  upTxdbuf[MAX_SIZE];
+
+    if(upRxdbuf == NULL)  return;
+
+    wRegAddr  = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取寄存器地址
+    wRegValue = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取数据
+
+    if((wRegAddr <= HOLD_REG_ADD_MAX))//(wRegAddr >= HOLD_REG_ADD_MIN) && 
+    {
+        WriteHoldRegData(wRegAddr, wRegValue);
+
+        upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+        upTxdbuf[uCommIndexNum ++] = WriteSingleReg;
+        memcpy(upTxdbuf + uCommIndexNum, upRxdbuf, 4);
+        uCommIndexNum += 4;
+
+        CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+        upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF); // crc16低字节在前
+        upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);   // crc16高字节在后
+
+        // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+        // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+        // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+        scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+        memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+        scom2_rs485.tx_flag = TRUE;
+
+        return;
+    }
+    else
+    {
+        uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+    }
+    modbus_errfunction_rtu(WriteSingleReg, uErrorCode);
+    return;
+}
+
+/*******************************************************************************
+函数名称 ： WriteMultiRegFUNC
+功    能 ： 功能码:0x10 写多个保持寄存器
+参    数 ： 无
+返 回 值 ： 无
+*******************************************************************************/
+void writemultireg_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint16_t i, wRegStartAdd, wRegNum, CRC16Temp, uErrorCode, wRegValue;
+    uint8_t  uCommIndexNum = 0, uByteNum;
+    uint8_t  upTxdbuf[MAX_SIZE];
+
+    if(upRxdbuf == NULL)  return;
+
+    wRegStartAdd = MAKEWORD(upRxdbuf[1], upRxdbuf[0]);     //获取寄存器地址
+    wRegNum      = MAKEWORD(upRxdbuf[3], upRxdbuf[2]);     //获取寄存器数量
+    uByteNum     = upRxdbuf[4];                            //获取字节数
+
+    if((wRegNum >= 0x01) && (wRegNum <= MAX_HOLD_REG_NUM) && (uByteNum == wRegNum * 2))
+    {
+        if(((wRegStartAdd <= HOLD_REG_ADD_MAX) && 
+			(wRegStartAdd + wRegNum <= HOLD_REG_ADD_MAX + 1)))//(wRegStartAdd >= HOLD_REG_ADD_MIN) && 
+        {
+            for(i = 0; i < wRegNum; i++)
+            {
+                wRegValue = MAKEWORD(upRxdbuf[6 + i * 2], upRxdbuf[5 + i * 2]);
+                WriteHoldRegData(wRegStartAdd + i, wRegValue);
+            }
+
+            upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = WriteMultiReg;
+            memcpy(upTxdbuf + uCommIndexNum, upRxdbuf, 4);
+            uCommIndexNum += 4;
+
+            CRC16Temp                 = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+
+            return;
+        }
+        else
+        {
+            uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+        }
+    }
+    else
+    {
+        uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+    }
+    modbus_errfunction_rtu(WriteMultiReg, uErrorCode);
+    return;
+}
+
+/*******************************************************************************
+函数名称 ： WriteSingleCoilFUNC
+功    能 ： 功能码:0x05 写单个线圈寄存器
+参    数 ： 无
+返 回 值 ： 无
+*******************************************************************************/
+void writesinglecoil_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+    uint16_t wCoilAddr, wCoilValue, CRC16Temp;
+    uint8_t  uCommIndexNum = 0, uErrorCode;
+    uint8_t  upTxdbuf[MAX_SIZE];
+
+    wCoilAddr  = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取线圈地址
+    wCoilValue = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取线圈数据
+
+    if((wCoilValue == 0x0000) || (wCoilValue == 0xFF00))
+    {
+        if((wCoilAddr <= COIL_ADD_MAX))//(wCoilAddr >= DIS_ADD_MIN ) && 
+        {
+            WriteOneCoilData(wCoilAddr, wCoilValue);
+
+            upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = WriteSingleCoil;
+            memcpy(upTxdbuf + uCommIndexNum, upRxdbuf, 4);
+            uCommIndexNum += 4;
+
+            CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+			
+			return;
+        }
+        else
+        {
+            uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+        }
+    }
+    else
+    {
+        uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+    }
+    modbus_errfunction_rtu(WriteSingleCoil, uErrorCode);
+    return;
+}
+
+/*******************************************************************************
+函数名称 ： WriteMultiCoilFUNC
+功    能 ： 功能码:0x0F,写多个线圈
+参    数 ： 无
+返 回 值 ： 无
+*发送:[硬件地址][0F][起始地址高][起始地址低][线圈数量高][线圈数量低][字节数][线圈值][CRC低][CRC高]
+*返回:[硬件地址][0F][起始地址高][起始地址低][线圈数量高][线圈数量低][CRC低][CRC高]
+*******************************************************************************/
+void writemulticoil_rtu(uint8_t * upRxdbuf, uint16_t wRxdLen)
+{
+	uint16_t wCoilStartAddr,wCoilNum,wCoilVal,wTotalCoilNum,CRC16Temp;
+    uint8_t  i,k,uCommIndexNum = 0,uByteNum,uByteVal,uExit = 0,uErrorCode;
+	uint8_t  upTxdbuf[MAX_SIZE];
+
+    wCoilStartAddr  = MAKEWORD(upRxdbuf[1], upRxdbuf[0]); //获取线圈地址
+    wCoilNum        = MAKEWORD(upRxdbuf[3], upRxdbuf[2]); //获取线圈个数
+	uByteNum        = upRxdbuf[4];                        //获取字节数
+
+	if((wCoilNum >= 0x01) && (wCoilNum <= MAX_COIL_NUM) && (wCoilNum  <= 8 * uByteNum))
+	{
+		if((wCoilStartAddr <= COIL_ADD_MAX) && 
+		   (wCoilStartAddr + wCoilNum <= COIL_ADD_MAX + 1))//(wCoilStartAddr >= COIL_ADD_MIN) && 
+		{
+			wTotalCoilNum = 0;
+            for(k = 0; k < uByteNum; k++)
+			{
+				uByteVal = upRxdbuf[5 + k];
+				for(i = 0; i < 8; i++)
+				{
+					if(uByteVal & (1 << i)) wCoilVal = 0xFF00;
+					else                    wCoilVal = 0x0000;
+					
+					WriteOneCoilData(wCoilStartAddr + wTotalCoilNum, wCoilVal);
+					 
+					wTotalCoilNum ++;
+					if(wTotalCoilNum >= wCoilNum)
+					{
+						 uExit = 1;
+						 break;
+					}
+				}
+				
+				if(uExit == 1)
+				{
+					break;
+				}
+			}
+			
+			upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+            upTxdbuf[uCommIndexNum ++] = WriteMultiCoil;
+            memcpy(upTxdbuf + uCommIndexNum, upRxdbuf, 4);
+            uCommIndexNum += 4;
+
+            CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF);
+            upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);
+
+            // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+            // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+            // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+            scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+            memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+            scom2_rs485.tx_flag = TRUE;
+
+			
+			return;
+		}
+		else
+		{
+			uErrorCode = MB_EX_ILLEGAL_DATA_ADDRESS;
+		}
+	}
+	else
+	{
+        uErrorCode = MB_EX_ILLEGAL_DATA_VALUE;
+	}
+    modbus_errfunction_rtu(WriteMultiCoil, uErrorCode);
+    return;
+}
+
+/********
+***********************************************************************
+函数名称 : MODBUS_ERRFunction
+功     能: 错误回应指令
+参     数: 无
+返 回  值: 无
+异常功能码 = 功能码+0x80
+*******************************************************************************/
+void modbus_errfunction_rtu(uint8_t uCmdCode, uint8_t uErrorCode)
+{
+    uint8_t  uCommIndexNum = 0;
+    uint16_t CRC16Temp     = 0;
+    uint8_t upTxdbuf[MAX_SIZE];
+
+    upTxdbuf[uCommIndexNum ++] = LOCAL_ADDRESS;
+    upTxdbuf[uCommIndexNum ++] = uCmdCode | 0x80;
+    upTxdbuf[uCommIndexNum ++] = uErrorCode;
+
+    CRC16Temp = ModbusCRC16(upTxdbuf, uCommIndexNum);
+    upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp & 0xFF); //crc16低字节在前
+    upTxdbuf[uCommIndexNum ++] = (uint8_t)(CRC16Temp >> 8);
+
+    // MODBUS_UART.tx_size = (uCommIndexNum <= MODBUS_UART.tx_buf_cnt ? uCommIndexNum : MODBUS_UART.tx_buf_cnt);
+    // memcpy(MODBUS_UART.tx_buf, upTxdbuf, MODBUS_UART.tx_size);
+    // uart_send(&MODBUS_HUART, MODBUS_UART.tx_buf, MODBUS_UART.tx_size);
+    scom2_rs485.tx_len = (uCommIndexNum <= MAX_SIZE)?(uCommIndexNum):(MAX_SIZE);
+    memcpy(scom2_rs485.tx_buff, upTxdbuf, scom2_rs485.tx_len);
+    scom2_rs485.tx_flag = TRUE;
+}
+
+/*******************************************************************************
+函数名称 ： ModbusCRC16
+功    能 ： CRC校验
+参    数 ： ptr--校验数组指针  len--校验数据长度
+返 回 值 ： CRC校验码，双字节
+*******************************************************************************/
+uint16_t ModbusCRC16(uint8_t *ptr, uint16_t len)
+{
+    uint8_t i;
+    uint16_t crc = ~0x00;
+
+    if((ptr == NULL) || (len == 0xFFFF)) return crc;
+
+    while(len--)
+    {
+        crc ^= *ptr++;
+        for(i = 0; i < 8; i++)
+        {
+            if(crc & 0x01)
+            {
+                crc >>= 1;
+                crc ^= 0xA001;
+            }
+            else
+            {
+                crc >>= 1;
+            }
+        }
+    }
+    return(crc);
+}
+
+void GetOneCoilVal(uint16_t wCoilAddr, uint8_t *pCoilVal)
+{
+	uint8_t uVal;
+	
+	uVal = CoilState[(wCoilAddr - COIL_ADD_MIN) / 8 ];
+	if(uVal & ( 1 << ((wCoilAddr - COIL_ADD_MIN) % 8 )))
+	{
+		*pCoilVal = 0x01;
+	}
+	else
+	{
+		*pCoilVal = 0x00;
+	}
+}
+
+void GetOneDisInputVal(uint16_t wDisInputAddr, uint8_t *pDisInputVal)
+{
+	uint8_t uVal;
+	
+	uVal = DisState[(wDisInputAddr - DIS_ADD_MIN) / 8 ];
+	if(uVal & ( 1 << ((wDisInputAddr - DIS_ADD_MIN) % 8 )))
+	{
+		*pDisInputVal = 0x01;
+	}
+	else
+	{
+		*pDisInputVal = 0x00;
+	}
+}
+
+/*******************************************************************************
+函数名称 ： GetHoldRegData
+功    能 ： 获取RegAdd的数据
+参    数 ： u16 RegAdd
+返 回 值 ： 两字节寄存器数据
+*******************************************************************************/
+uint16_t GetHoldRegData(uint16_t RegAdd)
+{
+    int16_t wRegValue;
+
+    wRegValue = HoldReg[RegAdd - HOLD_REG_ADD_MIN];
+
+    return wRegValue;
+}
+
+/*******************************************************************************
+函数名称 ： GetInputRegData
+功    能 ： 获取RegAdd的数据
+参    数 ： u16 RegAdd
+返 回 值 ： 两字节寄存器数据
+*******************************************************************************/
+uint16_t GetInputRegData(uint16_t RegAdd)
+{
+    int16_t wRegValue;
+
+    wRegValue = InputReg[RegAdd - INPUT_REG_ADD_MIN];
+	
+    return wRegValue;
+}
+
+/*******************************************************************************
+函数名称 : WriteHoldRegData
+功    能 : 保存写入的保持寄存器数据
+参    数 : u16 StartAdd
+返 回 值 : 无
+*******************************************************************************/
+void WriteHoldRegData(uint16_t wRegAddr, uint16_t RegData)
+{
+    HoldReg[wRegAddr - HOLD_REG_ADD_MIN] = RegData;
+}
+
+/*******************************************************************************
+函数名称 : WriteOneCoilData
+功    能 : 保存写入的线圈寄存器数据
+参    数 : u16 StartAdd
+返 回 值 : 无
+*******************************************************************************/
+void WriteOneCoilData(uint16_t wRegAddr, uint16_t RegData)
+{
+	if(RegData == 0xFF00)
+    {
+		CoilState[(wRegAddr - COIL_ADD_MIN) / 8] |= 1 << ((wRegAddr - COIL_ADD_MIN) % 8);
+	}
+	else if(RegData == 0x0000)
+	{
+		CoilState[(wRegAddr - COIL_ADD_MIN) / 8] &= ~(1 << ((wRegAddr - COIL_ADD_MIN) % 8));
+	}
+}

App/MODBUS/Src/modbus_rtu_master.c

@@ -0,0 +1,452 @@
+#include "modbus_rtu_master.h"
+
+MODBUS_MASTER mod_master;
+
+void modbus_rtu_master_init(void)
+{
+    mod_master.target_id = 0x00;
+    mod_master.command_code = 0x00;
+    mod_master.start_address = 0x0000;
+    mod_master.register_num = 0x0000;
+    mod_master.crc16 = 0x0000;
+    mod_master.byte_num = 0;
+    memset(mod_master.data_tx_value, 0, TX_DATA_MAX);
+    memset(mod_master.data_tx, 0, TX_BUFF_MAX);
+    memset(mod_master.data_rx, 0, RX_BUFF_MAX);
+    mod_master.data_tx_len = 0;
+    mod_master.data_rx_len = 0;
+    mod_master.rx_error_message = RX_ERROR_NONE;
+    mod_master.tx_error_message = TX_ERROR_NONE;
+    mod_master.timeout = 1000;
+    mod_master.rx_flag = RX_NONE;
+    mod_master.tx_flag = TX_NONE;
+    memset(mod_master.result_display, 0, sizeof(mod_master.result_display));
+
+    memset(window_trx_num, 16, sizeof(window_trx_num));
+}
+
+void modbus_rtu_master_load(void)
+{
+    //先清空之前的发送数据
+    memset(mod_master.data_tx, 0, sizeof(mod_master.data_tx));
+
+    mod_master.data_tx[0] = mod_master.target_id;
+    mod_master.data_tx[1] = mod_master.command_code;
+    mod_master.tx_error_message = TX_ERROR_NONE;
+
+    switch (mod_master.data_tx[1])
+    {
+        //读四种寄存器的格式一致
+        case ReadCoilState:
+        {
+            //注释break，直接向下穿透
+        }
+        //break;
+
+        case ReadDisInputState:
+        {
+            //注释break，直接向下穿透
+        }
+        //break;
+
+        case ReadHoldReg:
+        {
+            //注释break，直接向下穿透
+        }
+        //break;
+
+        //【从站地址】【功能码】【起始地址高】【起始地址低】【数量高】【数量低】【CRC16校验低】【CRC16校验高】
+        case ReadInputReg:
+        {
+            mod_master.data_tx[2] = (uint8_t)(mod_master.start_address >> 8);
+            mod_master.data_tx[3] = (uint8_t)(mod_master.start_address & 0x00FF); 
+            mod_master.data_tx[4] = (uint8_t)(mod_master.register_num >> 8);
+            mod_master.data_tx[5] = (uint8_t)(mod_master.register_num & 0x00FF); 
+            mod_master.crc16 = ModbusCRC16(mod_master.data_tx, 6);
+            mod_master.data_tx[6] = (uint8_t)(mod_master.crc16 & 0x00FF); 
+            mod_master.data_tx[7] = (uint8_t)(mod_master.crc16 >> 8);
+
+            mod_master.data_tx_len = 8;
+        }
+        break;
+
+        //【从站地址】【功能码】【地址高】【地址低】【标志位高】【标志位低】【CRC16校验低】【CRC16校验高】
+        //标志位0xFF00表示ON，0x0000表示OFF，其他所有值均视作无效
+        case WriteSingleCoil:
+        {
+            mod_master.data_tx[2] = (uint8_t)(mod_master.start_address >> 8);
+            mod_master.data_tx[3] = (uint8_t)(mod_master.start_address & 0x00FF); 
+            mod_master.data_tx[4] = (mod_master.data_tx_value[0] == 0xFF)?(0xFF):(0x00);
+            mod_master.data_tx[5] = 0x00;
+            mod_master.crc16 = ModbusCRC16(mod_master.data_tx, 6);
+            mod_master.data_tx[6] = (uint8_t)(mod_master.crc16 & 0x00FF); 
+            mod_master.data_tx[7] = (uint8_t)(mod_master.crc16 >> 8);
+
+            mod_master.data_tx_len = 8;
+        }
+        break;
+
+        //【从站地址】【功能码】【地址高】【地址低】【数据高】【数据低】【CRC16校验低】【CRC16校验高】
+        case WriteSingleReg:
+        {
+            mod_master.data_tx[2] = (uint8_t)(mod_master.start_address >> 8);
+            mod_master.data_tx[3] = (uint8_t)(mod_master.start_address & 0x00FF); 
+            mod_master.data_tx[4] = mod_master.data_tx_value[0];
+            mod_master.data_tx[5] = mod_master.data_tx_value[1]; 
+            mod_master.crc16 = ModbusCRC16(mod_master.data_tx, 6);
+            mod_master.data_tx[6] = (uint8_t)(mod_master.crc16 & 0x00FF); 
+            mod_master.data_tx[7] = (uint8_t)(mod_master.crc16 >> 8);
+
+            mod_master.data_tx_len = 8;
+        }
+        break;
+
+        //【从站地址】【功能码】【起始地址高】【起始地址低】【数量高】【数量低】【写入字节数n】【写入值1】...【写入值n】【CRC16校验低】【CRC16校验高】
+        case WriteMultiCoil:
+        {
+            if( mod_master.register_num % 8  )
+            {
+                //线圈数量不为8的倍数时，字节数 == （线圈数量/8 + 1）
+                if( (mod_master.register_num/8 + 1) != mod_master.byte_num )
+                {
+                    mod_master.tx_error_message = TX_ERROR_COIL_NUM;
+                    return;
+                }
+            }
+            else
+            {
+                //线圈数量为8的倍数时，字节数 == 线圈数量/8
+                if( (mod_master.register_num/8) != mod_master.byte_num )
+                {
+                    mod_master.tx_error_message = TX_ERROR_COIL_NUM;
+                    return;
+                }
+            }
+
+            mod_master.data_tx[2] = (uint8_t)(mod_master.start_address >> 8);
+            mod_master.data_tx[3] = (uint8_t)(mod_master.start_address & 0x00FF); 
+            mod_master.data_tx[4] = (uint8_t)(mod_master.register_num >> 8);
+            mod_master.data_tx[5] = (uint8_t)(mod_master.register_num & 0x00FF); 
+            mod_master.data_tx[6] = mod_master.byte_num;
+            for(uint8_t i = 1; i <= mod_master.byte_num; i++ )
+            {
+                mod_master.data_tx[6 + i] = mod_master.data_tx_value[i - 1];
+            }
+            mod_master.crc16 = ModbusCRC16(mod_master.data_tx, 7 + mod_master.byte_num);
+            mod_master.data_tx[7 + mod_master.byte_num] = (uint8_t)(mod_master.crc16 & 0x00FF); 
+            mod_master.data_tx[8 + mod_master.byte_num] = (uint8_t)(mod_master.crc16 >> 8);
+
+            mod_master.data_tx_len = 8 + mod_master.byte_num + 1;
+        }
+        break;
+
+        //【从站地址】【功能码】【起始地址高】【起始地址低】【数量高】【数量低】【写入字节数】【写入值1高】【写入值1低】...【写入值n高】【写入值n低】【CRC16校验低】【CRC16校验高】
+        case WriteMultiReg:
+        {
+            if( (mod_master.register_num * 2) != mod_master.byte_num )
+            {
+                //字节数 == （寄存器数量*2）
+                mod_master.tx_error_message = TX_ERROR_HOLDREG_NUM;
+                return;
+            }
+
+            mod_master.data_tx[2] = (uint8_t)(mod_master.start_address >> 8);
+            mod_master.data_tx[3] = (uint8_t)(mod_master.start_address & 0x00FF); 
+            mod_master.data_tx[4] = (uint8_t)(mod_master.register_num >> 8);
+            mod_master.data_tx[5] = (uint8_t)(mod_master.register_num & 0x00FF); 
+            mod_master.data_tx[6] = mod_master.byte_num;
+            for(uint8_t i = 1; i <= mod_master.byte_num; i++ )
+            {
+                mod_master.data_tx[6 + i] = mod_master.data_tx_value[i - 1];
+            }
+            mod_master.crc16 = ModbusCRC16(mod_master.data_tx, 7 + mod_master.byte_num);
+            mod_master.data_tx[7 + mod_master.byte_num] = (uint8_t)(mod_master.crc16 & 0x00FF); 
+            mod_master.data_tx[8 + mod_master.byte_num] = (uint8_t)(mod_master.crc16 >> 8);
+
+            mod_master.data_tx_len = 8 + mod_master.byte_num + 1;
+        }
+        break;
+    
+        default:
+        {
+            mod_master.tx_error_message = TX_ERROR_WRONG_CMD;
+        }
+        break;
+    }
+}
+
+void modbus_rtu_master_send(void)
+{
+    //先清空之间的接收数据与显示内容
+    memset(mod_master.data_rx, 0, sizeof(mod_master.data_rx));
+    memset(mod_master.result_display, 0, sizeof(mod_master.result_display));
+    lv_label_set_text(guider_ui.screen_modbus_trx_value_Rx, "");
+
+    if(mod_master.tx_error_message == TX_ERROR_NONE)
+    {
+        mod_master.rx_flag = TX_WAITING;
+
+        //将准备好的数据发送至从设备
+        memcpy(scom2_rs485.tx_buff, mod_master.data_tx, mod_master.data_tx_len);
+        scom2_rs485.tx_len = mod_master.data_tx_len;
+        scom2_rs485.tx_flag = TRUE;
+
+        if(scom2_rs485.tx_flag == TRUE)
+        {
+            scom2_rs485.tx_flag = FALSE;
+
+            //将数据发送至上位机
+            HAL_UART_Transmit_DMA(&huart2, scom2_rs485.tx_buff, scom2_rs485.tx_len);
+        }
+
+        //在发送回调中判断发送是否完成
+        sig_trans = TRANS_MODBUS_SIG_TO_SLAVE;
+    }
+}
+
+void modbus_rtu_master_analysis(void)
+{
+    //收到的数据是否溢出
+    if(scom2_rs485.rx_len > RX_BUFF_MAX)
+    {
+        mod_master.rx_error_message = RX_ERROR_OVERFLOW;
+        strcpy(mod_master.result_display, "ERROR: RX OVERFLOW");
+        return;
+    }
+    else
+    {
+        mod_master.data_rx_len = scom2_rs485.rx_len;
+        memcpy(mod_master.data_rx, scom2_rs485.rx_buff, mod_master.data_rx_len);
+    }
+
+    //返回的从站地址与目标设备是否一致
+    if(mod_master.data_rx[0] != mod_master.target_id)
+    {
+        mod_master.rx_error_message = RX_ERROR_WRONG_ID;
+        strcpy(mod_master.result_display, "ERROR: WRONG ID");
+        return;
+    }
+
+    //返回的命令字与发送的命令字是否一致
+    if(mod_master.data_rx[1] != mod_master.command_code)
+    {
+        mod_master.rx_error_message = RX_EEROR_WRONG_CMD;
+        strcpy(mod_master.result_display, "ERROR: WRONG COMMAND");
+        return;
+    }
+
+    //收到的是异常响应
+    if(mod_master.data_rx[1] > 0x80)
+    {
+        ex_message = (eMBException)mod_master.data_rx[2];
+        sprintf(mod_master.result_display, "Exceptional Response: %02x", mod_master.data_rx[2]);
+        return;
+    }
+
+    //处理接收到的数据
+    modbus_rtu_master_data_process();
+
+    mod_master.rx_flag = RX_OK;
+}
+
+void modbus_rtu_master_data_process(void)
+{
+    //获取功能码
+    uint8_t fun_cmd = mod_master.data_rx[1];
+
+    switch (fun_cmd)
+    {
+        //【从站地址】【功能码】【返回字节数n】【字节1~n】【CRC16校验低】【CRC16校验高】
+        case ReadCoilState:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != (mod_master.data_rx[2] + 5) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x Bytes:%02x Data: ", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2]);
+            char num2str[2];
+            for(uint8_t i = 0; i < mod_master.data_rx[2]; i++)
+            {   
+                sprintf(num2str, "%02x ", mod_master.data_rx[3 + i]);
+                strcat(mod_master.result_display, num2str);
+            }
+        }
+        break;
+
+        //【从站地址】【功能码】【返回字节数n】【字节1~n】【CRC16校验低】【CRC16校验高】
+        case ReadDisInputState:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != (mod_master.data_rx[2] + 5) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x Bytes:%02x Data: ", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2]);
+            char num2str[2];
+            for(uint8_t i = 0; i < mod_master.data_rx[2]; i++)
+            {   
+                sprintf(num2str, "%02x ", mod_master.data_rx[3 + i]);
+                strcat(mod_master.result_display, num2str);
+            }
+        }
+        break;
+
+        //【从站地址】【功能码】【返回字节数】【字1~n高】【字1~n低】【CRC16校验低】【CRC16校验高】
+        case ReadHoldReg:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != (mod_master.data_rx[2] + 5) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x Bytes:%02x Data: ", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2]);
+            char num2str[2];
+            for(uint8_t i = 0; i < mod_master.data_rx[2]; i++)
+            {   
+                sprintf(num2str, "%02x ", mod_master.data_rx[3 + i]);
+                strcat(mod_master.result_display, num2str);
+            }
+        }
+        break;
+
+        //【从站地址】【功能码】【返回字节数】【字1~n高】【字1~n低】【CRC16校验低】【CRC16校验高】
+        case ReadInputReg:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != (mod_master.data_rx[2] + 5) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x Bytes:%02x Data: ", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2]);
+            char num2str[2];
+            for(uint8_t i = 0; i < mod_master.data_rx[2]; i++)
+            {   
+                sprintf(num2str, "%02x ", mod_master.data_rx[3 + i]);
+                strcat(mod_master.result_display, num2str);
+            }
+        }
+        break;
+
+        //【从站地址】【功能码】【地址高】【地址低】【标志位高】【标志位低】【CRC16校验低】【CRC16校验高】
+        case WriteSingleCoil:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != 8 )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //应答数据报的标志位是否与发送的一致
+            if( (mod_master.data_rx[4] != mod_master.data_tx[4])||(mod_master.data_rx[5] != mod_master.data_tx[5]) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_DATA;
+                strcpy(mod_master.result_display, "ERROR: WRONG DATA");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x CoilAddress:0x%02x%02x Bits:0x%02x%02x", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2], mod_master.data_rx[3], mod_master.data_rx[4], mod_master.data_rx[5]);
+        }
+        break;
+
+        //【从站地址】【功能码】【地址高】【地址低】【数据高】【数据低】【CRC16校验低】【CRC16校验高】
+        case WriteSingleReg:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != 8 )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //应答数据报的数据是否与发送的一致
+            if( (mod_master.data_rx[4] != mod_master.data_tx[4])||(mod_master.data_rx[5] != mod_master.data_tx[5]) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_DATA;
+                strcpy(mod_master.result_display, "ERROR: WRONG DATA");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x RegAddress:0x%02x%02x Data:0x%02x%02x", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2], mod_master.data_rx[3], mod_master.data_rx[4], mod_master.data_rx[5]);
+        }
+        break;
+
+        //【从站地址】【功能码】【地址高】【地址低】【数量高】【数量低】【CRC16校验低】【CRC16校验高】
+        case WriteMultiCoil:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != 8 )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //应答数据报的寄存器数量是否与发送的一致
+            if( (mod_master.data_rx[4] != mod_master.data_tx[4])||(mod_master.data_rx[5] != mod_master.data_tx[5]) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_NUM;
+                strcpy(mod_master.result_display, "ERROR: WRONG NUMBER OF REGISTERS");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x CoilAddress:0x%02x%02x Num:0x%02x%02x", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2], mod_master.data_rx[3], mod_master.data_rx[4], mod_master.data_rx[5]);
+        }
+        break;
+
+        //【从站地址】【功能码】【地址高】【地址低】【数量高】【数量低】【CRC16校验低】【CRC16校验高】
+        case WriteMultiReg:
+        {
+            //应答数据报的长度是否正确
+            if( mod_master.data_rx_len != 8 )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_LENGTH;
+                strcpy(mod_master.result_display, "ERROR: WRONG LENGTH");
+                return;
+            }
+
+            //应答数据报的寄存器数量是否与发送的一致
+            if( (mod_master.data_rx[4] != mod_master.data_tx[4])||(mod_master.data_rx[5] != mod_master.data_tx[5]) )
+            {
+                mod_master.rx_error_message = RX_ERROR_WRONG_NUM;
+                strcpy(mod_master.result_display, "ERROR: WRONG NUMBER OF REGISTERS");
+                return;
+            }
+
+            //数据解析
+            sprintf(mod_master.result_display, "Address:0x%02x Command:0x%02x RegAddress:0x%02x%02x Num:0x%02x%02x", mod_master.data_rx[0], mod_master.data_rx[1], mod_master.data_rx[2], mod_master.data_rx[3], mod_master.data_rx[4], mod_master.data_rx[5]);
+        }
+        break;
+    
+        default:
+        {
+            mod_master.rx_error_message = RX_ERROR_INVALID_CMD;
+            strcpy(mod_master.result_display, "ERROR: INVALID COMMAND");
+        }
+        break;
+    }
+}
+
+

App/MODBUS/modbus.c

@@ -1,33 +0,0 @@
-
-#include "FreeRTOS.h"
-#include "task.h"
-#include "stdio.h"
-#include "modbus.h"
-#include "usart.h"
-
-static void scom_485_send(UART_HandleTypeDef *huart, char *str)
-{
-    RS485_RW(RS485_WR);
-    vTaskDelay(10);
-    printf("\r\n");
-    usart_printf(huart, "rs485 receive:[%s]\r\n", str);
-    printf("printf test_data:[%s]\r\n", str);
-    RS485_RW(RS485_RD);
-}
-
-void parse_scom_485(st_scom *scom)
-{
-    if ((scom == &scom2_rs485) && (scom->rx_flag == TRUE))
-    {
-        scom->rx_flag = FALSE;
-        if ((scom->rx_buff[0] == 0xff) && (scom->rx_buff[1] == 0xff) && (scom->rx_buff[scom->rx_len - 1] == 0xaa))
-        {
-            // scom_485_send(&huart2, scom->rx_buff);
-            RS485_RW(RS485_WR);
-            vTaskDelay(10);
-            HAL_UART_Transmit(&huart2, scom->rx_buff, scom->rx_len, 0xFFFF);
-            RS485_RW(RS485_RD);
-        }
-        scom->rx_len = 0;
-    }
-}

App/MODBUS/modbus.h

@@ -1,8 +0,0 @@
-#ifndef __MODBUS_H
-#define __MODBUS_H
-#include "stdint.h"
-#include "gpio.h"
-#include "usart.h"
-
-void parse_scom_485(st_scom *scom);
-#endif

App/MUX_SIGNAL/mux_signal.c

@@ -1,3 +1,11 @@
+/*
+ * @Author: wujunchao wujunchao@wuxismart.com
+ * @Date: 2024-12-24 08:18:26
+ * @LastEditors: wujunchao wujunchao@wuxismart.com
+ * @LastEditTime: 2025-03-20 15:01:22
+ * @FilePath: \signal_generator\App\MUX_SIGNAL\mux_signal.c
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
 /*
  * @Author: DaMingSY zxm5337@163.com
  * @Date: 2024-09-02 15:58:58
@@ -17,6 +25,7 @@
 #include "dac8552.h"
 #include "ads1220.h"
 #include "dac7811.h"
+#include "apps_gather.h"
 
 st_mux_signal mux_signal = {
     .channel = CHX_IN_MAX,
@@ -46,8 +55,10 @@ void fun_get_freq(st_freq_signal *freq_signal, float *data_pv)
     {
         freq_signal->capture_cnt = 0;
         __HAL_TIM_SET_COUNTER(&htim3, 0);
-        freq_signal->duty_time = freq_signal->capture_buf[1] + freq_signal->over_cnt * 60000 - freq_signal->capture_buf[0];
-        freq_signal->freq = 1000000 / freq_signal->duty_time;
+        // freq_signal->duty_time = freq_signal->capture_buf[1] + freq_signal->over_cnt * 60000 - freq_signal->capture_buf[0];
+        // freq_signal->freq = 1000000 / freq_signal->duty_time;
+        freq_signal->duty_time = freq_signal->capture_buf[1] + freq_signal->over_cnt * 65535 - freq_signal->capture_buf[0];
+        freq_signal->freq = 82944000 / freq_signal->duty_time;
         *data_pv = freq_signal->freq;
         freq_signal->over_cnt = 0;
     }
@@ -90,85 +101,190 @@ void pwr_cosume(BOOL rst, uint32_t ms)
     PWR_CTRL(GPIO_PIN_RESET);
 }
 
-static void fun_pwr12_ctrl(uint8_t ch)
-{
-    static uint8_t lasht_ch;
-    BOOL ch_flag = FALSE;
+// static void fun_pwr12_ctrl(uint8_t ch)
+// {
+//     static uint8_t lasht_ch;
+//     BOOL ch_flag = FALSE;
 
-    if (ch != lasht_ch)
-    {
-        ch_flag = TRUE;
-        lasht_ch = ch;
-    }
-    if (ch_flag == TRUE)
-    {
-        ch_flag = FALSE;
-        if ((ch == CH0_OUT_VOL_V) || (ch == CH2_OUT_CUR) || (ch == CH3_OUT_FRE) || (ch == CH4_OUT_RES))
-            PWR12_CTRL(GPIO_PIN_SET);
-        else
-            PWR12_CTRL(GPIO_PIN_RESET);
-    }
-}
+//     if (ch != lasht_ch)
+//     {
+//         ch_flag = TRUE;
+//         lasht_ch = ch;
+//     }
+//     if (ch_flag == TRUE)
+//     {
+//         ch_flag = FALSE;
+//         //if ((ch == CH0_OUT_VOL_V) || (ch == CH2_OUT_CUR) || (ch == CH3_OUT_FRE) || (ch == CH4_OUT_RES))
+//             //PWR12_CTRL(GPIO_PIN_SET);
+//         //else
+//             //PWR12_CTRL(GPIO_PIN_RESET);
+//     }
+// }
 
 uint8_t pulse = 50;
+float32 fre_set_mux = 0;
+float32 sv_prv = 0;
+CHANNEL ch_prv = CHX_IN_MAX;
+uint8_t mux_set_flag = 0;
 void mux_signal_switch(st_mux_signal *mux_signal)
 {
-    CHANNEL ch;
-
-    ch = mux_signal->channel;
-    fun_pwr12_ctrl(ch);
-    HC138_SEL_CH(ch);
-
-    switch (ch)
+    //只有频道和设定值改变时才执行设定操作（不影响回采和输入采集）
+    if( (mux_signal->channel == ch_prv)&&(mux_signal->data_sv == sv_prv) )
     {
-    case CH0_OUT_VOL_V:
-        dac_set_voltage(&mux_signal->data_sv);
-        fun_proc_adc1_dma(&mux_signal->data_pv);
-        break;
-    case CH1_OUT_VOL_MV:
-        dac8552_operation(NULL, &mux_signal->data_sv);
-        fun_get_sig16132_ch(4, &mux_signal->data_pv);
-        break;
-    case CH2_OUT_CUR:
-        dac8552_operation(&mux_signal->data_sv, NULL);
-        fun_get_sig16132_ch(7, &mux_signal->data_pv);
-        // ads1220_operation(CH2_OUT_CUR, &mux_signal->data_pv);
-        break;
-    case CH3_OUT_FRE:
-        freq_operation(mux_signal->data_sv, pulse);
-        fun_get_freq(&freq_signal, &mux_signal->data_pv);
-        break;
-    case CH4_OUT_RES:
-        fun_dac7811_operate(&mux_signal->data_sv);
-        break;
-    case CH5_IN_VOL:
-        fun_get_sig16132_ch(2, &mux_signal->data_pv);
-        // fun_rn7302_operate(CH0_IN_VOL, &mux_signal->data_pv);
-        break;
-    case CH6_IN_MVOL:
-        fun_get_sig16132_ch(3, &mux_signal->data_pv);
-        // fun_rn7302_operate(CH0_IN_VOL, &mux_signal->data_pv);
-        break;
-    case CH7_IN_CUR:
-        fun_get_sig16132_ch(5, &mux_signal->data_pv);
-        // fun_rn7302_operate(CH1_IN_CUR, &mux_signal->data_pv);
-        break;
-    case CH8_IN_FRE:
-        fun_get_freq(&freq_signal, &mux_signal->data_pv);
-        break;
-    case CH9_IN_TC:
-        ads1220_operation(CH9_IN_TC, &mux_signal->data_pv);
-        // fun_rn7302_operate(CH3_IN_RTD, &mux_signal->data_pv);
-        break;
-    case CH10_IN_RTD:
-        fun_get_sig16132_ch(10, &mux_signal->data_pv);
-        // fun_rn7302_operate(CH3_IN_RTD, &mux_signal->data_pv);
-        break;
-    case CH11_IN_HART:
-
+        mux_set_flag = 0;
+    }
+    else
+    {
+        mux_set_flag = 1;
+        if((mux_signal->channel != ch_prv))
+        {
+            //通道改变时切换通道
+            HC138_SEL_CH(mux_signal->channel);
+            ch_prv = mux_signal->channel;
+        }
+        
+        if(mux_signal->data_sv != sv_prv) sv_prv = mux_signal->data_sv;
+    }
+    
+    //执行通道对应的功能
+    switch (mux_signal->channel)
+    {
+        case CH0_OUT_VOL_V:
+        {
+            if(mux_set_flag) dac_set_voltage(&mux_signal->data_sv);             //设定
+            fun_proc_adc1_dma(&mux_signal->data_pv);                            //回采
+        }
         break;
 
-    default:
+        case CH1_OUT_VOL_MV:
+        {
+            if(mux_set_flag) dac8552_operation(NULL, &mux_signal->data_sv);     //设定
+            fun_get_sig16132_ch(4, &mux_signal->data_pv);                       //回采
+        }
+        break;
+
+        case CH2_OUT_CUR:
+        {
+            if(mux_set_flag) dac8552_operation(&mux_signal->data_sv, NULL);     //设定
+            fun_get_sig16132_ch(7, &mux_signal->data_pv);                       //回采
+        }
+        break;
+
+        case CH3_OUT_FRE:
+        {
+            if( (tabdata.hart_enable == 0)&&(mux_set_flag) ) 
+            {
+                frequence_output(mux_signal->data_sv, pulse, PWM_MUX);    //设定
+                fre_set_mux = mux_signal->data_sv;
+            }
+        }
+        break;
+
+        case CH4_OUT_RES:
+            if(mux_set_flag) fun_dac7811_operate(&mux_signal->data_sv);         //设定
+        break;
+
+        case CH5_EMPTY:
+        break;
+
+        case CH6_IN_VOL:
+            fun_get_sig16132_ch(2, &mux_signal->data_pv);                       //输入采集
+        break;
+
+        case CH7_IN_MVOL:
+            fun_get_sig16132_ch(3, &mux_signal->data_pv);                       //输入采集
+        break;
+
+        case CH8_IN_CUR:
+            fun_get_sig16132_ch(5, &mux_signal->data_pv);                       //输入采集
+        break;
+
+        case CH9_IN_FRE:
+            fun_get_freq(&freq_signal, &mux_signal->data_pv);                   //输入采集
+        break;
+
+        case CH10_IN_RTD:
+		    fun_get_sig16132_ch(CH10_IN_RTD, &mux_signal->data_pv);             //输入采集
+        break;
+
+        case CH11_IN_TC:
+            ads1220_operation(CH11_IN_TC, &mux_signal->data_pv);                //输入采集
+        break;
+
+        default:
         break;
     }
 }
+
+void frequence_output(uint32_t freq, uint8_t pulse, uint8_t pwm_select)
+{
+    int fre_duty = 0;  
+
+    switch (pwm_select)
+    {
+        case PWM_MUX:
+        {
+            HAL_TIMEx_PWMN_Stop(&htim8, TIM_CHANNEL_2); 
+            
+            if (freq <= 0 || freq >= 500000 || pulse <= 0 || pulse >= 100)       
+            {                                                                    
+                __HAL_TIM_SET_PRESCALER(&htim8, 1500-1);                           
+                __HAL_TIM_SET_AUTORELOAD(&htim8, 55-1);                            
+                __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_2, 28-1);                         
+                return;                                                             
+            }
+            
+            if(freq <= 650)                                   
+            {                                                                    
+                __HAL_TIM_SET_PRESCALER(&htim8, 1500-1);                           
+                fre_duty = ( (float32)FREQ_SYS / (float32)1500.0 / (float32)freq + (float32)0.5 );  
+            }                                                                    
+            else                                                 
+            {                                                                    
+                __HAL_TIM_SET_PRESCALER(&htim8, 2-1);                              
+                fre_duty = ( (float32)FREQ_SYS / (float32)2.0 / (float32)freq + (float32)0.5 );     
+            }
+            
+            __HAL_TIM_SET_AUTORELOAD(&htim8, fre_duty -1);                       
+            __HAL_TIM_SET_COMPARE(&htim8, TIM_CHANNEL_2, fre_duty * pulse / 100 - 1);
+
+            HAL_TIMEx_PWMN_Start(&htim8, TIM_CHANNEL_2);  
+        }
+        break;
+
+        case PWM_HART:
+        {
+            HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3); 
+
+            if (freq <= 0 || freq >= 500000 || pulse <= 0 || pulse >= 100)       
+            {                                                                    
+                __HAL_TIM_SET_PRESCALER(&htim1, 1500-1);                           
+                __HAL_TIM_SET_AUTORELOAD(&htim1, 55-1);                            
+                __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, 28-1);                         
+                return;                                                             
+            }
+            
+            if(freq <= 650)                                   
+            {                                                                    
+                __HAL_TIM_SET_PRESCALER(&htim1, 1500-1);                           
+                fre_duty = ( (float32)FREQ_SYS / (float32)1500.0 / (float32)freq + (float32)0.5 );  
+            }                                                                    
+            else                                                 
+            {                                                                    
+                __HAL_TIM_SET_PRESCALER(&htim1, 2-1);                              
+                fre_duty = ( (float32)FREQ_SYS / (float32)2.0 / (float32)freq + (float32)0.5 );     
+            }
+            
+            __HAL_TIM_SET_AUTORELOAD(&htim1, fre_duty -1);                       
+            __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, fre_duty * pulse / 100 - 1);
+
+            HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3); 
+        }
+        break;
+    
+        default:
+        break;
+    }                      
+}
+
+

App/MUX_SIGNAL/mux_signal.h

@@ -1,32 +1,28 @@
-/*
- * @Author: DaMingSY zxm5337@163.com
- * @Date: 2024-09-02 15:59:31
- * @LastEditors: DaMingSY zxm5337@163.com
- * @LastEditTime: 2024-11-28 10:07:48
- * @FilePath: \signal_generator\App\MUX_SIGNAL\mux_signal.h
- * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
- */
-#ifndef __MUX_SIGNAL_H_
-#define __MUX_SIGNAL_H_
+#ifndef _MUX_SIGNAL_H_
+#define _MUX_SIGNAL_H_
 
 #include "data_type_def.h"
 #include "gpio.h"
 
+#define PWM_MUX 0
+#define PWM_HART 1
+
 typedef enum
 {
     CH0_OUT_VOL_V = 0,
-    CH1_OUT_VOL_MV,
-    CH2_OUT_CUR,
-    CH3_OUT_FRE,
-    CH4_OUT_RES,
-    CH5_IN_VOL,
-    CH6_IN_MVOL,
-    CH7_IN_CUR,
-    CH8_IN_FRE,
-    CH9_IN_TC,
-    CH10_IN_RTD,
-    CH11_IN_HART,
-    CHX_IN_MAX,
+    CH1_OUT_VOL_MV = 1,
+    CH2_OUT_CUR = 2,
+    CH3_OUT_FRE = 3,
+    CH4_OUT_RES = 4,
+    CH5_EMPTY = 5,
+    CH6_IN_VOL = 6,
+    CH7_IN_MVOL = 7,
+    CH8_IN_CUR = 8,
+    CH9_IN_FRE = 9,
+    CH10_IN_RTD = 10,
+    CH11_IN_TC = 11,
+    CH12_IN_HART = 12,
+    CHX_IN_MAX = 13,
 
 } CHANNEL;
 
@@ -53,5 +49,6 @@ extern st_mux_signal mux_signal;
 
 void pwr_cosume(BOOL rst, uint32_t ms);
 void mux_signal_switch(st_mux_signal *mux_signal);
+void frequence_output(uint32_t freq, uint8_t pulse, uint8_t pwm_select);
 
 #endif

App/SIG24130/SIG24130.c

@@ -48,7 +48,9 @@
 #include "stm32f4xx_hal.h"
 #include "spi.h"
 #include <SIG24130.h>
-#include "math.h"
+//#include "math.h"
+#include "FreeRTOS.h"
+#include "task.h"
 
 // Add printf1 for debug purpose to print out register content.
 #include "usart.h"
@@ -613,7 +615,8 @@ void fun_get_sig16132_ch(uint8_t channel, float32 *data)
 
 		if ((channel == 2) || (channel == 3) || (channel == 4) || (channel == 5) || (channel == 7))
 		{
-			HAL_Delay(100); // Wait time after power-up before SPI communication. Power-On Reset(POR) time is 43ms.
+			//HAL_Delay(100); // Wait time after power-up before SPI communication. Power-On Reset(POR) time is 43ms.
+			vTaskDelay(100);
 			SIG24130_Reset();
 			delay_nus(100);					   // RESET SIG24130
 			SIG24130_SetRefMux(2);			   // 内部2.5V参考
@@ -624,7 +627,8 @@ void fun_get_sig16132_ch(uint8_t channel, float32 *data)
 		}
 		else if (channel == 10)
 		{
-			HAL_Delay(100); // Wait time after power-up before SPI communication. Power-On Reset(POR) time is 43ms.
+			//HAL_Delay(100); // Wait time after power-up before SPI communication. Power-On Reset(POR) time is 43ms.
+			vTaskDelay(100);
 			SIG24130_Reset();
 			delay_nus(100);				  // RESET SIG24130
 			SIG24130_SetRefMux(2);		  // 内部2.5V参考
@@ -641,7 +645,7 @@ void fun_get_sig16132_ch(uint8_t channel, float32 *data)
 	{
 		float32 ad_16 = SIG16130_RetrievalData(1, 0);
 		float32 voltage = (float32)(2.5f * ad_16 / 32767.0f);
-		float32 Rt = 0;
+		//float32 Rt = 0;
 
 		if (channel == 2) // 0~30V电压输入检测
 		{
@@ -673,16 +677,16 @@ void fun_get_sig16132_ch(uint8_t channel, float32 *data)
 // A=3.96847×10-3；
 // B=-5.847×10-7；
 // C=-4.22×10-12；
-#define R0 100.0f
-#define A 3.96847e-3
-#define B -5.847e-7
-#define C -4.22e-12
-			Rt = voltage * 1000.0f / 1.0f;
-			float32 temp1 = (-A + sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B);
-			float32 temp2 = (-A - sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B);
+// #define R0 100.0f
+// #define A 3.96847e-3
+// #define B -5.847e-7
+// #define C -4.22e-12
+			// Rt = voltage * 1000.0f / 1.0f;
+			// float32 temp1 = (-A + sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B);
+			// float32 temp2 = (-A - sqrt(A * A - 4 * B * (1 - Rt / R0))) / (2 * B);
 
-			*data = temp1;
-			//*data = voltage * 1000.0f;
+			// *data = temp1;
+			*data = voltage * 1000.0f/ 0.5f;
 		}
 	}
 }

App/TM1650/tm1650.c

@@ -1,6 +1,15 @@
+/*
+ * @Author: wujunchao wujunchao@wuxismart.com
+ * @Date: 2024-12-24 13:24:59
+ * @LastEditors: wujunchao wujunchao@wuxismart.com
+ * @LastEditTime: 2025-03-17 11:31:24
+ * @FilePath: \signal_generator\App\TM1650\tm1650.c
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
 #include "tm1650.h"
+#include "apps_gather.h"
 
-uint8_t key;
+uint8_t key = 0;
 BOOL kp_flag = FALSE;
 
 void tm1650_init(I2C_HandleTypeDef *hi2c)
@@ -27,13 +36,17 @@ void tm1650_read_key(I2C_HandleTypeDef *hi2c, BOOL *kp_flag, uint16_t cmd, uint8
     {
         *kp_flag = FALSE;
         HAL_I2C_Master_Receive(hi2c, cmd, key, 1, 0xff);
+
+        //数据转换
+        key_char2struct();
     }
 #endif
+
 }
 
 void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
 {
-    if (GPIO_Pin == TM1650_KP_Pin)
+    if (GPIO_Pin == KEY_KP_Pin)
     {
         kp_flag = TRUE;
     }

Core/Inc/FreeRTOSConfig.h

@@ -64,8 +64,10 @@
 #define configTICK_RATE_HZ                       ((TickType_t)1000)
 #define configMAX_PRIORITIES                     ( 7 )
 #define configMINIMAL_STACK_SIZE                 ((uint16_t)128)
-#define configTOTAL_HEAP_SIZE                    ((size_t)15360)
+#define configTOTAL_HEAP_SIZE                    ((size_t)20480)
 #define configMAX_TASK_NAME_LEN                  ( 16 )
+#define configUSE_TRACE_FACILITY                 1
+#define configUSE_STATS_FORMATTING_FUNCTIONS     1
 #define configUSE_16_BIT_TICKS                   0
 #define configUSE_MUTEXES                        1
 #define configQUEUE_REGISTRY_SIZE                8
@@ -90,6 +92,7 @@ to exclude the API function. */
 #define INCLUDE_vTaskDelayUntil              0
 #define INCLUDE_vTaskDelay                   1
 #define INCLUDE_xTaskGetSchedulerState       1
+#define INCLUDE_uxTaskGetStackHighWaterMark  1
 
 /* Cortex-M specific definitions. */
 #ifdef __NVIC_PRIO_BITS

Core/Inc/dma.h

@@ -7,7 +7,7 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2024 STMicroelectronics.
+  * Copyright (c) 2025 STMicroelectronics.
   * All rights reserved.
   *
   * This software is licensed under terms that can be found in the LICENSE file

Core/Inc/gpio.h

@@ -22,8 +22,7 @@
 #define __GPIO_H__
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 /* Includes ------------------------------------------------------------------*/
@@ -36,152 +35,149 @@ extern "C"
 #define RS485_RD GPIO_PIN_RESET
 #define RS485_WR GPIO_PIN_SET
 
-    /* USER CODE END Includes */
+/* USER CODE END Includes */
 
-    /* USER CODE BEGIN Private defines */
+/* USER CODE BEGIN Private defines */
 
 #define PWR_CTRL(STATE) HAL_GPIO_WritePin(PWR_EN_GPIO_Port, PWR_EN_Pin, STATE)
 
-#define PWR12_CTRL(STATE) HAL_GPIO_WritePin(PWR12_EN_GPIO_Port, PWR12_EN_Pin, STATE)
+//#define PWR12_CTRL(STATE) HAL_GPIO_WritePin(PWR12_EN_GPIO_Port, PWR12_EN_Pin, STATE)
 
 #define LIGHT_PWR(STATE) HAL_GPIO_WritePin(light_GPIO_Port, light_Pin, STATE)
 
-#define RS485_RW(RW) HAL_GPIO_WritePin(RS485_RW_GPIO_Port, RS485_RW_Pin, RW)
+#define LED_TOG HAL_GPIO_TogglePin(light_GPIO_Port, light_Pin)
+
+// #define LIGHT_ON HAL_GPIO_WritePin(light_GPIO_Port, light_Pin, GPIO_PIN_SET)
+
+// #define LIGHT_OFF HAL_GPIO_WritePin(light_GPIO_Port, light_Pin, GPIO_PIN_RESET)
+
+//#define RS485_RW(RW) HAL_GPIO_WritePin(RS485_RW_GPIO_Port, RS485_RW_Pin, RW)
 
 #define BLE_RSTN(STATE) HAL_GPIO_WritePin(BLE_RSTN_GPIO_Port, BLE_RSTN_Pin, STATE)
 
 #define HART_OCD() HAL_GPIO_ReadPin(HART_OCD_GPIO_Port, HART_OCD_Pin)
 
+#define HART_RESET(STATE) HAL_GPIO_WritePin(HART_RST_GPIO_Port, HART_RST_Pin, STATE)
+
 #define HART_RTS(SEND) HAL_GPIO_WritePin(HART_RTS_GPIO_Port, HART_RTS_Pin, SEND)
 
 #define HC138_SEL_CH(CH)                                                           \
     do                                                                             \
     {                                                                              \
-        HAL_GPIO_WritePin(HC138_E13_GPIO_Port, HC138_E13_Pin, GPIO_PIN_SET);       \
+        HAL_GPIO_WritePin(G1_GPIO_Port, G1_Pin, GPIO_PIN_SET);       \
         if (CH < 5)                                                                \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_SET);   \
         }                                                                          \
         else                                                                       \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A10_GPIO_Port, HC138_A10_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A11_GPIO_Port, HC138_A11_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A12_GPIO_Port, HC138_A12_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A0_GPIO_Port, INPUT_A0_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_GPIO_Port, INPUT_A2_Pin, GPIO_PIN_SET);   \
         }                                                                          \
         if (CH == 0)                                                               \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A10_GPIO_Port, HC138_A10_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A11_GPIO_Port, HC138_A11_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A12_GPIO_Port, HC138_A12_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A0_GPIO_Port, INPUT_A0_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_GPIO_Port, INPUT_A2_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 1)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A10_GPIO_Port, HC138_A10_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A11_GPIO_Port, HC138_A11_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A12_GPIO_Port, HC138_A12_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A0_GPIO_Port, INPUT_A0_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_GPIO_Port, INPUT_A2_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 2)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A10_GPIO_Port, HC138_A10_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A11_GPIO_Port, HC138_A11_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A12_GPIO_Port, HC138_A12_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A0_GPIO_Port, INPUT_A0_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_GPIO_Port, INPUT_A2_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 3)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A10_GPIO_Port, HC138_A10_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A11_GPIO_Port, HC138_A11_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A12_GPIO_Port, HC138_A12_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A0_GPIO_Port, INPUT_A0_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_GPIO_Port, INPUT_A2_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 4)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A10_GPIO_Port, HC138_A10_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A11_GPIO_Port, HC138_A11_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A12_GPIO_Port, HC138_A12_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(RLY_K1_GPIO_Port, RLY_K1_Pin, GPIO_PIN_SET);         \
-            HAL_GPIO_WritePin(RLY_K2_GPIO_Port, RLY_K2_Pin, GPIO_PIN_RESET);       \
-            HAL_GPIO_WritePin(RLY_K3_GPIO_Port, RLY_K3_Pin, GPIO_PIN_RESET);       \
+            HAL_GPIO_WritePin(INPUT_A0_GPIO_Port, INPUT_A0_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_GPIO_Port, INPUT_A2_Pin, GPIO_PIN_SET);   \
         }                                                                          \
         else if (CH == 5)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 6)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_RESET); \
-        }                                                                          \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_RESET); \
+        }                                                                            \
         else if (CH == 7)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 8)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_RESET); \
         }                                                                          \
         else if (CH == 9)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(RLY_K1_GPIO_Port, RLY_K1_Pin, GPIO_PIN_RESET);       \
-            HAL_GPIO_WritePin(RLY_K2_GPIO_Port, RLY_K2_Pin, GPIO_PIN_RESET);       \
-            HAL_GPIO_WritePin(RLY_K3_GPIO_Port, RLY_K3_Pin, GPIO_PIN_SET);         \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_RESET); \
         }                                                                          \
-        else if (CH == 10)                                                         \
+        else if (CH == 10)                                                          \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(RLY_K1_GPIO_Port, RLY_K1_Pin, GPIO_PIN_RESET);       \
-            HAL_GPIO_WritePin(RLY_K2_GPIO_Port, RLY_K2_Pin, GPIO_PIN_SET);         \
-            HAL_GPIO_WritePin(RLY_K3_GPIO_Port, RLY_K3_Pin, GPIO_PIN_RESET);       \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_SET);   \
         }                                                                          \
         else if (CH == 11)                                                         \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_RESET); \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_SET);   \
         }                                                                          \
         else if (CH == 12)                                                         \
         {                                                                          \
-            HAL_GPIO_WritePin(HC138_A20_GPIO_Port, HC138_A20_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A21_GPIO_Port, HC138_A21_Pin, GPIO_PIN_SET);   \
-            HAL_GPIO_WritePin(HC138_A22_GPIO_Port, HC138_A22_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_RESET); \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_SET);   \
         }                                                                          \
-        if (CH != 4 && CH != 9 && CH != 10)                                        \
+        else if (CH == 13)                                                         \
         {                                                                          \
-            HAL_GPIO_WritePin(RLY_K1_GPIO_Port, RLY_K1_Pin, GPIO_PIN_RESET);       \
-            HAL_GPIO_WritePin(RLY_K2_GPIO_Port, RLY_K2_Pin, GPIO_PIN_RESET);       \
-            HAL_GPIO_WritePin(RLY_K3_GPIO_Port, RLY_K3_Pin, GPIO_PIN_RESET);       \
+            HAL_GPIO_WritePin(INPUT_A0_1_GPIO_Port, INPUT_A0_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A1_1_GPIO_Port, INPUT_A1_1_Pin, GPIO_PIN_SET);   \
+            HAL_GPIO_WritePin(INPUT_A2_1_GPIO_Port, INPUT_A2_1_Pin, GPIO_PIN_SET);   \
         }                                                                          \
     } while (0)
 
 #define DAC8552_SYNC(SYNC) HAL_GPIO_WritePin(DAC8552_SYNC_GPIO_Port, DAC8552_SYNC_Pin, SYNC)
 
-#define RN7302_CS(CS) HAL_GPIO_WritePin(RN7302_CS_GPIO_Port, RN7302_CS_Pin, CS)
+//#define RN7302_CS(CS) HAL_GPIO_WritePin(RN7302_CS_GPIO_Port, RN7302_CS_Pin, CS)
 
 #define ADS1220_CS(CS) HAL_GPIO_WritePin(ADS1220_CS_GPIO_Port, ADS1220_CS_Pin, CS)
 
-#define DAC7811_CS(CS) HAL_GPIO_WritePin(DAC7811_CS_GPIO_Port, DAC7811_CS_Pin, CS)
+//#define DAC7811_CS(CS) HAL_GPIO_WritePin(DAC7811_CS_GPIO_Port, DAC7811_CS_Pin, CS)
 
-    /* USER CODE END Private defines */
+/* USER CODE END Private defines */
 
-    void MX_GPIO_Init(void);
+void MX_GPIO_Init(void);
 
-    /* USER CODE BEGIN Prototypes */
+/* USER CODE BEGIN Prototypes */
 
-    /* USER CODE END Prototypes */
+/* USER CODE END Prototypes */
 
 #ifdef __cplusplus
 }
 #endif
 #endif /*__ GPIO_H__ */
+

Core/Inc/i2c.h

@@ -34,11 +34,14 @@ extern "C" {
 
 extern I2C_HandleTypeDef hi2c1;
 
+extern I2C_HandleTypeDef hi2c3;
+
 /* USER CODE BEGIN Private defines */
 
 /* USER CODE END Private defines */
 
 void MX_I2C1_Init(void);
+void MX_I2C3_Init(void);
 
 /* USER CODE BEGIN Prototypes */
 

Core/Inc/main.h

@@ -58,49 +58,45 @@ void Error_Handler(void);
 
 /* Private defines -----------------------------------------------------------*/
 #define xx xx
-#define HC138_A22_Pin GPIO_PIN_2
-#define HC138_A22_GPIO_Port GPIOE
-#define HC138_A21_Pin GPIO_PIN_3
-#define HC138_A21_GPIO_Port GPIOE
-#define HC138_A20_Pin GPIO_PIN_4
-#define HC138_A20_GPIO_Port GPIOE
-#define ADS1220_CS_Pin GPIO_PIN_5
-#define ADS1220_CS_GPIO_Port GPIOE
+#define PWR_EN_Pin GPIO_PIN_2
+#define PWR_EN_GPIO_Port GPIOE
+#define PWR_IN_Pin GPIO_PIN_3
+#define PWR_IN_GPIO_Port GPIOE
 #define light_Pin GPIO_PIN_14
 #define light_GPIO_Port GPIOC
-#define RLY_K1_Pin GPIO_PIN_15
-#define RLY_K1_GPIO_Port GPIOC
-#define RLY_K2_Pin GPIO_PIN_0
-#define RLY_K2_GPIO_Port GPIOC
-#define DAC7811_CS_Pin GPIO_PIN_1
-#define DAC7811_CS_GPIO_Port GPIOC
-#define RN7302_MISO_Pin GPIO_PIN_2
-#define RN7302_MISO_GPIO_Port GPIOC
-#define RN7302_MOSI_Pin GPIO_PIN_3
-#define RN7302_MOSI_GPIO_Port GPIOC
-#define V30_BACK_Pin GPIO_PIN_0
-#define V30_BACK_GPIO_Port GPIOA
-#define TM1650_KP_Pin GPIO_PIN_1
-#define TM1650_KP_GPIO_Port GPIOA
-#define TM1650_KP_EXTI_IRQn EXTI1_IRQn
+#define BUZZER_Pin GPIO_PIN_0
+#define BUZZER_GPIO_Port GPIOC
+#define KEY_KP_Pin GPIO_PIN_1
+#define KEY_KP_GPIO_Port GPIOC
+#define KEY_KP_EXTI_IRQn EXTI1_IRQn
+#define EM_MISO_Pin GPIO_PIN_2
+#define EM_MISO_GPIO_Port GPIOC
+#define EM_MOSI_Pin GPIO_PIN_3
+#define EM_MOSI_GPIO_Port GPIOC
+#define ADS1220_DRDY_Pin GPIO_PIN_0
+#define ADS1220_DRDY_GPIO_Port GPIOA
+#define CV_ADC_Pin GPIO_PIN_1
+#define CV_ADC_GPIO_Port GPIOA
 #define RS485_TX_Pin GPIO_PIN_2
 #define RS485_TX_GPIO_Port GPIOA
 #define RS485_RX_Pin GPIO_PIN_3
 #define RS485_RX_GPIO_Port GPIOA
-#define DAC_36V_Pin GPIO_PIN_4
-#define DAC_36V_GPIO_Port GPIOA
+#define CV_DAC_Pin GPIO_PIN_4
+#define CV_DAC_GPIO_Port GPIOA
 #define ADS1220_SCK_Pin GPIO_PIN_5
 #define ADS1220_SCK_GPIO_Port GPIOA
 #define ADS1220_MISO_Pin GPIO_PIN_6
 #define ADS1220_MISO_GPIO_Port GPIOA
 #define ADS1220_MOSI_Pin GPIO_PIN_7
 #define ADS1220_MOSI_GPIO_Port GPIOA
-#define RLY_K3_Pin GPIO_PIN_4
-#define RLY_K3_GPIO_Port GPIOC
-#define PWM_OUT_Pin GPIO_PIN_0
-#define PWM_OUT_GPIO_Port GPIOB
+#define ADS1220_CS_Pin GPIO_PIN_4
+#define ADS1220_CS_GPIO_Port GPIOC
+#define INPUT_A2_1_Pin GPIO_PIN_5
+#define INPUT_A2_1_GPIO_Port GPIOC
 #define FREQ_IN_Pin GPIO_PIN_1
 #define FREQ_IN_GPIO_Port GPIOB
+#define INPUT_A1_1_Pin GPIO_PIN_2
+#define INPUT_A1_1_GPIO_Port GPIOB
 #define LCD_DB4_Pin GPIO_PIN_7
 #define LCD_DB4_GPIO_Port GPIOE
 #define LCD_DB5_Pin GPIO_PIN_8
@@ -109,18 +105,30 @@ void Error_Handler(void);
 #define LCD_DB6_GPIO_Port GPIOE
 #define LCD_DB7_Pin GPIO_PIN_10
 #define LCD_DB7_GPIO_Port GPIOE
-#define RN7302_RSTN_Pin GPIO_PIN_14
-#define RN7302_RSTN_GPIO_Port GPIOE
-#define RN7302_INTN_Pin GPIO_PIN_15
-#define RN7302_INTN_GPIO_Port GPIOE
-#define RN7302_CS_Pin GPIO_PIN_12
-#define RN7302_CS_GPIO_Port GPIOB
-#define RN7302_SCLK_Pin GPIO_PIN_13
-#define RN7302_SCLK_GPIO_Port GPIOB
-#define PWR_EN_Pin GPIO_PIN_14
-#define PWR_EN_GPIO_Port GPIOB
-#define PWR12_EN_Pin GPIO_PIN_9
-#define PWR12_EN_GPIO_Port GPIOD
+#define INPUT_A0_1_Pin GPIO_PIN_11
+#define INPUT_A0_1_GPIO_Port GPIOE
+#define INPUT_A2_Pin GPIO_PIN_12
+#define INPUT_A2_GPIO_Port GPIOE
+#define HART_4608_Pin GPIO_PIN_13
+#define HART_4608_GPIO_Port GPIOE
+#define INPUT_A1_Pin GPIO_PIN_14
+#define INPUT_A1_GPIO_Port GPIOE
+#define INPUT_A0_Pin GPIO_PIN_15
+#define INPUT_A0_GPIO_Port GPIOE
+#define CH340_TX_Pin GPIO_PIN_10
+#define CH340_TX_GPIO_Port GPIOB
+#define CH340_RX_Pin GPIO_PIN_11
+#define CH340_RX_GPIO_Port GPIOB
+#define EM_CS_Pin GPIO_PIN_12
+#define EM_CS_GPIO_Port GPIOB
+#define EM_SCLK_Pin GPIO_PIN_13
+#define EM_SCLK_GPIO_Port GPIOB
+#define G1_Pin GPIO_PIN_14
+#define G1_GPIO_Port GPIOB
+#define DAC7811_SYNC_Pin GPIO_PIN_15
+#define DAC7811_SYNC_GPIO_Port GPIOB
+#define DAC8552_SYNC_Pin GPIO_PIN_8
+#define DAC8552_SYNC_GPIO_Port GPIOD
 #define HART_RST_Pin GPIO_PIN_10
 #define HART_RST_GPIO_Port GPIOD
 #define HART_OCD_Pin GPIO_PIN_11
@@ -139,38 +147,50 @@ void Error_Handler(void);
 #define BLE_RX_GPIO_Port GPIOC
 #define BLE_RSTN_Pin GPIO_PIN_8
 #define BLE_RSTN_GPIO_Port GPIOC
+#define BAT_SDA_Pin GPIO_PIN_9
+#define BAT_SDA_GPIO_Port GPIOC
+#define BAT_SCL_Pin GPIO_PIN_8
+#define BAT_SCL_GPIO_Port GPIOA
 #define HART_TX_Pin GPIO_PIN_9
 #define HART_TX_GPIO_Port GPIOA
 #define HART_RX_Pin GPIO_PIN_10
 #define HART_RX_GPIO_Port GPIOA
-#define RS485_RW_Pin GPIO_PIN_11
-#define RS485_RW_GPIO_Port GPIOA
+#define TEMP_Pin GPIO_PIN_11
+#define TEMP_GPIO_Port GPIOA
 #define HART_RTS_Pin GPIO_PIN_12
 #define HART_RTS_GPIO_Port GPIOA
+#define DAC_CS_Pin GPIO_PIN_15
+#define DAC_CS_GPIO_Port GPIOA
+#define DAC_SCLK_Pin GPIO_PIN_10
+#define DAC_SCLK_GPIO_Port GPIOC
+#define DAC_MISO_Pin GPIO_PIN_11
+#define DAC_MISO_GPIO_Port GPIOC
+#define DAC_MOSI_Pin GPIO_PIN_12
+#define DAC_MOSI_GPIO_Port GPIOC
 #define LCD_DB2_Pin GPIO_PIN_0
 #define LCD_DB2_GPIO_Port GPIOD
 #define LCD_DB3_Pin GPIO_PIN_1
 #define LCD_DB3_GPIO_Port GPIOD
-#define DAC8552_SYNC_Pin GPIO_PIN_2
-#define DAC8552_SYNC_GPIO_Port GPIOD
-#define HC138_A10_Pin GPIO_PIN_3
-#define HC138_A10_GPIO_Port GPIOD
 #define LCD_RD_Pin GPIO_PIN_4
 #define LCD_RD_GPIO_Port GPIOD
 #define LCD_WR_Pin GPIO_PIN_5
 #define LCD_WR_GPIO_Port GPIOD
+#define EEPROM_WR_Pin GPIO_PIN_6
+#define EEPROM_WR_GPIO_Port GPIOD
 #define LCD_CS_Pin GPIO_PIN_7
 #define LCD_CS_GPIO_Port GPIOD
+#define EEPROM_SCLK_Pin GPIO_PIN_3
+#define EEPROM_SCLK_GPIO_Port GPIOB
+#define EEPROM_MISO_Pin GPIO_PIN_4
+#define EEPROM_MISO_GPIO_Port GPIOB
+#define EEPROM_MOSI_Pin GPIO_PIN_5
+#define EEPROM_MOSI_GPIO_Port GPIOB
 #define TM1650_SCL_Pin GPIO_PIN_6
 #define TM1650_SCL_GPIO_Port GPIOB
 #define TM1650_SDA_Pin GPIO_PIN_7
 #define TM1650_SDA_GPIO_Port GPIOB
-#define HC138_A11_Pin GPIO_PIN_8
-#define HC138_A11_GPIO_Port GPIOB
-#define HC138_A12_Pin GPIO_PIN_0
-#define HC138_A12_GPIO_Port GPIOE
-#define HC138_E13_Pin GPIO_PIN_1
-#define HC138_E13_GPIO_Port GPIOE
+#define EEPROM_CS_Pin GPIO_PIN_9
+#define EEPROM_CS_GPIO_Port GPIOB
 
 /* USER CODE BEGIN Private defines */
 

Core/Inc/stm32f4xx_hal_conf.h

@@ -96,7 +96,7 @@
   *        (when HSE is used as system clock source, directly or through the PLL).
   */
 #if !defined  (HSE_VALUE)
-  #define HSE_VALUE    8000000U /*!< Value of the External oscillator in Hz */
+  #define HSE_VALUE    11059200U /*!< Value of the External oscillator in Hz */
 #endif /* HSE_VALUE */
 
 #if !defined  (HSE_STARTUP_TIMEOUT)
@@ -214,7 +214,7 @@
 #define MAC_ADDR5   0U
 
 /* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                 /* buffer size for receive               */
+#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
 #define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
 #define ETH_RXBUFNB                    4U       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
 #define ETH_TXBUFNB                    4U       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */

Core/Inc/stm32f4xx_it.h

@@ -53,11 +53,22 @@ void BusFault_Handler(void);
 void UsageFault_Handler(void);
 void DebugMon_Handler(void);
 void EXTI1_IRQHandler(void);
+void DMA1_Stream5_IRQHandler(void);
+void DMA1_Stream6_IRQHandler(void);
+void TIM1_UP_TIM10_IRQHandler(void);
+void TIM2_IRQHandler(void);
 void TIM3_IRQHandler(void);
 void USART1_IRQHandler(void);
 void USART2_IRQHandler(void);
+void USART3_IRQHandler(void);
+void TIM8_UP_TIM13_IRQHandler(void);
+void TIM6_DAC_IRQHandler(void);
 void TIM7_IRQHandler(void);
 void DMA2_Stream0_IRQHandler(void);
+void DMA2_Stream1_IRQHandler(void);
+void DMA2_Stream2_IRQHandler(void);
+void DMA2_Stream6_IRQHandler(void);
+void DMA2_Stream7_IRQHandler(void);
 void USART6_IRQHandler(void);
 /* USER CODE BEGIN EFP */
 

Core/Inc/tim.h

@@ -29,32 +29,64 @@ extern "C" {
 #include "main.h"
 
 /* USER CODE BEGIN Includes */
-#define freq_operation(FREQ, PULSE)                                      \
+#define FREQ_SYS 82944000
+#define freq_operation(FREQ, PULSE, CHAN)                                \
   do                                                                     \
   {                                                                      \
-    if (FREQ <= 0 || FREQ >= 1000000 || PULSE <= 0 || PULSE >= 100)      \
+    HAL_TIMEx_PWMN_Stop(&htim1, TIM_CHANNEL_2);                          \
+    HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);                             \
+    if (FREQ <= 0 || FREQ >= 500000 || PULSE <= 0 || PULSE >= 100)       \
     {                                                                    \
-      HAL_TIMEx_PWMN_Stop(&htim1, TIM_CHANNEL_2);                        \
-      return;                                                            \
+      __HAL_TIM_SET_PRESCALER(&htim1, 1500-1);                           \
+      __HAL_TIM_SET_AUTORELOAD(&htim1, 55-1);                            \
+      __HAL_TIM_SET_COMPARE(&htim1, CHAN, 28-1);                         \
+      break;                                                             \
+    }                                                                    \
+    int fre_duty = 0;                                                    \
+    if( (0 < FREQ )&&(FREQ <= 650) )                                     \
+    {                                                                    \
+      __HAL_TIM_SET_PRESCALER(&htim1, 1500-1);                           \
+      fre_duty = ( (float32)FREQ_SYS / (float32)1500.0 / (float32)FREQ + (float32)0.5 );  \
+    }                                                                    \
+    else if(FREQ > 650)                                                  \
+    {                                                                    \
+      __HAL_TIM_SET_PRESCALER(&htim1, 2-1);                              \
+      fre_duty = ( (float32)FREQ_SYS / (float32)2.0 / (float32)FREQ + (float32)0.5 );     \
+    }                                                                    \
+    __HAL_TIM_SET_AUTORELOAD(&htim1, fre_duty -1);                       \
+    __HAL_TIM_SET_COMPARE(&htim1, CHAN, fre_duty *PULSE / 100 - 1);      \
+    if( CHAN == TIM_CHANNEL_2)                                           \
+    {                                                                    \
+      HAL_TIMEx_PWMN_Start(&htim1, CHAN);                                \
+    }                                                                    \
+    else                                                                 \
+    {                                                                    \
+      HAL_TIM_PWM_Start(&htim1, CHAN);                                   \
     }                                                                    \
-    uint16_t duty = 1000000 / FREQ - 1;                                  \
-    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, duty *PULSE / 100 - 1); \
-    __HAL_TIM_SET_AUTORELOAD(&htim1, duty);                              \
-    HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_2);                         \
   } while (0)
 
+
 /* USER CODE END Includes */
 
 extern TIM_HandleTypeDef htim1;
 
+extern TIM_HandleTypeDef htim2;
+
 extern TIM_HandleTypeDef htim3;
 
+extern TIM_HandleTypeDef htim6;
+
+extern TIM_HandleTypeDef htim8;
+
 /* USER CODE BEGIN Private defines */
 
 /* USER CODE END Private defines */
 
 void MX_TIM1_Init(void);
+void MX_TIM2_Init(void);
 void MX_TIM3_Init(void);
+void MX_TIM6_Init(void);
+void MX_TIM8_Init(void);
 
 void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
 

Core/Inc/usart.h

@@ -38,11 +38,15 @@ extern UART_HandleTypeDef huart1;
 
 extern UART_HandleTypeDef huart2;
 
+extern UART_HandleTypeDef huart3;
+
 extern UART_HandleTypeDef huart6;
 
 /* USER CODE BEGIN Private defines */
 
-#define BUFFER_SIZE 255
+#define RX_DMA_ENABLE 1
+
+#define BUFFER_SIZE 128
 
   typedef struct
   {
@@ -70,11 +74,13 @@ extern UART_HandleTypeDef huart6;
 
 void MX_USART1_UART_Init(void);
 void MX_USART2_UART_Init(void);
+void MX_USART3_UART_Init(void);
 void MX_USART6_UART_Init(void);
 
 /* USER CODE BEGIN Prototypes */
   void usart_printf(UART_HandleTypeDef *huart, char *fmt, ...);
   void proc_huart_it(UART_HandleTypeDef *huart);
+  void proc_huart_it_dma(UART_HandleTypeDef *huart);
 /* USER CODE END Prototypes */
 
 #ifdef __cplusplus

Core/Src/adc.c

@@ -52,8 +52,8 @@ void MX_ADC1_Init(void)
   hadc1.Instance = ADC1;
   hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;
   hadc1.Init.Resolution = ADC_RESOLUTION_12B;
-  hadc1.Init.ScanConvMode = ENABLE;
-  hadc1.Init.ContinuousConvMode = ENABLE;
+  hadc1.Init.ScanConvMode = DISABLE;
+  hadc1.Init.ContinuousConvMode = DISABLE;
   hadc1.Init.DiscontinuousConvMode = DISABLE;
   hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
   hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
@@ -68,7 +68,7 @@ void MX_ADC1_Init(void)
 
   /** Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
   */
-  sConfig.Channel = ADC_CHANNEL_0;
+  sConfig.Channel = ADC_CHANNEL_1;
   sConfig.Rank = 1;
   sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
@@ -95,12 +95,12 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
 
     __HAL_RCC_GPIOA_CLK_ENABLE();
     /**ADC1 GPIO Configuration
-    PA0-WKUP     ------> ADC1_IN0
+    PA1     ------> ADC1_IN1
     */
-    GPIO_InitStruct.Pin = V30_BACK_Pin;
+    GPIO_InitStruct.Pin = CV_ADC_Pin;
     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(V30_BACK_GPIO_Port, &GPIO_InitStruct);
+    HAL_GPIO_Init(CV_ADC_GPIO_Port, &GPIO_InitStruct);
 
     /* ADC1 DMA Init */
     /* ADC1 Init */
@@ -139,9 +139,9 @@ void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
     __HAL_RCC_ADC1_CLK_DISABLE();
 
     /**ADC1 GPIO Configuration
-    PA0-WKUP     ------> ADC1_IN0
+    PA1     ------> ADC1_IN1
     */
-    HAL_GPIO_DeInit(V30_BACK_GPIO_Port, V30_BACK_Pin);
+    HAL_GPIO_DeInit(CV_ADC_GPIO_Port, CV_ADC_Pin);
 
     /* ADC1 DMA DeInit */
     HAL_DMA_DeInit(adcHandle->DMA_Handle);

Core/Src/dac.c

@@ -78,11 +78,14 @@ void HAL_DAC_MspInit(DAC_HandleTypeDef* dacHandle)
     /**DAC GPIO Configuration
     PA4     ------> DAC_OUT1
     */
-    GPIO_InitStruct.Pin = DAC_36V_Pin;
+    GPIO_InitStruct.Pin = CV_DAC_Pin;
     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(DAC_36V_GPIO_Port, &GPIO_InitStruct);
+    HAL_GPIO_Init(CV_DAC_GPIO_Port, &GPIO_InitStruct);
 
+    /* DAC interrupt Init */
+    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
   /* USER CODE BEGIN DAC_MspInit 1 */
 
   /* USER CODE END DAC_MspInit 1 */
@@ -103,7 +106,16 @@ void HAL_DAC_MspDeInit(DAC_HandleTypeDef* dacHandle)
     /**DAC GPIO Configuration
     PA4     ------> DAC_OUT1
     */
-    HAL_GPIO_DeInit(DAC_36V_GPIO_Port, DAC_36V_Pin);
+    HAL_GPIO_DeInit(CV_DAC_GPIO_Port, CV_DAC_Pin);
+
+    /* DAC interrupt Deinit */
+  /* USER CODE BEGIN DAC:TIM6_DAC_IRQn disable */
+    /**
+    * Uncomment the line below to disable the "TIM6_DAC_IRQn" interrupt
+    * Be aware, disabling shared interrupt may affect other IPs
+    */
+    /* HAL_NVIC_DisableIRQ(TIM6_DAC_IRQn); */
+  /* USER CODE END DAC:TIM6_DAC_IRQn disable */
 
   /* USER CODE BEGIN DAC_MspDeInit 1 */
 

Core/Src/dma.c

@@ -7,7 +7,7 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2024 STMicroelectronics.
+  * Copyright (c) 2025 STMicroelectronics.
   * All rights reserved.
   *
   * This software is licensed under terms that can be found in the LICENSE file
@@ -41,11 +41,30 @@ void MX_DMA_Init(void)
 
   /* DMA controller clock enable */
   __HAL_RCC_DMA2_CLK_ENABLE();
+  __HAL_RCC_DMA1_CLK_ENABLE();
 
   /* DMA interrupt init */
+  /* DMA1_Stream5_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
+  /* DMA1_Stream6_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
   /* DMA2_Stream0_IRQn interrupt configuration */
   HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 5, 0);
   HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
+  /* DMA2_Stream1_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
+  /* DMA2_Stream2_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
+  /* DMA2_Stream6_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
+  /* DMA2_Stream7_IRQn interrupt configuration */
+  HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 5, 0);
+  HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
 
 }
 

Core/Src/freertos.c

@@ -25,18 +25,7 @@
 
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
-#include <string.h>
-#include "gpio.h"
-#include "JLX240-00301-BN.h"
-#include "modbus.h"
-#include "ble.h"
-#include "hart.h"
-#include "mux_signal.h"
-#include "rn7302.h"
-#include "SIG24130.h"
-
-#include "tm1650.h"
-
+#include "apps_gather.h"
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -56,7 +45,7 @@
 
 /* Private variables ---------------------------------------------------------*/
 /* USER CODE BEGIN Variables */
-
+uint8_t screen_suspend_flag = 0;
 /* USER CODE END Variables */
 osThreadId defaultTaskHandle;
 osThreadId task_lcdHandle;
@@ -64,7 +53,8 @@ osThreadId task_hartHandle;
 osThreadId task_bleHandle;
 osThreadId task_rs485Handle;
 osThreadId task_mux_analogHandle;
-osMessageQId myQueue01Handle;
+osThreadId task_menuHandle;
+osThreadId task_monitorHandle;
 
 /* Private function prototypes -----------------------------------------------*/
 /* USER CODE BEGIN FunctionPrototypes */
@@ -77,6 +67,8 @@ void start_task_hart(void const * argument);
 void start_task_ble(void const * argument);
 void start_rs485(void const * argument);
 void start_mux_analog(void const * argument);
+void start_menu(void const * argument);
+void start_task_monitor(void const * argument);
 
 void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */
 
@@ -118,40 +110,43 @@ void MX_FREERTOS_Init(void) {
   /* start timers, add new ones, ... */
   /* USER CODE END RTOS_TIMERS */
 
-  /* Create the queue(s) */
-  /* definition and creation of myQueue01 */
-  osMessageQDef(myQueue01, 16, uint16_t);
-  myQueue01Handle = osMessageCreate(osMessageQ(myQueue01), NULL);
-
   /* USER CODE BEGIN RTOS_QUEUES */
   /* add queues, ... */
   /* USER CODE END RTOS_QUEUES */
 
   /* Create the thread(s) */
   /* definition and creation of defaultTask */
-  osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
+  osThreadDef(defaultTask, StartDefaultTask, osPriorityIdle, 0, 128);
   defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
 
   /* definition and creation of task_lcd */
-  osThreadDef(task_lcd, start_task_lcd, osPriorityLow, 0, 256);
+  osThreadDef(task_lcd, start_task_lcd, osPriorityAboveNormal, 0, 768);
   task_lcdHandle = osThreadCreate(osThread(task_lcd), NULL);
 
   /* definition and creation of task_hart */
-  osThreadDef(task_hart, start_task_hart, osPriorityNormal, 0, 128);
+  osThreadDef(task_hart, start_task_hart, osPriorityHigh, 0, 256);
   task_hartHandle = osThreadCreate(osThread(task_hart), NULL);
 
   /* definition and creation of task_ble */
-  osThreadDef(task_ble, start_task_ble, osPriorityIdle, 0, 128);
+  osThreadDef(task_ble, start_task_ble, osPriorityBelowNormal, 0, 256);
   task_bleHandle = osThreadCreate(osThread(task_ble), NULL);
 
   /* definition and creation of task_rs485 */
-  osThreadDef(task_rs485, start_rs485, osPriorityIdle, 0, 128);
+  osThreadDef(task_rs485, start_rs485, osPriorityHigh, 0, 256);
   task_rs485Handle = osThreadCreate(osThread(task_rs485), NULL);
 
   /* definition and creation of task_mux_analog */
-  osThreadDef(task_mux_analog, start_mux_analog, osPriorityAboveNormal, 0, 128);
+  osThreadDef(task_mux_analog, start_mux_analog, osPriorityRealtime, 0, 128);
   task_mux_analogHandle = osThreadCreate(osThread(task_mux_analog), NULL);
 
+  /* definition and creation of task_menu */
+  osThreadDef(task_menu, start_menu, osPriorityNormal, 0, 512);
+  task_menuHandle = osThreadCreate(osThread(task_menu), NULL);
+
+  /* definition and creation of task_monitor */
+  osThreadDef(task_monitor, start_task_monitor, osPriorityIdle, 0, 128);
+  task_monitorHandle = osThreadCreate(osThread(task_monitor), NULL);
+
   /* USER CODE BEGIN RTOS_THREADS */
   /* add threads, ... */
   /* USER CODE END RTOS_THREADS */
@@ -168,13 +163,19 @@ void MX_FREERTOS_Init(void) {
 void StartDefaultTask(void const * argument)
 {
   /* USER CODE BEGIN StartDefaultTask */
+  uint8_t default_enable = 0;
+  system_sts.default_stack_consume_max = 0;
   /* Infinite loop */
   for (;;)
   {
-    LIGHT_PWR(OFF);
-    // pwr_cosume(kp_flag, 20000);
-    tm1650_read_key(&hi2c1, &kp_flag, COMMAND_READ_KEY_DATA, &key);
-    osDelay(500);
+
+    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);
+
+    osDelay(5000);
   }
   /* USER CODE END StartDefaultTask */
 }
@@ -189,12 +190,18 @@ void StartDefaultTask(void const * argument)
 void start_task_lcd(void const * argument)
 {
   /* USER CODE BEGIN start_task_lcd */
-  lcd_initial();
+  system_sts.lvgl_stack_consume_max = 0;
   /* Infinite loop */
   for (;;)
   {
-    lcd_menu();
-    osDelay(10);
+    //挂起自身
+    if( screen_suspend_flag == 1 ) vTaskSuspend(task_lcdHandle);
+
+	  lv_timer_handler();		//LVGL刷新任务
+
+    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);
   }
   /* USER CODE END start_task_lcd */
 }
@@ -205,15 +212,46 @@ void start_task_lcd(void const * argument)
  * @param argument: Not used
  * @retval None
  */
+uint8_t hart_test = 0;
+float32 fre_set_hart = 0;
 /* USER CODE END Header_start_task_hart */
 void start_task_hart(void const * argument)
 {
   /* USER CODE BEGIN start_task_hart */
+  system_sts.hart_stack_consume_max = 0;
   /* Infinite loop */
   for (;;)
   {
-    hart_communicate(&scom1_hart);
-    osDelay(10);
+    //该任务用于设置HART芯片所需频率、驱动验证
+    if(tabdata.hart_enable == 1)
+    {
+      if(fre_set_hart != 460800)
+      {
+        fre_set_hart = 460800;
+        frequence_output(fre_set_hart, 50, PWM_HART);
+      }
+
+      //驱动验证，DEVICE <--- HART ---> SIG
+      if(hart_test == 1)
+      {
+        hart_test = 0;
+
+        scom1_hart.tx_flag = TRUE;
+        hart_communicate(&scom1_hart);
+      }
+    }
+    else
+    {
+      if(fre_set_hart != 0)
+      {
+        fre_set_hart = 0;
+        frequence_output(fre_set_hart, 50, PWM_HART);
+      }
+    }
+   
+    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);
   }
   /* USER CODE END start_task_hart */
 }
@@ -224,16 +262,35 @@ void start_task_hart(void const * argument)
  * @param argument: Not used
  * @retval None
  */
+uint8_t ble_send_test = 0;
 /* USER CODE END Header_start_task_ble */
 void start_task_ble(void const * argument)
 {
   /* USER CODE BEGIN start_task_ble */
+  system_sts.ble_stack_consume_max = 0;
   /* Infinite loop */
   for (;;)
   {
-    strcpy((char *)(scom6_ble.tx_buff), "hellow I am ble.\r\n");
-    ble_send(&huart6, scom6_ble.tx_buff);
-    osDelay(1000);
+    //该任务用于蓝牙设备初始化、驱动验证
+    if( ble_init() == 1 )
+    {
+      if(tabdata.bluetooth_enable == 1)
+      {
+        if(ble_send_test == 1)
+        {
+          ble_send_test = 0;
+        
+          //驱动验证，DEVICE <--- BLUETOOTH ---> SIG
+          strcpy((char *)scom6_ble.tx_buff, "hellow I am ble.\r\n");
+          ble_send(&huart6, scom6_ble.tx_buff);
+        }
+
+      }
+    }
+
+    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);
   }
   /* USER CODE END start_task_ble */
 }
@@ -248,12 +305,22 @@ void start_task_ble(void const * argument)
 void start_rs485(void const * argument)
 {
   /* USER CODE BEGIN start_rs485 */
-  RS485_RW(RS485_RD); // rs485从机
+  system_sts.rs485_stack_consume_max = 0;
   /* Infinite loop */
   for (;;)
   {
-    parse_scom_485(&scom2_rs485);
-    osDelay(1);
+    //当前通讯状态的更新
+    if( !(tabdata.bluetooth_enable||tabdata.hart_enable||tabdata.modbus_enable) )
+    {
+      sig_trans = TRANS_NONE;
+    }
+
+    //更新modbus的寄存器值
+    modbus_registers_update();
+
+    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);
   }
   /* USER CODE END start_rs485 */
 }
@@ -264,22 +331,124 @@ void start_rs485(void const * argument)
  * @param argument: Not used
  * @retval None
  */
+uint8_t my_monitor_cnt = 0;
+lv_mem_monitor_t my_mon;
 /* USER CODE END Header_start_mux_analog */
 void start_mux_analog(void const * argument)
 {
   /* USER CODE BEGIN start_mux_analog */
-  // rn7302_Init();
-  SIG24130_Init();
+  SIG24130_Init();                        //多路输入输出初始化
+  system_sts.mux_stack_consume_max = 0;
   /* Infinite loop */
   for (;;)
   {
-    // get_rn7302_ch_value();
+    //编程输出过程，放在此处实时性更好
+    if(progout_data.process == PROGOUT_RUNNING)
+    {
+      switch (progout_data.output_mode)
+      {
+        case PROG_OUT_STEP:
+        {
+          running_process_step();
+        }
+        break;
+
+        case PROG_OUT_TRIANGLE:
+        {
+          running_process_triangle();
+        }
+        break;
+      
+        default:
+        break;
+      }
+    }
+
+    //按键扫描
+    tm1650_read_key(&hi2c1, &kp_flag, COMMAND_READ_KEY_DATA, &key);
+
+    //输出&输入通道切换
     mux_signal_switch(&mux_signal);
-    osDelay(50);
+    
+    //内存、内存碎片、CPU占用监控
+    my_monitor_cnt++;
+    if( my_monitor_cnt * MUX_TASK_PERIOD >= 200)
+    {
+      my_monitor_cnt = 0;
+
+      system_sts.cpu_consume = 100 - lv_timer_get_idle();
+
+      lv_mem_monitor(&my_mon);
+      system_sts.mem_consume = my_mon.used_pct;
+      system_sts.mem_frag = my_mon.frag_pct;
+      system_sts.mem_consume_max = (system_sts.mem_consume_max < system_sts.mem_consume)?(system_sts.mem_consume):(system_sts.mem_consume_max);
+    }
+
+    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);
   }
   /* USER CODE END start_mux_analog */
 }
 
+/* USER CODE BEGIN Header_start_menu */
+/**
+* @brief Function implementing the task_menu thread.
+* @param argument: Not used
+* @retval None
+*/
+/* USER CODE END Header_start_menu */
+void start_menu(void const * argument)
+{
+  /* USER CODE BEGIN start_menu */
+  screen_data_init();
+  system_sts.menu_stack_consume_max = 0;
+  /* Infinite loop */
+  for(;;)
+  {
+    //挂起自身
+    if( screen_suspend_flag == 1 ) vTaskSuspend(task_menuHandle);
+
+    screen_run();
+    
+    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);
+  }
+  /* USER CODE END start_menu */
+}
+
+/* USER CODE BEGIN Header_start_task_monitor */
+/**
+* @brief Function implementing the task_monitor thread.
+* @param argument: Not used
+* @retval None
+*/
+/* USER CODE END Header_start_task_monitor */
+void start_task_monitor(void const * argument)
+{
+  /* USER CODE BEGIN start_task_monitor */
+  uint8_t monitor_enable = 0;
+  system_sts.monitor_stack_consume_max = 0;
+  /* Infinite loop */
+  for(;;)
+  {
+    //串口打印当前各个任务的详细信息
+    //任务名  状态  优先级  空闲栈  任务号
+    //vTaskList(task_status);
+    //HAL_UART_Transmit(&huart3, (uint8_t *)task_status, 255, 0xFFFF);
+
+    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);
+
+    osDelay(3000);
+  }
+  /* USER CODE END start_task_monitor */
+}
+
 /* Private application code --------------------------------------------------*/
 /* USER CODE BEGIN Application */
 

Core/Src/gpio.c

@@ -53,54 +53,43 @@ void MX_GPIO_Init(void)
   __HAL_RCC_GPIOD_CLK_ENABLE();
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOE, HC138_A22_Pin|HC138_A21_Pin|HC138_A20_Pin|ADS1220_CS_Pin
-                          |LCD_DB4_Pin|LCD_DB5_Pin|LCD_DB6_Pin|LCD_DB7_Pin
-                          |HC138_A12_Pin|HC138_E13_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(GPIOE, PWR_EN_Pin|PWR_IN_Pin|LCD_DB4_Pin|LCD_DB5_Pin
+                          |LCD_DB6_Pin|LCD_DB7_Pin|INPUT_A0_1_Pin|INPUT_A2_Pin
+                          |INPUT_A0_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|light_Pin|RLY_K1_Pin|RLY_K2_Pin
-                          |RLY_K3_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(GPIOC, light_Pin|BUZZER_Pin|INPUT_A2_1_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOC, DAC7811_CS_Pin|BLE_RSTN_Pin, GPIO_PIN_SET);
+  HAL_GPIO_WritePin(GPIOC, ADS1220_CS_Pin|BLE_RSTN_Pin, GPIO_PIN_SET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(RN7302_RSTN_GPIO_Port, RN7302_RSTN_Pin, GPIO_PIN_SET);
+  HAL_GPIO_WritePin(GPIOB, INPUT_A1_1_Pin|EM_CS_Pin|G1_Pin|DAC7811_SYNC_Pin
+                          |EEPROM_SCLK_Pin|EEPROM_MOSI_Pin|EEPROM_CS_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOB, RN7302_CS_Pin|PWR_EN_Pin|HC138_A11_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(INPUT_A1_GPIO_Port, INPUT_A1_Pin, GPIO_PIN_SET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOD, PWR12_EN_Pin|LCD_RST_Pin|LCD_RS_Pin|LCD_DB0_Pin
-                          |LCD_DB1_Pin|LCD_DB2_Pin|LCD_DB3_Pin|HC138_A10_Pin
-                          |LCD_RD_Pin|LCD_WR_Pin|LCD_CS_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(GPIOD, DAC8552_SYNC_Pin|LCD_RST_Pin|LCD_RS_Pin|LCD_DB0_Pin
+                          |LCD_DB1_Pin|LCD_DB2_Pin|LCD_DB3_Pin|LCD_RD_Pin
+                          |LCD_WR_Pin|EEPROM_WR_Pin|LCD_CS_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOD, HART_RST_Pin|DAC8552_SYNC_Pin, GPIO_PIN_SET);
+  HAL_GPIO_WritePin(HART_RST_GPIO_Port, HART_RST_Pin, GPIO_PIN_SET);
 
   /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOA, RS485_RW_Pin|HART_RTS_Pin, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(GPIOA, TEMP_Pin|HART_RTS_Pin|DAC_CS_Pin, GPIO_PIN_RESET);
 
   /*Configure GPIO pins : PEPin PEPin PEPin PEPin
-                           PEPin PEPin PEPin PEPin
-                           PEPin PEPin PEPin */
-  GPIO_InitStruct.Pin = HC138_A22_Pin|HC138_A21_Pin|HC138_A20_Pin|ADS1220_CS_Pin
-                          |LCD_DB4_Pin|LCD_DB5_Pin|LCD_DB6_Pin|LCD_DB7_Pin
-                          |RN7302_RSTN_Pin|HC138_A12_Pin|HC138_E13_Pin;
+                           PEPin PEPin */
+  GPIO_InitStruct.Pin = PWR_EN_Pin|PWR_IN_Pin|INPUT_A0_1_Pin|INPUT_A2_Pin
+                          |INPUT_A1_Pin|INPUT_A0_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
-  /*Configure GPIO pins : PC13 PCPin PCPin PCPin
-                           PCPin PCPin */
-  GPIO_InitStruct.Pin = GPIO_PIN_13|RLY_K1_Pin|RLY_K2_Pin|DAC7811_CS_Pin
-                          |RLY_K3_Pin|BLE_RSTN_Pin;
-  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
-  GPIO_InitStruct.Pull = GPIO_NOPULL;
-  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
-
   /*Configure GPIO pin : PtPin */
   GPIO_InitStruct.Pin = light_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
@@ -108,35 +97,45 @@ void MX_GPIO_Init(void)
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(light_GPIO_Port, &GPIO_InitStruct);
 
+  /*Configure GPIO pins : PCPin PCPin PCPin PCPin */
+  GPIO_InitStruct.Pin = BUZZER_Pin|ADS1220_CS_Pin|INPUT_A2_1_Pin|BLE_RSTN_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
   /*Configure GPIO pin : PtPin */
-  GPIO_InitStruct.Pin = TM1650_KP_Pin;
+  GPIO_InitStruct.Pin = KEY_KP_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
-  HAL_GPIO_Init(TM1650_KP_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init(KEY_KP_GPIO_Port, &GPIO_InitStruct);
 
   /*Configure GPIO pin : PtPin */
-  GPIO_InitStruct.Pin = RN7302_INTN_Pin;
-  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
+  GPIO_InitStruct.Pin = ADS1220_DRDY_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
-  HAL_GPIO_Init(RN7302_INTN_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init(ADS1220_DRDY_GPIO_Port, &GPIO_InitStruct);
 
-  /*Configure GPIO pins : PBPin PBPin PBPin */
-  GPIO_InitStruct.Pin = RN7302_CS_Pin|PWR_EN_Pin|HC138_A11_Pin;
+  /*Configure GPIO pins : PBPin PBPin PBPin PBPin */
+  GPIO_InitStruct.Pin = INPUT_A1_1_Pin|EM_CS_Pin|G1_Pin|DAC7811_SYNC_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
-  /*Configure GPIO pins : PDPin PDPin PDPin PDPin
-                           PDPin PDPin PDPin PDPin
-                           PDPin PDPin PDPin */
-  GPIO_InitStruct.Pin = PWR12_EN_Pin|LCD_RST_Pin|LCD_RS_Pin|LCD_DB0_Pin
-                          |LCD_DB1_Pin|LCD_DB2_Pin|LCD_DB3_Pin|HC138_A10_Pin
-                          |LCD_RD_Pin|LCD_WR_Pin|LCD_CS_Pin;
+  /*Configure GPIO pins : PEPin PEPin PEPin PEPin */
+  GPIO_InitStruct.Pin = LCD_DB4_Pin|LCD_DB5_Pin|LCD_DB6_Pin|LCD_DB7_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
+
+  /*Configure GPIO pin : PtPin */
+  GPIO_InitStruct.Pin = DAC8552_SYNC_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_PULLUP;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+  HAL_GPIO_Init(DAC8552_SYNC_GPIO_Port, &GPIO_InitStruct);
 
   /*Configure GPIO pin : PtPin */
   GPIO_InitStruct.Pin = HART_RST_Pin;
@@ -151,12 +150,23 @@ void MX_GPIO_Init(void)
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   HAL_GPIO_Init(HART_OCD_GPIO_Port, &GPIO_InitStruct);
 
-  /*Configure GPIO pin : PtPin */
-  GPIO_InitStruct.Pin = RS485_RW_Pin;
+  /*Configure GPIO pins : PDPin PDPin PDPin PDPin
+                           PDPin PDPin PDPin PDPin
+                           PDPin */
+  GPIO_InitStruct.Pin = LCD_RST_Pin|LCD_RS_Pin|LCD_DB0_Pin|LCD_DB1_Pin
+                          |LCD_DB2_Pin|LCD_DB3_Pin|LCD_RD_Pin|LCD_WR_Pin
+                          |LCD_CS_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+
+  /*Configure GPIO pins : PAPin PAPin */
+  GPIO_InitStruct.Pin = TEMP_Pin|DAC_CS_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init(RS485_RW_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
   /*Configure GPIO pin : PtPin */
   GPIO_InitStruct.Pin = HART_RTS_Pin;
@@ -166,11 +176,24 @@ void MX_GPIO_Init(void)
   HAL_GPIO_Init(HART_RTS_GPIO_Port, &GPIO_InitStruct);
 
   /*Configure GPIO pin : PtPin */
-  GPIO_InitStruct.Pin = DAC8552_SYNC_Pin;
+  GPIO_InitStruct.Pin = EEPROM_WR_Pin;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
-  GPIO_InitStruct.Pull = GPIO_PULLUP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
-  HAL_GPIO_Init(DAC8552_SYNC_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_Init(EEPROM_WR_GPIO_Port, &GPIO_InitStruct);
+
+  /*Configure GPIO pins : PBPin PBPin PBPin */
+  GPIO_InitStruct.Pin = EEPROM_SCLK_Pin|EEPROM_MOSI_Pin|EEPROM_CS_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+  /*Configure GPIO pin : PtPin */
+  GPIO_InitStruct.Pin = EEPROM_MISO_Pin;
+  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+  GPIO_InitStruct.Pull = GPIO_PULLUP;
+  HAL_GPIO_Init(EEPROM_MISO_GPIO_Port, &GPIO_InitStruct);
 
   /* EXTI interrupt init*/
   HAL_NVIC_SetPriority(EXTI1_IRQn, 5, 0);

Core/Src/i2c.c

@@ -25,6 +25,7 @@
 /* USER CODE END 0 */
 
 I2C_HandleTypeDef hi2c1;
+I2C_HandleTypeDef hi2c3;
 
 /* I2C1 init function */
 void MX_I2C1_Init(void)
@@ -54,6 +55,35 @@ void MX_I2C1_Init(void)
 
   /* USER CODE END I2C1_Init 2 */
 
+}
+/* I2C3 init function */
+void MX_I2C3_Init(void)
+{
+
+  /* USER CODE BEGIN I2C3_Init 0 */
+
+  /* USER CODE END I2C3_Init 0 */
+
+  /* USER CODE BEGIN I2C3_Init 1 */
+
+  /* USER CODE END I2C3_Init 1 */
+  hi2c3.Instance = I2C3;
+  hi2c3.Init.ClockSpeed = 100000;
+  hi2c3.Init.DutyCycle = I2C_DUTYCYCLE_2;
+  hi2c3.Init.OwnAddress1 = 0;
+  hi2c3.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
+  hi2c3.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
+  hi2c3.Init.OwnAddress2 = 0;
+  hi2c3.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
+  hi2c3.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
+  if (HAL_I2C_Init(&hi2c3) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN I2C3_Init 2 */
+
+  /* USER CODE END I2C3_Init 2 */
+
 }
 
 void HAL_I2C_MspInit(I2C_HandleTypeDef* i2cHandle)
@@ -84,6 +114,38 @@ void HAL_I2C_MspInit(I2C_HandleTypeDef* i2cHandle)
 
   /* USER CODE END I2C1_MspInit 1 */
   }
+  else if(i2cHandle->Instance==I2C3)
+  {
+  /* USER CODE BEGIN I2C3_MspInit 0 */
+
+  /* USER CODE END I2C3_MspInit 0 */
+
+    __HAL_RCC_GPIOC_CLK_ENABLE();
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+    /**I2C3 GPIO Configuration
+    PC9     ------> I2C3_SDA
+    PA8     ------> I2C3_SCL
+    */
+    GPIO_InitStruct.Pin = BAT_SDA_Pin;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF4_I2C3;
+    HAL_GPIO_Init(BAT_SDA_GPIO_Port, &GPIO_InitStruct);
+
+    GPIO_InitStruct.Pin = BAT_SCL_Pin;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF4_I2C3;
+    HAL_GPIO_Init(BAT_SCL_GPIO_Port, &GPIO_InitStruct);
+
+    /* I2C3 clock enable */
+    __HAL_RCC_I2C3_CLK_ENABLE();
+  /* USER CODE BEGIN I2C3_MspInit 1 */
+
+  /* USER CODE END I2C3_MspInit 1 */
+  }
 }
 
 void HAL_I2C_MspDeInit(I2C_HandleTypeDef* i2cHandle)
@@ -109,6 +171,26 @@ void HAL_I2C_MspDeInit(I2C_HandleTypeDef* i2cHandle)
 
   /* USER CODE END I2C1_MspDeInit 1 */
   }
+  else if(i2cHandle->Instance==I2C3)
+  {
+  /* USER CODE BEGIN I2C3_MspDeInit 0 */
+
+  /* USER CODE END I2C3_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_I2C3_CLK_DISABLE();
+
+    /**I2C3 GPIO Configuration
+    PC9     ------> I2C3_SDA
+    PA8     ------> I2C3_SCL
+    */
+    HAL_GPIO_DeInit(BAT_SDA_GPIO_Port, BAT_SDA_Pin);
+
+    HAL_GPIO_DeInit(BAT_SCL_GPIO_Port, BAT_SCL_Pin);
+
+  /* USER CODE BEGIN I2C3_MspDeInit 1 */
+
+  /* USER CODE END I2C3_MspDeInit 1 */
+  }
 }
 
 /* USER CODE BEGIN 1 */

Core/Src/main.c

@@ -30,8 +30,7 @@
 
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
-#include "tm1650.h"
-#include "mux_signal.h"
+#include "apps_gather.h"
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -52,7 +51,7 @@
 /* Private variables ---------------------------------------------------------*/
 
 /* USER CODE BEGIN PV */
-
+lv_ui  guider_ui;                      // 声明 lvgl界面对象
 /* USER CODE END PV */
 
 /* Private function prototypes -----------------------------------------------*/
@@ -73,6 +72,7 @@ void MX_FREERTOS_Init(void);
   */
 int main(void)
 {
+
   /* USER CODE BEGIN 1 */
 
   /* USER CODE END 1 */
@@ -107,17 +107,35 @@ int main(void)
   MX_TIM1_Init();
   MX_TIM3_Init();
   MX_ADC1_Init();
+  MX_TIM6_Init();
+  MX_USART3_UART_Init();
+  MX_I2C3_Init();
+  MX_TIM2_Init();
+  MX_TIM8_Init();
   /* USER CODE BEGIN 2 */
-  tm1650_init(&hi2c1);
+
+  my_inits_gather();
+
+  HAL_TIM_Base_Start_IT(&htim2);
+  HAL_TIM_Base_Start_IT(&htim6);
+  HAL_TIM_Base_Start_IT(&htim8);
+  
+  #if RX_DMA_ENABLE
+  HAL_UART_Receive_DMA(&huart1, scom1_hart.rx_buff, BUFFER_SIZE);
+  HAL_UART_Receive_DMA(&huart2, scom2_rs485.rx_buff, BUFFER_SIZE);
+  HAL_UART_Receive_DMA(&huart6, scom6_ble.rx_buff, BUFFER_SIZE);
+  #endif
+
   /* USER CODE END 2 */
 
-  /* Call init function for freertos objects (in freertos.c) */
+  /* Call init function for freertos objects (in cmsis_os2.c) */
   MX_FREERTOS_Init();
 
   /* Start scheduler */
   osKernelStart();
 
   /* We should never get here as control is now taken by the scheduler */
+
   /* Infinite loop */
   /* USER CODE BEGIN WHILE */
   while (1)
@@ -148,7 +166,12 @@ void SystemClock_Config(void)
   */
   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
-  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
+  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
+  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
+  RCC_OscInitStruct.PLL.PLLM = 10;
+  RCC_OscInitStruct.PLL.PLLN = 300;
+  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
+  RCC_OscInitStruct.PLL.PLLQ = 4;
   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
   {
     Error_Handler();
@@ -158,19 +181,19 @@ void SystemClock_Config(void)
   */
   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
-  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
-  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
-  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
-  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
+  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
+  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2;
+  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
+  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
 
-  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
+  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
   {
     Error_Handler();
   }
 }
 
 /* USER CODE BEGIN 4 */
-
+int tim8_test_cnt = 0;
 /* USER CODE END 4 */
 
 /**
@@ -192,8 +215,34 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   /* USER CODE BEGIN Callback 1 */
   if (htim->Instance == TIM3)
   {
-    freq_signal.over_cnt++;
+    duty_tim3();
   }
+  if (htim->Instance == TIM6)
+  {
+    duty_tim6();
+  }
+  if (htim->Instance == TIM8)
+  {
+    tim8_test_cnt++;
+  }
+
+  if (htim->Instance == TIM2)
+  {
+    if(sig_trans == TRANS_NONE)
+    {
+      //无通讯的情况下直接返回
+      return;
+    }
+
+    HAL_TIM_Base_Stop(&htim2);
+
+    //数据传输
+    transparent_tim();
+
+    __HAL_TIM_SET_COUNTER(&htim2, 0);
+    HAL_TIM_Base_Start(&htim2);
+  }
+
   /* USER CODE END Callback 1 */
 }
 

Core/Src/spi.c

@@ -46,7 +46,7 @@ void MX_SPI1_Init(void)
   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
   hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
   hspi1.Init.NSS = SPI_NSS_SOFT;
-  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
+  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
@@ -78,7 +78,7 @@ void MX_SPI2_Init(void)
   hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
   hspi2.Init.CLKPhase = SPI_PHASE_2EDGE;
   hspi2.Init.NSS = SPI_NSS_SOFT;
-  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
+  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
   hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
   hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
   hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
@@ -169,19 +169,19 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
     PC3     ------> SPI2_MOSI
     PB13     ------> SPI2_SCK
     */
-    GPIO_InitStruct.Pin = RN7302_MISO_Pin|RN7302_MOSI_Pin;
+    GPIO_InitStruct.Pin = EM_MISO_Pin|EM_MOSI_Pin;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
-    GPIO_InitStruct.Pin = RN7302_SCLK_Pin;
+    GPIO_InitStruct.Pin = EM_SCLK_Pin;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
-    HAL_GPIO_Init(RN7302_SCLK_GPIO_Port, &GPIO_InitStruct);
+    HAL_GPIO_Init(EM_SCLK_GPIO_Port, &GPIO_InitStruct);
 
   /* USER CODE BEGIN SPI2_MspInit 1 */
 
@@ -201,7 +201,7 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
     PC11     ------> SPI3_MISO
     PC12     ------> SPI3_MOSI
     */
-    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
+    GPIO_InitStruct.Pin = DAC_SCLK_Pin|DAC_MISO_Pin|DAC_MOSI_Pin;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_NOPULL;
     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@@ -249,9 +249,9 @@ void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle)
     PC3     ------> SPI2_MOSI
     PB13     ------> SPI2_SCK
     */
-    HAL_GPIO_DeInit(GPIOC, RN7302_MISO_Pin|RN7302_MOSI_Pin);
+    HAL_GPIO_DeInit(GPIOC, EM_MISO_Pin|EM_MOSI_Pin);
 
-    HAL_GPIO_DeInit(RN7302_SCLK_GPIO_Port, RN7302_SCLK_Pin);
+    HAL_GPIO_DeInit(EM_SCLK_GPIO_Port, EM_SCLK_Pin);
 
   /* USER CODE BEGIN SPI2_MspDeInit 1 */
 
@@ -270,7 +270,7 @@ void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle)
     PC11     ------> SPI3_MISO
     PC12     ------> SPI3_MOSI
     */
-    HAL_GPIO_DeInit(GPIOC, GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12);
+    HAL_GPIO_DeInit(GPIOC, DAC_SCLK_Pin|DAC_MISO_Pin|DAC_MOSI_Pin);
 
   /* USER CODE BEGIN SPI3_MspDeInit 1 */
 

Core/Src/stm32f4xx_hal_msp.c

@@ -1,3 +1,4 @@
+
 /* USER CODE BEGIN Header */
 /**
   ******************************************************************************
@@ -20,7 +21,6 @@
 
 /* Includes ------------------------------------------------------------------*/
 #include "main.h"
-
 /* USER CODE BEGIN Includes */
 
 /* USER CODE END Includes */
@@ -63,6 +63,7 @@
   */
 void HAL_MspInit(void)
 {
+
   /* USER CODE BEGIN MspInit 0 */
 
   /* USER CODE END MspInit 0 */

Core/Src/stm32f4xx_hal_timebase_tim.c

@@ -49,10 +49,8 @@ HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
 
   /* Enable TIM7 clock */
   __HAL_RCC_TIM7_CLK_ENABLE();
-
   /* Get clock configuration */
   HAL_RCC_GetClockConfig(&clkconfig, &pFLatency);
-
   /* Get APB1 prescaler */
   uwAPB1Prescaler = clkconfig.APB1CLKDivider;
   /* Compute TIM7 clock */

Core/Src/stm32f4xx_it.c

@@ -22,7 +22,7 @@
 #include "stm32f4xx_it.h"
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
-#include "usart.h"
+#include "apps_gather.h"
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -57,9 +57,21 @@
 
 /* External variables --------------------------------------------------------*/
 extern DMA_HandleTypeDef hdma_adc1;
+extern DAC_HandleTypeDef hdac;
+extern TIM_HandleTypeDef htim1;
+extern TIM_HandleTypeDef htim2;
 extern TIM_HandleTypeDef htim3;
+extern TIM_HandleTypeDef htim6;
+extern TIM_HandleTypeDef htim8;
+extern DMA_HandleTypeDef hdma_usart1_tx;
+extern DMA_HandleTypeDef hdma_usart1_rx;
+extern DMA_HandleTypeDef hdma_usart2_tx;
+extern DMA_HandleTypeDef hdma_usart2_rx;
+extern DMA_HandleTypeDef hdma_usart6_tx;
+extern DMA_HandleTypeDef hdma_usart6_rx;
 extern UART_HandleTypeDef huart1;
 extern UART_HandleTypeDef huart2;
+extern UART_HandleTypeDef huart3;
 extern UART_HandleTypeDef huart6;
 extern TIM_HandleTypeDef htim7;
 
@@ -173,12 +185,68 @@ void EXTI1_IRQHandler(void)
   /* USER CODE BEGIN EXTI1_IRQn 0 */
 
   /* USER CODE END EXTI1_IRQn 0 */
-  HAL_GPIO_EXTI_IRQHandler(TM1650_KP_Pin);
+  HAL_GPIO_EXTI_IRQHandler(KEY_KP_Pin);
   /* USER CODE BEGIN EXTI1_IRQn 1 */
 
   /* USER CODE END EXTI1_IRQn 1 */
 }
 
+/**
+  * @brief This function handles DMA1 stream5 global interrupt.
+  */
+void DMA1_Stream5_IRQHandler(void)
+{
+  /* USER CODE BEGIN DMA1_Stream5_IRQn 0 */
+
+  /* USER CODE END DMA1_Stream5_IRQn 0 */
+  HAL_DMA_IRQHandler(&hdma_usart2_rx);
+  /* USER CODE BEGIN DMA1_Stream5_IRQn 1 */
+
+  /* USER CODE END DMA1_Stream5_IRQn 1 */
+}
+
+/**
+  * @brief This function handles DMA1 stream6 global interrupt.
+  */
+void DMA1_Stream6_IRQHandler(void)
+{
+  /* USER CODE BEGIN DMA1_Stream6_IRQn 0 */
+
+  /* USER CODE END DMA1_Stream6_IRQn 0 */
+  HAL_DMA_IRQHandler(&hdma_usart2_tx);
+  /* USER CODE BEGIN DMA1_Stream6_IRQn 1 */
+  
+  /* USER CODE END DMA1_Stream6_IRQn 1 */
+}
+
+/**
+  * @brief This function handles TIM1 update interrupt and TIM10 global interrupt.
+  */
+void TIM1_UP_TIM10_IRQHandler(void)
+{
+  /* USER CODE BEGIN TIM1_UP_TIM10_IRQn 0 */
+
+  /* USER CODE END TIM1_UP_TIM10_IRQn 0 */
+  HAL_TIM_IRQHandler(&htim1);
+  /* USER CODE BEGIN TIM1_UP_TIM10_IRQn 1 */
+
+  /* USER CODE END TIM1_UP_TIM10_IRQn 1 */
+}
+
+/**
+  * @brief This function handles TIM2 global interrupt.
+  */
+void TIM2_IRQHandler(void)
+{
+  /* USER CODE BEGIN TIM2_IRQn 0 */
+
+  /* USER CODE END TIM2_IRQn 0 */
+  HAL_TIM_IRQHandler(&htim2);
+  /* USER CODE BEGIN TIM2_IRQn 1 */
+
+  /* USER CODE END TIM2_IRQn 1 */
+}
+
 /**
   * @brief This function handles TIM3 global interrupt.
   */
@@ -203,7 +271,13 @@ void USART1_IRQHandler(void)
   /* USER CODE END USART1_IRQn 0 */
   HAL_UART_IRQHandler(&huart1);
   /* USER CODE BEGIN USART1_IRQn 1 */
-  proc_huart_it(&huart1);
+
+  #if RX_DMA_ENABLE
+    proc_huart_it_dma(&huart1);
+  #else
+    proc_huart_it(&huart1);
+  #endif
+
   /* USER CODE END USART1_IRQn 1 */
 }
 
@@ -217,10 +291,59 @@ void USART2_IRQHandler(void)
   /* USER CODE END USART2_IRQn 0 */
   HAL_UART_IRQHandler(&huart2);
   /* USER CODE BEGIN USART2_IRQn 1 */
-  proc_huart_it(&huart2);
+ 
+  #if RX_DMA_ENABLE
+    proc_huart_it_dma(&huart2);
+  #else
+    proc_huart_it(&huart2);
+  #endif
+
   /* USER CODE END USART2_IRQn 1 */
 }
 
+/**
+  * @brief This function handles USART3 global interrupt.
+  */
+void USART3_IRQHandler(void)
+{
+  /* USER CODE BEGIN USART3_IRQn 0 */
+
+  /* USER CODE END USART3_IRQn 0 */
+  HAL_UART_IRQHandler(&huart3);
+  /* USER CODE BEGIN USART3_IRQn 1 */
+
+  /* USER CODE END USART3_IRQn 1 */
+}
+
+/**
+  * @brief This function handles TIM8 update interrupt and TIM13 global interrupt.
+  */
+void TIM8_UP_TIM13_IRQHandler(void)
+{
+  /* USER CODE BEGIN TIM8_UP_TIM13_IRQn 0 */
+
+  /* USER CODE END TIM8_UP_TIM13_IRQn 0 */
+  HAL_TIM_IRQHandler(&htim8);
+  /* USER CODE BEGIN TIM8_UP_TIM13_IRQn 1 */
+
+  /* USER CODE END TIM8_UP_TIM13_IRQn 1 */
+}
+
+/**
+  * @brief This function handles TIM6 global interrupt, DAC1 and DAC2 underrun error interrupts.
+  */
+void TIM6_DAC_IRQHandler(void)
+{
+  /* USER CODE BEGIN TIM6_DAC_IRQn 0 */
+
+  /* USER CODE END TIM6_DAC_IRQn 0 */
+  HAL_DAC_IRQHandler(&hdac);
+  HAL_TIM_IRQHandler(&htim6);
+  /* USER CODE BEGIN TIM6_DAC_IRQn 1 */
+
+  /* USER CODE END TIM6_DAC_IRQn 1 */
+}
+
 /**
   * @brief This function handles TIM7 global interrupt.
   */
@@ -249,6 +372,62 @@ void DMA2_Stream0_IRQHandler(void)
   /* USER CODE END DMA2_Stream0_IRQn 1 */
 }
 
+/**
+  * @brief This function handles DMA2 stream1 global interrupt.
+  */
+void DMA2_Stream1_IRQHandler(void)
+{
+  /* USER CODE BEGIN DMA2_Stream1_IRQn 0 */
+
+  /* USER CODE END DMA2_Stream1_IRQn 0 */
+  HAL_DMA_IRQHandler(&hdma_usart6_rx);
+  /* USER CODE BEGIN DMA2_Stream1_IRQn 1 */
+
+  /* USER CODE END DMA2_Stream1_IRQn 1 */
+}
+
+/**
+  * @brief This function handles DMA2 stream2 global interrupt.
+  */
+void DMA2_Stream2_IRQHandler(void)
+{
+  /* USER CODE BEGIN DMA2_Stream2_IRQn 0 */
+
+  /* USER CODE END DMA2_Stream2_IRQn 0 */
+  HAL_DMA_IRQHandler(&hdma_usart1_rx);
+  /* USER CODE BEGIN DMA2_Stream2_IRQn 1 */
+
+  /* USER CODE END DMA2_Stream2_IRQn 1 */
+}
+
+/**
+  * @brief This function handles DMA2 stream6 global interrupt.
+  */
+void DMA2_Stream6_IRQHandler(void)
+{
+  /* USER CODE BEGIN DMA2_Stream6_IRQn 0 */
+
+  /* USER CODE END DMA2_Stream6_IRQn 0 */
+  HAL_DMA_IRQHandler(&hdma_usart6_tx);
+  /* USER CODE BEGIN DMA2_Stream6_IRQn 1 */
+
+  /* USER CODE END DMA2_Stream6_IRQn 1 */
+}
+
+/**
+  * @brief This function handles DMA2 stream7 global interrupt.
+  */
+void DMA2_Stream7_IRQHandler(void)
+{
+  /* USER CODE BEGIN DMA2_Stream7_IRQn 0 */
+
+  /* USER CODE END DMA2_Stream7_IRQn 0 */
+  HAL_DMA_IRQHandler(&hdma_usart1_tx);
+  /* USER CODE BEGIN DMA2_Stream7_IRQn 1 */
+
+  /* USER CODE END DMA2_Stream7_IRQn 1 */
+}
+
 /**
   * @brief This function handles USART6 global interrupt.
   */
@@ -259,7 +438,13 @@ void USART6_IRQHandler(void)
   /* USER CODE END USART6_IRQn 0 */
   HAL_UART_IRQHandler(&huart6);
   /* USER CODE BEGIN USART6_IRQn 1 */
-  proc_huart_it(&huart6);
+  
+  #if RX_DMA_ENABLE
+    proc_huart_it_dma(&huart6);
+  #else
+    proc_huart_it(&huart6);
+  #endif
+
   /* USER CODE END USART6_IRQn 1 */
 }
 

Core/Src/tim.c

@@ -25,7 +25,10 @@
 /* USER CODE END 0 */
 
 TIM_HandleTypeDef htim1;
+TIM_HandleTypeDef htim2;
 TIM_HandleTypeDef htim3;
+TIM_HandleTypeDef htim6;
+TIM_HandleTypeDef htim8;
 
 /* TIM1 init function */
 void MX_TIM1_Init(void)
@@ -44,9 +47,9 @@ void MX_TIM1_Init(void)
 
   /* USER CODE END TIM1_Init 1 */
   htim1.Instance = TIM1;
-  htim1.Init.Prescaler = 8-1;
+  htim1.Init.Prescaler = 1500-1;
   htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
-  htim1.Init.Period = 1000-1;
+  htim1.Init.Period = 55-1;
   htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   htim1.Init.RepetitionCounter = 0;
   htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
@@ -70,13 +73,13 @@ void MX_TIM1_Init(void)
     Error_Handler();
   }
   sConfigOC.OCMode = TIM_OCMODE_PWM1;
-  sConfigOC.Pulse = 500;
+  sConfigOC.Pulse = 28-1;
   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
   sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
   sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
   sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
   sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
-  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
+  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
   {
     Error_Handler();
   }
@@ -96,6 +99,46 @@ void MX_TIM1_Init(void)
   /* USER CODE END TIM1_Init 2 */
   HAL_TIM_MspPostInit(&htim1);
 
+}
+/* TIM2 init function */
+void MX_TIM2_Init(void)
+{
+
+  /* USER CODE BEGIN TIM2_Init 0 */
+
+  /* USER CODE END TIM2_Init 0 */
+
+  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
+  TIM_MasterConfigTypeDef sMasterConfig = {0};
+
+  /* USER CODE BEGIN TIM2_Init 1 */
+
+  /* USER CODE END TIM2_Init 1 */
+  htim2.Instance = TIM2;
+  htim2.Init.Prescaler = 2-1;
+  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
+  htim2.Init.Period = 41472-1;
+  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
+  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
+  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN TIM2_Init 2 */
+
+  /* USER CODE END TIM2_Init 2 */
+
 }
 /* TIM3 init function */
 void MX_TIM3_Init(void)
@@ -113,9 +156,9 @@ void MX_TIM3_Init(void)
 
   /* USER CODE END TIM3_Init 1 */
   htim3.Instance = TIM3;
-  htim3.Init.Prescaler = 8-1;
+  htim3.Init.Prescaler = 0;
   htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
-  htim3.Init.Period = 60000-1;
+  htim3.Init.Period = 65535;
   htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
   htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
   if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
@@ -149,6 +192,109 @@ void MX_TIM3_Init(void)
 
   /* USER CODE END TIM3_Init 2 */
 
+}
+/* TIM6 init function */
+void MX_TIM6_Init(void)
+{
+
+  /* USER CODE BEGIN TIM6_Init 0 */
+
+  /* USER CODE END TIM6_Init 0 */
+
+  TIM_MasterConfigTypeDef sMasterConfig = {0};
+
+  /* USER CODE BEGIN TIM6_Init 1 */
+
+  /* USER CODE END TIM6_Init 1 */
+  htim6.Instance = TIM6;
+  htim6.Init.Prescaler = 2-1;
+  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
+  htim6.Init.Period = 41472-1;
+  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
+  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
+  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN TIM6_Init 2 */
+
+  /* USER CODE END TIM6_Init 2 */
+
+}
+/* TIM8 init function */
+void MX_TIM8_Init(void)
+{
+
+  /* USER CODE BEGIN TIM8_Init 0 */
+
+  /* USER CODE END TIM8_Init 0 */
+
+  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
+  TIM_MasterConfigTypeDef sMasterConfig = {0};
+  TIM_OC_InitTypeDef sConfigOC = {0};
+  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
+
+  /* USER CODE BEGIN TIM8_Init 1 */
+
+  /* USER CODE END TIM8_Init 1 */
+  htim8.Instance = TIM8;
+  htim8.Init.Prescaler = 1500-1;
+  htim8.Init.CounterMode = TIM_COUNTERMODE_UP;
+  htim8.Init.Period = 55-1;
+  htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+  htim8.Init.RepetitionCounter = 0;
+  htim8.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
+  if (HAL_TIM_Base_Init(&htim8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
+  if (HAL_TIM_ConfigClockSource(&htim8, &sClockSourceConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  if (HAL_TIM_PWM_Init(&htim8) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
+  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+  if (HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sConfigOC.OCMode = TIM_OCMODE_PWM1;
+  sConfigOC.Pulse = 28-1;
+  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
+  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
+  sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
+  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
+  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
+  if (HAL_TIM_PWM_ConfigChannel(&htim8, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
+  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
+  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
+  sBreakDeadTimeConfig.DeadTime = 0;
+  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
+  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
+  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
+  if (HAL_TIMEx_ConfigBreakDeadTime(&htim8, &sBreakDeadTimeConfig) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN TIM8_Init 2 */
+
+  /* USER CODE END TIM8_Init 2 */
+  HAL_TIM_MspPostInit(&htim8);
+
 }
 
 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
@@ -162,10 +308,29 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
   /* USER CODE END TIM1_MspInit 0 */
     /* TIM1 clock enable */
     __HAL_RCC_TIM1_CLK_ENABLE();
+
+    /* TIM1 interrupt Init */
+    HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
   /* USER CODE BEGIN TIM1_MspInit 1 */
 
   /* USER CODE END TIM1_MspInit 1 */
   }
+  else if(tim_baseHandle->Instance==TIM2)
+  {
+  /* USER CODE BEGIN TIM2_MspInit 0 */
+
+  /* USER CODE END TIM2_MspInit 0 */
+    /* TIM2 clock enable */
+    __HAL_RCC_TIM2_CLK_ENABLE();
+
+    /* TIM2 interrupt Init */
+    HAL_NVIC_SetPriority(TIM2_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(TIM2_IRQn);
+  /* USER CODE BEGIN TIM2_MspInit 1 */
+
+  /* USER CODE END TIM2_MspInit 1 */
+  }
   else if(tim_baseHandle->Instance==TIM3)
   {
   /* USER CODE BEGIN TIM3_MspInit 0 */
@@ -192,6 +357,36 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
 
   /* USER CODE END TIM3_MspInit 1 */
   }
+  else if(tim_baseHandle->Instance==TIM6)
+  {
+  /* USER CODE BEGIN TIM6_MspInit 0 */
+
+  /* USER CODE END TIM6_MspInit 0 */
+    /* TIM6 clock enable */
+    __HAL_RCC_TIM6_CLK_ENABLE();
+
+    /* TIM6 interrupt Init */
+    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
+  /* USER CODE BEGIN TIM6_MspInit 1 */
+
+  /* USER CODE END TIM6_MspInit 1 */
+  }
+  else if(tim_baseHandle->Instance==TIM8)
+  {
+  /* USER CODE BEGIN TIM8_MspInit 0 */
+
+  /* USER CODE END TIM8_MspInit 0 */
+    /* TIM8 clock enable */
+    __HAL_RCC_TIM8_CLK_ENABLE();
+
+    /* TIM8 interrupt Init */
+    HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
+  /* USER CODE BEGIN TIM8_MspInit 1 */
+
+  /* USER CODE END TIM8_MspInit 1 */
+  }
 }
 void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
 {
@@ -202,22 +397,42 @@ void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
   /* USER CODE BEGIN TIM1_MspPostInit 0 */
 
   /* USER CODE END TIM1_MspPostInit 0 */
-
-    __HAL_RCC_GPIOB_CLK_ENABLE();
+    __HAL_RCC_GPIOE_CLK_ENABLE();
     /**TIM1 GPIO Configuration
-    PB0     ------> TIM1_CH2N
+    PE13     ------> TIM1_CH3
     */
-    GPIO_InitStruct.Pin = PWM_OUT_Pin;
+    GPIO_InitStruct.Pin = HART_4608_Pin;
     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull = GPIO_PULLUP;
     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
     GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
-    HAL_GPIO_Init(PWM_OUT_GPIO_Port, &GPIO_InitStruct);
+    HAL_GPIO_Init(HART_4608_GPIO_Port, &GPIO_InitStruct);
 
   /* USER CODE BEGIN TIM1_MspPostInit 1 */
 
   /* USER CODE END TIM1_MspPostInit 1 */
   }
+  else if(timHandle->Instance==TIM8)
+  {
+  /* USER CODE BEGIN TIM8_MspPostInit 0 */
+
+  /* USER CODE END TIM8_MspPostInit 0 */
+
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    /**TIM8 GPIO Configuration
+    PB0     ------> TIM8_CH2N
+    */
+    GPIO_InitStruct.Pin = GPIO_PIN_0;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    GPIO_InitStruct.Alternate = GPIO_AF3_TIM8;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+  /* USER CODE BEGIN TIM8_MspPostInit 1 */
+
+  /* USER CODE END TIM8_MspPostInit 1 */
+  }
 
 }
 
@@ -231,10 +446,27 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
   /* USER CODE END TIM1_MspDeInit 0 */
     /* Peripheral clock disable */
     __HAL_RCC_TIM1_CLK_DISABLE();
+
+    /* TIM1 interrupt Deinit */
+    HAL_NVIC_DisableIRQ(TIM1_UP_TIM10_IRQn);
   /* USER CODE BEGIN TIM1_MspDeInit 1 */
 
   /* USER CODE END TIM1_MspDeInit 1 */
   }
+  else if(tim_baseHandle->Instance==TIM2)
+  {
+  /* USER CODE BEGIN TIM2_MspDeInit 0 */
+
+  /* USER CODE END TIM2_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_TIM2_CLK_DISABLE();
+
+    /* TIM2 interrupt Deinit */
+    HAL_NVIC_DisableIRQ(TIM2_IRQn);
+  /* USER CODE BEGIN TIM2_MspDeInit 1 */
+
+  /* USER CODE END TIM2_MspDeInit 1 */
+  }
   else if(tim_baseHandle->Instance==TIM3)
   {
   /* USER CODE BEGIN TIM3_MspDeInit 0 */
@@ -254,6 +486,41 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
 
   /* USER CODE END TIM3_MspDeInit 1 */
   }
+  else if(tim_baseHandle->Instance==TIM6)
+  {
+  /* USER CODE BEGIN TIM6_MspDeInit 0 */
+
+  /* USER CODE END TIM6_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_TIM6_CLK_DISABLE();
+
+    /* TIM6 interrupt Deinit */
+  /* USER CODE BEGIN TIM6:TIM6_DAC_IRQn disable */
+    /**
+    * Uncomment the line below to disable the "TIM6_DAC_IRQn" interrupt
+    * Be aware, disabling shared interrupt may affect other IPs
+    */
+    /* HAL_NVIC_DisableIRQ(TIM6_DAC_IRQn); */
+  /* USER CODE END TIM6:TIM6_DAC_IRQn disable */
+
+  /* USER CODE BEGIN TIM6_MspDeInit 1 */
+
+  /* USER CODE END TIM6_MspDeInit 1 */
+  }
+  else if(tim_baseHandle->Instance==TIM8)
+  {
+  /* USER CODE BEGIN TIM8_MspDeInit 0 */
+
+  /* USER CODE END TIM8_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_TIM8_CLK_DISABLE();
+
+    /* TIM8 interrupt Deinit */
+    HAL_NVIC_DisableIRQ(TIM8_UP_TIM13_IRQn);
+  /* USER CODE BEGIN TIM8_MspDeInit 1 */
+
+  /* USER CODE END TIM8_MspDeInit 1 */
+  }
 }
 
 /* USER CODE BEGIN 1 */

Core/Src/usart.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
+#include "apps_gather.h"
 
 /**
  ******************************************************************************
@@ -41,7 +42,14 @@ st_scom scom6_ble;
 
 UART_HandleTypeDef huart1;
 UART_HandleTypeDef huart2;
+UART_HandleTypeDef huart3;
 UART_HandleTypeDef huart6;
+DMA_HandleTypeDef hdma_usart1_tx;
+DMA_HandleTypeDef hdma_usart1_rx;
+DMA_HandleTypeDef hdma_usart2_tx;
+DMA_HandleTypeDef hdma_usart2_rx;
+DMA_HandleTypeDef hdma_usart6_tx;
+DMA_HandleTypeDef hdma_usart6_rx;
 
 /* USART1 init function */
 
@@ -86,7 +94,7 @@ void MX_USART2_UART_Init(void)
 
   /* USER CODE END USART2_Init 1 */
   huart2.Instance = USART2;
-  huart2.Init.BaudRate = 9600;
+  huart2.Init.BaudRate = 115200;
   huart2.Init.WordLength = UART_WORDLENGTH_8B;
   huart2.Init.StopBits = UART_STOPBITS_1;
   huart2.Init.Parity = UART_PARITY_NONE;
@@ -102,6 +110,35 @@ void MX_USART2_UART_Init(void)
   __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
   /* USER CODE END USART2_Init 2 */
 
+}
+/* USART3 init function */
+
+void MX_USART3_UART_Init(void)
+{
+
+  /* USER CODE BEGIN USART3_Init 0 */
+
+  /* USER CODE END USART3_Init 0 */
+
+  /* USER CODE BEGIN USART3_Init 1 */
+
+  /* USER CODE END USART3_Init 1 */
+  huart3.Instance = USART3;
+  huart3.Init.BaudRate = 115200;
+  huart3.Init.WordLength = UART_WORDLENGTH_8B;
+  huart3.Init.StopBits = UART_STOPBITS_1;
+  huart3.Init.Parity = UART_PARITY_NONE;
+  huart3.Init.Mode = UART_MODE_TX_RX;
+  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
+  if (HAL_UART_Init(&huart3) != HAL_OK)
+  {
+    Error_Handler();
+  }
+  /* USER CODE BEGIN USART3_Init 2 */
+
+  /* USER CODE END USART3_Init 2 */
+
 }
 /* USART6 init function */
 
@@ -158,6 +195,43 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
+    /* USART1 DMA Init */
+    /* USART1_TX Init */
+    hdma_usart1_tx.Instance = DMA2_Stream7;
+    hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4;
+    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
+    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_usart1_tx.Init.Mode = DMA_NORMAL;
+    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
+    hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);
+
+    /* USART1_RX Init */
+    hdma_usart1_rx.Instance = DMA2_Stream2;
+    hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
+    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
+    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_usart1_rx.Init.Mode = DMA_NORMAL;
+    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
+    hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);
+
     /* USART1 interrupt Init */
     HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
     HAL_NVIC_EnableIRQ(USART1_IRQn);
@@ -185,6 +259,43 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
+    /* USART2 DMA Init */
+    /* USART2_TX Init */
+    hdma_usart2_tx.Instance = DMA1_Stream6;
+    hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;
+    hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
+    hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_usart2_tx.Init.Mode = DMA_NORMAL;
+    hdma_usart2_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
+    hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx);
+
+    /* USART2_RX Init */
+    hdma_usart2_rx.Instance = DMA1_Stream5;
+    hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
+    hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
+    hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_usart2_rx.Init.Mode = DMA_NORMAL;
+    hdma_usart2_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
+    hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx);
+
     /* USART2 interrupt Init */
     HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
     HAL_NVIC_EnableIRQ(USART2_IRQn);
@@ -192,6 +303,33 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
 
   /* USER CODE END USART2_MspInit 1 */
   }
+  else if(uartHandle->Instance==USART3)
+  {
+  /* USER CODE BEGIN USART3_MspInit 0 */
+
+  /* USER CODE END USART3_MspInit 0 */
+    /* USART3 clock enable */
+    __HAL_RCC_USART3_CLK_ENABLE();
+
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    /**USART3 GPIO Configuration
+    PB10     ------> USART3_TX
+    PB11     ------> USART3_RX
+    */
+    GPIO_InitStruct.Pin = CH340_TX_Pin|CH340_RX_Pin;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+    /* USART3 interrupt Init */
+    HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(USART3_IRQn);
+  /* USER CODE BEGIN USART3_MspInit 1 */
+
+  /* USER CODE END USART3_MspInit 1 */
+  }
   else if(uartHandle->Instance==USART6)
   {
   /* USER CODE BEGIN USART6_MspInit 0 */
@@ -212,6 +350,43 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
     GPIO_InitStruct.Alternate = GPIO_AF8_USART6;
     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
+    /* USART6 DMA Init */
+    /* USART6_TX Init */
+    hdma_usart6_tx.Instance = DMA2_Stream6;
+    hdma_usart6_tx.Init.Channel = DMA_CHANNEL_5;
+    hdma_usart6_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
+    hdma_usart6_tx.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_usart6_tx.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_usart6_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_usart6_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_usart6_tx.Init.Mode = DMA_NORMAL;
+    hdma_usart6_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
+    hdma_usart6_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    if (HAL_DMA_Init(&hdma_usart6_tx) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart6_tx);
+
+    /* USART6_RX Init */
+    hdma_usart6_rx.Instance = DMA2_Stream1;
+    hdma_usart6_rx.Init.Channel = DMA_CHANNEL_5;
+    hdma_usart6_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
+    hdma_usart6_rx.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_usart6_rx.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_usart6_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_usart6_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_usart6_rx.Init.Mode = DMA_NORMAL;
+    hdma_usart6_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
+    hdma_usart6_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    if (HAL_DMA_Init(&hdma_usart6_rx) != HAL_OK)
+    {
+      Error_Handler();
+    }
+
+    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart6_rx);
+
     /* USART6 interrupt Init */
     HAL_NVIC_SetPriority(USART6_IRQn, 5, 0);
     HAL_NVIC_EnableIRQ(USART6_IRQn);
@@ -238,6 +413,10 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
     */
     HAL_GPIO_DeInit(GPIOA, HART_TX_Pin|HART_RX_Pin);
 
+    /* USART1 DMA DeInit */
+    HAL_DMA_DeInit(uartHandle->hdmatx);
+    HAL_DMA_DeInit(uartHandle->hdmarx);
+
     /* USART1 interrupt Deinit */
     HAL_NVIC_DisableIRQ(USART1_IRQn);
   /* USER CODE BEGIN USART1_MspDeInit 1 */
@@ -258,12 +437,36 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
     */
     HAL_GPIO_DeInit(GPIOA, RS485_TX_Pin|RS485_RX_Pin);
 
+    /* USART2 DMA DeInit */
+    HAL_DMA_DeInit(uartHandle->hdmatx);
+    HAL_DMA_DeInit(uartHandle->hdmarx);
+
     /* USART2 interrupt Deinit */
     HAL_NVIC_DisableIRQ(USART2_IRQn);
   /* USER CODE BEGIN USART2_MspDeInit 1 */
 
   /* USER CODE END USART2_MspDeInit 1 */
   }
+  else if(uartHandle->Instance==USART3)
+  {
+  /* USER CODE BEGIN USART3_MspDeInit 0 */
+
+  /* USER CODE END USART3_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_USART3_CLK_DISABLE();
+
+    /**USART3 GPIO Configuration
+    PB10     ------> USART3_TX
+    PB11     ------> USART3_RX
+    */
+    HAL_GPIO_DeInit(GPIOB, CH340_TX_Pin|CH340_RX_Pin);
+
+    /* USART3 interrupt Deinit */
+    HAL_NVIC_DisableIRQ(USART3_IRQn);
+  /* USER CODE BEGIN USART3_MspDeInit 1 */
+
+  /* USER CODE END USART3_MspDeInit 1 */
+  }
   else if(uartHandle->Instance==USART6)
   {
   /* USER CODE BEGIN USART6_MspDeInit 0 */
@@ -278,6 +481,10 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
     */
     HAL_GPIO_DeInit(GPIOC, BLE_TX_Pin|BLE_RX_Pin);
 
+    /* USART6 DMA DeInit */
+    HAL_DMA_DeInit(uartHandle->hdmatx);
+    HAL_DMA_DeInit(uartHandle->hdmarx);
+
     /* USART6 interrupt Deinit */
     HAL_NVIC_DisableIRQ(USART6_IRQn);
   /* USER CODE BEGIN USART6_MspDeInit 1 */
@@ -306,34 +513,130 @@ void usart_printf(UART_HandleTypeDef *huart, char *fmt, ...)
   HAL_UART_Transmit(huart, (uint8_t *)tx_buff, length, 0xFFFF);
 }
 
+//不使用DMA，每接收到一帧都能产生中断，靠空闲中断判断接收结束
+//未避免丢失空闲中断，接收到数据后需要将显示任务挂起
+//该函数位于中断回调函数之后
 void proc_huart_it(UART_HandleTypeDef *huart)
-{
-  st_scom *scom;
-
-  if (huart == &huart1)
-    scom = &scom1_hart;
-  else if (huart == &huart2)
-    scom = &scom2_rs485;
-  else if (huart == &huart6)
-    scom = &scom6_ble;
-
-  if (!scom)
+{ 
+  //不对发送中断进行处理
+  if(st_flag == TRANSPARENT_TRANSMIT_END)
+  {
+    st_flag = TRANSPARENT_WAIT;
     return;
+  }
+
+  //端口选择
+  st_scom *scom;
+  if(huart == &huart1) scom = &scom1_hart;
+  if(huart == &huart6) scom = &scom6_ble;
+  if(huart == &huart2) scom = &scom2_rs485;
+  if( !scom ) return;
+
+  //对应功能是否使能
+  if(trans_enable_check(scom) == 0)
+  {
+    scom->rx_len = 0;
+    memset(scom->rx_buff, 0, BUFFER_SIZE);
+
+    sig_trans = TRANS_NONE;
+    __HAL_UART_CLEAR_IDLEFLAG(huart);
+    HAL_UART_DMAStop(huart);
+    HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
+
+    return;
+  }
+
+  //进入此处说明接收到数据，并且对应通道使能
+
+  //显示任务挂起
+  screen_suspend_flag = 1;
+
+  //记录起始时刻
+  if(st_flag == TRANSPARENT_WAIT)
+  {
+    st_flag = TRANSPARENT_RECIEVE_START;
+    tick_start = xTaskGetTickCountFromISR();
+  }
 
   if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET)
   {
     if (scom->rx_len >= BUFFER_SIZE - 1)
       scom->rx_len = 0;
 
+    //将接收到的数据逐个存入数组
     scom->rx_buff[scom->rx_len++] = (uint8_t)(huart->Instance->DR & 0xff);
 
     __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
+
   }
   if (__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE) != RESET)
   {
+    //接收结束
     scom->rx_flag = TRUE;
 
+    //记录中间时刻
+    st_flag = TRANSPARENT_RECIEVE_FINISHED;
+    tick_middle = xTaskGetTickCountFromISR();
+
     __HAL_UART_CLEAR_IDLEFLAG(huart);
+    
+  }
+}
+
+//DMA接收
+//DMA接收只有半满中断、空闲中断和完成（溢出）中断，能够使用的只有空闲中断，因此起始时刻在定时器tim2中尝试捕获
+//DMA绕过CPU，因此可以不用挂起显示任务
+void proc_huart_it_dma(UART_HandleTypeDef *huart)
+{
+  //不对发送中断进行处理
+  if(st_flag == TRANSPARENT_TRANSMIT_END)
+  {
+    st_flag = TRANSPARENT_WAIT;
+    return;
+  }
+
+  //端口选择
+  st_scom *scom;
+  if(huart == &huart1) scom = &scom1_hart;
+  if(huart == &huart6) scom = &scom6_ble;
+  if(huart == &huart2) scom = &scom2_rs485;
+  if( !scom ) return;
+
+  //对应功能是否使能
+  if(trans_enable_check(scom) == 0)
+  {
+    scom->rx_len = 0;
+    memset(scom->rx_buff, 0, BUFFER_SIZE);
+
+    sig_trans = TRANS_NONE;
+    __HAL_UART_CLEAR_IDLEFLAG(huart);
+    HAL_UART_DMAStop(huart);
+    HAL_UART_Receive_DMA(huart, scom->rx_buff, BUFFER_SIZE);
+
+    return;
+  }
+
+  //进入此处说明DMA接收已经完成
+  if (__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE) != RESET)
+  {
+    __HAL_UART_CLEAR_IDLEFLAG(huart);
+
+    HAL_UART_DMAStop(huart);
+
+    //计算接收到的数据长度
+    scom->rx_len = BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart->hdmarx);
+    if( ( 0 < scom->rx_len )&&( scom->rx_len <= BUFFER_SIZE ) )
+    {
+      scom->rx_flag = TRUE;
+    }
+    else
+    {
+      memset(scom->rx_buff, 0, BUFFER_SIZE);
+      scom->rx_len = 0;
+    }
+
+    st_flag = TRANSPARENT_RECIEVE_FINISHED; 
+    //tick_middle = xTaskGetTickCountFromISR();
   }
 }
 /* USER CODE END 1 */

Drivers/CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h

@@ -3,16 +3,16 @@
   * @file    stm32f4xx.h
   * @author  MCD Application Team
   * @brief   CMSIS STM32F4xx Device Peripheral Access Layer Header File.
-  *            
+  *
   *          The file is the unique include file that the application programmer
   *          is using in the C source code, usually in main.c. This file contains:
   *           - Configuration section that allows to select:
   *              - The STM32F4xx device used in the target application
-  *              - To use or not the peripheral's drivers in application code(i.e. 
-  *                code will be based on direct access to peripheral's registers 
-  *                rather than drivers API), this option is controlled by 
+  *              - To use or not the peripheral's drivers in application code(i.e.
+  *                code will be based on direct access to peripheral's registers
+  *                rather than drivers API), this option is controlled by
   *                "#define USE_HAL_DRIVER"
-  *  
+  *
   ******************************************************************************
   * @attention
   *
@@ -33,18 +33,18 @@
 /** @addtogroup stm32f4xx
   * @{
   */
-    
+
 #ifndef __STM32F4xx_H
 #define __STM32F4xx_H
 
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif /* __cplusplus */
-   
+
 /** @addtogroup Library_configuration_section
   * @{
   */
-  
+
 /**
   * @brief STM32 Family
   */
@@ -53,7 +53,7 @@
 #endif /* STM32F4 */
 
 /* Uncomment the line below according to the target STM32 device used in your
-   application 
+   application
   */
 #if !defined (STM32F405xx) && !defined (STM32F415xx) && !defined (STM32F407xx) && !defined (STM32F417xx) && \
     !defined (STM32F427xx) && !defined (STM32F437xx) && !defined (STM32F429xx) && !defined (STM32F439xx) && \
@@ -61,55 +61,55 @@
     !defined (STM32F410Rx) && !defined (STM32F411xE) && !defined (STM32F446xx) && !defined (STM32F469xx) && \
     !defined (STM32F479xx) && !defined (STM32F412Cx) && !defined (STM32F412Rx) && !defined (STM32F412Vx) && \
     !defined (STM32F412Zx) && !defined (STM32F413xx) && !defined (STM32F423xx)
-  /* #define STM32F405xx */   /*!< STM32F405RG, STM32F405VG and STM32F405ZG Devices */
-  /* #define STM32F415xx */   /*!< STM32F415RG, STM32F415VG and STM32F415ZG Devices */
-  /* #define STM32F407xx */   /*!< STM32F407VG, STM32F407VE, STM32F407ZG, STM32F407ZE, STM32F407IG  and STM32F407IE Devices */
-  /* #define STM32F417xx */   /*!< STM32F417VG, STM32F417VE, STM32F417ZG, STM32F417ZE, STM32F417IG and STM32F417IE Devices */
-  /* #define STM32F427xx */   /*!< STM32F427VG, STM32F427VI, STM32F427ZG, STM32F427ZI, STM32F427IG and STM32F427II Devices */
-  /* #define STM32F437xx */   /*!< STM32F437VG, STM32F437VI, STM32F437ZG, STM32F437ZI, STM32F437IG and STM32F437II Devices */
-  /* #define STM32F429xx */   /*!< STM32F429VG, STM32F429VI, STM32F429ZG, STM32F429ZI, STM32F429BG, STM32F429BI, STM32F429NG, 
-                                   STM32F439NI, STM32F429IG  and STM32F429II Devices */
-  /* #define STM32F439xx */   /*!< STM32F439VG, STM32F439VI, STM32F439ZG, STM32F439ZI, STM32F439BG, STM32F439BI, STM32F439NG, 
-                                   STM32F439NI, STM32F439IG and STM32F439II Devices */
-  /* #define STM32F401xC */   /*!< STM32F401CB, STM32F401CC, STM32F401RB, STM32F401RC, STM32F401VB and STM32F401VC Devices */
-  /* #define STM32F401xE */   /*!< STM32F401CD, STM32F401RD, STM32F401VD, STM32F401CE, STM32F401RE and STM32F401VE Devices */
-  /* #define STM32F410Tx */   /*!< STM32F410T8 and STM32F410TB Devices */
-  /* #define STM32F410Cx */   /*!< STM32F410C8 and STM32F410CB Devices */
-  /* #define STM32F410Rx */   /*!< STM32F410R8 and STM32F410RB Devices */
-  /* #define STM32F411xE */   /*!< STM32F411CC, STM32F411RC, STM32F411VC, STM32F411CE, STM32F411RE and STM32F411VE Devices */
-  /* #define STM32F446xx */   /*!< STM32F446MC, STM32F446ME, STM32F446RC, STM32F446RE, STM32F446VC, STM32F446VE, STM32F446ZC, 
-                                   and STM32F446ZE Devices */
-  /* #define STM32F469xx */   /*!< STM32F469AI, STM32F469II, STM32F469BI, STM32F469NI, STM32F469AG, STM32F469IG, STM32F469BG, 
-                                   STM32F469NG, STM32F469AE, STM32F469IE, STM32F469BE and STM32F469NE Devices */
-  /* #define STM32F479xx */   /*!< STM32F479AI, STM32F479II, STM32F479BI, STM32F479NI, STM32F479AG, STM32F479IG, STM32F479BG 
-                                   and STM32F479NG Devices */
-  /* #define STM32F412Cx */   /*!< STM32F412CEU and STM32F412CGU Devices */
-  /* #define STM32F412Zx */   /*!< STM32F412ZET, STM32F412ZGT, STM32F412ZEJ and STM32F412ZGJ Devices */
-  /* #define STM32F412Vx */   /*!< STM32F412VET, STM32F412VGT, STM32F412VEH and STM32F412VGH Devices */
-  /* #define STM32F412Rx */   /*!< STM32F412RET, STM32F412RGT, STM32F412REY and STM32F412RGY Devices */
-  /* #define STM32F413xx */   /*!< STM32F413CH, STM32F413MH, STM32F413RH, STM32F413VH, STM32F413ZH, STM32F413CG, STM32F413MG,
-                                   STM32F413RG, STM32F413VG and STM32F413ZG Devices */
-  /* #define STM32F423xx */   /*!< STM32F423CH, STM32F423RH, STM32F423VH and STM32F423ZH Devices */
+/* #define STM32F405xx */   /*!< STM32F405RG, STM32F405VG and STM32F405ZG Devices */
+/* #define STM32F415xx */   /*!< STM32F415RG, STM32F415VG and STM32F415ZG Devices */
+/* #define STM32F407xx */   /*!< STM32F407VG, STM32F407VE, STM32F407ZG, STM32F407ZE, STM32F407IG  and STM32F407IE Devices */
+/* #define STM32F417xx */   /*!< STM32F417VG, STM32F417VE, STM32F417ZG, STM32F417ZE, STM32F417IG and STM32F417IE Devices */
+/* #define STM32F427xx */   /*!< STM32F427VG, STM32F427VI, STM32F427ZG, STM32F427ZI, STM32F427IG and STM32F427II Devices */
+/* #define STM32F437xx */   /*!< STM32F437VG, STM32F437VI, STM32F437ZG, STM32F437ZI, STM32F437IG and STM32F437II Devices */
+/* #define STM32F429xx */   /*!< STM32F429VG, STM32F429VI, STM32F429ZG, STM32F429ZI, STM32F429BG, STM32F429BI, STM32F429NG,
+                                 STM32F439NI, STM32F429IG  and STM32F429II Devices */
+/* #define STM32F439xx */   /*!< STM32F439VG, STM32F439VI, STM32F439ZG, STM32F439ZI, STM32F439BG, STM32F439BI, STM32F439NG,
+                                 STM32F439NI, STM32F439IG and STM32F439II Devices */
+/* #define STM32F401xC */   /*!< STM32F401CB, STM32F401CC, STM32F401RB, STM32F401RC, STM32F401VB and STM32F401VC Devices */
+/* #define STM32F401xE */   /*!< STM32F401CD, STM32F401RD, STM32F401VD, STM32F401CE, STM32F401RE and STM32F401VE Devices */
+/* #define STM32F410Tx */   /*!< STM32F410T8 and STM32F410TB Devices */
+/* #define STM32F410Cx */   /*!< STM32F410C8 and STM32F410CB Devices */
+/* #define STM32F410Rx */   /*!< STM32F410R8 and STM32F410RB Devices */
+/* #define STM32F411xE */   /*!< STM32F411CC, STM32F411RC, STM32F411VC, STM32F411CE, STM32F411RE and STM32F411VE Devices */
+/* #define STM32F446xx */   /*!< STM32F446MC, STM32F446ME, STM32F446RC, STM32F446RE, STM32F446VC, STM32F446VE, STM32F446ZC,
+                                 and STM32F446ZE Devices */
+/* #define STM32F469xx */   /*!< STM32F469AI, STM32F469II, STM32F469BI, STM32F469NI, STM32F469AG, STM32F469IG, STM32F469BG,
+                                 STM32F469NG, STM32F469AE, STM32F469IE, STM32F469BE and STM32F469NE Devices */
+/* #define STM32F479xx */   /*!< STM32F479AI, STM32F479II, STM32F479BI, STM32F479NI, STM32F479AG, STM32F479IG, STM32F479BG
+                                 and STM32F479NG Devices */
+/* #define STM32F412Cx */   /*!< STM32F412CEU and STM32F412CGU Devices */
+/* #define STM32F412Zx */   /*!< STM32F412ZET, STM32F412ZGT, STM32F412ZEJ and STM32F412ZGJ Devices */
+/* #define STM32F412Vx */   /*!< STM32F412VET, STM32F412VGT, STM32F412VEH and STM32F412VGH Devices */
+/* #define STM32F412Rx */   /*!< STM32F412RET, STM32F412RGT, STM32F412REY and STM32F412RGY Devices */
+/* #define STM32F413xx */   /*!< STM32F413CH, STM32F413MH, STM32F413RH, STM32F413VH, STM32F413ZH, STM32F413CG, STM32F413MG,
+                                 STM32F413RG, STM32F413VG and STM32F413ZG Devices */
+/* #define STM32F423xx */   /*!< STM32F423CH, STM32F423RH, STM32F423VH and STM32F423ZH Devices */
 #endif
-   
+
 /*  Tip: To avoid modifying this file each time you need to switch between these
         devices, you can define the device in your toolchain compiler preprocessor.
   */
 #if !defined  (USE_HAL_DRIVER)
 /**
  * @brief Comment the line below if you will not use the peripherals drivers.
-   In this case, these drivers will not be included and the application code will 
-   be based on direct access to peripherals registers 
+   In this case, these drivers will not be included and the application code will
+   be based on direct access to peripherals registers
    */
-  /*#define USE_HAL_DRIVER */
+/*#define USE_HAL_DRIVER */
 #endif /* USE_HAL_DRIVER */
 
 /**
-  * @brief CMSIS version number V2.6.8
+  * @brief CMSIS version number V2.6.10
   */
 #define __STM32F4xx_CMSIS_VERSION_MAIN   (0x02U) /*!< [31:24] main version */
 #define __STM32F4xx_CMSIS_VERSION_SUB1   (0x06U) /*!< [23:16] sub1 version */
-#define __STM32F4xx_CMSIS_VERSION_SUB2   (0x08U) /*!< [15:8]  sub2 version */
+#define __STM32F4xx_CMSIS_VERSION_SUB2   (0x0AU) /*!< [15:8]  sub2 version */
 #define __STM32F4xx_CMSIS_VERSION_RC     (0x00U) /*!< [7:0]  release candidate */
 #define __STM32F4xx_CMSIS_VERSION        ((__STM32F4xx_CMSIS_VERSION_MAIN << 24)\
                                          |(__STM32F4xx_CMSIS_VERSION_SUB1 << 16)\
@@ -125,53 +125,53 @@
   */
 
 #if defined(STM32F405xx)
-  #include "stm32f405xx.h"
+#include "stm32f405xx.h"
 #elif defined(STM32F415xx)
-  #include "stm32f415xx.h"
+#include "stm32f415xx.h"
 #elif defined(STM32F407xx)
-  #include "stm32f407xx.h"
+#include "stm32f407xx.h"
 #elif defined(STM32F417xx)
-  #include "stm32f417xx.h"
+#include "stm32f417xx.h"
 #elif defined(STM32F427xx)
-  #include "stm32f427xx.h"
+#include "stm32f427xx.h"
 #elif defined(STM32F437xx)
-  #include "stm32f437xx.h"
+#include "stm32f437xx.h"
 #elif defined(STM32F429xx)
-  #include "stm32f429xx.h"
+#include "stm32f429xx.h"
 #elif defined(STM32F439xx)
-  #include "stm32f439xx.h"
+#include "stm32f439xx.h"
 #elif defined(STM32F401xC)
-  #include "stm32f401xc.h"
+#include "stm32f401xc.h"
 #elif defined(STM32F401xE)
-  #include "stm32f401xe.h"
+#include "stm32f401xe.h"
 #elif defined(STM32F410Tx)
-  #include "stm32f410tx.h"
+#include "stm32f410tx.h"
 #elif defined(STM32F410Cx)
-  #include "stm32f410cx.h"
+#include "stm32f410cx.h"
 #elif defined(STM32F410Rx)
-  #include "stm32f410rx.h"
+#include "stm32f410rx.h"
 #elif defined(STM32F411xE)
-  #include "stm32f411xe.h"
+#include "stm32f411xe.h"
 #elif defined(STM32F446xx)
-  #include "stm32f446xx.h"
+#include "stm32f446xx.h"
 #elif defined(STM32F469xx)
-  #include "stm32f469xx.h"
+#include "stm32f469xx.h"
 #elif defined(STM32F479xx)
-  #include "stm32f479xx.h"
+#include "stm32f479xx.h"
 #elif defined(STM32F412Cx)
-  #include "stm32f412cx.h"
+#include "stm32f412cx.h"
 #elif defined(STM32F412Zx)
-  #include "stm32f412zx.h"
+#include "stm32f412zx.h"
 #elif defined(STM32F412Rx)
-  #include "stm32f412rx.h"
+#include "stm32f412rx.h"
 #elif defined(STM32F412Vx)
-  #include "stm32f412vx.h"
+#include "stm32f412vx.h"
 #elif defined(STM32F413xx)
-  #include "stm32f413xx.h"
+#include "stm32f413xx.h"
 #elif defined(STM32F423xx)
-  #include "stm32f423xx.h"
+#include "stm32f423xx.h"
 #else
- #error "Please select first the target STM32F4xx device used in your application (in stm32f4xx.h file)"
+#error "Please select first the target STM32F4xx device used in your application (in stm32f4xx.h file)"
 #endif
 
 /**
@@ -180,16 +180,16 @@
 
 /** @addtogroup Exported_types
   * @{
-  */ 
-typedef enum 
+  */
+typedef enum
 {
-  RESET = 0U, 
+  RESET = 0U,
   SET = !RESET
 } FlagStatus, ITStatus;
 
-typedef enum 
+typedef enum
 {
-  DISABLE = 0U, 
+  DISABLE = 0U,
   ENABLE = !DISABLE
 } FunctionalState;
 #define IS_FUNCTIONAL_STATE(STATE) (((STATE) == DISABLE) || ((STATE) == ENABLE))
@@ -222,7 +222,7 @@ typedef enum
 
 #define MODIFY_REG(REG, CLEARMASK, SETMASK)  WRITE_REG((REG), (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))
 
-#define POSITION_VAL(VAL)     (__CLZ(__RBIT(VAL))) 
+#define POSITION_VAL(VAL)     (__CLZ(__RBIT(VAL)))
 
 /* Use of CMSIS compiler intrinsics for register exclusive access */
 /* Atomic 32-bit register access macro to set one or several bits */
@@ -284,7 +284,7 @@ typedef enum
   */
 
 #if defined (USE_HAL_DRIVER)
- #include "stm32f4xx_hal.h"
+#include "stm32f4xx_hal.h"
 #endif /* USE_HAL_DRIVER */
 
 #ifdef __cplusplus

Drivers/CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h

@@ -2,7 +2,7 @@
   ******************************************************************************
   * @file    system_stm32f4xx.h
   * @author  MCD Application Team
-  * @brief   CMSIS Cortex-M4 Device System Source File for STM32F4xx devices.       
+  * @brief   CMSIS Cortex-M4 Device System Source File for STM32F4xx devices.
   ******************************************************************************
   * @attention
   *
@@ -13,8 +13,8 @@
   * in the root directory of this software component.
   * If no LICENSE file comes with this software, it is provided AS-IS.
   *
-  ******************************************************************************  
-  */ 
+  ******************************************************************************
+  */
 
 /** @addtogroup CMSIS
   * @{
@@ -22,8 +22,8 @@
 
 /** @addtogroup stm32f4xx_system
   * @{
-  */  
-  
+  */
+
 /**
   * @brief Define to prevent recursive inclusion
   */
@@ -31,8 +31,8 @@
 #define __SYSTEM_STM32F4XX_H
 
 #ifdef __cplusplus
- extern "C" {
-#endif 
+extern "C" {
+#endif
 
 /** @addtogroup STM32F4xx_System_Includes
   * @{
@@ -46,14 +46,14 @@
 /** @addtogroup STM32F4xx_System_Exported_types
   * @{
   */
-  /* This variable is updated in three ways:
-      1) by calling CMSIS function SystemCoreClockUpdate()
-      2) by calling HAL API function HAL_RCC_GetSysClockFreq()
-      3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency 
-         Note: If you use this function to configure the system clock; then there
-               is no need to call the 2 first functions listed above, since SystemCoreClock
-               variable is updated automatically.
-  */
+/* This variable is updated in three ways:
+    1) by calling CMSIS function SystemCoreClockUpdate()
+    2) by calling HAL API function HAL_RCC_GetSysClockFreq()
+    3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
+       Note: If you use this function to configure the system clock; then there
+             is no need to call the 2 first functions listed above, since SystemCoreClock
+             variable is updated automatically.
+*/
 extern uint32_t SystemCoreClock;          /*!< System Clock Frequency (Core Clock) */
 
 extern const uint8_t  AHBPrescTable[16];    /*!< AHB prescalers table values */
@@ -82,7 +82,7 @@ extern const uint8_t  APBPrescTable[8];     /*!< APB prescalers table values */
 /** @addtogroup STM32F4xx_System_Exported_Functions
   * @{
   */
-  
+
 extern void SystemInit(void);
 extern void SystemCoreClockUpdate(void);
 /**
@@ -98,7 +98,7 @@ extern void SystemCoreClockUpdate(void);
 /**
   * @}
   */
-  
+
 /**
   * @}
-  */  
+  */

Drivers/CMSIS/Include/cachel1_armv7.h

@@ -0,0 +1,411 @@
+/******************************************************************************
+ * @file     cachel1_armv7.h
+ * @brief    CMSIS Level 1 Cache API for Armv7-M and later
+ * @version  V1.0.1
+ * @date     19. April 2021
+ ******************************************************************************/
+/*
+ * Copyright (c) 2020-2021 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header    /* treat file as system include file */
+#endif
+
+#ifndef ARM_CACHEL1_ARMV7_H
+#define ARM_CACHEL1_ARMV7_H
+
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_CacheFunctions Cache Functions
+  \brief    Functions that configure Instruction and Data cache.
+  @{
+ */
+
+/* Cache Size ID Register Macros */
+#define CCSIDR_WAYS(x)         (((x) & SCB_CCSIDR_ASSOCIATIVITY_Msk) >> SCB_CCSIDR_ASSOCIATIVITY_Pos)
+#define CCSIDR_SETS(x)         (((x) & SCB_CCSIDR_NUMSETS_Msk      ) >> SCB_CCSIDR_NUMSETS_Pos      )
+
+#ifndef __SCB_DCACHE_LINE_SIZE
+#define __SCB_DCACHE_LINE_SIZE  32U /*!< Cortex-M7 cache line size is fixed to 32 bytes (8 words). See also register SCB_CCSIDR */
+#endif
+
+#ifndef __SCB_ICACHE_LINE_SIZE
+#define __SCB_ICACHE_LINE_SIZE  32U /*!< Cortex-M7 cache line size is fixed to 32 bytes (8 words). See also register SCB_CCSIDR */
+#endif
+
+/**
+  \brief   Enable I-Cache
+  \details Turns on I-Cache
+  */
+__STATIC_FORCEINLINE void SCB_EnableICache (void)
+{
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
+    if (SCB->CCR & SCB_CCR_IC_Msk) return;  /* return if ICache is already enabled */
+
+    __DSB();
+    __ISB();
+    SCB->ICIALLU = 0UL;                     /* invalidate I-Cache */
+    __DSB();
+    __ISB();
+    SCB->CCR |=  (uint32_t)SCB_CCR_IC_Msk;  /* enable I-Cache */
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   Disable I-Cache
+  \details Turns off I-Cache
+  */
+__STATIC_FORCEINLINE void SCB_DisableICache (void)
+{
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
+    __DSB();
+    __ISB();
+    SCB->CCR &= ~(uint32_t)SCB_CCR_IC_Msk;  /* disable I-Cache */
+    SCB->ICIALLU = 0UL;                     /* invalidate I-Cache */
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   Invalidate I-Cache
+  \details Invalidates I-Cache
+  */
+__STATIC_FORCEINLINE void SCB_InvalidateICache (void)
+{
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
+    __DSB();
+    __ISB();
+    SCB->ICIALLU = 0UL;
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   I-Cache Invalidate by address
+  \details Invalidates I-Cache for the given address.
+           I-Cache is invalidated starting from a 32 byte aligned address in 32 byte granularity.
+           I-Cache memory blocks which are part of given address + given size are invalidated.
+  \param[in]   addr    address
+  \param[in]   isize   size of memory block (in number of bytes)
+*/
+__STATIC_FORCEINLINE void SCB_InvalidateICache_by_Addr (volatile void *addr, int32_t isize)
+{
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
+    if ( isize > 0 ) {
+       int32_t op_size = isize + (((uint32_t)addr) & (__SCB_ICACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_ICACHE_LINE_SIZE - 1U) */;
+
+      __DSB();
+
+      do {
+        SCB->ICIMVAU = op_addr;             /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr += __SCB_ICACHE_LINE_SIZE;
+        op_size -= __SCB_ICACHE_LINE_SIZE;
+      } while ( op_size > 0 );
+
+      __DSB();
+      __ISB();
+    }
+  #endif
+}
+
+
+/**
+  \brief   Enable D-Cache
+  \details Turns on D-Cache
+  */
+__STATIC_FORCEINLINE void SCB_EnableDCache (void)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    uint32_t ccsidr;
+    uint32_t sets;
+    uint32_t ways;
+
+    if (SCB->CCR & SCB_CCR_DC_Msk) return;  /* return if DCache is already enabled */
+
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
+    __DSB();
+
+    ccsidr = SCB->CCSIDR;
+
+                                            /* invalidate D-Cache */
+    sets = (uint32_t)(CCSIDR_SETS(ccsidr));
+    do {
+      ways = (uint32_t)(CCSIDR_WAYS(ccsidr));
+      do {
+        SCB->DCISW = (((sets << SCB_DCISW_SET_Pos) & SCB_DCISW_SET_Msk) |
+                      ((ways << SCB_DCISW_WAY_Pos) & SCB_DCISW_WAY_Msk)  );
+        #if defined ( __CC_ARM )
+          __schedule_barrier();
+        #endif
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
+    __DSB();
+
+    SCB->CCR |=  (uint32_t)SCB_CCR_DC_Msk;  /* enable D-Cache */
+
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   Disable D-Cache
+  \details Turns off D-Cache
+  */
+__STATIC_FORCEINLINE void SCB_DisableDCache (void)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    uint32_t ccsidr;
+    uint32_t sets;
+    uint32_t ways;
+
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
+    __DSB();
+
+    SCB->CCR &= ~(uint32_t)SCB_CCR_DC_Msk;  /* disable D-Cache */
+    __DSB();
+
+    ccsidr = SCB->CCSIDR;
+
+                                            /* clean & invalidate D-Cache */
+    sets = (uint32_t)(CCSIDR_SETS(ccsidr));
+    do {
+      ways = (uint32_t)(CCSIDR_WAYS(ccsidr));
+      do {
+        SCB->DCCISW = (((sets << SCB_DCCISW_SET_Pos) & SCB_DCCISW_SET_Msk) |
+                       ((ways << SCB_DCCISW_WAY_Pos) & SCB_DCCISW_WAY_Msk)  );
+        #if defined ( __CC_ARM )
+          __schedule_barrier();
+        #endif
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
+
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   Invalidate D-Cache
+  \details Invalidates D-Cache
+  */
+__STATIC_FORCEINLINE void SCB_InvalidateDCache (void)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    uint32_t ccsidr;
+    uint32_t sets;
+    uint32_t ways;
+
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
+    __DSB();
+
+    ccsidr = SCB->CCSIDR;
+
+                                            /* invalidate D-Cache */
+    sets = (uint32_t)(CCSIDR_SETS(ccsidr));
+    do {
+      ways = (uint32_t)(CCSIDR_WAYS(ccsidr));
+      do {
+        SCB->DCISW = (((sets << SCB_DCISW_SET_Pos) & SCB_DCISW_SET_Msk) |
+                      ((ways << SCB_DCISW_WAY_Pos) & SCB_DCISW_WAY_Msk)  );
+        #if defined ( __CC_ARM )
+          __schedule_barrier();
+        #endif
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
+
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   Clean D-Cache
+  \details Cleans D-Cache
+  */
+__STATIC_FORCEINLINE void SCB_CleanDCache (void)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    uint32_t ccsidr;
+    uint32_t sets;
+    uint32_t ways;
+
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
+    __DSB();
+
+    ccsidr = SCB->CCSIDR;
+
+                                            /* clean D-Cache */
+    sets = (uint32_t)(CCSIDR_SETS(ccsidr));
+    do {
+      ways = (uint32_t)(CCSIDR_WAYS(ccsidr));
+      do {
+        SCB->DCCSW = (((sets << SCB_DCCSW_SET_Pos) & SCB_DCCSW_SET_Msk) |
+                      ((ways << SCB_DCCSW_WAY_Pos) & SCB_DCCSW_WAY_Msk)  );
+        #if defined ( __CC_ARM )
+          __schedule_barrier();
+        #endif
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
+
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   Clean & Invalidate D-Cache
+  \details Cleans and Invalidates D-Cache
+  */
+__STATIC_FORCEINLINE void SCB_CleanInvalidateDCache (void)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    uint32_t ccsidr;
+    uint32_t sets;
+    uint32_t ways;
+
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
+    __DSB();
+
+    ccsidr = SCB->CCSIDR;
+
+                                            /* clean & invalidate D-Cache */
+    sets = (uint32_t)(CCSIDR_SETS(ccsidr));
+    do {
+      ways = (uint32_t)(CCSIDR_WAYS(ccsidr));
+      do {
+        SCB->DCCISW = (((sets << SCB_DCCISW_SET_Pos) & SCB_DCCISW_SET_Msk) |
+                       ((ways << SCB_DCCISW_WAY_Pos) & SCB_DCCISW_WAY_Msk)  );
+        #if defined ( __CC_ARM )
+          __schedule_barrier();
+        #endif
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
+
+    __DSB();
+    __ISB();
+  #endif
+}
+
+
+/**
+  \brief   D-Cache Invalidate by address
+  \details Invalidates D-Cache for the given address.
+           D-Cache is invalidated starting from a 32 byte aligned address in 32 byte granularity.
+           D-Cache memory blocks which are part of given address + given size are invalidated.
+  \param[in]   addr    address
+  \param[in]   dsize   size of memory block (in number of bytes)
+*/
+__STATIC_FORCEINLINE void SCB_InvalidateDCache_by_Addr (volatile void *addr, int32_t dsize)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    if ( dsize > 0 ) {
+       int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */;
+
+      __DSB();
+
+      do {
+        SCB->DCIMVAC = op_addr;             /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr += __SCB_DCACHE_LINE_SIZE;
+        op_size -= __SCB_DCACHE_LINE_SIZE;
+      } while ( op_size > 0 );
+
+      __DSB();
+      __ISB();
+    }
+  #endif
+}
+
+
+/**
+  \brief   D-Cache Clean by address
+  \details Cleans D-Cache for the given address
+           D-Cache is cleaned starting from a 32 byte aligned address in 32 byte granularity.
+           D-Cache memory blocks which are part of given address + given size are cleaned.
+  \param[in]   addr    address
+  \param[in]   dsize   size of memory block (in number of bytes)
+*/
+__STATIC_FORCEINLINE void SCB_CleanDCache_by_Addr (volatile void *addr, int32_t dsize)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    if ( dsize > 0 ) {
+       int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */;
+
+      __DSB();
+
+      do {
+        SCB->DCCMVAC = op_addr;             /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr += __SCB_DCACHE_LINE_SIZE;
+        op_size -= __SCB_DCACHE_LINE_SIZE;
+      } while ( op_size > 0 );
+
+      __DSB();
+      __ISB();
+    }
+  #endif
+}
+
+
+/**
+  \brief   D-Cache Clean and Invalidate by address
+  \details Cleans and invalidates D_Cache for the given address
+           D-Cache is cleaned and invalidated starting from a 32 byte aligned address in 32 byte granularity.
+           D-Cache memory blocks which are part of given address + given size are cleaned and invalidated.
+  \param[in]   addr    address (aligned to 32-byte boundary)
+  \param[in]   dsize   size of memory block (in number of bytes)
+*/
+__STATIC_FORCEINLINE void SCB_CleanInvalidateDCache_by_Addr (volatile void *addr, int32_t dsize)
+{
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    if ( dsize > 0 ) {
+       int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */;
+
+      __DSB();
+
+      do {
+        SCB->DCCIMVAC = op_addr;            /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr +=          __SCB_DCACHE_LINE_SIZE;
+        op_size -=          __SCB_DCACHE_LINE_SIZE;
+      } while ( op_size > 0 );
+
+      __DSB();
+      __ISB();
+    }
+  #endif
+}
+
+/*@} end of CMSIS_Core_CacheFunctions */
+
+#endif /* ARM_CACHEL1_ARMV7_H */

Drivers/CMSIS/Include/cmsis_armcc.h

@@ -1,11 +1,11 @@
 /**************************************************************************//**
  * @file     cmsis_armcc.h
  * @brief    CMSIS compiler ARMCC (Arm Compiler 5) header file
- * @version  V5.0.4
- * @date     10. January 2018
+ * @version  V5.3.2
+ * @date     27. May 2021
  ******************************************************************************/
 /*
- * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ * Copyright (c) 2009-2021 Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -46,7 +46,12 @@
 
   /* __ARM_ARCH_8M_BASE__  not applicable */
   /* __ARM_ARCH_8M_MAIN__  not applicable */
+  /* __ARM_ARCH_8_1M_MAIN__  not applicable */
 
+/* CMSIS compiler control DSP macros */
+#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
+  #define __ARM_FEATURE_DSP         1
+#endif
 
 /* CMSIS compiler specific defines */
 #ifndef   __ASM
@@ -58,9 +63,9 @@
 #ifndef   __STATIC_INLINE
   #define __STATIC_INLINE                        static __inline
 #endif
-#ifndef   __STATIC_FORCEINLINE                 
+#ifndef   __STATIC_FORCEINLINE
   #define __STATIC_FORCEINLINE                   static __forceinline
-#endif           
+#endif
 #ifndef   __NO_RETURN
   #define __NO_RETURN                            __declspec(noreturn)
 #endif
@@ -100,279 +105,31 @@
 #ifndef   __RESTRICT
   #define __RESTRICT                             __restrict
 #endif
-
-/* ###########################  Core Function Access  ########################### */
-/** \ingroup  CMSIS_Core_FunctionInterface
-    \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
-  @{
- */
-
-/**
-  \brief   Enable IRQ Interrupts
-  \details Enables IRQ interrupts by clearing the I-bit in the CPSR.
-           Can only be executed in Privileged modes.
- */
-/* intrinsic void __enable_irq();     */
-
-
-/**
-  \brief   Disable IRQ Interrupts
-  \details Disables IRQ interrupts by setting the I-bit in the CPSR.
-           Can only be executed in Privileged modes.
- */
-/* intrinsic void __disable_irq();    */
-
-/**
-  \brief   Get Control Register
-  \details Returns the content of the Control Register.
-  \return               Control Register value
- */
-__STATIC_INLINE uint32_t __get_CONTROL(void)
-{
-  register uint32_t __regControl         __ASM("control");
-  return(__regControl);
-}
-
-
-/**
-  \brief   Set Control Register
-  \details Writes the given value to the Control Register.
-  \param [in]    control  Control Register value to set
- */
-__STATIC_INLINE void __set_CONTROL(uint32_t control)
-{
-  register uint32_t __regControl         __ASM("control");
-  __regControl = control;
-}
-
-
-/**
-  \brief   Get IPSR Register
-  \details Returns the content of the IPSR Register.
-  \return               IPSR Register value
- */
-__STATIC_INLINE uint32_t __get_IPSR(void)
-{
-  register uint32_t __regIPSR          __ASM("ipsr");
-  return(__regIPSR);
-}
-
-
-/**
-  \brief   Get APSR Register
-  \details Returns the content of the APSR Register.
-  \return               APSR Register value
- */
-__STATIC_INLINE uint32_t __get_APSR(void)
-{
-  register uint32_t __regAPSR          __ASM("apsr");
-  return(__regAPSR);
-}
-
-
-/**
-  \brief   Get xPSR Register
-  \details Returns the content of the xPSR Register.
-  \return               xPSR Register value
- */
-__STATIC_INLINE uint32_t __get_xPSR(void)
-{
-  register uint32_t __regXPSR          __ASM("xpsr");
-  return(__regXPSR);
-}
-
-
-/**
-  \brief   Get Process Stack Pointer
-  \details Returns the current value of the Process Stack Pointer (PSP).
-  \return               PSP Register value
- */
-__STATIC_INLINE uint32_t __get_PSP(void)
-{
-  register uint32_t __regProcessStackPointer  __ASM("psp");
-  return(__regProcessStackPointer);
-}
-
-
-/**
-  \brief   Set Process Stack Pointer
-  \details Assigns the given value to the Process Stack Pointer (PSP).
-  \param [in]    topOfProcStack  Process Stack Pointer value to set
- */
-__STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
-{
-  register uint32_t __regProcessStackPointer  __ASM("psp");
-  __regProcessStackPointer = topOfProcStack;
-}
-
-
-/**
-  \brief   Get Main Stack Pointer
-  \details Returns the current value of the Main Stack Pointer (MSP).
-  \return               MSP Register value
- */
-__STATIC_INLINE uint32_t __get_MSP(void)
-{
-  register uint32_t __regMainStackPointer     __ASM("msp");
-  return(__regMainStackPointer);
-}
-
-
-/**
-  \brief   Set Main Stack Pointer
-  \details Assigns the given value to the Main Stack Pointer (MSP).
-  \param [in]    topOfMainStack  Main Stack Pointer value to set
- */
-__STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
-{
-  register uint32_t __regMainStackPointer     __ASM("msp");
-  __regMainStackPointer = topOfMainStack;
-}
-
-
-/**
-  \brief   Get Priority Mask
-  \details Returns the current state of the priority mask bit from the Priority Mask Register.
-  \return               Priority Mask value
- */
-__STATIC_INLINE uint32_t __get_PRIMASK(void)
-{
-  register uint32_t __regPriMask         __ASM("primask");
-  return(__regPriMask);
-}
-
-
-/**
-  \brief   Set Priority Mask
-  \details Assigns the given value to the Priority Mask Register.
-  \param [in]    priMask  Priority Mask
- */
-__STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
-{
-  register uint32_t __regPriMask         __ASM("primask");
-  __regPriMask = (priMask);
-}
-
-
-#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
-     (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
-
-/**
-  \brief   Enable FIQ
-  \details Enables FIQ interrupts by clearing the F-bit in the CPSR.
-           Can only be executed in Privileged modes.
- */
-#define __enable_fault_irq                __enable_fiq
-
-
-/**
-  \brief   Disable FIQ
-  \details Disables FIQ interrupts by setting the F-bit in the CPSR.
-           Can only be executed in Privileged modes.
- */
-#define __disable_fault_irq               __disable_fiq
-
-
-/**
-  \brief   Get Base Priority
-  \details Returns the current value of the Base Priority register.
-  \return               Base Priority register value
- */
-__STATIC_INLINE uint32_t  __get_BASEPRI(void)
-{
-  register uint32_t __regBasePri         __ASM("basepri");
-  return(__regBasePri);
-}
-
-
-/**
-  \brief   Set Base Priority
-  \details Assigns the given value to the Base Priority register.
-  \param [in]    basePri  Base Priority value to set
- */
-__STATIC_INLINE void __set_BASEPRI(uint32_t basePri)
-{
-  register uint32_t __regBasePri         __ASM("basepri");
-  __regBasePri = (basePri & 0xFFU);
-}
-
-
-/**
-  \brief   Set Base Priority with condition
-  \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
-           or the new value increases the BASEPRI priority level.
-  \param [in]    basePri  Base Priority value to set
- */
-__STATIC_INLINE void __set_BASEPRI_MAX(uint32_t basePri)
-{
-  register uint32_t __regBasePriMax      __ASM("basepri_max");
-  __regBasePriMax = (basePri & 0xFFU);
-}
-
-
-/**
-  \brief   Get Fault Mask
-  \details Returns the current value of the Fault Mask register.
-  \return               Fault Mask register value
- */
-__STATIC_INLINE uint32_t __get_FAULTMASK(void)
-{
-  register uint32_t __regFaultMask       __ASM("faultmask");
-  return(__regFaultMask);
-}
-
-
-/**
-  \brief   Set Fault Mask
-  \details Assigns the given value to the Fault Mask register.
-  \param [in]    faultMask  Fault Mask value to set
- */
-__STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
-{
-  register uint32_t __regFaultMask       __ASM("faultmask");
-  __regFaultMask = (faultMask & (uint32_t)1U);
-}
-
-#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
-           (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
-
-
-/**
-  \brief   Get FPSCR
-  \details Returns the current value of the Floating Point Status/Control register.
-  \return               Floating Point Status/Control register value
- */
-__STATIC_INLINE uint32_t __get_FPSCR(void)
-{
-#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
-     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
-  register uint32_t __regfpscr         __ASM("fpscr");
-  return(__regfpscr);
-#else
-   return(0U);
+#ifndef   __COMPILER_BARRIER
+  #define __COMPILER_BARRIER()                   __memory_changed()
 #endif
-}
 
+/* #########################  Startup and Lowlevel Init  ######################## */
 
-/**
-  \brief   Set FPSCR
-  \details Assigns the given value to the Floating Point Status/Control register.
-  \param [in]    fpscr  Floating Point Status/Control value to set
- */
-__STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
-{
-#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
-     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
-  register uint32_t __regfpscr         __ASM("fpscr");
-  __regfpscr = (fpscr);
-#else
-  (void)fpscr;
+#ifndef __PROGRAM_START
+#define __PROGRAM_START           __main
 #endif
-}
 
+#ifndef __INITIAL_SP
+#define __INITIAL_SP              Image$$ARM_LIB_STACK$$ZI$$Limit
+#endif
 
-/*@} end of CMSIS_Core_RegAccFunctions */
+#ifndef __STACK_LIMIT
+#define __STACK_LIMIT             Image$$ARM_LIB_STACK$$ZI$$Base
+#endif
 
+#ifndef __VECTOR_TABLE
+#define __VECTOR_TABLE            __Vectors
+#endif
+
+#ifndef __VECTOR_TABLE_ATTRIBUTE
+#define __VECTOR_TABLE_ATTRIBUTE  __attribute__((used, section("RESET")))
+#endif
 
 /* ##########################  Core Instruction Access  ######################### */
 /** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
@@ -415,35 +172,23 @@ __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
            so that all instructions following the ISB are fetched from cache or memory,
            after the instruction has been completed.
  */
-#define __ISB() do {\
-                   __schedule_barrier();\
-                   __isb(0xF);\
-                   __schedule_barrier();\
-                } while (0U)
+#define __ISB()                           __isb(0xF)
 
 /**
   \brief   Data Synchronization Barrier
   \details Acts as a special kind of Data Memory Barrier.
            It completes when all explicit memory accesses before this instruction complete.
  */
-#define __DSB() do {\
-                   __schedule_barrier();\
-                   __dsb(0xF);\
-                   __schedule_barrier();\
-                } while (0U)
+#define __DSB()                           __dsb(0xF)
 
 /**
   \brief   Data Memory Barrier
   \details Ensures the apparent order of the explicit memory operations before
            and after the instruction, without ensuring their completion.
  */
-#define __DMB() do {\
-                   __schedule_barrier();\
-                   __dmb(0xF);\
-                   __schedule_barrier();\
-                } while (0U)
+#define __DMB()                           __dmb(0xF)
+
 
-                  
 /**
   \brief   Reverse byte order (32 bit)
   \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
@@ -781,6 +526,280 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAT(int32_t val, uint
 /*@}*/ /* end of group CMSIS_Core_InstructionInterface */
 
 
+/* ###########################  Core Function Access  ########################### */
+/** \ingroup  CMSIS_Core_FunctionInterface
+    \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
+  @{
+ */
+
+/**
+  \brief   Enable IRQ Interrupts
+  \details Enables IRQ interrupts by clearing special-purpose register PRIMASK.
+           Can only be executed in Privileged modes.
+ */
+/* intrinsic void __enable_irq();     */
+
+
+/**
+  \brief   Disable IRQ Interrupts
+  \details Disables IRQ interrupts by setting special-purpose register PRIMASK.
+           Can only be executed in Privileged modes.
+ */
+/* intrinsic void __disable_irq();    */
+
+/**
+  \brief   Get Control Register
+  \details Returns the content of the Control Register.
+  \return               Control Register value
+ */
+__STATIC_INLINE uint32_t __get_CONTROL(void)
+{
+  register uint32_t __regControl         __ASM("control");
+  return(__regControl);
+}
+
+
+/**
+  \brief   Set Control Register
+  \details Writes the given value to the Control Register.
+  \param [in]    control  Control Register value to set
+ */
+__STATIC_INLINE void __set_CONTROL(uint32_t control)
+{
+  register uint32_t __regControl         __ASM("control");
+  __regControl = control;
+  __ISB();
+}
+
+
+/**
+  \brief   Get IPSR Register
+  \details Returns the content of the IPSR Register.
+  \return               IPSR Register value
+ */
+__STATIC_INLINE uint32_t __get_IPSR(void)
+{
+  register uint32_t __regIPSR          __ASM("ipsr");
+  return(__regIPSR);
+}
+
+
+/**
+  \brief   Get APSR Register
+  \details Returns the content of the APSR Register.
+  \return               APSR Register value
+ */
+__STATIC_INLINE uint32_t __get_APSR(void)
+{
+  register uint32_t __regAPSR          __ASM("apsr");
+  return(__regAPSR);
+}
+
+
+/**
+  \brief   Get xPSR Register
+  \details Returns the content of the xPSR Register.
+  \return               xPSR Register value
+ */
+__STATIC_INLINE uint32_t __get_xPSR(void)
+{
+  register uint32_t __regXPSR          __ASM("xpsr");
+  return(__regXPSR);
+}
+
+
+/**
+  \brief   Get Process Stack Pointer
+  \details Returns the current value of the Process Stack Pointer (PSP).
+  \return               PSP Register value
+ */
+__STATIC_INLINE uint32_t __get_PSP(void)
+{
+  register uint32_t __regProcessStackPointer  __ASM("psp");
+  return(__regProcessStackPointer);
+}
+
+
+/**
+  \brief   Set Process Stack Pointer
+  \details Assigns the given value to the Process Stack Pointer (PSP).
+  \param [in]    topOfProcStack  Process Stack Pointer value to set
+ */
+__STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
+{
+  register uint32_t __regProcessStackPointer  __ASM("psp");
+  __regProcessStackPointer = topOfProcStack;
+}
+
+
+/**
+  \brief   Get Main Stack Pointer
+  \details Returns the current value of the Main Stack Pointer (MSP).
+  \return               MSP Register value
+ */
+__STATIC_INLINE uint32_t __get_MSP(void)
+{
+  register uint32_t __regMainStackPointer     __ASM("msp");
+  return(__regMainStackPointer);
+}
+
+
+/**
+  \brief   Set Main Stack Pointer
+  \details Assigns the given value to the Main Stack Pointer (MSP).
+  \param [in]    topOfMainStack  Main Stack Pointer value to set
+ */
+__STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
+{
+  register uint32_t __regMainStackPointer     __ASM("msp");
+  __regMainStackPointer = topOfMainStack;
+}
+
+
+/**
+  \brief   Get Priority Mask
+  \details Returns the current state of the priority mask bit from the Priority Mask Register.
+  \return               Priority Mask value
+ */
+__STATIC_INLINE uint32_t __get_PRIMASK(void)
+{
+  register uint32_t __regPriMask         __ASM("primask");
+  return(__regPriMask);
+}
+
+
+/**
+  \brief   Set Priority Mask
+  \details Assigns the given value to the Priority Mask Register.
+  \param [in]    priMask  Priority Mask
+ */
+__STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
+{
+  register uint32_t __regPriMask         __ASM("primask");
+  __regPriMask = (priMask);
+}
+
+
+#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+     (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
+
+/**
+  \brief   Enable FIQ
+  \details Enables FIQ interrupts by clearing special-purpose register FAULTMASK.
+           Can only be executed in Privileged modes.
+ */
+#define __enable_fault_irq                __enable_fiq
+
+
+/**
+  \brief   Disable FIQ
+  \details Disables FIQ interrupts by setting special-purpose register FAULTMASK.
+           Can only be executed in Privileged modes.
+ */
+#define __disable_fault_irq               __disable_fiq
+
+
+/**
+  \brief   Get Base Priority
+  \details Returns the current value of the Base Priority register.
+  \return               Base Priority register value
+ */
+__STATIC_INLINE uint32_t  __get_BASEPRI(void)
+{
+  register uint32_t __regBasePri         __ASM("basepri");
+  return(__regBasePri);
+}
+
+
+/**
+  \brief   Set Base Priority
+  \details Assigns the given value to the Base Priority register.
+  \param [in]    basePri  Base Priority value to set
+ */
+__STATIC_INLINE void __set_BASEPRI(uint32_t basePri)
+{
+  register uint32_t __regBasePri         __ASM("basepri");
+  __regBasePri = (basePri & 0xFFU);
+}
+
+
+/**
+  \brief   Set Base Priority with condition
+  \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
+           or the new value increases the BASEPRI priority level.
+  \param [in]    basePri  Base Priority value to set
+ */
+__STATIC_INLINE void __set_BASEPRI_MAX(uint32_t basePri)
+{
+  register uint32_t __regBasePriMax      __ASM("basepri_max");
+  __regBasePriMax = (basePri & 0xFFU);
+}
+
+
+/**
+  \brief   Get Fault Mask
+  \details Returns the current value of the Fault Mask register.
+  \return               Fault Mask register value
+ */
+__STATIC_INLINE uint32_t __get_FAULTMASK(void)
+{
+  register uint32_t __regFaultMask       __ASM("faultmask");
+  return(__regFaultMask);
+}
+
+
+/**
+  \brief   Set Fault Mask
+  \details Assigns the given value to the Fault Mask register.
+  \param [in]    faultMask  Fault Mask value to set
+ */
+__STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
+{
+  register uint32_t __regFaultMask       __ASM("faultmask");
+  __regFaultMask = (faultMask & (uint32_t)1U);
+}
+
+#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+           (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
+
+
+/**
+  \brief   Get FPSCR
+  \details Returns the current value of the Floating Point Status/Control register.
+  \return               Floating Point Status/Control register value
+ */
+__STATIC_INLINE uint32_t __get_FPSCR(void)
+{
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+  register uint32_t __regfpscr         __ASM("fpscr");
+  return(__regfpscr);
+#else
+   return(0U);
+#endif
+}
+
+
+/**
+  \brief   Set FPSCR
+  \details Assigns the given value to the Floating Point Status/Control register.
+  \param [in]    fpscr  Floating Point Status/Control value to set
+ */
+__STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
+{
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+  register uint32_t __regfpscr         __ASM("fpscr");
+  __regfpscr = (fpscr);
+#else
+  (void)fpscr;
+#endif
+}
+
+
+/*@} end of CMSIS_Core_RegAccFunctions */
+
+
 /* ###################  Compiler specific Intrinsics  ########################### */
 /** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
   Access to dedicated SIMD instructions
@@ -858,6 +877,10 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAT(int32_t val, uint
 #define __SMMLA(ARG1,ARG2,ARG3)          ( (int32_t)((((int64_t)(ARG1) * (ARG2)) + \
                                                       ((int64_t)(ARG3) << 32U)     ) >> 32U))
 
+#define __SXTB16_RORn(ARG1, ARG2)        __SXTB16(__ROR(ARG1, ARG2))
+
+#define __SXTAB16_RORn(ARG1, ARG2, ARG3) __SXTAB16(ARG1, __ROR(ARG2, ARG3))
+
 #endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 /*@} end of group CMSIS_SIMD_intrinsics */
 

Drivers/CMSIS/Include/cmsis_compiler.h

@@ -1,8 +1,8 @@
 /**************************************************************************//**
  * @file     cmsis_compiler.h
  * @brief    CMSIS compiler generic header file
- * @version  V5.0.4
- * @date     10. January 2018
+ * @version  V5.1.0
+ * @date     09. October 2018
  ******************************************************************************/
 /*
  * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
@@ -35,9 +35,15 @@
 
 
 /*
- * Arm Compiler 6 (armclang)
+ * Arm Compiler 6.6 LTM (armclang)
  */
-#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) && (__ARMCC_VERSION < 6100100)
+  #include "cmsis_armclang_ltm.h"
+
+  /*
+ * Arm Compiler above 6.10.1 (armclang)
+ */
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6100100)
   #include "cmsis_armclang.h"
 
 
@@ -115,8 +121,11 @@
     #define __ALIGNED(x)                           __attribute__((aligned(x)))
   #endif
   #ifndef   __RESTRICT
-    #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
-    #define __RESTRICT
+    #define __RESTRICT                             __restrict
+  #endif
+  #ifndef   __COMPILER_BARRIER
+    #warning No compiler specific solution for __COMPILER_BARRIER. __COMPILER_BARRIER is ignored.
+    #define __COMPILER_BARRIER()                   (void)0
   #endif
 
 
@@ -187,6 +196,10 @@
     #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
     #define __RESTRICT
   #endif
+  #ifndef   __COMPILER_BARRIER
+    #warning No compiler specific solution for __COMPILER_BARRIER. __COMPILER_BARRIER is ignored.
+    #define __COMPILER_BARRIER()                   (void)0
+  #endif
 
 
 /*
@@ -255,6 +268,10 @@
     #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
     #define __RESTRICT
   #endif
+  #ifndef   __COMPILER_BARRIER
+    #warning No compiler specific solution for __COMPILER_BARRIER. __COMPILER_BARRIER is ignored.
+    #define __COMPILER_BARRIER()                   (void)0
+  #endif
 
 
 #else

Drivers/CMSIS/Include/cmsis_iccarm.h

@@ -1,13 +1,16 @@
 /**************************************************************************//**
  * @file     cmsis_iccarm.h
  * @brief    CMSIS compiler ICCARM (IAR Compiler for Arm) header file
- * @version  V5.0.7
- * @date     19. June 2018
+ * @version  V5.3.0
+ * @date     14. April 2021
  ******************************************************************************/
 
 //------------------------------------------------------------------------------
 //
-// Copyright (c) 2017-2018 IAR Systems
+// Copyright (c) 2017-2021 IAR Systems
+// Copyright (c) 2017-2021 Arm Limited. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
 //
 // Licensed under the Apache License, Version 2.0 (the "License")
 // you may not use this file except in compliance with the License.
@@ -110,6 +113,10 @@
   #define __ASM __asm
 #endif
 
+#ifndef   __COMPILER_BARRIER
+  #define __COMPILER_BARRIER() __ASM volatile("":::"memory")
+#endif
+
 #ifndef __INLINE
   #define __INLINE inline
 #endif
@@ -150,7 +157,12 @@
 #endif
 
 #ifndef   __RESTRICT
-  #define __RESTRICT            __restrict
+  #if __ICCARM_V8
+    #define __RESTRICT            __restrict
+  #else
+    /* Needs IAR language extensions */
+    #define __RESTRICT            restrict
+  #endif
 #endif
 
 #ifndef   __STATIC_INLINE
@@ -226,6 +238,7 @@ __packed struct  __iar_u32 { uint32_t v; };
   #endif
 #endif
 
+#undef __WEAK                           /* undo the definition from DLib_Defaults.h */
 #ifndef   __WEAK
   #if __ICCARM_V8
     #define __WEAK __attribute__((weak))
@@ -234,6 +247,43 @@ __packed struct  __iar_u32 { uint32_t v; };
   #endif
 #endif
 
+#ifndef __PROGRAM_START
+#define __PROGRAM_START           __iar_program_start
+#endif
+
+#ifndef __INITIAL_SP
+#define __INITIAL_SP              CSTACK$$Limit
+#endif
+
+#ifndef __STACK_LIMIT
+#define __STACK_LIMIT             CSTACK$$Base
+#endif
+
+#ifndef __VECTOR_TABLE
+#define __VECTOR_TABLE            __vector_table
+#endif
+
+#ifndef __VECTOR_TABLE_ATTRIBUTE
+#define __VECTOR_TABLE_ATTRIBUTE  @".intvec"
+#endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+#ifndef __STACK_SEAL
+#define __STACK_SEAL              STACKSEAL$$Base
+#endif
+
+#ifndef __TZ_STACK_SEAL_SIZE
+#define __TZ_STACK_SEAL_SIZE      8U
+#endif
+
+#ifndef __TZ_STACK_SEAL_VALUE
+#define __TZ_STACK_SEAL_VALUE     0xFEF5EDA5FEF5EDA5ULL
+#endif
+
+__STATIC_FORCEINLINE void __TZ_set_STACKSEAL_S (uint32_t* stackTop) {
+  *((uint64_t *)stackTop) = __TZ_STACK_SEAL_VALUE;
+}
+#endif
 
 #ifndef __ICCARM_INTRINSICS_VERSION__
   #define __ICCARM_INTRINSICS_VERSION__  0
@@ -305,7 +355,13 @@ __packed struct  __iar_u32 { uint32_t v; };
 
   #define __set_BASEPRI(VALUE)        (__arm_wsr("BASEPRI", (VALUE)))
   #define __set_BASEPRI_MAX(VALUE)    (__arm_wsr("BASEPRI_MAX", (VALUE)))
-  #define __set_CONTROL(VALUE)        (__arm_wsr("CONTROL", (VALUE)))
+
+__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control)
+{
+  __arm_wsr("CONTROL", control);
+  __iar_builtin_ISB();
+}
+
   #define __set_FAULTMASK(VALUE)      (__arm_wsr("FAULTMASK", (VALUE)))
   #define __set_MSP(VALUE)            (__arm_wsr("MSP", (VALUE)))
 
@@ -327,7 +383,13 @@ __packed struct  __iar_u32 { uint32_t v; };
   #endif
 
   #define __TZ_get_CONTROL_NS()       (__arm_rsr("CONTROL_NS"))
-  #define __TZ_set_CONTROL_NS(VALUE)  (__arm_wsr("CONTROL_NS", (VALUE)))
+
+__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control)
+{
+  __arm_wsr("CONTROL_NS", control);
+  __iar_builtin_ISB();
+}
+
   #define __TZ_get_PSP_NS()           (__arm_rsr("PSP_NS"))
   #define __TZ_set_PSP_NS(VALUE)      (__arm_wsr("PSP_NS", (VALUE)))
   #define __TZ_get_MSP_NS()           (__arm_rsr("MSP_NS"))
@@ -567,7 +629,7 @@ __packed struct  __iar_u32 { uint32_t v; };
     __IAR_FT uint32_t __RRX(uint32_t value)
     {
       uint32_t result;
-      __ASM("RRX      %0, %1" : "=r"(result) : "r" (value) : "cc");
+      __ASM volatile("RRX      %0, %1" : "=r"(result) : "r" (value));
       return(result);
     }
 
@@ -649,6 +711,7 @@ __packed struct  __iar_u32 { uint32_t v; };
     __IAR_FT void   __TZ_set_CONTROL_NS(uint32_t value)
     {
       __asm volatile("MSR      CONTROL_NS,%0" :: "r" (value));
+      __iar_builtin_ISB();
     }
 
     __IAR_FT uint32_t   __TZ_get_PSP_NS(void)
@@ -806,37 +869,37 @@ __packed struct  __iar_u32 { uint32_t v; };
   __IAR_FT uint8_t __LDRBT(volatile uint8_t *addr)
   {
     uint32_t res;
-    __ASM("LDRBT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
+    __ASM volatile ("LDRBT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
     return ((uint8_t)res);
   }
 
   __IAR_FT uint16_t __LDRHT(volatile uint16_t *addr)
   {
     uint32_t res;
-    __ASM("LDRHT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
+    __ASM volatile ("LDRHT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
     return ((uint16_t)res);
   }
 
   __IAR_FT uint32_t __LDRT(volatile uint32_t *addr)
   {
     uint32_t res;
-    __ASM("LDRT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
+    __ASM volatile ("LDRT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
     return res;
   }
 
   __IAR_FT void __STRBT(uint8_t value, volatile uint8_t *addr)
   {
-    __ASM("STRBT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
+    __ASM volatile ("STRBT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
   }
 
   __IAR_FT void __STRHT(uint16_t value, volatile uint16_t *addr)
   {
-    __ASM("STRHT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
+    __ASM volatile ("STRHT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
   }
 
   __IAR_FT void __STRT(uint32_t value, volatile uint32_t *addr)
   {
-    __ASM("STRT %1, [%0]" : : "r" (addr), "r" (value) : "memory");
+    __ASM volatile ("STRT %1, [%0]" : : "r" (addr), "r" (value) : "memory");
   }
 
 #endif /* (__CORTEX_M >= 0x03) */
@@ -932,4 +995,8 @@ __packed struct  __iar_u32 { uint32_t v; };
 #pragma diag_default=Pe940
 #pragma diag_default=Pe177
 
+#define __SXTB16_RORn(ARG1, ARG2) __SXTB16(__ROR(ARG1, ARG2))
+
+#define __SXTAB16_RORn(ARG1, ARG2, ARG3) __SXTAB16(ARG1, __ROR(ARG2, ARG3))
+
 #endif /* __CMSIS_ICCARM_H__ */

Drivers/CMSIS/Include/cmsis_version.h

@@ -1,11 +1,11 @@
 /**************************************************************************//**
  * @file     cmsis_version.h
  * @brief    CMSIS Core(M) Version definitions
- * @version  V5.0.2
- * @date     19. April 2017
+ * @version  V5.0.5
+ * @date     02. February 2022
  ******************************************************************************/
 /*
- * Copyright (c) 2009-2017 ARM Limited. All rights reserved.
+ * Copyright (c) 2009-2022 ARM Limited. All rights reserved.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -33,7 +33,7 @@
 
 /*  CMSIS Version definitions */
 #define __CM_CMSIS_VERSION_MAIN  ( 5U)                                      /*!< [31:16] CMSIS Core(M) main version */
-#define __CM_CMSIS_VERSION_SUB   ( 1U)                                      /*!< [15:0]  CMSIS Core(M) sub version */
+#define __CM_CMSIS_VERSION_SUB   ( 6U)                                      /*!< [15:0]  CMSIS Core(M) sub version */
 #define __CM_CMSIS_VERSION       ((__CM_CMSIS_VERSION_MAIN << 16U) | \
                                    __CM_CMSIS_VERSION_SUB           )       /*!< CMSIS Core(M) version number */
 #endif

Drivers/CMSIS/Include/core_armv8mbl.h

@@ -1,11 +1,11 @@
 /**************************************************************************//**
  * @file     core_armv8mbl.h
  * @brief    CMSIS Armv8-M Baseline Core Peripheral Access Layer Header File
- * @version  V5.0.7
- * @date     22. June 2018
+ * @version  V5.1.0
+ * @date     27. March 2020
  ******************************************************************************/
 /*
- * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ * Copyright (c) 2009-2020 Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -23,9 +23,11 @@
  */
 
 #if   defined ( __ICCARM__ )
-  #pragma system_include         /* treat file as system include file for MISRA check */
+  #pragma system_include                        /* treat file as system include file for MISRA check */
 #elif defined (__clang__)
-  #pragma clang system_header   /* treat file as system include file */
+  #pragma clang system_header                   /* treat file as system include file */
+#elif defined ( __GNUC__ )
+  #pragma GCC diagnostic ignored "-Wpedantic"   /* disable pedantic warning due to unnamed structs/unions */
 #endif
 
 #ifndef __CORE_ARMV8MBL_H_GENERIC
@@ -68,7 +70,7 @@
 #define __ARMv8MBL_CMSIS_VERSION       ((__ARMv8MBL_CMSIS_VERSION_MAIN << 16U) | \
                                          __ARMv8MBL_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#define __CORTEX_M                     ( 2U)                                            /*!< Cortex-M Core */
+#define __CORTEX_M                     (2U)                                        /*!< Cortex-M Core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     This core does not support an FPU at all
@@ -81,7 +83,7 @@
   #endif
 
 #elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
+  #if defined __ARM_FP
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
@@ -975,6 +977,7 @@ typedef struct
 #endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
 
 
+/* CoreDebug is deprecated. replaced by DCB (Debug Control Block) */
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
@@ -983,7 +986,7 @@ typedef struct
  */
 
 /**
-  \brief  Structure type to access the Core Debug Register (CoreDebug).
+  \brief  \deprecated Structure type to access the Core Debug Register (CoreDebug).
  */
 typedef struct
 {
@@ -991,91 +994,276 @@ typedef struct
   __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
   __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
   __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
-        uint32_t RESERVED4[1U];
+        uint32_t RESERVED0[1U];
   __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
   __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
 } CoreDebug_Type;
 
 /* Debug Halting Control and Status Register Definitions */
-#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
-#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< \deprecated CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< \deprecated CoreDebug DHCSR: DBGKEY Mask */
 
-#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
-#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< \deprecated CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< \deprecated CoreDebug DHCSR: S_RESTART_ST Mask */
 
-#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
-#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< \deprecated CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< \deprecated CoreDebug DHCSR: S_RESET_ST Mask */
 
-#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
-#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< \deprecated CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< \deprecated CoreDebug DHCSR: S_RETIRE_ST Mask */
 
-#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
-#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< \deprecated CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< \deprecated CoreDebug DHCSR: S_LOCKUP Mask */
 
-#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
-#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< \deprecated CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< \deprecated CoreDebug DHCSR: S_SLEEP Mask */
 
-#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
-#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< \deprecated CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< \deprecated CoreDebug DHCSR: S_HALT Mask */
 
-#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
-#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< \deprecated CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< \deprecated CoreDebug DHCSR: S_REGRDY Mask */
 
-#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
-#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< \deprecated CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< \deprecated CoreDebug DHCSR: C_MASKINTS Mask */
 
-#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
-#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< \deprecated CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< \deprecated CoreDebug DHCSR: C_STEP Mask */
 
-#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
-#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< \deprecated CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< \deprecated CoreDebug DHCSR: C_HALT Mask */
 
-#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
-#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< \deprecated CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< \deprecated CoreDebug DHCSR: C_DEBUGEN Mask */
 
 /* Debug Core Register Selector Register Definitions */
-#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
-#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< \deprecated CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< \deprecated CoreDebug DCRSR: REGWnR Mask */
 
-#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
-#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< \deprecated CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< \deprecated CoreDebug DCRSR: REGSEL Mask */
 
-/* Debug Exception and Monitor Control Register */
-#define CoreDebug_DEMCR_DWTENA_Pos         24U                                            /*!< CoreDebug DEMCR: DWTENA Position */
-#define CoreDebug_DEMCR_DWTENA_Msk         (1UL << CoreDebug_DEMCR_DWTENA_Pos)            /*!< CoreDebug DEMCR: DWTENA Mask */
+/* Debug Exception and Monitor Control Register Definitions */
+#define CoreDebug_DEMCR_DWTENA_Pos         24U                                            /*!< \deprecated CoreDebug DEMCR: DWTENA Position */
+#define CoreDebug_DEMCR_DWTENA_Msk         (1UL << CoreDebug_DEMCR_DWTENA_Pos)            /*!< \deprecated CoreDebug DEMCR: DWTENA Mask */
 
-#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
-#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< \deprecated CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< \deprecated CoreDebug DEMCR: VC_HARDERR Mask */
 
-#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
-#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< \deprecated CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< \deprecated CoreDebug DEMCR: VC_CORERESET Mask */
 
 /* Debug Authentication Control Register Definitions */
-#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
-#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< \deprecated CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< \deprecated CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
 
-#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
-#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< \deprecated CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< \deprecated CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
 
-#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
-#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< \deprecated CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< \deprecated CoreDebug DAUTHCTRL: INTSPIDEN Mask */
 
-#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
-#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< \deprecated CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< \deprecated CoreDebug DAUTHCTRL: SPIDENSEL Mask */
 
 /* Debug Security Control and Status Register Definitions */
-#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
-#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< \deprecated CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< \deprecated CoreDebug DSCSR: CDS Mask */
 
-#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
-#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< \deprecated CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< \deprecated CoreDebug DSCSR: SBRSEL Mask */
 
-#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
-#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< \deprecated CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< \deprecated CoreDebug DSCSR: SBRSELEN Mask */
 
 /*@} end of group CMSIS_CoreDebug */
 
 
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup CMSIS_DCB       Debug Control Block
+  \brief    Type definitions for the Debug Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Debug Control Block Registers (DCB).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED0[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} DCB_Type;
+
+/* DHCSR, Debug Halting Control and Status Register Definitions */
+#define DCB_DHCSR_DBGKEY_Pos               16U                                            /*!< DCB DHCSR: Debug key Position */
+#define DCB_DHCSR_DBGKEY_Msk               (0xFFFFUL << DCB_DHCSR_DBGKEY_Pos)             /*!< DCB DHCSR: Debug key Mask */
+
+#define DCB_DHCSR_S_RESTART_ST_Pos         26U                                            /*!< DCB DHCSR: Restart sticky status Position */
+#define DCB_DHCSR_S_RESTART_ST_Msk         (0x1UL << DCB_DHCSR_S_RESTART_ST_Pos)          /*!< DCB DHCSR: Restart sticky status Mask */
+
+#define DCB_DHCSR_S_RESET_ST_Pos           25U                                            /*!< DCB DHCSR: Reset sticky status Position */
+#define DCB_DHCSR_S_RESET_ST_Msk           (0x1UL << DCB_DHCSR_S_RESET_ST_Pos)            /*!< DCB DHCSR: Reset sticky status Mask */
+
+#define DCB_DHCSR_S_RETIRE_ST_Pos          24U                                            /*!< DCB DHCSR: Retire sticky status Position */
+#define DCB_DHCSR_S_RETIRE_ST_Msk          (0x1UL << DCB_DHCSR_S_RETIRE_ST_Pos)           /*!< DCB DHCSR: Retire sticky status Mask */
+
+#define DCB_DHCSR_S_SDE_Pos                20U                                            /*!< DCB DHCSR: Secure debug enabled Position */
+#define DCB_DHCSR_S_SDE_Msk                (0x1UL << DCB_DHCSR_S_SDE_Pos)                 /*!< DCB DHCSR: Secure debug enabled Mask */
+
+#define DCB_DHCSR_S_LOCKUP_Pos             19U                                            /*!< DCB DHCSR: Lockup status Position */
+#define DCB_DHCSR_S_LOCKUP_Msk             (0x1UL << DCB_DHCSR_S_LOCKUP_Pos)              /*!< DCB DHCSR: Lockup status Mask */
+
+#define DCB_DHCSR_S_SLEEP_Pos              18U                                            /*!< DCB DHCSR: Sleeping status Position */
+#define DCB_DHCSR_S_SLEEP_Msk              (0x1UL << DCB_DHCSR_S_SLEEP_Pos)               /*!< DCB DHCSR: Sleeping status Mask */
+
+#define DCB_DHCSR_S_HALT_Pos               17U                                            /*!< DCB DHCSR: Halted status Position */
+#define DCB_DHCSR_S_HALT_Msk               (0x1UL << DCB_DHCSR_S_HALT_Pos)                /*!< DCB DHCSR: Halted status Mask */
+
+#define DCB_DHCSR_S_REGRDY_Pos             16U                                            /*!< DCB DHCSR: Register ready status Position */
+#define DCB_DHCSR_S_REGRDY_Msk             (0x1UL << DCB_DHCSR_S_REGRDY_Pos)              /*!< DCB DHCSR: Register ready status Mask */
+
+#define DCB_DHCSR_C_MASKINTS_Pos            3U                                            /*!< DCB DHCSR: Mask interrupts control Position */
+#define DCB_DHCSR_C_MASKINTS_Msk           (0x1UL << DCB_DHCSR_C_MASKINTS_Pos)            /*!< DCB DHCSR: Mask interrupts control Mask */
+
+#define DCB_DHCSR_C_STEP_Pos                2U                                            /*!< DCB DHCSR: Step control Position */
+#define DCB_DHCSR_C_STEP_Msk               (0x1UL << DCB_DHCSR_C_STEP_Pos)                /*!< DCB DHCSR: Step control Mask */
+
+#define DCB_DHCSR_C_HALT_Pos                1U                                            /*!< DCB DHCSR: Halt control Position */
+#define DCB_DHCSR_C_HALT_Msk               (0x1UL << DCB_DHCSR_C_HALT_Pos)                /*!< DCB DHCSR: Halt control Mask */
+
+#define DCB_DHCSR_C_DEBUGEN_Pos             0U                                            /*!< DCB DHCSR: Debug enable control Position */
+#define DCB_DHCSR_C_DEBUGEN_Msk            (0x1UL /*<< DCB_DHCSR_C_DEBUGEN_Pos*/)         /*!< DCB DHCSR: Debug enable control Mask */
+
+/* DCRSR, Debug Core Register Select Register Definitions */
+#define DCB_DCRSR_REGWnR_Pos               16U                                            /*!< DCB DCRSR: Register write/not-read Position */
+#define DCB_DCRSR_REGWnR_Msk               (0x1UL << DCB_DCRSR_REGWnR_Pos)                /*!< DCB DCRSR: Register write/not-read Mask */
+
+#define DCB_DCRSR_REGSEL_Pos                0U                                            /*!< DCB DCRSR: Register selector Position */
+#define DCB_DCRSR_REGSEL_Msk               (0x7FUL /*<< DCB_DCRSR_REGSEL_Pos*/)           /*!< DCB DCRSR: Register selector Mask */
+
+/* DCRDR, Debug Core Register Data Register Definitions */
+#define DCB_DCRDR_DBGTMP_Pos                0U                                            /*!< DCB DCRDR: Data temporary buffer Position */
+#define DCB_DCRDR_DBGTMP_Msk               (0xFFFFFFFFUL /*<< DCB_DCRDR_DBGTMP_Pos*/)     /*!< DCB DCRDR: Data temporary buffer Mask */
+
+/* DEMCR, Debug Exception and Monitor Control Register Definitions */
+#define DCB_DEMCR_TRCENA_Pos               24U                                            /*!< DCB DEMCR: Trace enable Position */
+#define DCB_DEMCR_TRCENA_Msk               (0x1UL << DCB_DEMCR_TRCENA_Pos)                /*!< DCB DEMCR: Trace enable Mask */
+
+#define DCB_DEMCR_VC_HARDERR_Pos           10U                                            /*!< DCB DEMCR: Vector Catch HardFault errors Position */
+#define DCB_DEMCR_VC_HARDERR_Msk           (0x1UL << DCB_DEMCR_VC_HARDERR_Pos)            /*!< DCB DEMCR: Vector Catch HardFault errors Mask */
+
+#define DCB_DEMCR_VC_CORERESET_Pos          0U                                            /*!< DCB DEMCR: Vector Catch Core reset Position */
+#define DCB_DEMCR_VC_CORERESET_Msk         (0x1UL /*<< DCB_DEMCR_VC_CORERESET_Pos*/)      /*!< DCB DEMCR: Vector Catch Core reset Mask */
+
+/* DAUTHCTRL, Debug Authentication Control Register Definitions */
+#define DCB_DAUTHCTRL_INTSPNIDEN_Pos        3U                                            /*!< DCB DAUTHCTRL: Internal Secure non-invasive debug enable Position */
+#define DCB_DAUTHCTRL_INTSPNIDEN_Msk       (0x1UL << DCB_DAUTHCTRL_INTSPNIDEN_Pos)        /*!< DCB DAUTHCTRL: Internal Secure non-invasive debug enable Mask */
+
+#define DCB_DAUTHCTRL_SPNIDENSEL_Pos        2U                                            /*!< DCB DAUTHCTRL: Secure non-invasive debug enable select Position */
+#define DCB_DAUTHCTRL_SPNIDENSEL_Msk       (0x1UL << DCB_DAUTHCTRL_SPNIDENSEL_Pos)        /*!< DCB DAUTHCTRL: Secure non-invasive debug enable select Mask */
+
+#define DCB_DAUTHCTRL_INTSPIDEN_Pos         1U                                            /*!< DCB DAUTHCTRL: Internal Secure invasive debug enable Position */
+#define DCB_DAUTHCTRL_INTSPIDEN_Msk        (0x1UL << DCB_DAUTHCTRL_INTSPIDEN_Pos)         /*!< DCB DAUTHCTRL: Internal Secure invasive debug enable Mask */
+
+#define DCB_DAUTHCTRL_SPIDENSEL_Pos         0U                                            /*!< DCB DAUTHCTRL: Secure invasive debug enable select Position */
+#define DCB_DAUTHCTRL_SPIDENSEL_Msk        (0x1UL /*<< DCB_DAUTHCTRL_SPIDENSEL_Pos*/)     /*!< DCB DAUTHCTRL: Secure invasive debug enable select Mask */
+
+/* DSCSR, Debug Security Control and Status Register Definitions */
+#define DCB_DSCSR_CDSKEY_Pos               17U                                            /*!< DCB DSCSR: CDS write-enable key Position */
+#define DCB_DSCSR_CDSKEY_Msk               (0x1UL << DCB_DSCSR_CDSKEY_Pos)                /*!< DCB DSCSR: CDS write-enable key Mask */
+
+#define DCB_DSCSR_CDS_Pos                  16U                                            /*!< DCB DSCSR: Current domain Secure Position */
+#define DCB_DSCSR_CDS_Msk                  (0x1UL << DCB_DSCSR_CDS_Pos)                   /*!< DCB DSCSR: Current domain Secure Mask */
+
+#define DCB_DSCSR_SBRSEL_Pos                1U                                            /*!< DCB DSCSR: Secure banked register select Position */
+#define DCB_DSCSR_SBRSEL_Msk               (0x1UL << DCB_DSCSR_SBRSEL_Pos)                /*!< DCB DSCSR: Secure banked register select Mask */
+
+#define DCB_DSCSR_SBRSELEN_Pos              0U                                            /*!< DCB DSCSR: Secure banked register select enable Position */
+#define DCB_DSCSR_SBRSELEN_Msk             (0x1UL /*<< DCB_DSCSR_SBRSELEN_Pos*/)          /*!< DCB DSCSR: Secure banked register select enable Mask */
+
+/*@} end of group CMSIS_DCB */
+
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DIB       Debug Identification Block
+  \brief    Type definitions for the Debug Identification Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Debug Identification Block Registers (DIB).
+ */
+typedef struct
+{
+  __OM  uint32_t DLAR;                   /*!< Offset: 0x000 ( /W)  SCS Software Lock Access Register */
+  __IM  uint32_t DLSR;                   /*!< Offset: 0x004 (R/ )  SCS Software Lock Status Register */
+  __IM  uint32_t DAUTHSTATUS;            /*!< Offset: 0x008 (R/ )  Debug Authentication Status Register */
+  __IM  uint32_t DDEVARCH;               /*!< Offset: 0x00C (R/ )  SCS Device Architecture Register */
+  __IM  uint32_t DDEVTYPE;               /*!< Offset: 0x010 (R/ )  SCS Device Type Register */
+} DIB_Type;
+
+/* DLAR, SCS Software Lock Access Register Definitions */
+#define DIB_DLAR_KEY_Pos                    0U                                            /*!< DIB DLAR: KEY Position */
+#define DIB_DLAR_KEY_Msk                   (0xFFFFFFFFUL /*<< DIB_DLAR_KEY_Pos */)        /*!< DIB DLAR: KEY Mask */
+
+/* DLSR, SCS Software Lock Status Register Definitions */
+#define DIB_DLSR_nTT_Pos                    2U                                            /*!< DIB DLSR: Not thirty-two bit Position */
+#define DIB_DLSR_nTT_Msk                   (0x1UL << DIB_DLSR_nTT_Pos )                   /*!< DIB DLSR: Not thirty-two bit Mask */
+
+#define DIB_DLSR_SLK_Pos                    1U                                            /*!< DIB DLSR: Software Lock status Position */
+#define DIB_DLSR_SLK_Msk                   (0x1UL << DIB_DLSR_SLK_Pos )                   /*!< DIB DLSR: Software Lock status Mask */
+
+#define DIB_DLSR_SLI_Pos                    0U                                            /*!< DIB DLSR: Software Lock implemented Position */
+#define DIB_DLSR_SLI_Msk                   (0x1UL /*<< DIB_DLSR_SLI_Pos*/)                /*!< DIB DLSR: Software Lock implemented Mask */
+
+/* DAUTHSTATUS, Debug Authentication Status Register Definitions */
+#define DIB_DAUTHSTATUS_SNID_Pos            6U                                            /*!< DIB DAUTHSTATUS: Secure Non-invasive Debug Position */
+#define DIB_DAUTHSTATUS_SNID_Msk           (0x3UL << DIB_DAUTHSTATUS_SNID_Pos )           /*!< DIB DAUTHSTATUS: Secure Non-invasive Debug Mask */
+
+#define DIB_DAUTHSTATUS_SID_Pos             4U                                            /*!< DIB DAUTHSTATUS: Secure Invasive Debug Position */
+#define DIB_DAUTHSTATUS_SID_Msk            (0x3UL << DIB_DAUTHSTATUS_SID_Pos )            /*!< DIB DAUTHSTATUS: Secure Invasive Debug Mask */
+
+#define DIB_DAUTHSTATUS_NSNID_Pos           2U                                            /*!< DIB DAUTHSTATUS: Non-secure Non-invasive Debug Position */
+#define DIB_DAUTHSTATUS_NSNID_Msk          (0x3UL << DIB_DAUTHSTATUS_NSNID_Pos )          /*!< DIB DAUTHSTATUS: Non-secure Non-invasive Debug Mask */
+
+#define DIB_DAUTHSTATUS_NSID_Pos            0U                                            /*!< DIB DAUTHSTATUS: Non-secure Invasive Debug Position */
+#define DIB_DAUTHSTATUS_NSID_Msk           (0x3UL /*<< DIB_DAUTHSTATUS_NSID_Pos*/)        /*!< DIB DAUTHSTATUS: Non-secure Invasive Debug Mask */
+
+/* DDEVARCH, SCS Device Architecture Register Definitions */
+#define DIB_DDEVARCH_ARCHITECT_Pos         21U                                            /*!< DIB DDEVARCH: Architect Position */
+#define DIB_DDEVARCH_ARCHITECT_Msk         (0x7FFUL << DIB_DDEVARCH_ARCHITECT_Pos )       /*!< DIB DDEVARCH: Architect Mask */
+
+#define DIB_DDEVARCH_PRESENT_Pos           20U                                            /*!< DIB DDEVARCH: DEVARCH Present Position */
+#define DIB_DDEVARCH_PRESENT_Msk           (0x1FUL << DIB_DDEVARCH_PRESENT_Pos )          /*!< DIB DDEVARCH: DEVARCH Present Mask */
+
+#define DIB_DDEVARCH_REVISION_Pos          16U                                            /*!< DIB DDEVARCH: Revision Position */
+#define DIB_DDEVARCH_REVISION_Msk          (0xFUL << DIB_DDEVARCH_REVISION_Pos )          /*!< DIB DDEVARCH: Revision Mask */
+
+#define DIB_DDEVARCH_ARCHVER_Pos           12U                                            /*!< DIB DDEVARCH: Architecture Version Position */
+#define DIB_DDEVARCH_ARCHVER_Msk           (0xFUL << DIB_DDEVARCH_ARCHVER_Pos )           /*!< DIB DDEVARCH: Architecture Version Mask */
+
+#define DIB_DDEVARCH_ARCHPART_Pos           0U                                            /*!< DIB DDEVARCH: Architecture Part Position */
+#define DIB_DDEVARCH_ARCHPART_Msk          (0xFFFUL /*<< DIB_DDEVARCH_ARCHPART_Pos*/)     /*!< DIB DDEVARCH: Architecture Part Mask */
+
+/* DDEVTYPE, SCS Device Type Register Definitions */
+#define DIB_DDEVTYPE_SUB_Pos                4U                                            /*!< DIB DDEVTYPE: Sub-type Position */
+#define DIB_DDEVTYPE_SUB_Msk               (0xFUL << DIB_DDEVTYPE_SUB_Pos )               /*!< DIB DDEVTYPE: Sub-type Mask */
+
+#define DIB_DDEVTYPE_MAJOR_Pos              0U                                            /*!< DIB DDEVTYPE: Major type Position */
+#define DIB_DDEVTYPE_MAJOR_Msk             (0xFUL /*<< DIB_DDEVTYPE_MAJOR_Pos*/)          /*!< DIB DDEVTYPE: Major type Mask */
+
+
+/*@} end of group CMSIS_DIB */
+
+
 /**
   \ingroup    CMSIS_core_register
   \defgroup   CMSIS_core_bitfield     Core register bit field macros
@@ -1113,7 +1301,9 @@ typedef struct
   #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
   #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
   #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
-  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< \deprecated Core Debug Base Address */
+  #define DCB_BASE            (0xE000EDF0UL)                             /*!< DCB Base Address */
+  #define DIB_BASE            (0xE000EFB0UL)                             /*!< DIB Base Address */
   #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
   #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
   #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
@@ -1124,7 +1314,9 @@ typedef struct
   #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
   #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
   #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
-  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< \deprecated Core Debug configuration struct */
+  #define DCB                 ((DCB_Type       *)     DCB_BASE         ) /*!< DCB configuration struct */
+  #define DIB                 ((DIB_Type       *)     DIB_BASE         ) /*!< DIB configuration struct */
 
   #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
     #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
@@ -1138,7 +1330,9 @@ typedef struct
 
 #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
   #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
-  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< \deprecated Core Debug Base Address           (non-secure address space) */
+  #define DCB_BASE_NS         (0xE002EDF0UL)                             /*!< DCB Base Address                  (non-secure address space) */
+  #define DIB_BASE_NS         (0xE002EFB0UL)                             /*!< DIB Base Address                  (non-secure address space) */
   #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
   #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
   #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
@@ -1146,7 +1340,9 @@ typedef struct
   #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
   #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
   #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
-  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< \deprecated Core Debug configuration struct   (non-secure address space) */
+  #define DCB_NS              ((DCB_Type       *)     DCB_BASE_NS      ) /*!< DCB configuration struct          (non-secure address space) */
+  #define DIB_NS              ((DIB_Type       *)     DIB_BASE_NS      ) /*!< DIB configuration struct          (non-secure address space) */
 
   #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
     #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
@@ -1163,6 +1359,7 @@ typedef struct
   Core Function Interface contains:
   - Core NVIC Functions
   - Core SysTick Functions
+  - Core Debug Functions
   - Core Register Access Functions
  ******************************************************************************/
 /**
@@ -1223,7 +1420,7 @@ typedef struct
 #define EXC_RETURN_DCRS            (0x00000020UL)     /* bit [5] stacking rules for called registers: 0=skipped 1=saved       */
 #define EXC_RETURN_FTYPE           (0x00000010UL)     /* bit [4] allocate stack for floating-point context: 0=done 1=skipped  */
 #define EXC_RETURN_MODE            (0x00000008UL)     /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode      */
-#define EXC_RETURN_SPSEL           (0x00000002UL)     /* bit [1] stack pointer used to restore context: 0=MSP 1=PSP           */
+#define EXC_RETURN_SPSEL           (0x00000004UL)     /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP           */
 #define EXC_RETURN_ES              (0x00000001UL)     /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */
 
 /* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking                            */
@@ -1253,7 +1450,9 @@ __STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
   if ((int32_t)(IRQn) >= 0)
   {
+    __COMPILER_BARRIER();
     NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __COMPILER_BARRIER();
   }
 }
 
@@ -1552,6 +1751,7 @@ __STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
   uint32_t *vectors = (uint32_t *)0x0U;
 #endif
   vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+  __DSB();
 }
 
 
@@ -1835,6 +2035,110 @@ __STATIC_INLINE void TZ_SAU_Disable(void)
 
 
 
+/* ##################################    Debug Control function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_DCBFunctions Debug Control Functions
+  \brief    Functions that access the Debug Control Block.
+  @{
+ */
+
+ 
+/**
+  \brief   Set Debug Authentication Control Register
+  \details writes to Debug Authentication Control register.
+  \param [in]  value  value to be writen.
+ */
+__STATIC_INLINE void DCB_SetAuthCtrl(uint32_t value)
+{
+    __DSB();
+    __ISB();
+    DCB->DAUTHCTRL = value;
+    __DSB();
+    __ISB();
+}
+
+
+/**
+  \brief   Get Debug Authentication Control Register
+  \details Reads Debug Authentication Control register.
+  \return             Debug Authentication Control Register.
+ */
+__STATIC_INLINE uint32_t DCB_GetAuthCtrl(void)
+{
+    return (DCB->DAUTHCTRL);
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Set Debug Authentication Control Register (non-secure)
+  \details writes to non-secure Debug Authentication Control register when in secure state.
+  \param [in]  value  value to be writen
+ */
+__STATIC_INLINE void TZ_DCB_SetAuthCtrl_NS(uint32_t value)
+{
+    __DSB();
+    __ISB();
+    DCB_NS->DAUTHCTRL = value;
+    __DSB();
+    __ISB();
+}
+
+
+/**
+  \brief   Get Debug Authentication Control Register (non-secure)
+  \details Reads non-secure Debug Authentication Control register when in secure state.
+  \return             Debug Authentication Control Register.
+ */
+__STATIC_INLINE uint32_t TZ_DCB_GetAuthCtrl_NS(void)
+{
+    return (DCB_NS->DAUTHCTRL);
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_DCBFunctions */
+
+
+
+
+/* ##################################    Debug Identification function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_DIBFunctions Debug Identification Functions
+  \brief    Functions that access the Debug Identification Block.
+  @{
+ */
+
+ 
+/**
+  \brief   Get Debug Authentication Status Register
+  \details Reads Debug Authentication Status register.
+  \return             Debug Authentication Status Register.
+ */
+__STATIC_INLINE uint32_t DIB_GetAuthStatus(void)
+{
+    return (DIB->DAUTHSTATUS);
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Debug Authentication Status Register (non-secure)
+  \details Reads non-secure Debug Authentication Status register when in secure state.
+  \return             Debug Authentication Status Register.
+ */
+__STATIC_INLINE uint32_t TZ_DIB_GetAuthStatus_NS(void)
+{
+    return (DIB_NS->DAUTHSTATUS);
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_DCBFunctions */
+
+
+
+
 /* ##################################    SysTick function  ############################################ */
 /**
   \ingroup  CMSIS_Core_FunctionInterface