解决了状态更新过程中有一个空缺的问题是因为状态更新中断中有一个循环函数去将数值付给上位机,解决了高频转低频会停不下来的问题,原因是时序问题,修改TIM6和TIM2的优先级可以解决,让TIM6先执行完再出发TIM2就可以避免

PLSR/PLSR/Core/Inc/tim.h

@@ -74,7 +74,8 @@ typedef enum {
 } PLSR_AccelAlgorithm_t;
 
 // 运行状态枚举
-typedef enum {
+typedef enum 
+{
     PLSR_STATE_IDLE = 0,        //< 空闲状态
     PLSR_STATE_ACCEL = 1,       //< 加速状态
     PLSR_STATE_CONST = 2,       //< 匀速状态
@@ -83,7 +84,8 @@ typedef enum {
 } PLSR_RunState_t;
 
 // 路径状态枚举
-typedef enum {
+typedef enum 
+{
     PLSR_ROUTE_IDLE = 0,        // 路径空闲
     PLSR_ROUTE_RUNNING = 1,     // 路径运行中
     PLSR_ROUTE_COMPLETED = 2,   // 路径完成

PLSR/PLSR/Core/Inc/usart.h

@@ -44,8 +44,6 @@ extern UART_HandleTypeDef huart1;
 
 /* USER CODE BEGIN Private defines */
 ///> ==================== 寄存器配置 ====================
-#define MODBUS_HOLDING_REG_COUNT    0x2500    ///> 保持寄存器数量 (40001-49999)
-#define MODBUS_OFFSET               0x1000
 
 #define MODBUS_FC_READ_HOLDING_REGS     0x03  ///> 读保持寄存器
 #define MODBUS_FC_WRITE_REG             0x06
@@ -68,7 +66,6 @@ extern UART_HandleTypeDef huart1;
 typedef struct
 {
     uint8_t slave_address;          ///> 从机地址
-    uint16_t holding_regs[MODBUS_HOLDING_REG_COUNT];    ///> 保持寄存器 (40001-49999)
 } ModbusSlave_t;
 /* USER CODE END Private defines */
 

PLSR/PLSR/Core/Src/main.c

@@ -267,7 +267,7 @@ static void KeyTask(void *p_arg)
     // PLSR_Route_Start(&g_plsr_route);
     while (1) 
     {
-      if(ModbusSlave.holding_regs[0x2000] == 1) //按下发送脉冲按钮后,向0x3000地址写1,松手写2,设置地址偏移为0x1000,所以这里值为0x2000
+      if(FlashSave_Get_Holding_Register(MODBUS_ADDR_PULSE_SEND_BUTTON) == 1) //按下发送脉冲按钮后,向0x3000地址写1,松手写2
       {
           startflag = 1;
           g_plsr_route.route_state = PLSR_ROUTE_IDLE;

PLSR/PLSR/Core/Src/tim.c

@@ -19,6 +19,7 @@
 /* USER CODE END Header */
 /* Includes ------------------------------------------------------------------*/
 #include "tim.h"
+#include "flash_save.h"  // 包含Modbus地址定义和寄存器操作函数
 #include <math.h>  // 用于sinf函数
 
 /* USER CODE BEGIN 0 */
@@ -315,7 +316,7 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
     /* TIM2 interrupt Init */
-    HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);
+    HAL_NVIC_SetPriority(TIM2_IRQn, 4, 4);
     HAL_NVIC_EnableIRQ(TIM2_IRQn);
   /* USER CODE BEGIN TIM2_MspInit 1 */
 
@@ -330,7 +331,7 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
     __HAL_RCC_TIM6_CLK_ENABLE();
 
     // 配置TIM6中断
-    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 5, 5);            
+    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 3, 3);            
     HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);                    
   /* USER CODE BEGIN TIM6_MspInit 1 */
 
@@ -851,8 +852,8 @@ static void PLSR_UpdateGlobalPulseCount(int32_t current_pulse_count)
     }
     // 将32位全局累加脉冲计数分解为两个16位寄存器（支持负数）
     int32_t signed_count = g_plsr_location;  // 使用有符号数进行计算
-    ModbusSlave.holding_regs[0x1000] = signed_count & 0xFFFF;        // 低16位
-    ModbusSlave.holding_regs[0x1001] = (signed_count >> 16) & 0xFFFF; // 高16位
+    backup_data->holding_regs[73] = signed_count & 0xFFFF;
+    backup_data->holding_regs[74] = (signed_count >> 16) & 0xFFFF;
 }
 
 void PLSR_HandleSectionEnd(void)
