更新：

1、保持寄存器输出值设定功能验证与bug修复；
2、保持寄存器量程设置功能完成，下限设置尚待验证；

App/APP_WU/Src/apps_gather.c

@@ -393,6 +393,9 @@ void sig_channel_select(uint8_t io, SIG_FUNCTIONS_TYPE type)
 }
 
 //更新设定值（根据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)
@@ -426,9 +429,22 @@ void sig_sv_update(void)
         }
     }
 
-    uint32_t mcpy_temp = (uint32_t)mux2real(mux_signal.data_sv);
+    //本地控制的情况下，保持寄存器的值跟随设定值变化
+    if(get_coil_val(COIL_ADDR_HOLD_SV_CTRL) == 0)
+    {
+        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;
+    }
+
+    //手动输入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);
 }
 
 //数据转换，将输入热电偶电压值转换为实际温度值℃

App/APP_WU/Src/key_functions_setting.c

@@ -1046,6 +1046,9 @@ void key_functions_setting(void)
                 }
                 menu_data.io_on2off = IO_ON;
                 io_on2off_status();
+
+                //切换至本地控制
+                set_coil_val(COIL_ADDR_HOLD_SV_CTRL, 0);
             }
         }
         break;

App/MODBUS/Inc/modbus_register_process.h

@@ -9,6 +9,8 @@
 #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
 
 //自定义离散状态寄存器地址
 
@@ -38,14 +40,25 @@ 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);
 
 //离散输入寄存器，上位机只读
@@ -54,18 +67,26 @@ 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 modbus_reg_update_input(void);
 
-//设置线圈寄存器，输入参数：地址、标志位
-void set_coil_val(uint8_t addr, uint8_t bit_val);
 
-//获取线圈值，应对上位机修改线圈的情况
+
-uint8_t get_coil_val(uint8_t addr);
 
 #endif
 

App/MODBUS/Src/modbus_register_process.c

@@ -172,15 +172,24 @@ void modbus_reg_update_dis(void)
 void modbus_reg_update_hold(void)
 {
     hold_deal_set_work_mode();
+
+    hold_deal_muxsv();
+
+    hold_deal_range_type();
+
+    hold_deal_range_max();
+
+    hold_deal_range_min();
 }
 
 void hold_deal_set_work_mode(void)
 {
     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;
@@ -242,20 +251,276 @@ void hold_deal_set_work_mode(void)
 
 void hold_deal_muxsv(void)
 {
-    float32 real_hold = (HoldReg[HOLD_ADDR_MUX_SV_H] << 16) + HoldReg[HOLD_ADDR_MUX_SV_L];
+    //上位机控制的情况下，设定值跟随保持寄存器的值变化
-    if( real2mux(real_hold) != mux_signal.data_sv )
+    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 )
+        if( (menu_data.scr_now == SCREEN_MAIN)&&(pltdata.yreal_pri_low <= real_hold)&&(real_hold <= pltdata.yreal_pri_up) )
         {
-            mux_signal.data_sv = real2mux(real_hold);
+            set_output(real_hold);
         }
         else
         {
             //拒绝修改
-            uint32_t mcpy_temp = (uint32_t)mux2real(mux_signal.data_sv);
+            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 phyunit_prv = 0;
+uint8_t *p8low = 0, *p8up = 0;
+int16_t *p16low = 0, *p16up = 0;
+int16_t neg_watch = 0;
+void hold_deal_range_type(void)
+{
+    //发生变化时才执行以下操作
+    if( HoldReg[HOLD_ADDR_PHY_UNIT] == phyunit_prv ) return;
+
+    phyunit_prv = HoldReg[HOLD_ADDR_PHY_UNIT];
+    if( HoldReg[HOLD_ADDR_PHY_UNIT] == 0 ) return;
+
+    //选择指定物理量之后，更新上限和下限的寄存器值
+    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];
+
+            memcpy(&neg_watch, HoldReg + HOLD_ADDR_PHY_LOW, 2);
+        }
+        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];
+
+            memcpy(&neg_watch, HoldReg + HOLD_ADDR_PHY_LOW, 2);
+        }
+        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;
+
+            memcpy(&neg_watch, HoldReg + HOLD_ADDR_PHY_LOW, 2);
+        }
+        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;
+            *p16low = 0;
+            *p16up = 0; 
+        }
+        break;
+    }
+}
+
+uint16_t range_max_prv = 0;
+void hold_deal_range_max(void)
+{
+    //发生改变才执行
+    if(range_max_prv == HoldReg[HOLD_ADDR_PHY_UP]) 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 == 0)|(*p8low == 0) ) return;
+
+        uint8_t hold_temp8 = 0x00FF & HoldReg[HOLD_ADDR_PHY_UP];
+
+        if( (*p8low <= hold_temp8)&&(hold_temp8 <= (uint8_t)rg_max) ) 
+        {
+            *p8up = 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( (*p16up == 0)|(*p16low == 0) ) 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;
+
+            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);
+                }
+            }
+        }
+    }
+}
+
+uint16_t range_min_prv = 0;
+void hold_deal_range_min(void)
+{
+    //与hold_deal_range_max相同
+    if(range_min_prv == HoldReg[HOLD_ADDR_PHY_LOW]) return;
+
+    range_min_prv = HoldReg[HOLD_ADDR_PHY_LOW];
+
+    if( (HoldReg[HOLD_ADDR_PHY_UNIT] == 1)|(HoldReg[HOLD_ADDR_PHY_UNIT] == 5) )
+    {
+        if( (*p8up == 0)|(*p8low == 0) ) 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( (*p16up == 0)|(*p16low == 0) ) return;
+
+        int16_t hold_temp16 = 0;
+
+        memcpy(&hold_temp16, HoldReg + HOLD_ADDR_PHY_LOW, 2);
+        if( ((uint8_t)rg_min <= hold_temp16)&&(hold_temp16 <= *p16up) ) 
+        {
+            *p16up = 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);
+                }
+            }
+        }
     }
 }
 

MDK-ARM/signal_generator.uvoptx

@@ -260,6 +260,11 @@
           <WinNumber>1</WinNumber>
           <ItemText>progout_data,0x0A</ItemText>
         </Ww>
+        <Ww>
+          <count>21</count>
+          <WinNumber>1</WinNumber>
+          <ItemText>neg_watch,0x0A</ItemText>
+        </Ww>
       </WatchWindow1>
       <WatchWindow2>
         <Ww>