@@ -866,9 +867,10 @@ void PLSR_HandleSectionEnd(void)
     // 重置部分状态
     g_plsr_route.current_part = PLSR_PART_COMPLETE;
     
-    if(g_plsr_route.current_section_num == g_plsr_route.section_num 
-           && g_plsr_route.section[g_plsr_route.current_section_num - 1].next_section == 0)
+    if(g_plsr_route.current_section_num >= g_plsr_route.section_num
+        && g_plsr_route.section[g_plsr_route.current_section_num - 1].next_section == 0)
     {
+        // 最后一段完成，路径结束
         PLSR_Route_Stop(&g_plsr_route);
     }
     else
@@ -895,14 +897,13 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   // TIM2中断：负责段切换逻辑
   if(htim->Instance == TIM2)
   {     
-    // if(g_plsr_route.current_section_num >= g_plsr_route.section_num && 
-    //                                     g_plsr_route.current_part != PLSR_PART_1 && 
-    //                                     g_plsr_route.run_state == PLSR_STATE_DECEL)
-    // {
-    //     PLSR_Route_PWM_Stop();
-    // }
-    // else PLSR_Section_PWM_Stop();
-    PLSR_Route_PWM_Stop();
+    if(g_plsr_route.current_section_num >= g_plsr_route.section_num && 
+                                        g_plsr_route.current_part != PLSR_PART_1 && 
+                                        g_plsr_route.run_state == PLSR_STATE_DECEL)
+    {
+        PLSR_Route_PWM_Stop();
+    }
+    else PLSR_Section_PWM_Stop();
     if(g_plsr_route.part1_target_freq == g_plsr_route.section[g_plsr_route.current_section_num - 1].target_freq
                                       && g_plsr_route.current_part == 1)
     {
@@ -1053,9 +1054,12 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
         // 更新路由结构体的脉冲计数（使用原子操作保证一致性）
     g_plsr_route.pulse_count = current_pulse_count;
     
+    // 计算当前段的Modbus地址基址
+    uint16_t current_seg_base_addr = MODBUS_ADDR_SEGMENT_BASE + ((g_plsr_route.current_section_num-1) * MODBUS_ADDR_SEGMENT_OFFSET);
+    
     g_plsr_route.section[g_plsr_route.current_section_num-1].target_freq = 
-                       (((uint32_t)ModbusSlave.holding_regs[256+(16*(g_plsr_route.current_section_num-1))]) | 
-                       (uint32_t)ModbusSlave.holding_regs[257+(16*(g_plsr_route.current_section_num-1))]<<16);
+                       ((uint32_t)FlashSave_Get_Holding_Register(current_seg_base_addr + MODBUS_OFFSET_FREQ_LOW)) | 
+                       ((uint32_t)FlashSave_Get_Holding_Register(current_seg_base_addr + MODBUS_OFFSET_FREQ_HIGH) << 16);
                        
     if(g_plsr_route.section[g_plsr_route.current_section_num-1].target_freq != g_plsr_current_target_freq &&
            g_plsr_route.current_part != PLSR_PART_COMPLETE)
@@ -1076,24 +1080,31 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
 }
 
 
+/**
+ * @brief 设置PLSR路径配置参数
+ * @param[in,out] route 路径控制结构体指针
+ * @note 使用Modbus地址映射表中的索引访问寄存器数据
+ */
 void PLSR_Route_Set(PLSR_RouteConfig_t* route)
 {
-    route->output_port = ModbusSlave.holding_regs[0];                     
-    route->dir_port = ModbusSlave.holding_regs[1];
-    route->ext_port = ModbusSlave.holding_regs[2];
-    route->dir_delay = ModbusSlave.holding_regs[3];
-    route->dir_logic = ModbusSlave.holding_regs[4];
-    route->accel_config.accel_algorithm = ModbusSlave.holding_regs[5];
-    route->mode = ModbusSlave.holding_regs[6];          //绝对/相对
-    route->section_num = ModbusSlave.holding_regs[7];   //总段数
-    route->start_section = ModbusSlave.holding_regs[8];
-    route->default_freq = ModbusSlave.holding_regs[9]|ModbusSlave.holding_regs[10]<<16;
-    route->default_accel_time_ms = ModbusSlave.holding_regs[11];
-    route->default_decel_time_ms = ModbusSlave.holding_regs[12];
-
-    // 新增：设置默认加减速时间
-    route->default_accel_time_ms = ModbusSlave.holding_regs[11];  // 使用相同的加速时间
-    route->default_decel_time_ms = ModbusSlave.holding_regs[12];  // 使用相同的减速时间
+    /* 基本配置参数 - 使用Modbus地址访问 */
+    route->output_port = FlashSave_Get_Holding_Register(MODBUS_ADDR_PULSE_OUTPUT_PIN);        ///< 脉冲输出端子
+    route->dir_port = FlashSave_Get_Holding_Register(MODBUS_ADDR_DIRECTION_OUTPUT_PIN);       ///< 方向输出端子
+    route->ext_port = FlashSave_Get_Holding_Register(MODBUS_ADDR_EXT_INPUT_PIN);              ///< 外部输入端子
+    route->dir_delay = FlashSave_Get_Holding_Register(MODBUS_ADDR_DIRECTION_DELAY_TIME);      ///< 方向延时时间
+    route->dir_logic = FlashSave_Get_Holding_Register(MODBUS_ADDR_DIRECTION_LOGIC);           ///< 方向逻辑
+    route->accel_config.accel_algorithm = FlashSave_Get_Holding_Register(MODBUS_ADDR_ACCEL_DECEL_MODE);  ///< 加减速算法
+    route->mode = FlashSave_Get_Holding_Register(MODBUS_ADDR_RUN_MODE);                       ///< 运行模式(绝对/相对)
+    route->section_num = FlashSave_Get_Holding_Register(MODBUS_ADDR_TOTAL_SEGMENTS);           ///< 总段数
+    route->start_section = FlashSave_Get_Holding_Register(MODBUS_ADDR_START_SEGMENT);          ///< 起始段
+    
+    /* 默认频率(32位) = 低16位 | (高16位 << 16) */
+    route->default_freq = ((uint32_t)FlashSave_Get_Holding_Register(MODBUS_ADDR_DEFAULT_SPEED_LOW)) | 
+                         ((uint32_t)FlashSave_Get_Holding_Register(MODBUS_ADDR_DEFAULT_SPEED_HIGH) << 16);
+    
+    route->default_accel_time_ms = FlashSave_Get_Holding_Register(MODBUS_ADDR_DEFAULT_ACCEL_TIME);  ///< 默认加速时间
+    route->default_decel_time_ms = FlashSave_Get_Holding_Register(MODBUS_ADDR_DEFAULT_DECEL_TIME);  ///< 默认减速时间
+
     // 自动更新加减速度
     PLSR_Accel_UpdateRates(route);
 
@@ -1101,15 +1112,25 @@ void PLSR_Route_Set(PLSR_RouteConfig_t* route)
     route->end_freq = 0;                         // 结束频率：0Hz
     route->initial_freq = 0;                     // 加减速初始频率：0Hz
 
-    // 初始化所有段的配置 - 遍历并初始化每个段
+    /* 初始化所有段的配置 - 使用Modbus地址访问段参数 */
     for (uint8_t i = 0; i < route->section_num; i++) 
     {
-    
         route->section[i].section_num = i + 1;
-        route->section[i].target_freq = (((uint32_t)ModbusSlave.holding_regs[256+(16*i)]) | (uint32_t)ModbusSlave.holding_regs[257+(16*i)]<<16);
-        route->section[i].target_pulse = (((int32_t)ModbusSlave.holding_regs[258+(16*i)]) | (int32_t)ModbusSlave.holding_regs[259+(16*i)]<<16);
-        route->section[i].wait_condition.wait_type = ModbusSlave.holding_regs[260+(16*i)];
-        route->section[i].next_section = ModbusSlave.holding_regs[261+(16*i)];
+        
+        /* 计算当前段的Modbus地址基址 */
+        uint16_t seg_base_addr = MODBUS_ADDR_SEGMENT_BASE + (i * MODBUS_ADDR_SEGMENT_OFFSET);
+        
+        /* 目标频率 = 低16位 | (高16位 << 16) */
+        route->section[i].target_freq = ((uint32_t)FlashSave_Get_Holding_Register(seg_base_addr + MODBUS_OFFSET_FREQ_LOW)) | 
+                                       ((uint32_t)FlashSave_Get_Holding_Register(seg_base_addr + MODBUS_OFFSET_FREQ_HIGH) << 16);
+        
+        /* 目标脉冲数 = 低16位 | (高16位 << 16) */
+        route->section[i].target_pulse = ((int32_t)FlashSave_Get_Holding_Register(seg_base_addr + MODBUS_OFFSET_PULSE_COUNT_LOW)) | 
+                                        ((int32_t)FlashSave_Get_Holding_Register(seg_base_addr + MODBUS_OFFSET_PULSE_COUNT_HIGH) << 16);
+        
+        /* 等待条件和跳转编号 */
+        route->section[i].wait_condition.wait_type = FlashSave_Get_Holding_Register(seg_base_addr + MODBUS_OFFSET_WAIT_CONDITION);
+        route->section[i].next_section = FlashSave_Get_Holding_Register(seg_base_addr + MODBUS_OFFSET_JUMP_NUMBER);
     } 
 }
 
@@ -1982,6 +2003,9 @@ void PLSR_Accel_SetDefaultParams(PLSR_RouteConfig_t* route, uint32_t accel_time_
 void PLSR_TaskSectionSwitch(PLSR_RouteConfig_t* route)
 {
     if (route == NULL) return;
+    
+    // 如果路径已完成，直接返回，不执行任何操作
+    if (route->route_state == PLSR_ROUTE_COMPLETED) return;
      /* 获取当前段配置 */
     PLSR_SectionConfig_t* current_section = &route->section[route->current_section_num - 1];
     if(current_section->wait_condition.wait_type == PLSR_WAIT_EXT_EVENT)
@@ -2118,7 +2142,7 @@ uint8_t PLSR_Section_CheckWaitCondition(PLSR_RouteConfig_t* route)
     switch (wait_cond->wait_type) {
         case PLSR_WAIT_PLUSEEND:
             return PLSR_Section_CheckPulseComplete(route); 
-                
+
         case PLSR_WAIT_EXT_EVENT:
             // 外部事件条件：等待外部事件触发
             // 外部事件可通过PLSR_SetExtEvent函数设置
@@ -2225,7 +2249,8 @@ void PLSR_SectionSwitchTask(void *p_arg)
     
     (void)p_arg; // 避免编译器警告
     
-    while (1) {
+    while (1) 
+    {
         /* 等待段切换信号量 */
         OSSemPend(s_section_switch_sem, 0, &err);
         
@@ -2233,6 +2258,5 @@ void PLSR_SectionSwitchTask(void *p_arg)
             /* 信号量获取成功，执行段切换逻辑 */
             PLSR_TaskSectionSwitch(&g_plsr_route);
         }
-        /* 如果信号量获取失败，继续等待下一次信号 */
     }
 }

PLSR/PLSR/Core/Src/usart.c

@@ -19,6 +19,7 @@
 /* USER CODE END Header */
 /* Includes ------------------------------------------------------------------*/
 #include "usart.h"
+#include "flash_save.h"
 
 /* USER CODE BEGIN 0 */
 // USART1缓冲区变量定义 - 添加内存对齐确保DMA传输稳定
@@ -72,7 +73,6 @@ void MX_USART1_UART_Init(void)
   // 初始化Modbus
   Modbus_Init(1);  // 默认从机地址为1
   /* USER CODE END USART1_Init 2 */
-
 }
 
 void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
@@ -276,7 +276,6 @@ void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 void Modbus_Init(uint8_t slave_addr)
 {
     ModbusSlave.slave_address = slave_addr;
-    memset(ModbusSlave.holding_regs, 0, sizeof(ModbusSlave.holding_regs));
 }
 
 /**
@@ -352,8 +351,9 @@ void Modbus_Clear_Pluse(uint8_t* frame, uint16_t length)
     g_plsr_total_pulse_count = 0;  // 假设0x100寄存器用于存储脉冲计数
     g_plsr_location = 0;
     int32_t signed_count = g_plsr_location;  // 使用有符号数进行计算
-    ModbusSlave.holding_regs[0x1000] = signed_count & 0xFFFF;        // 低16位
-    ModbusSlave.holding_regs[0x1001] = (signed_count >> 16) & 0xFFFF; // 高16位
+    /* 使用地址映射更新脉冲计数监控值 */
+    FlashSave_Set_Holding_Register(MODBUS_ADDR_PULSE_COUNT_LOW, signed_count & 0xFFFF);        // 低16位
+    FlashSave_Set_Holding_Register(MODBUS_ADDR_PULSE_COUNT_HIGH, (signed_count >> 16) & 0xFFFF); // 高16位
     Modbus_Send_Response(response, 3);
 }
 
@@ -421,10 +421,10 @@ void Modbus_Handle_SendLog(uint8_t* frame, uint16_t length)
          return;
      }
      
-     uint16_t start_addr = ((frame[2] << 8) | frame[3]) - MODBUS_OFFSET;
+     uint16_t start_addr = (frame[2] << 8) | frame[3];  // 不减去MODBUS_OFFSET，保持原始地址
      uint16_t reg_count = (frame[4] << 8) | frame[5];
      
-     if(reg_count == 0 || reg_count > 125 || start_addr + reg_count > MODBUS_HOLDING_REG_COUNT)
+     if(reg_count == 0 || reg_count > 125)
      {
          Modbus_Send_Exception(MODBUS_FC_READ_HOLDING_REGS, MODBUS_EX_ILLEGAL_DATA_ADDRESS);
          return;
@@ -435,9 +435,26 @@ void Modbus_Handle_SendLog(uint8_t* frame, uint16_t length)
      response[1] = MODBUS_FC_READ_HOLDING_REGS;
      response[2] = reg_count * 2;  // 字节数
      
+     /* 使用地址映射读取寄存器值 */
      for(uint16_t i = 0; i < reg_count; i++)
      {
-         uint16_t reg_value = ModbusSlave.holding_regs[start_addr + i];
+         uint16_t current_addr = start_addr + i;
+         uint16_t reg_value = FlashSave_Get_Holding_Register(current_addr);
+         
+         /* 如果地址无效，返回异常 */
+         if(reg_value == 0 && current_addr != MODBUS_ADDR_PULSE_OUTPUT_PIN) // 避免误判地址0x1000的值为0的情况
+         {
+             // 检查是否为有效地址范围
+             if(!((current_addr >= 0x1000 && current_addr <= 0x100C) ||
+                  (current_addr >= 0x1100 && current_addr <= 0x1195) ||
+                  (current_addr >= 0x2000 && current_addr <= 0x2001) ||
+                  (current_addr == 0x3000)))
+             {
+                 Modbus_Send_Exception(MODBUS_FC_READ_HOLDING_REGS, MODBUS_EX_ILLEGAL_DATA_ADDRESS);
+                 return;
+             }
+         }
+         
          response[3 + i * 2] = (reg_value >> 8) & 0xFF;
          response[4 + i * 2] = reg_value & 0xFF;
      }
@@ -459,19 +476,24 @@ void Modbus_Handle_SendLog(uint8_t* frame, uint16_t length)
          return;
      }
      
-     uint16_t reg_addr = ((frame[2] << 8) | frame[3]); 
-     uint16_t write_addr = ((frame[2] << 8) | frame[3]) - MODBUS_OFFSET;
+     uint16_t reg_addr = (frame[2] << 8) | frame[3];  // 保持原始地址
      uint16_t write_num = (frame[4] << 8) | frame[5];
      
-    if(write_addr > MODBUS_HOLDING_REG_COUNT)
+     /* 检查地址是否有效 */
+     if(!((reg_addr >= 0x1000 && reg_addr <= 0x100C) ||
+          (reg_addr >= 0x1100 && reg_addr <= 0x1195) ||
+          (reg_addr >= 0x2000 && reg_addr <= 0x2001) ||
+          (reg_addr == 0x3000)))
      {
          Modbus_Send_Exception(MODBUS_FC_WRITE_REG, MODBUS_EX_ILLEGAL_DATA_ADDRESS);
          return;
      }
 
-    ModbusSlave.holding_regs[write_addr] = write_num;
+     /* 使用地址映射写入寄存器值 */
+     FlashSave_Set_Holding_Register(reg_addr, write_num);
 
-    BackupSRAM_SaveRegData();
+     /* 保存到备份SRAM */
+     BackupSRAM_SaveRegData();
      
      // 发送响应
      uint8_t response[8];
@@ -498,24 +520,39 @@ void Modbus_Handle_SendLog(uint8_t* frame, uint16_t length)
          return;
      }
      
-     uint16_t start_addr = ((frame[2] << 8) | frame[3]);
-     uint16_t write_addr = ((frame[2] << 8) | frame[3]) - MODBUS_OFFSET;
+     uint16_t start_addr = (frame[2] << 8) | frame[3];  // 保持原始地址
      uint16_t reg_count = (frame[4] << 8) | frame[5];
      
-     if((reg_count == 0) || (reg_count > 123) || ((write_addr + reg_count) > MODBUS_HOLDING_REG_COUNT))
+     if(reg_count == 0 || reg_count > 123)
      {
          Modbus_Send_Exception(MODBUS_FC_WRITE_MULTIPLE_REGS, MODBUS_EX_ILLEGAL_DATA_ADDRESS);
          return;
      }
      
-     // 写入寄存器数据
+     /* 检查所有地址是否有效 */
+     for(uint16_t i = 0; i < reg_count; i++)
+     {
+         uint16_t current_addr = start_addr + i;
+         if(!((current_addr >= 0x1000 && current_addr <= 0x100C) ||
+              (current_addr >= 0x1100 && current_addr <= 0x1195) ||
+              (current_addr >= 0x2000 && current_addr <= 0x2001) ||
+              (current_addr == 0x3000)))
+         {
+             Modbus_Send_Exception(MODBUS_FC_WRITE_MULTIPLE_REGS, MODBUS_EX_ILLEGAL_DATA_ADDRESS);
+             return;
+         }
+     }
+     
+     /* 使用地址映射写入寄存器数据 */
      for(uint16_t i = 0; i < reg_count; i++)
      {
+         uint16_t current_addr = start_addr + i;
          uint16_t reg_value = (frame[7 + i * 2] << 8) | frame[8 + i * 2];
-         ModbusSlave.holding_regs[write_addr + i] = reg_value;
+         FlashSave_Set_Holding_Register(current_addr, reg_value);
      }
 
-    BackupSRAM_SaveRegData();
+     /* 保存到备份SRAM */
+     BackupSRAM_SaveRegData();
      
      // 发送响应
      uint8_t response[8];
@@ -565,29 +602,24 @@ void Modbus_Handle_SendLog(uint8_t* frame, uint16_t length)
 
  /**
   * @brief 设置保持寄存器值
-  * @param addr 寄存器地址
+  * @param addr 寄存器地址（Modbus地址）
   * @param value 寄存器值
   */
  void Modbus_SetHoldingRegister(uint16_t addr, uint16_t value)
  {
-     if(addr < MODBUS_HOLDING_REG_COUNT)
-     {
-         ModbusSlave.holding_regs[addr] = value;
-     }
+     /* 使用地址映射设置寄存器值 */
+     FlashSave_Set_Holding_Register(addr, value);
  }
  
  /**
   * @brief 获取保持寄存器值
-  * @param addr 寄存器地址
+  * @param addr 寄存器地址（Modbus地址）
   * @return 寄存器值
   */
  uint16_t Modbus_GetHoldingRegister(uint16_t addr)
  {
-     if(addr < MODBUS_HOLDING_REG_COUNT)
-     {
-         return ModbusSlave.holding_regs[addr];
-     }
-     return 0;
+     /* 使用地址映射获取寄存器值 */
+     return FlashSave_Get_Holding_Register(addr);
  }
 
  /* USER CODE END 1 */

PLSR/PLSR/EWARM/settings/test.1.dnx

@@ -12,12 +12,12 @@
         <ByteLimit>50</ByteLimit>
     </Stack>
     <StLinkDriver>
-        <stlinkserialNo>46232557</stlinkserialNo>
-        <stlinkfoundProbes />
         <CStepIntDis>_ 0</CStepIntDis>
         <LeaveTargetRunning>_ 0</LeaveTargetRunning>
         <stlinkResetStyle>0</stlinkResetStyle>
         <stlinkResetStrategy>2</stlinkResetStrategy>
+        <stlinkserialNo>46232557</stlinkserialNo>
+        <stlinkfoundProbes />
     </StLinkDriver>
     <DebugChecksum>
         <Checksum>630028761</Checksum>