解决有卡顿的问题,添加正弦加减速功能

.vscode/settings.json

@@ -0,0 +1,17 @@
+{
+    "files.associations": {
+        "usart.h": "c",
+        "modbus_log.h": "c",
+        "ucos_ii.h": "c",
+        "app_cfg.h": "c",
+        "tim.h": "c",
+        "tool.h": "c",
+        "main.h": "c",
+        "ctype.h": "c",
+        "math.h": "c",
+        "stm32f4xx_hal.h": "c",
+        "stm32f4xx_hal_conf.h": "c",
+        "intrinsics.h": "c",
+        "gpio.h": "c"
+    }
+}

PLSR/PLSR/Core/Inc/flash_save.h

@@ -0,0 +1,161 @@
+#ifndef FLASH_SAVE_H
+#define FLASH_SAVE_H
+
+#include "stm32f4xx_hal.h"
+#include <stdint.h>
+
+// 实际需要的寄存器数量（优化内存使用）
+#define MODBUS_ACTUAL_REG_COUNT     76      // 实际使用的寄存器数量
+
+// Modbus 地址宏定义
+// 基本配置参数地址 (0x1000-0x100C)
+#define MODBUS_ADDR_PULSE_OUTPUT_PIN        0x1000  // 脉冲发送端子
+#define MODBUS_ADDR_DIRECTION_OUTPUT_PIN    0x1001  // 脉冲方向端子
+#define MODBUS_ADDR_EXT_INPUT_PIN           0x1002  // EXT信号
+#define MODBUS_ADDR_DIRECTION_DELAY_TIME    0x1003  // 脉冲方向延时时间
+#define MODBUS_ADDR_DIRECTION_LOGIC         0x1004  // 脉冲方向逻辑
+#define MODBUS_ADDR_ACCEL_DECEL_MODE        0x1005  // 脉冲加减速模式
+#define MODBUS_ADDR_RUN_MODE                0x1006  // 运行模式
+#define MODBUS_ADDR_TOTAL_SEGMENTS          0x1007  // 脉冲总段数
+#define MODBUS_ADDR_START_SEGMENT           0x1008  // 起始执行段数
+#define MODBUS_ADDR_DEFAULT_SPEED_LOW       0x1009  // 脉冲默认速度低16位
+#define MODBUS_ADDR_DEFAULT_SPEED_HIGH      0x100A  // 脉冲默认速度高16位
+#define MODBUS_ADDR_DEFAULT_ACCEL_TIME      0x100B  // 脉冲默认速度加速时间
+#define MODBUS_ADDR_DEFAULT_DECEL_TIME      0x100C  // 脉冲默认速度减速时间
+
+// 段参数地址基址定义
+#define MODBUS_ADDR_SEGMENT_BASE            0x1100  // 段参数基址
+#define MODBUS_ADDR_SEGMENT_OFFSET          0x0010  // 段间地址偏移
+
+// 段参数偏移定义
+#define MODBUS_OFFSET_FREQ_LOW              0x0000  // 脉冲频率低16位偏移
+#define MODBUS_OFFSET_FREQ_HIGH             0x0001  // 脉冲频率高16位偏移
+#define MODBUS_OFFSET_PULSE_COUNT_LOW       0x0002  // 脉冲个数低16位偏移
+#define MODBUS_OFFSET_PULSE_COUNT_HIGH      0x0003  // 脉冲个数高16位偏移
+#define MODBUS_OFFSET_WAIT_CONDITION        0x0004  // 等待条件偏移
+#define MODBUS_OFFSET_JUMP_NUMBER           0x0005  // 跳转编号偏移
+
+// 各段参数地址宏定义
+#define MODBUS_ADDR_SEG1_FREQ_LOW           0x1100  // 第1段脉冲频率低16位
+#define MODBUS_ADDR_SEG1_FREQ_HIGH          0x1101  // 第1段脉冲频率高16位
+#define MODBUS_ADDR_SEG1_PULSE_COUNT_LOW    0x1102  // 第1段脉冲个数低16位
+#define MODBUS_ADDR_SEG1_PULSE_COUNT_HIGH   0x1103  // 第1段脉冲个数高16位
+#define MODBUS_ADDR_SEG1_WAIT_CONDITION     0x1104  // 第1段等待条件
+#define MODBUS_ADDR_SEG1_JUMP_NUMBER        0x1105  // 第1段跳转编号
+
+#define MODBUS_ADDR_SEG2_FREQ_LOW           0x1110  // 第2段脉冲频率低16位
+#define MODBUS_ADDR_SEG2_FREQ_HIGH          0x1111  // 第2段脉冲频率高16位
+#define MODBUS_ADDR_SEG2_PULSE_COUNT_LOW    0x1112  // 第2段脉冲个数低16位
+#define MODBUS_ADDR_SEG2_PULSE_COUNT_HIGH   0x1113  // 第2段脉冲个数高16位
+#define MODBUS_ADDR_SEG2_WAIT_CONDITION     0x1114  // 第2段等待条件
+#define MODBUS_ADDR_SEG2_JUMP_NUMBER        0x1115  // 第2段跳转编号
+
+#define MODBUS_ADDR_SEG3_FREQ_LOW           0x1120  // 第3段脉冲频率低16位
+#define MODBUS_ADDR_SEG3_FREQ_HIGH          0x1121  // 第3段脉冲频率高16位
+#define MODBUS_ADDR_SEG3_PULSE_COUNT_LOW    0x1122  // 第3段脉冲个数低16位
+#define MODBUS_ADDR_SEG3_PULSE_COUNT_HIGH   0x1123  // 第3段脉冲个数高16位
+#define MODBUS_ADDR_SEG3_WAIT_CONDITION     0x1124  // 第3段等待条件
+#define MODBUS_ADDR_SEG3_JUMP_NUMBER        0x1125  // 第3段跳转编号
+
+#define MODBUS_ADDR_SEG4_FREQ_LOW           0x1130  // 第4段脉冲频率低16位
+#define MODBUS_ADDR_SEG4_FREQ_HIGH          0x1131  // 第4段脉冲频率高16位
+#define MODBUS_ADDR_SEG4_PULSE_COUNT_LOW    0x1132  // 第4段脉冲个数低16位
+#define MODBUS_ADDR_SEG4_PULSE_COUNT_HIGH   0x1133  // 第4段脉冲个数高16位
+#define MODBUS_ADDR_SEG4_WAIT_CONDITION     0x1134  // 第4段等待条件
+#define MODBUS_ADDR_SEG4_JUMP_NUMBER        0x1135  // 第4段跳转编号
+
+#define MODBUS_ADDR_SEG5_FREQ_LOW           0x1140  // 第5段脉冲频率低16位
+#define MODBUS_ADDR_SEG5_FREQ_HIGH          0x1141  // 第5段脉冲频率高16位
+#define MODBUS_ADDR_SEG5_PULSE_COUNT_LOW    0x1142  // 第5段脉冲个数低16位
+#define MODBUS_ADDR_SEG5_PULSE_COUNT_HIGH   0x1143  // 第5段脉冲个数高16位
+#define MODBUS_ADDR_SEG5_WAIT_CONDITION     0x1144  // 第5段等待条件
+#define MODBUS_ADDR_SEG5_JUMP_NUMBER        0x1145  // 第5段跳转编号
+
+#define MODBUS_ADDR_SEG6_FREQ_LOW           0x1150  // 第6段脉冲频率低16位
+#define MODBUS_ADDR_SEG6_FREQ_HIGH          0x1151  // 第6段脉冲频率高16位
+#define MODBUS_ADDR_SEG6_PULSE_COUNT_LOW    0x1152  // 第6段脉冲个数低16位
+#define MODBUS_ADDR_SEG6_PULSE_COUNT_HIGH   0x1153  // 第6段脉冲个数高16位
+#define MODBUS_ADDR_SEG6_WAIT_CONDITION     0x1154  // 第6段等待条件
+#define MODBUS_ADDR_SEG6_JUMP_NUMBER        0x1155  // 第6段跳转编号
+
+#define MODBUS_ADDR_SEG7_FREQ_LOW           0x1160  // 第7段脉冲频率低16位
+#define MODBUS_ADDR_SEG7_FREQ_HIGH          0x1161  // 第7段脉冲频率高16位
+#define MODBUS_ADDR_SEG7_PULSE_COUNT_LOW    0x1162  // 第7段脉冲个数低16位
+#define MODBUS_ADDR_SEG7_PULSE_COUNT_HIGH   0x1163  // 第7段脉冲个数高16位
+#define MODBUS_ADDR_SEG7_WAIT_CONDITION     0x1164  // 第7段等待条件
+#define MODBUS_ADDR_SEG7_JUMP_NUMBER        0x1165  // 第7段跳转编号
+
+#define MODBUS_ADDR_SEG8_FREQ_LOW           0x1170  // 第8段脉冲频率低16位
+#define MODBUS_ADDR_SEG8_FREQ_HIGH          0x1171  // 第8段脉冲频率高16位
+#define MODBUS_ADDR_SEG8_PULSE_COUNT_LOW    0x1172  // 第8段脉冲个数低16位
+#define MODBUS_ADDR_SEG8_PULSE_COUNT_HIGH   0x1173  // 第8段脉冲个数高16位
+#define MODBUS_ADDR_SEG8_WAIT_CONDITION     0x1174  // 第8段等待条件
+#define MODBUS_ADDR_SEG8_JUMP_NUMBER        0x1175  // 第8段跳转编号
+
+#define MODBUS_ADDR_SEG9_FREQ_LOW           0x1180  // 第9段脉冲频率低16位
+#define MODBUS_ADDR_SEG9_FREQ_HIGH          0x1181  // 第9段脉冲频率高16位
+#define MODBUS_ADDR_SEG9_PULSE_COUNT_LOW    0x1182  // 第9段脉冲个数低16位
+#define MODBUS_ADDR_SEG9_PULSE_COUNT_HIGH   0x1183  // 第9段脉冲个数高16位
+#define MODBUS_ADDR_SEG9_WAIT_CONDITION     0x1184  // 第9段等待条件
+#define MODBUS_ADDR_SEG9_JUMP_NUMBER        0x1185  // 第9段跳转编号
+
+#define MODBUS_ADDR_SEG10_FREQ_LOW          0x1190  // 第10段脉冲频率低16位
+#define MODBUS_ADDR_SEG10_FREQ_HIGH         0x1191  // 第10段脉冲频率高16位
+#define MODBUS_ADDR_SEG10_PULSE_COUNT_LOW   0x1192  // 第10段脉冲个数低16位
+#define MODBUS_ADDR_SEG10_PULSE_COUNT_HIGH  0x1193  // 第10段脉冲个数高16位
+#define MODBUS_ADDR_SEG10_WAIT_CONDITION    0x1194  // 第10段等待条件
+#define MODBUS_ADDR_SEG10_JUMP_NUMBER       0x1195  // 第10段跳转编号
+
+// 监控值地址 (0x2000-0x2001)
+#define MODBUS_ADDR_PULSE_COUNT_MONITOR_LOW  0x2000  // 脉冲个数监控值低16位
+#define MODBUS_ADDR_PULSE_COUNT_MONITOR_HIGH 0x2001  // 脉冲个数监控值高16位
+#define MODBUS_ADDR_PULSE_COUNT_LOW          0x2000  // 脉冲个数监控值低16位（别名）
+#define MODBUS_ADDR_PULSE_COUNT_HIGH         0x2001  // 脉冲个数监控值高16位（别名）
+
+// 控制按钮地址 (0x3000)
+#define MODBUS_ADDR_PULSE_SEND_BUTTON       0x3000  // 脉冲发送按钮
+
+// 特殊值定义
+#define MODBUS_INVALID_ADDRESS              0xFFFF  // 无效地址标识
+
+// 地址映射结构体
+typedef struct {
+    uint16_t modbus_addr;    ///< Modbus地址s
+    uint16_t array_index;    ///< 数组索引
+} modbus_addr_map_t;
+
+
+// 备份SRAM相关定义
+#define BACKUP_SRAM_BASE    0x40024000
+#define BACKUP_MAGIC_NUMBER 0x12345678
+#define BKPSRAM_BASE_ADDR   ((uint32_t)0x40024000)
+
+#define OFFSET_REGS   0x00   // 假设占字节
+/**
+ * @brief 备份数据结构
+ * @note 使用MODBUS_ACTUAL_REG_COUNT(76)作为数组大小，减少内存占用
+ */
+typedef struct {
+    uint16_t holding_regs[MODBUS_ACTUAL_REG_COUNT];  ///< 保持寄存器数组，大小为76
+    uint32_t holding_crc;                            ///< 保持寄存器CRC校验值
+    uint32_t magic_number;                           ///< 魔法数字，用于验证数据有效性
+    uint32_t save_timestamp;                         ///< 保存时间戳（可选）
+} BackupData_t;
+
+void DMA_Start_CopyToBKPSRAM(uint8_t *src, uint32_t len,uint32_t offset);
+void DMA_Start_CopyFromBKPSRAM(uint8_t *dst, uint32_t len, uint32_t offset);
+// ==================== 备份SRAM相关函数 ====================
+void BackupSRAM_Init(void);
+void BackupSRAM_SaveRegData(void);
+uint8_t BackupSRAM_RestoreData(void);
+void BackupSRAM_ClearData(void);
+
+// 全局变量声明
+extern BackupData_t* backup_data;
+
+// Modbus寄存器操作函数
+void FlashSave_Set_Holding_Register(uint16_t address, uint16_t value);
+uint16_t FlashSave_Get_Holding_Register(uint16_t address);
+
+
+#endif // FLASH_SAVE_H

PLSR/PLSR/Core/Inc/modbus_crc.h

@@ -0,0 +1,9 @@
+#ifndef __MODBUS_CRC_H
+#define __MODBUS_CRC_H
+
+#include "stm32f4xx.h"
+
+uint16_t Modbus_CRC16(uint8_t *data, uint16_t length);
+uint8_t Modbus_CheckCRC(uint8_t *data, uint16_t length);
+
+#endif

PLSR/PLSR/Core/Inc/modbus_log.h

@@ -0,0 +1,17 @@
+#ifndef MODBUS_LOG_H
+#define MODBUS_LOG_H
+#include "usart.h"
+
+#define MODBUS_LOG_MAX  128  ///> 最多保存128条记录
+
+typedef struct {
+    uint8_t element_type;    ///> 软元件类型：0x01=保持寄存器，0x02=线圈，0x03=输入寄存器，0x04=离散输入
+    uint8_t function_code;   ///> 功能码：0x01, 0x03, 0x10等
+    uint16_t start_address;  ///> 操作起始地址
+    uint16_t data_len;       ///> 数据长度（读写寄存器数）
+    uint8_t operation_type;  ///> 0x01=读, 0x02=写
+    uint8_t error_code;      ///> 0=无错，其它=异常码（如0x02地址非法）
+}ModbusLog;
+void Modbus_Log(uint8_t element, uint8_t func, uint16_t addr, uint16_t len, uint8_t op_type, uint8_t err);
+extern ModbusLog modbus_logs[MODBUS_LOG_MAX];
+#endif

PLSR/PLSR/Core/Inc/tim.h

@@ -31,7 +31,9 @@ extern "C" {
 #include "math.h"
 #include "ucos_ii.h"
 #include "app_cfg.h"
-
+#include "gpio.h"
+#include <intrinsics.h>
+#include <math.h>  
 /* USER CODE BEGIN Includes */
 
 /* USER CODE END Includes */
@@ -48,26 +50,22 @@ extern TIM_HandleTypeDef htim13;
 
 extern TIM_HandleTypeDef htim14;
 
+/* 全局变量声明 */
+
+
 /* USER CODE BEGIN Private defines */
 // PLSR系统配置参数
 #define PLSR_MAX_SECTIONS     10        // 最大段数
 #define PLSR_PWM_FREQ_MIN     1         // 最小PWM频率 1Hz
 #define PLSR_PWM_FREQ_MAX     100000    // 最大PWM频率 100kHz
-#define PLSR_PWM_FREQ_DEFAULT 1000      // 默认PWM频率 1kHz
-#define PLSR_DUTY_CYCLE       50        // 初始占空比 50%
-
-// PWM输出引脚定义 (仅PF6)
-#define PLSR_PWM_PIN          GPIO_PIN_6   // PF6 - TIM10_CH1
-#define PLSR_PWM_PORT         GPIOF
-
+#define CLAMP_FREQUENCY(v) ((v) > PLSR_PWM_FREQ_MAX ? PLSR_PWM_FREQ_MAX : (uint32_t)(v))
+#define CLAMP_MIN(val, min) ((val) < (min) ? (min) : (val))
+#define DIV_ROUND(a, b) (((a) + ((b)>>1)) / (b))
 // TIM2硬件计数器已删除 - 改用TIM10中断计数
 
 // 等待条件类型枚举
 typedef enum {
     PLSR_WAIT_PLUSEEND = 0,     // 脉冲发送完成
-    PLSR_WAIT_TIME = 4,         // 等待时间
-    PLSR_WAIT_CONDITION = 2,    // 等待条件      
-    PLSR_WAIT_ACT_TIME = 3,     // ACT时间
     PLSR_WAIT_EXT_EVENT = 1,    // 外部事件
     PLSR_WAIT_EXT_OR_END = 5    // 外部事件或结束
 } PLSR_WaitType_t;
@@ -80,7 +78,8 @@ typedef enum {
 } PLSR_AccelAlgorithm_t;
 
 // 运行状态枚举
-typedef enum {
+typedef enum 
+{
     PLSR_STATE_IDLE = 0,        //< 空闲状态
     PLSR_STATE_ACCEL = 1,       //< 加速状态
     PLSR_STATE_CONST = 2,       //< 匀速状态
@@ -89,7 +88,8 @@ typedef enum {
 } PLSR_RunState_t;
 
 // 路径状态枚举
-typedef enum {
+typedef enum 
+{
     PLSR_ROUTE_IDLE = 0,        // 路径空闲
     PLSR_ROUTE_RUNNING = 1,     // 路径运行中
     PLSR_ROUTE_COMPLETED = 2,   // 路径完成
@@ -108,6 +108,7 @@ typedef enum {
     PLSR_DIR_FORWARD = 0,       // 正向
     PLSR_DIR_REVERSE = 1        // 反向
 } PLSR_Direction_t;
+
 /* USER CODE END Private defines */
 
 void MX_TIM2_Init(void); // TIM2恢复用于脉冲计数
@@ -119,86 +120,93 @@ void MX_TIM14_Init(void);
 
 void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
 
-// PLSR等待条件结构体
 typedef struct {
-    PLSR_WaitType_t wait_type;      // 等待条件类型
-    uint32_t wait_time_ms;          // 等待时间(ms)
-    uint32_t act_time_ms;           // ACT时间(ms)
-    uint8_t condition_flag;         // 等待条件标志
-    uint8_t ext_event_flag;         // 外部事件标志
+    /* 加速段参数 */
+    uint32_t accel_jerk;           // 加加速度 (Hz/ms²)
+    uint32_t accel_max;            // 最大加速度 (Hz/ms)
+    uint32_t accel_jerk_time_ms;   // 单边jerk时间 (ms)
+    uint32_t accel_phase1_pulses;  // 加速第一阶段脉冲数
+    uint32_t accel_phase2_pulses;  // 加速第二阶段脉冲数
+    
+    /* 减速段参数 */
+    uint32_t decel_jerk;           // 减加速度 (Hz/ms²)
+    uint32_t decel_max;            // 最大减速度 (Hz/ms)
+    uint32_t decel_jerk_time_ms;   // 单边jerk时间 (ms)
+    uint32_t decel_phase1_pulses;  // 减速第一阶段脉冲数
+    uint32_t decel_phase2_pulses;  // 减速第二阶段脉冲数
+} SCurve_Params_t;
+
+typedef struct 
+{
+    PLSR_WaitType_t wait_type;      ///< 等待条件类型
+    uint8_t ext_event_flag;         ///< 外部事件标志
 } PLSR_WaitCondition_t;
 
-// PLSR加减速配置结构体
 typedef struct {
-    uint32_t accel_time_ms;         // 加速时间(ms)
-    uint32_t decel_time_ms;         // 减速时间(ms)
-    PLSR_AccelAlgorithm_t accel_algorithm;  // 加减速算法
+    PLSR_AccelAlgorithm_t accel_algorithm;  ///< 加减速算法
 } PLSR_AccelConfig_t;
 
-// PLSR段配置结构体
-typedef struct {
-    uint8_t section_num;            // 段号(1-10)
-    uint32_t target_freq;           // 目标频率(Hz)
-    int32_t target_pulse;          // 目标脉冲数
-    int32_t actual_pulse;          ///< 实际可发脉冲数
-    uint8_t next_section;           // 下一段号(0表示结束)
-    PLSR_WaitCondition_t wait_condition;    // 等待条件
+
+typedef struct 
+{
+    uint32_t target_freq;           ///< 目标频率(Hz)
+    int64_t target_pulse;           ///< 目标脉冲数
+    int64_t actual_pulse;           ///< 实际可发脉冲数
+    PLSR_WaitCondition_t wait_condition;    ///< 等待条件
+    uint8_t section_num;            ///< 段号(1-10)
+    uint8_t next_section;           ///< 下一段号(0表示结束)
 } PLSR_SectionConfig_t;
 
-// PLSR路径控制结构体 - 添加三部分状态管理
-typedef struct {
-    PLSR_RouteState_t route_state;  // 路径状态
-    uint8_t current_section_num;    // 当前段号
-    uint32_t current_freq;          // 当前频率
-    uint32_t target_freq;           // 目标频率
-    int32_t pulse_count;           // 当前脉冲计数
-    int32_t prevPulseCount;        // 上阶段目标脉冲
-    uint32_t start_freq;            // 起始频率
-    uint32_t end_freq;              // 结束频率
-    uint8_t output_port;            // 输出端口选择
-    uint8_t ext_port;               // 外部事件端口选择
-    uint8_t dir_port;               ///< 方向端口选择：
-    uint16_t dir_delay;             //<方向延时时间
-    uint16_t dir_logic;             //<脉冲方向逻辑,0-正逻辑(脉冲递增)，1-负逻辑(脉冲递减)
-    PLSR_Mode_t mode;               // 模式(相对/绝对)
-    PLSR_Direction_t direction;     // 方向
-    PLSR_AccelConfig_t accel_config;        // 加减速配置
+typedef struct 
+{
+    uint32_t current_freq;          ///< 当前频率
+    uint32_t target_freq;           ///< 目标频率
+    uint32_t initial_freq;          ///< 加减速初始频率，专门用于存储加减速开始时的频率
+    uint32_t start_freq;            ///< 起始频率
+    uint32_t end_freq;              ///< 结束频率
+    uint32_t part1_target_freq;     ///< 第一部分目标频率
+    uint32_t part2_target_freq;     ///< 第二部分目标频率（匀速频率）
+    uint32_t part3_target_freq;     ///< 第三部分目标频率（通常是0）
+    uint32_t part1_time;
+    uint32_t part3_time;
+    uint32_t freq_step;             ///< 频率步长
+    uint32_t default_freq;          ///< 脉冲默认速度
+
+    int64_t pulse_count;            ///< 当前脉冲计数（支持正负值）
+    int64_t prevPulseCount;         ///< 上阶段目标脉冲
+    int64_t accel_pulse_count;      ///< 第一部分脉冲数（可能是加速、减速或匀速）
+    int64_t const_pulse_count;      ///< 第二部分脉冲数（匀速）
+    int64_t decel_pulse_count;      ///< 第三部分脉冲数（减速到0）
     
-    // 运行状态参数
-    PLSR_RunState_t run_state;      // 当前运行状态
+    uint32_t wait_start_tick;       ///< 等待开始时间
+    uint32_t act_start_tick;        ///< ACT开始时间
+    uint32_t default_accel_time_ms; ///< 默认加速时间(ms)
+    uint32_t default_decel_time_ms; ///< 默认减速时间(ms)
+    uint32_t accel_rate;            ///< 加速度(Hz/ms) = default_freq / default_accel_time_ms
+    uint32_t decel_rate;            ///< 减速度(Hz/ms) = default_freq / default_decel_time_ms
     
-    // 三部分脉冲计数（重新定义用途）
-    int32_t accel_pulse_count;      // 第一部分脉冲数（可能是加速、减速或匀速）
-    int32_t const_pulse_count;      // 第二部分脉冲数（匀速）
-    int32_t decel_pulse_count;      // 第三部分脉冲数（减速到0）
+    PLSR_AccelConfig_t accel_config; ///< 加减速配置
+    PLSR_SectionConfig_t section[PLSR_MAX_SECTIONS];  ///< 段配置数组
     
-    // 新增：三部分状态标识
-    PLSR_RunState_t part1_state;     // 第一部分状态（ACCEL/DECEL/CONST）
-    PLSR_RunState_t part2_state;     // 第二部分状态（通常是CONST）
-    PLSR_RunState_t part3_state;     // 第三部分状态（通常是DECEL）
+    uint16_t dir_delay;             ///< 方向延时时间
+    uint16_t dir_logic;             ///< 脉冲方向逻辑,0-正逻辑(脉冲递增)，1-负逻辑(脉冲递减)
+    uint16_t section_num;           ///< 脉冲总段数
+    uint16_t start_section;         ///< 起始段数
     
-    // 新增：三部分目标频率
-    uint32_t part1_target_freq;      // 第一部分目标频率
-    uint32_t part2_target_freq;      // 第二部分目标频率（匀速频率）
-    uint32_t part3_target_freq;      // 第三部分目标频率（通常是0）
+    PLSR_RouteState_t route_state;  ///< 路径状态
+    SCurve_Params_t scurve;
+    PLSR_RunState_t run_state;      ///< 当前运行状态
+    PLSR_RunState_t part1_state;    ///< 第一部分状态（ACCEL/DECEL/CONST）
+    PLSR_RunState_t part2_state;    ///< 第二部分状态（通常是CONST）
+    PLSR_RunState_t part3_state;    ///< 第三部分状态（通常是DECEL）
+    PLSR_Mode_t mode;               ///< 模式(相对/绝对)
+    PLSR_Direction_t direction;     ///< 方向
     
-    // 新增：当前执行部分
-    uint8_t current_part;            // 当前执行部分：1-第一部分，2-第二部分，3-第三部分
-    
-    uint32_t freq_step;             // 频率步长
-    uint32_t wait_start_tick;       // 等待开始时间
-    uint32_t act_start_tick;        // ACT开始时间
-    uint16_t section_num;           //<脉冲总段数
-    uint16_t start_section;         //<起始段数
-    uint32_t default_freq;          //<脉冲默认速度
-    
-    // 默认加减速参数
-    uint32_t default_accel_time_ms; // 默认加速时间(ms)
-    uint32_t default_decel_time_ms; // 默认减速时间(ms)
-    uint32_t accel_rate;            // 加速度(Hz/ms) = default_freq / default_accel_time_ms
-    uint32_t decel_rate;            // 减速度(Hz/ms) = default_freq / default_decel_time_ms
-    
-    PLSR_SectionConfig_t section[PLSR_MAX_SECTIONS];  // 段配置数组
+    uint8_t current_section_num;    ///< 当前段号
+    uint8_t output_port;            ///< 输出端口选择
+    uint8_t ext_port;               ///< 外部事件端口选择
+    uint8_t dir_port;               ///< 方向端口选择
+    uint8_t current_part;           ///< 当前执行部分：1-第一部分，2-第二部分，3-第三部分
 } PLSR_RouteConfig_t;
 
 // 三部分执行状态枚举
@@ -210,20 +218,22 @@ typedef enum {
 } PLSR_PartState_t;
 
 // 默认参数定义
-#define PLSR_DEFAULT_STEP_FREQ_US     1000  // 默认TIM6更新频率1000微秒(1ms)
-#define PLSR_DEFAULT_ACCEL_TIME_MS    100   // 默认加速时间100ms
-#define PLSR_DEFAULT_DECEL_TIME_MS    100   // 默认减速时间100ms
-#define PLSR_DEFAULT_ACT_TIME_MS      200   // 默认ACT时间200ms
-#define PLSR_DEFAULT_WAIT_TIME_MS     200   // 默认等待时间200ms
-#define PLSR_DEFAULT_START_SECTION    0     // 默认起始段编号
-#define PLSR_TASK_CHECK_INTERVAL      100   // 每100个脉冲通知任务一次
-
-// 基础PWM函数
-// ==================== PWM控制函数 ====================
+#define PLSR_DEFAULT_STEP_FREQ_US     100  // 默认TIM6更新频率1000微秒(1ms)
+#define SCALE_FACTOR 2000ULL
+
+void Calculate_PluseNum(PLSR_RouteConfig_t *route); //<计算段脉冲数,根据加减速率和目标频率计算每段的加速、匀速、减速脉冲数
+void Calculate_PluseNum_Simplified(PLSR_RouteConfig_t *route); //<简化的脉冲数计算,用于快速计算每段的脉冲数,不考虑加减速
+
+uint64_t integer_sqrt_64(uint64_t n);
+uint64_t square_u32(uint32_t x); 
+
 void PLSR_PWM_Init(void);
 void PLSR_PWM_Start(void);
-void PLSR_PWM_Stop(void);
+void PLSR_Section_PWM_Stop(void);
+void PLSR_Route_PWM_Stop();
 void PLSR_PWM_SetFrequency(uint32_t frequency);
+void PLSR_CalculateTimerParams(uint32_t frequency, uint16_t* prescaler, uint32_t* period);
+void PLSR_Fix_Compensated(uint32_t frequency, uint32_t* ccr);
 
 // ==================== PLSR路径控制函数 ====================
 void PLSR_Route_Init(PLSR_RouteConfig_t* route);      //<路径初始化
@@ -234,20 +244,17 @@ void PLSR_Route_Stop(PLSR_RouteConfig_t* route);      //<路径停止
 // ==================== PLSR段控制函数 ====================
 void PLSR_Section_SwitchNext(PLSR_RouteConfig_t* route, uint8_t is_pulse_complete);            //<切换段
 uint8_t PLSR_Section_CheckWaitCondition(PLSR_RouteConfig_t* route); //<检查等待条件是否满足
-void PLSR_Section_StartNewSection(PLSR_RouteConfig_t* route);       //<启动新段,段更新后调用
-void Calculate_PluseNum(PLSR_RouteConfig_t *route); //<计算段脉冲数,根据加减速率和目标频率计算每段的加速、匀速、减速脉冲数
-void Calculate_PluseNum_Simplified(PLSR_RouteConfig_t *route); //<简化的脉冲数计算,用于快速计算每段的脉冲数,不考虑加减速
+uint8_t PLSR_Section_StartNewSection(PLSR_RouteConfig_t* route);       //<启动新段,段更新后调用
 void PLSR_SetupThreePartExecution(PLSR_RouteConfig_t* route); //<设置三部分执行状态和目标频率
 
 // ==================== PLSR加减速算法函数 ====================
 void PLSR_Accel_Process(PLSR_RouteConfig_t* route); //<加减速执行函数(新的直线加减速)
 void PLSR_Accel_UpdateRates(PLSR_RouteConfig_t* route); //<更新加减速度
 void PLSR_Accel_SetDefaultParams(PLSR_RouteConfig_t* route, uint32_t accel_time_ms, uint32_t decel_time_ms); //<设置默认加减速参数
-
-// ==================== PLSR等待条件处理函数 ====================
-void PLSR_Wait_StartTimer(PLSR_RouteConfig_t* route);            //<等待条件计数器
-uint8_t PLSR_Wait_CheckTime(PLSR_RouteConfig_t* route);          //<检查等待时间是否满足 ACT时间或等待时间
-
+uint32_t PLSR_Calculate_FreqByPosition(PLSR_RouteConfig_t* route, uint8_t is_accel); //<根据当前脉冲位置计算频率
+uint32_t PLSR_Calculate_SCurve_FreqByPosition(PLSR_RouteConfig_t* route, uint8_t is_accel);
+uint32_t PLSR_SCurve_Control(PLSR_RouteConfig_t* route);
+void SCurve_InitializeParameters(PLSR_RouteConfig_t* route, uint32_t accel_time_ms, uint32_t decel_time_ms);
 
 // ==================== PLSR TIM6频率配置函数 ====================
 void PLSR_TIM6_SetUpdateFreq(uint32_t freq_us);
@@ -268,10 +275,18 @@ void PLSR_SectionSwitchTask(void *p_arg);
 void PLSR_SectionSwitchInit(void);                                                             //<段切换信号量初始化
 void PLSR_SectionSwitchSignal(void);                                                           //<发送段切换信号量(中断中调用)
 
+uint32_t BinarySearchOptimalFreq(uint32_t v0, uint32_t vt_desired, 
+                                int64_t total_pulses, uint32_t a, uint32_t d, 
+                                uint8_t is_accel); // 二分搜索优化目标频率
+uint32_t OptimalIntermediateFrequency(uint32_t v0, uint32_t vt_desired, 
+                                     int64_t total_pulses, uint32_t a, uint32_t d); // 计算最优中间频率
 // ==================== PLSR全局变量声明 ====================
-extern PLSR_RouteConfig_t g_plsr_route;    // 全局PLSR路径控制结构体
-extern uint8_t g_plsr_ext_event_flag;      // 外部事件标志
-extern int32_t g_plsr_total_pulse_count;   // 全局累加脉冲计数器(程序运行期间持续累加，支持负数) 
+extern PLSR_RouteConfig_t PlsrRoute;    // 全局PLSR路径控制结构体
+extern uint8_t PlsrExtEventFlag;      // 外部事件标志
+extern int64_t PlsrTotalPulseCount;   // 全局累加脉冲计数器(程序运行期间持续累加，支持负数) 
+extern int64_t PlsrLocation;
+extern volatile uint8_t PlsrFreqUpdateRequest;  // 频率更新请求标志(中断安全)
+extern volatile uint32_t PlsrPendingFreq;       // 待更新的频率值(中断安全)
 /* USER CODE END Prototypes */
 
 #ifdef __cplusplus

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/flash_save.c

@@ -0,0 +1,308 @@
+#include "flash_save.h"
+#include "modbus_crc.h"
+#include "stm32f4xx_hal.h"
+#include <string.h>
+
+// 前向声明，避免循环依赖
+typedef struct {
+    uint8_t slave_address;
+} ModbusSlave_t;
+extern ModbusSlave_t ModbusSlave;
+
+// Modbus地址映射表（将Modbus地址映射到紧凑的数组索引）
+static const modbus_addr_map_t modbus_address_map[MODBUS_ACTUAL_REG_COUNT] = {
+    // 基本配置参数 (0x1000-0x100C) -> 索引 0-12
+    {MODBUS_ADDR_PULSE_OUTPUT_PIN, 0}, {MODBUS_ADDR_DIRECTION_OUTPUT_PIN, 1}, {MODBUS_ADDR_EXT_INPUT_PIN, 2}, 
+    {MODBUS_ADDR_DIRECTION_DELAY_TIME, 3}, {MODBUS_ADDR_DIRECTION_LOGIC, 4}, {MODBUS_ADDR_ACCEL_DECEL_MODE, 5},
+    {MODBUS_ADDR_RUN_MODE, 6}, {MODBUS_ADDR_TOTAL_SEGMENTS, 7}, {MODBUS_ADDR_START_SEGMENT, 8}, 
+    {MODBUS_ADDR_DEFAULT_SPEED_LOW, 9}, {MODBUS_ADDR_DEFAULT_SPEED_HIGH, 10}, {MODBUS_ADDR_DEFAULT_ACCEL_TIME, 11}, {MODBUS_ADDR_DEFAULT_DECEL_TIME, 12},
+    
+    // 第1段参数 (0x1100-0x1105) -> 索引 13-18
+    {MODBUS_ADDR_SEG1_FREQ_LOW, 13}, {MODBUS_ADDR_SEG1_FREQ_HIGH, 14}, {MODBUS_ADDR_SEG1_PULSE_COUNT_LOW, 15}, 
+    {MODBUS_ADDR_SEG1_PULSE_COUNT_HIGH, 16}, {MODBUS_ADDR_SEG1_WAIT_CONDITION, 17}, {MODBUS_ADDR_SEG1_JUMP_NUMBER, 18},
+    
+    // 第2段参数 (0x1110-0x1115) -> 索引 19-24
+    {MODBUS_ADDR_SEG2_FREQ_LOW, 19}, {MODBUS_ADDR_SEG2_FREQ_HIGH, 20}, {MODBUS_ADDR_SEG2_PULSE_COUNT_LOW, 21}, 
+    {MODBUS_ADDR_SEG2_PULSE_COUNT_HIGH, 22}, {MODBUS_ADDR_SEG2_WAIT_CONDITION, 23}, {MODBUS_ADDR_SEG2_JUMP_NUMBER, 24},
+    
+    // 第3段参数 (0x1120-0x1125) -> 索引 25-30
+    {MODBUS_ADDR_SEG3_FREQ_LOW, 25}, {MODBUS_ADDR_SEG3_FREQ_HIGH, 26}, {MODBUS_ADDR_SEG3_PULSE_COUNT_LOW, 27}, 
+    {MODBUS_ADDR_SEG3_PULSE_COUNT_HIGH, 28}, {MODBUS_ADDR_SEG3_WAIT_CONDITION, 29}, {MODBUS_ADDR_SEG3_JUMP_NUMBER, 30},
+    
+    // 第4段参数 (0x1130-0x1135) -> 索引 31-36
+    {MODBUS_ADDR_SEG4_FREQ_LOW, 31}, {MODBUS_ADDR_SEG4_FREQ_HIGH, 32}, {MODBUS_ADDR_SEG4_PULSE_COUNT_LOW, 33}, 
+    {MODBUS_ADDR_SEG4_PULSE_COUNT_HIGH, 34}, {MODBUS_ADDR_SEG4_WAIT_CONDITION, 35}, {MODBUS_ADDR_SEG4_JUMP_NUMBER, 36},
+    
+    // 第5段参数 (0x1140-0x1145) -> 索引 37-42
+    {MODBUS_ADDR_SEG5_FREQ_LOW, 37}, {MODBUS_ADDR_SEG5_FREQ_HIGH, 38}, {MODBUS_ADDR_SEG5_PULSE_COUNT_LOW, 39}, 
+    {MODBUS_ADDR_SEG5_PULSE_COUNT_HIGH, 40}, {MODBUS_ADDR_SEG5_WAIT_CONDITION, 41}, {MODBUS_ADDR_SEG5_JUMP_NUMBER, 42},
+    
+    // 第6段参数 (0x1150-0x1155) -> 索引 43-48
+    {MODBUS_ADDR_SEG6_FREQ_LOW, 43}, {MODBUS_ADDR_SEG6_FREQ_HIGH, 44}, {MODBUS_ADDR_SEG6_PULSE_COUNT_LOW, 45}, 
+    {MODBUS_ADDR_SEG6_PULSE_COUNT_HIGH, 46}, {MODBUS_ADDR_SEG6_WAIT_CONDITION, 47}, {MODBUS_ADDR_SEG6_JUMP_NUMBER, 48},
+    
+    // 第7段参数 (0x1160-0x1165) -> 索引 49-54
+    {MODBUS_ADDR_SEG7_FREQ_LOW, 49}, {MODBUS_ADDR_SEG7_FREQ_HIGH, 50}, {MODBUS_ADDR_SEG7_PULSE_COUNT_LOW, 51}, 
+    {MODBUS_ADDR_SEG7_PULSE_COUNT_HIGH, 52}, {MODBUS_ADDR_SEG7_WAIT_CONDITION, 53}, {MODBUS_ADDR_SEG7_JUMP_NUMBER, 54},
+    
+    // 第8段参数 (0x1170-0x1175) -> 索引 55-60
+    {MODBUS_ADDR_SEG8_FREQ_LOW, 55}, {MODBUS_ADDR_SEG8_FREQ_HIGH, 56}, {MODBUS_ADDR_SEG8_PULSE_COUNT_LOW, 57}, 
+    {MODBUS_ADDR_SEG8_PULSE_COUNT_HIGH, 58}, {MODBUS_ADDR_SEG8_WAIT_CONDITION, 59}, {MODBUS_ADDR_SEG8_JUMP_NUMBER, 60},
+    
+    // 第9段参数 (0x1180-0x1185) -> 索引 61-66
+    {MODBUS_ADDR_SEG9_FREQ_LOW, 61}, {MODBUS_ADDR_SEG9_FREQ_HIGH, 62}, {MODBUS_ADDR_SEG9_PULSE_COUNT_LOW, 63}, 
+    {MODBUS_ADDR_SEG9_PULSE_COUNT_HIGH, 64}, {MODBUS_ADDR_SEG9_WAIT_CONDITION, 65}, {MODBUS_ADDR_SEG9_JUMP_NUMBER, 66},
+    
+    // 第10段参数 (0x1190-0x1195) -> 索引 67-72
+    {MODBUS_ADDR_SEG10_FREQ_LOW, 67}, {MODBUS_ADDR_SEG10_FREQ_HIGH, 68}, {MODBUS_ADDR_SEG10_PULSE_COUNT_LOW, 69}, 
+    {MODBUS_ADDR_SEG10_PULSE_COUNT_HIGH, 70}, {MODBUS_ADDR_SEG10_WAIT_CONDITION, 71}, {MODBUS_ADDR_SEG10_JUMP_NUMBER, 72},
+    
+    // 监控值 (0x2000-0x2001) -> 索引 73-74
+    {MODBUS_ADDR_PULSE_COUNT_MONITOR_LOW, 73}, {MODBUS_ADDR_PULSE_COUNT_MONITOR_HIGH, 74},
+    
+    // 控制按钮 (0x3000) -> 索引 75
+    {MODBUS_ADDR_PULSE_SEND_BUTTON, 75}
+};
+
+// 备份SRAM中的数据指针声明在头文件中
+
+/**
+ * @brief 根据Modbus地址获取数组索引
+ * @param modbus_addr: Modbus地址
+ * @retval 数组索引，如果地址无效返回0xFFFF
+ */
+static uint16_t FlashSave_Get_Array_Index(uint16_t modbus_addr)
+{
+    for (uint16_t i = 0; i < MODBUS_ACTUAL_REG_COUNT; i++) {
+        if (modbus_address_map[i].modbus_addr == modbus_addr) 
+        {
+            return modbus_address_map[i].array_index;
+        }
+    }
+    return MODBUS_INVALID_ADDRESS;  // 无效地址
+}
+
+/**
+ * @brief 设置保持寄存器值
+ * @param address: 寄存器地址
+ * @param value: 寄存器值
+ * @retval None
+ */
+void FlashSave_Set_Holding_Register(uint16_t address, uint16_t value)
+{
+    uint16_t array_index = FlashSave_Get_Array_Index(address);
+    if (array_index != MODBUS_INVALID_ADDRESS && backup_data != NULL) {
+        backup_data->holding_regs[array_index] = value;
+    }
+}
+
+/**
+ * @brief 获取保持寄存器值
+ * @param address: 寄存器地址
+ * @retval uint16_t: 寄存器值
+ */
+uint16_t FlashSave_Get_Holding_Register(uint16_t address)
+{
+    uint16_t array_index = FlashSave_Get_Array_Index(address);
+    if (array_index != MODBUS_INVALID_ADDRESS && backup_data != NULL) 
+    {
+        return backup_data->holding_regs[array_index];
+    }
+    return 0;
+}
+
+volatile uint8_t dma_bkpsram_done_flag = 0;
+
+// 添加备份域访问使能函数
+void EnableBackupDomain(void) {
+    // 1. 使能PWR时钟
+    __HAL_RCC_PWR_CLK_ENABLE();
+    
+    // 2. 使能备份域访问
+    HAL_PWR_EnableBkUpAccess();
+}
+
+// DMA句柄
+DMA_HandleTypeDef hdma_backup;
+
+// 备份数据指针定义，指向备份SRAM中的数据结构
+BackupData_t* backup_data = (BackupData_t*)BKPSRAM_BASE_ADDR;
+
+// Error_Handler函数已在main.c中定义，此处移除重复定义
+
+void DMA_Backup_Init(void) 
+{
+    EnableBackupDomain();
+    __HAL_RCC_DMA2_CLK_ENABLE();
+
+    // 配置DMA2 Stream0用于内存到备份SRAM传输
+    hdma_backup.Instance = DMA2_Stream0;
+    hdma_backup.Init.Channel = DMA_CHANNEL_0;
+    hdma_backup.Init.Direction = DMA_MEMORY_TO_MEMORY;
+    hdma_backup.Init.PeriphInc = DMA_PINC_ENABLE;
+    hdma_backup.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_backup.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    hdma_backup.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
+    hdma_backup.Init.Mode = DMA_NORMAL;
+    hdma_backup.Init.Priority = DMA_PRIORITY_HIGH;
+    hdma_backup.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+    hdma_backup.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
+    hdma_backup.Init.MemBurst = DMA_MBURST_SINGLE;
+    hdma_backup.Init.PeriphBurst = DMA_PBURST_SINGLE;
+
+    HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 5, 0);
+    HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
+}
+
+void DMA_Start_CopyToBKPSRAM(uint8_t *src, uint32_t len, uint32_t offset) 
+{
+    EnableBackupDomain();
+    
+    // 停止之前的DMA传输
+    HAL_DMA_Abort(&hdma_backup);
+    
+    // 清除标志位
+    dma_bkpsram_done_flag = 0;
+    
+    // 使用HAL库函数启动DMA传输
+    if(HAL_DMA_Start_IT(&hdma_backup, (uint32_t)src, BKPSRAM_BASE_ADDR + offset, len) != HAL_OK)
+    {
+        // DMA启动失败，设置标志位避免死等
+        dma_bkpsram_done_flag = 1;
+    }
+}
+
+void DMA_Start_CopyFromBKPSRAM(uint8_t *dst, uint32_t len, uint32_t offset) 
+{
+    EnableBackupDomain();
+    
+    // 停止之前的DMA传输
+    HAL_DMA_Abort(&hdma_backup);
+    
+    // 清除标志位
+    dma_bkpsram_done_flag = 0;
+    
+    // 使用HAL库函数启动DMA传输
+    HAL_DMA_Start_IT(&hdma_backup, BKPSRAM_BASE_ADDR + offset, (uint32_t)dst, len);
+     dma_bkpsram_done_flag = 1;
+}
+
+
+// DMA传输完成回调函数
+void HAL_DMA_XferCpltCallback(DMA_HandleTypeDef *hdma)
+{
+    if(hdma->Instance == DMA2_Stream0)
+    {
+        dma_bkpsram_done_flag = 1;
+    }
+}
+
+
+
+
+/**
+ * @brief 初始化备份域和PVD
+ */
+void BackupSRAM_Init(void)
+{
+    // 1. 使能PWR和备份域时钟
+    __HAL_RCC_PWR_CLK_ENABLE();
+    __HAL_RCC_BKPSRAM_CLK_ENABLE();
+    
+    // 2. 使能备份域访问
+    HAL_PWR_EnableBkUpAccess();
+    
+    // 3. 使能备份SRAM
+    HAL_PWREx_EnableBkUpReg();
+    
+    // 4. 等待备份稳压器就绪
+    while(__HAL_PWR_GET_FLAG(PWR_FLAG_BRR) == RESET);
+    
+    // 初始化DMA
+    DMA_Backup_Init();
+}
+
+
+/**
+ * @brief 保存数据到备份SRAM
+ * @note 该函数执行时间很短，适合在掉电中断中调用
+ */
+void BackupSRAM_SaveRegData(void)
+{
+    // 检查备份SRAM是否可用
+    if(__HAL_PWR_GET_FLAG(PWR_FLAG_BRR) == RESET)
+    {
+        return;
+    }
+    
+    /* 使用DMA传输76个uint16_t寄存器到备份SRAM */
+    DMA_Start_CopyToBKPSRAM((uint8_t*)backup_data->holding_regs, 
+                            MODBUS_ACTUAL_REG_COUNT * sizeof(uint16_t),
+                            OFFSET_REGS);
+    
+    // 使用HAL_GetTick()实现100ms超时机制
+    uint32_t start_tick = HAL_GetTick();
+    while(!dma_bkpsram_done_flag)
+    {
+        if((HAL_GetTick() - start_tick) > 100)  // 100ms超时
+        {
+            HAL_DMA_Abort(&hdma_backup);  // 超时则中止DMA传输
+            break;
+        }
+        HAL_Delay(1);  // 让出CPU时间
+    }
+    
+    // 计算CRC校验
+    backup_data->holding_crc = 0xffff;
+}
+
+/**
+ * @brief 从备份SRAM恢复数据
+ * @param[out] 无直接输出参数，数据恢复到backup_data->holding_regs
+ * @return 1-恢复成功, 0-恢复失败
+ * @note 恢复MODBUS_ACTUAL_REG_COUNT(76)个uint16_t寄存器数据
+ */
+uint8_t BackupSRAM_RestoreData(void)
+{
+    if(backup_data->holding_crc != 0xffff)
+    {
+        //printf("Backup holding registers CRC error\r\n");
+        return 0;
+    }
+    
+    /* 确保数据长度为4字节对齐，提高DMA传输效率 */
+    uint32_t transfer_len = MODBUS_ACTUAL_REG_COUNT * sizeof(uint16_t);
+    if(transfer_len % 4 != 0)
+    {
+        transfer_len = ((transfer_len + 3) / 4) * 4;  // 向上对齐到4字节边界
+    }
+    
+    // 恢复保持寄存器
+    DMA_Start_CopyFromBKPSRAM((uint8_t*)backup_data->holding_regs, 
+                            transfer_len, OFFSET_REGS);
+    
+    // 使用HAL_GetTick()实现100ms超时机制
+    uint32_t start_tick = HAL_GetTick();
+    while(!dma_bkpsram_done_flag)
+    {
+        if((HAL_GetTick() - start_tick) > 100)  // 100ms超时
+        {
+            HAL_DMA_Abort(&hdma_backup);  // 超时则中止DMA传输
+            return 0;  // 超时失败
+        }
+        HAL_Delay(1);  // 让出CPU时间
+    }
+    
+    return 1;  // 恢复成功
+}
+
+/**
+ * @brief 清除备份SRAM数据
+ */
+void BackupSRAM_ClearData(void)
+{
+    memset((void*)backup_data, 0, sizeof(BackupData_t));
+}
+
+
+

PLSR/PLSR/Core/Src/gpio.c

@@ -74,9 +74,9 @@ void MX_GPIO_Init(void)
   HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
 
   /* EXTI interrupt init*/
-  HAL_NVIC_SetPriority(EXTI9_5_IRQn, 3, 0);
+  HAL_NVIC_SetPriority(EXTI9_5_IRQn, 1, 0);
 
-  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
+  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 1, 0);
 
 }
 
@@ -103,8 +103,8 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
         {
             s_trigger_flag = 1;  // 设置触发标志，防止重复触发
             
-            g_plsr_ext_event_flag = 1; // 设置外部事件标志
-            PLSR_SetExtEvent(&g_plsr_route); // 将全局标志传递到当前段
+            PlsrExtEventFlag = 1; // 设置外部事件标志
+            PLSR_SetExtEvent(&PlsrRoute); // 将全局标志传递到当前段
             PLSR_SectionSwitchSignal();
             s_last_trigger_time = current_time; // 更新上次触发时间
         }

PLSR/PLSR/Core/Src/main.c

@@ -263,21 +263,20 @@ static void KeyTask(void *p_arg)
     
     OSTimeDly(2000);                    //<等待硬件完全初始化.
     uint8_t startflag = 0; 
-    // 初始化PLSR路径配置
-    PLSR_Route_Init(&g_plsr_route);
+    backup_data->holding_regs[73] = 0 & 0xFFFF;
+    backup_data->holding_regs[74] = (0 >> 16) & 0xFFFF;
     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;
+          PlsrRoute.route_state = PLSR_ROUTE_IDLE;
       }
       else
       {
           if(startflag == 1)
           {
-              PLSR_Route_Init(&g_plsr_route);
-              PLSR_Route_Start(&g_plsr_route);
+              PLSR_Route_Start(&PlsrRoute);
               startflag = 0;
           }
       }

PLSR/PLSR/Core/Src/modbus_crc.c

@@ -0,0 +1,71 @@
+#include "modbus_crc.h"
+
+static const uint16_t crc_table[256] = 
+{
+    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
+    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
+    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
+    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
+    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
+    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
+    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
+    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
+    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
+    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
+    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
+    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
+    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
+    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
+    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
+    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
+    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
+    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
+    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
+    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
+    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
+    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
+    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
+    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
+    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
+    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
+    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
+    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
+    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
+    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
+    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
+    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
+};
+
+/**
+ * @brief 计算Modbus CRC16校验码
+ * @param data 数据指针
+ * @param length 数据长度
+ * @return CRC16校验码
+ */
+uint16_t Modbus_CRC16(uint8_t *data, uint16_t length)
+{
+    uint16_t crc = 0xFFFF;
+    
+    while(length--)
+    {
+        crc = (crc >> 8) ^ crc_table[(crc ^ *data++) & 0xFF];
+    }
+    
+    return crc;
+}
+
+/**
+ * @brief 检查Modbus帧的CRC校验
+ * @param data 帧数据指针
+ * @param length 帧长度（包括CRC）
+ * @return 1:校验正确, 0:校验错误
+ */
+uint8_t Modbus_CheckCRC(uint8_t *data, uint16_t length)
+{
+    if(length < 3) return 0;
+    
+    uint16_t crc_calculated = Modbus_CRC16(data, length - 2);
+    uint16_t crc_received = (data[length-1] << 8) | data[length-2];
+    
+    return (crc_calculated == crc_received) ? 1 : 0;
+}

PLSR/PLSR/Core/Src/modbus_log.c

@@ -0,0 +1,24 @@
+#include "modbus_log.h"
+
+uint16_t log_write_index = 0;
+ModbusLog modbus_logs[MODBUS_LOG_MAX];
+/*@brief  记录Modbus操作日志
+ @param element  软元件类型：0x01=保持寄存器，0x02=线圈，0x03=输入寄存器，0x04=离散输入
+ @param func  功能码：0x01, 0x03, 0x10等
+ @param addr  操作起始地址
+ @param len  数据长度（读写寄存器数）
+ @param op_type  0x01=读, 0x02=写
+ @param err  错误码：0=无错，其它=异常码（如0x02地址非法）
+ */
+void Modbus_Log(uint8_t element, uint8_t func, uint16_t addr, uint16_t len, uint8_t op_type, uint8_t err)
+{
+    ModbusLog* log = &modbus_logs[log_write_index];
+    log->element_type = element;
+    log->function_code = func;
+    log->start_address = addr;
+    log->data_len = len;
+    log->operation_type = op_type;
+    log->error_code = err;
+
+    log_write_index = (log_write_index + 1) % MODBUS_LOG_MAX;
+}

PLSR/PLSR/Core/Src/tools.c

@@ -0,0 +1,971 @@
+#include "tim.h"
+void PLSR_Fix_Compensated(uint32_t frequency, uint32_t* ccr)
+{  
+    if (frequency >= 100000)      // >= 100kHz
+    {
+        *ccr *= 1.05f;  // 5% 补偿
+    }
+    else if (frequency >= 50000)  // 50-100kHz
+    {
+        *ccr *= 1.04f;  // 3% 补偿
+    }
+    else if (frequency >= 20000)  // 20-50kHz
+    {
+        *ccr *= 1.02f;  // 2% 补偿
+    }
+}
+/**
+ * @brief  计算定时器参数
+ * @param  frequency: 目标频率(Hz)
+ * @param  prescaler: 预分频器值指针
+ * @param  period: 周期值指针
+ * @retval None
+ * @note   根据目标频率计算定时器的预分频器和周期值，使用64位数据类型避免高频时溢出
+ */
+void PLSR_CalculateTimerParams(uint32_t frequency, uint16_t* prescaler, uint32_t* period)
+{
+    /* 参数有效性检查 */
+    if (frequency < PLSR_PWM_FREQ_MIN)  frequency = PLSR_PWM_FREQ_MIN;
+    if (frequency > PLSR_PWM_FREQ_MAX)  frequency = PLSR_PWM_FREQ_MAX;
+    
+    /* 使用64位数据类型避免高频计算时的溢出 */
+    uint64_t timer_clock = 0;
+    if(PlsrRoute.output_port == 0 || PlsrRoute.output_port == 1)
+    {
+       timer_clock = 168000000ULL; ///< TIM10/TIM11时钟 (APB2 168MHz)
+    }
+    else
+    {
+        timer_clock = 84000000ULL; ///< TIM13/TIM14时钟 (APB1 84MHz)
+    }
+    
+    /* 防止除零错误 */
+    if (frequency == 0) frequency = 1;
+    
+    /* 使用64位计算避免溢出，四舍五入处理 */
+    uint64_t divider = (timer_clock + (uint64_t)frequency / 2) / (uint64_t)frequency;
+    if (divider < 2) divider = 2; ///< 最小分频比为2
+
+    /* 计算预分频器，限制ARR <= 65535 */
+    uint64_t psc = (divider + 65535ULL) / 65536ULL; ///< 向上取整
+    if (psc > 0xFFFFULL) psc = 0xFFFFULL; ///< 限制预分频器最大值
+
+    /* 计算自动重载值 */
+    uint64_t arr = (divider / psc) - 1;
+    if (arr < 1) arr = 1; ///< 最小ARR值为1
+    if (arr > 65535ULL) arr = 65535ULL; ///< 限制ARR最大值
+
+    /* 安全转换为16位和32位数据类型 */
+    *prescaler = (uint16_t)(psc - 1);
+    *period = (uint32_t)arr;
+}
+
+// ==================== PLSR 路径计算函数实现 ====================
+//在加速度较小时,可能会出现计算脉冲数为0的情况,此时会导致无法进入加速状态
+/**
+ * @brief  计算段脉冲数分配(简化版)
+ * @param  route: 路径控制结构体指针
+ * @retval None
+ * @note   为最后一段或等待脉冲结束的段设计，不区分算法类型
+ */
+void Calculate_PluseNum_Simplified(PLSR_RouteConfig_t *route)
+{
+    int64_t accel_pulse_num = 0;    // 加速过程脉冲数
+    int64_t decel_pulse_num = 0;    // 减速过程脉冲数
+    int64_t const_pulse_num = 0;    // 匀速过程脉冲数
+    uint32_t accel_time = 0;         // 加速时间(ms)
+    uint32_t decel_time = 0;         // 减速时间(ms)
+    
+    // 参数有效性检查
+    if (route == NULL || route->current_section_num == 0) return;
+    
+    // 边界检查
+    if (route->current_section_num > PLSR_MAX_SECTIONS) return;
+    
+    // 获取当前段配置（段号从1开始，数组索引从0开始）
+    PLSR_SectionConfig_t* current_section = &route->section[route->current_section_num - 1];
+    
+    uint32_t v0 = route->current_freq;               // 起始频率
+    uint32_t vt = current_section->target_freq;      // 目标频率
+    uint32_t a = route->accel_rate;                  // 加速度
+    uint32_t d = route->decel_rate;                  // 减速度
+    // 使用实际可发脉冲数，不再区分相对/绝对模式
+    int64_t total_pulses = current_section->actual_pulse; // 总脉冲数
+    
+    
+    // 防止除零错误
+    if (a == 0) a = 1;
+    if (d == 0) d = 1;
+    
+    if (vt > v0) 
+    {
+        // 情况1：目标频率大于当前频率，需要加速
+        route->run_state = PLSR_STATE_ACCEL;
+        
+        // 计算从v0加速到vt所需的时间和脉冲数
+        accel_time = (vt - v0) / a;  // 加速时间(ms)
+        if (accel_time == 0) accel_time = 1;  // 至少1ms
+        
+        // 加速阶段脉冲数 = (起始频率 + 目标频率) * 时间 / 2000
+        // 使用梯形积分公式：面积 = (上底 + 下底) * 高 / 2
+        uint64_t temp_accel = (uint64_t)(v0 + vt) * accel_time;
+        int64_t required_accel_pulses = (int64_t)(temp_accel / 2000);
+        if(required_accel_pulses == 0) required_accel_pulses = 1; // 至少1个脉冲
+        
+        if (required_accel_pulses <= total_pulses) 
+        {
+            // 脉冲数足够完成加速，剩余脉冲用于匀速
+            accel_pulse_num = required_accel_pulses;
+            const_pulse_num = total_pulses - required_accel_pulses;
+            decel_pulse_num = 0;
+        }
+        else 
+        {
+            // 脉冲数不够完成完整加速，全部用于加速
+            accel_pulse_num = total_pulses;
+            const_pulse_num = 0;
+            decel_pulse_num = 0;
+            
+            // 重新计算实际能达到的最大频率
+            // 根据：pulses = (v0 + v_actual) * t / 2000，且 t = (v_actual - v0) / a
+            // 代入得：pulses = (v0 + v_actual) * (v_actual - v0) / (2000 * a)
+            // 整理得：pulses * 2000 * a = v_actual^2 - v0^2
+            // 所以：v_actual^2 = pulses * 2000 * a + v0^2
+            
+            uint64_t v_actual_squared = (uint64_t)total_pulses * 2000ULL * a + (uint64_t)v0 * v0;
+            
+            // 检查是否溢出
+            if (v_actual_squared <= 0xFFFFFFFFULL) 
+            {
+                uint32_t v_actual = integer_sqrt_64((uint32_t)v_actual_squared);
+                
+                // 确保不超过目标频率
+                if (v_actual > vt) 
+                    v_actual = vt;      
+            }
+        }
+    }
+    else if (vt < v0) 
+    {
+        // 情况2：目标频率小于当前频率，需要减速
+        route->run_state = PLSR_STATE_DECEL;
+        
+        // 计算从v0减速到vt所需的时间和脉冲数
+        decel_time = (v0 - vt) / d;  // 减速时间(ms)
+        if (decel_time == 0) decel_time = 1;  // 至少1ms
+        
+        // 减速阶段脉冲数 = (起始频率 + 目标频率) * 时间 / 2000
+        uint64_t temp_decel = (uint64_t)(v0 + vt) * decel_time;
+        int64_t required_decel_pulses = (int64_t)(temp_decel / 2000);
+        if(required_decel_pulses == 0) required_decel_pulses = 1; // 至少1个脉冲
+        
+        if (required_decel_pulses <= total_pulses) 
+        {
+            // 脉冲数足够完成减速，剩余脉冲用于匀速
+            decel_pulse_num = required_decel_pulses;
+            const_pulse_num = total_pulses - required_decel_pulses;
+            accel_pulse_num = 0;
+        }
+        else 
+        {
+            // 脉冲数不够完成完整减速，全部用于减速
+            decel_pulse_num = total_pulses;
+            const_pulse_num = 0;
+            accel_pulse_num = 0;
+            
+            // 重新计算实际能减速到的最低频率
+            // 根据：pulses = (v0 + v_actual) * t / 2000，且 t = (v0 - v_actual) / d
+            // 代入得：pulses = (v0 + v_actual) * (v0 - v_actual) / (2000 * d)
+            // 整理得：pulses * 2000 * d = v0^2 - v_actual^2
+            // 所以：v_actual^2 = v0^2 - pulses * 2000 * d
+            
+            uint64_t v0_squared = (uint64_t)v0 * v0;  // 起始频率的平方
+            uint64_t reduction = (uint64_t)total_pulses * 2000ULL * d; // 减速所需的脉冲数
+            
+            if (v0_squared > reduction) 
+            {
+                uint32_t v_actual_squared = (uint32_t)(v0_squared - reduction);
+                uint32_t v_actual = integer_sqrt_64(v_actual_squared);
+                
+                // 确保不低于目标频率（理论上不应该，但防御性编程）
+                if (v_actual < vt) 
+                    v_actual = vt;
+            }
+        }
+    }
+    else 
+    {
+        // 情况3：目标频率等于当前频率，全部为匀速
+        route->run_state = PLSR_STATE_CONST;
+        accel_pulse_num = 0;
+        const_pulse_num = total_pulses;
+        decel_pulse_num = 0;
+    }
+    
+    // 保存计算结果
+    route->accel_pulse_count = accel_pulse_num;
+    route->const_pulse_count = const_pulse_num;
+    route->decel_pulse_count = decel_pulse_num;
+}
+
+void Calculate_PluseNum(PLSR_RouteConfig_t *route)
+{
+    int64_t part1_pulse_num = 0;    // 第一部分脉冲数
+    int64_t part2_pulse_num = 0;    // 第二部分脉冲数
+    int64_t part3_pulse_num = 0;    // 第三部分脉冲数
+    uint32_t part1_time = 0;         // 第一部分时间(ms)
+    uint32_t part3_time = 0;         // 第三部分时间(ms)
+    
+    // 参数有效性检查
+    if (route == NULL || route->current_section_num == 0) return;
+    
+    // 边界检查
+    if (route->current_section_num > PLSR_MAX_SECTIONS) return;
+    
+    // 获取当前段配置（段号从1开始，数组索引从0开始）
+    PLSR_SectionConfig_t* current_section = &route->section[route->current_section_num - 1];
+    
+
+        uint32_t v0 = route->current_freq;        // 起始频率
+        uint32_t vt_desired = current_section->target_freq; // 期望目标频率
+        uint32_t vt = vt_desired;                 // 实际目标频率（可能会被调整）
+        uint32_t a = route->accel_rate;           // 加速度
+        uint32_t d = route->decel_rate;           // 减速度
+        
+        // 在PLSR_Section_StartNewSection中已经根据模式计算了actual_pulse
+        int64_t total_pulses = current_section->actual_pulse; // 总脉冲数
+        
+        // 防止除零错误
+        if (a == 0) a = 1;
+        if (d == 0) d = 1;
+        
+        // 初始计算：按理想情况计算各部分脉冲数
+        PLSR_RunState_t part1_state = PLSR_STATE_CONST;
+        PLSR_RunState_t part2_state = PLSR_STATE_CONST;
+        PLSR_RunState_t part3_state = PLSR_STATE_DECEL;
+        
+        // 计算理想情况下的第一部分：v0 -> vt
+        if (v0 < vt) 
+        {
+            part1_state = PLSR_STATE_ACCEL;
+            part1_time = (vt - v0) / a;
+            if (part1_time == 0) part1_time = 1;
+            
+            uint64_t temp_calc = (uint64_t)(v0 + vt) * part1_time;
+            part1_pulse_num = (uint32_t)(temp_calc / 2000);
+            if(part1_pulse_num == 0) part1_pulse_num = 1;
+        } 
+        else if (v0 > vt) 
+        {
+            part1_state = PLSR_STATE_DECEL;
+            part1_time = (v0 - vt) / d;
+            if (part1_time == 0) part1_time = 1;
+            
+            uint64_t temp_calc = (uint64_t)(v0 + vt) * part1_time;
+            part1_pulse_num = (uint32_t)(temp_calc / 2000);
+            if(part1_pulse_num == 0) part1_pulse_num = 1;
+        } 
+        else 
+        {
+            part1_pulse_num = 0;
+            part1_time = 0;
+        }
+        
+        // 计算理想情况下的第三部分：vt -> 0
+        if (vt > 0) 
+        {
+            part3_time = vt / d;
+            if (part3_time == 0) part3_time = 1;
+            
+            uint64_t temp_calc = (uint64_t)vt * part3_time;
+            part3_pulse_num = (uint32_t)(temp_calc / 2000);
+            if(part3_pulse_num == 0) part3_pulse_num = 1;
+        } 
+        else 
+        {
+            part3_pulse_num = 0;
+            part3_time = 0;
+        }
+        
+        // 检查脉冲数是否足够
+        int64_t used_pulses = part1_pulse_num + part3_pulse_num;
+        
+        if (used_pulses <= total_pulses) 
+        {
+            // 脉冲数足够，计算匀速部分
+            part2_pulse_num = total_pulses - used_pulses;
+        } 
+        else 
+        {
+            // 脉冲数不足，需要重新规划运动
+            part2_pulse_num = 0; // 没有匀速阶段
+            
+            // 优化策略：寻找最优的中间频率vm，使得总脉冲数刚好等于available_pulses
+            uint32_t vm = OptimalIntermediateFrequency(v0, vt_desired, total_pulses, a, d);
+            
+            if (vm != v0) // 找到了有效的中间频率
+            {
+                vt = vm; // 更新实际目标频率
+                
+                // 重新计算第一部分
+                if (v0 < vm) 
+                {
+                    part1_state = PLSR_STATE_ACCEL;
+                    // 使用运动学公式：s = (v0 + vm) * t / 2，其中 t = (vm - v0) / a
+                    // 所以：s = (v0 + vm) * (vm - v0) / (2 * a) = (vm^2 - v0^2) / (2 * a)
+                    uint64_t numerator = (uint64_t)vm * vm - (uint64_t)v0 * v0;
+                    part1_pulse_num = (uint32_t)(numerator / (2000ULL * a));
+                    if (part1_pulse_num == 0) part1_pulse_num = 1;
+                    
+                    part1_time = (vm - v0) / a;
+                    if (part1_time == 0) part1_time = 1;
+                } 
+                else if (v0 > vm) 
+                {
+                    part1_state = PLSR_STATE_DECEL;
+                    // 减速情况：s = (v0^2 - vm^2) / (2 * d)
+                    uint64_t numerator = (uint64_t)v0 * v0 - (uint64_t)vm * vm;
+                    part1_pulse_num = (uint32_t)(numerator / (2000ULL * d));
+                    if (part1_pulse_num == 0) part1_pulse_num = 1;
+                    
+                    part1_time = (v0 - vm) / d;
+                    if (part1_time == 0) part1_time = 1;
+                } 
+                else 
+                {
+                    part1_state = PLSR_STATE_CONST;
+                    part1_pulse_num = 0;
+                    part1_time = 0;
+                }
+                
+                // 重新计算第三部分：vm -> 0
+                if (vm > 0) 
+                {
+                    part3_state = PLSR_STATE_DECEL;
+                    // s = vm^2 / (2 * d)
+                    uint64_t numerator = (uint64_t)vm * vm;
+                    part3_pulse_num = (uint32_t)(numerator / (2000ULL * d));
+                    if (part3_pulse_num == 0) part3_pulse_num = 1;
+                    
+                    part3_time = vm / d;
+                    if (part3_time == 0) part3_time = 1;
+                } 
+                else 
+                {
+                    part3_pulse_num = 0;
+                    part3_time = 0;
+                }
+                
+                // 确保总脉冲数完全匹配
+                int64_t calculated_total = part1_pulse_num + part3_pulse_num;
+                if (calculated_total != total_pulses) 
+                {
+                    if (calculated_total > total_pulses) 
+                    {
+                        // 脉冲数超出限制，按比例缩减
+                        if (part1_pulse_num > 0 && part3_pulse_num > 0) 
+                        {
+                            // 两个阶段都有脉冲，按比例分配
+                            part1_pulse_num = ((part1_pulse_num * total_pulses) + calculated_total / 2) / calculated_total; //解决脉冲数过小时导致的问题
+                            part3_pulse_num = total_pulses - part1_pulse_num;
+                        } 
+                        else if (part1_pulse_num > 0) 
+                        {
+                            // 只有第一阶段有脉冲
+                            part1_pulse_num = total_pulses;
+                        } 
+                        else if (part3_pulse_num > 0) 
+                        {
+                            // 只有第三阶段有脉冲
+                            part3_pulse_num = total_pulses;
+                        }
+                    } 
+                    else 
+                    {
+                        // 脉冲数不足，将剩余脉冲分配给匀速阶段
+                        int64_t remaining_pulses = total_pulses - calculated_total;
+                        
+                        // 将剩余脉冲分配给第二阶段（匀速阶段）
+                        // 这样既不影响加减速的数学精确性，又能充分利用所有脉冲
+                        part2_pulse_num = remaining_pulses;
+
+                        // 更新第二阶段状态为匀速
+                        part2_state = PLSR_STATE_CONST;
+                    }
+                }
+            } 
+            else 
+            {
+                // 无法找到有效的运动规划，保持当前频率
+                part1_state = PLSR_STATE_DECEL;
+                part1_pulse_num = total_pulses;
+                part1_time = (total_pulses * 1000) / v0;
+                part3_pulse_num = 0;
+                part3_time = 0;
+                vt = 0; // 实际目标频率等于起始频率
+            }
+        }
+        
+        // 保存计算结果到结构体
+        if (part1_state == PLSR_STATE_ACCEL) 
+        {
+            route->accel_pulse_count = part1_pulse_num;
+        } 
+        else 
+        {
+            route->accel_pulse_count = (part1_state == PLSR_STATE_DECEL) ? part1_pulse_num : 0;
+        }
+        
+        route->const_pulse_count = part2_pulse_num;
+        route->decel_pulse_count = part3_pulse_num;
+        
+        route->part1_state = part1_state;
+        route->part2_state = part2_state;
+        route->part3_state = part3_state;
+        route->part1_time = part1_time;
+        route->part3_time = part3_time;
+        route->part1_target_freq = vt;
+        route->part2_target_freq = vt;
+        route->part3_target_freq = 0;
+        
+        // 设置初始运行状态
+        if (part1_pulse_num > 0) 
+        {
+            route->run_state = part1_state;
+            route->target_freq = vt;
+        } else if (part2_pulse_num > 0) 
+        {
+            route->run_state = PLSR_STATE_CONST;
+            route->target_freq = vt;
+        } else if (part3_pulse_num > 0) 
+        {
+            route->run_state = PLSR_STATE_DECEL;
+            route->target_freq = 0;
+        } else 
+        {
+            route->run_state = PLSR_STATE_CONST;
+            route->target_freq = v0;
+        }
+}
+
+
+/**
+ * @brief 计算最优中间频率
+ */
+uint32_t OptimalIntermediateFrequency(uint32_t v0, uint32_t vt_desired,
+                                     int64_t total_pulses, uint32_t a, uint32_t d)
+{
+    if (total_pulses <= 0 || a == 0 || d == 0) {
+        return v0; // 无法优化
+    }
+
+    uint32_t vm = v0;
+
+    // 统一平方项
+    uint64_t v0_sq = square_u32(v0);
+
+    if (v0 < vt_desired) 
+    {
+        // 加速情况
+        // 公式：vm^2 = [(total + v0^2/(2a)) * 2ad] / (a+d)
+        uint64_t rhs = (uint64_t)total_pulses * SCALE_FACTOR + (v0_sq / a); //total*2000 + v0^2/a
+        uint64_t vm_sq = (rhs * a * d) / (a + d); 
+
+        if (vm_sq > 0xFFFFFFFFULL) vm_sq = 0xFFFFFFFFULL;
+        vm = integer_sqrt_64((uint32_t)vm_sq);
+
+        if (vm > vt_desired * 2) vm = vt_desired * 2;
+
+        // 验证是否超出 total_pulses
+        uint64_t s1 = (square_u32(vm) - v0_sq) / (SCALE_FACTOR * a);
+        uint64_t s3 = square_u32(vm) / (SCALE_FACTOR * d);
+        if (s1 + s3 > (uint64_t)total_pulses) {
+            vm = BinarySearchOptimalFreq(v0, vt_desired, total_pulses, a, d, 1);
+        }
+
+    } 
+    else if (v0 > vt_desired) 
+    {
+        // 减速情况
+        uint64_t required = v0_sq / (SCALE_FACTOR * d);
+        if (required <= (uint64_t)total_pulses) {
+            vm = (vt_desired < v0) ? vt_desired : v0 / 2;
+        } else 
+        {
+            uint64_t reduction = (uint64_t)total_pulses * SCALE_FACTOR * d;
+            vm = (v0_sq > reduction) ? integer_sqrt_64((uint32_t)(v0_sq - reduction)) : 0;
+        }
+    }
+
+    return vm;
+}
+
+/**
+ * @brief 二分搜索寻找最优频率
+ * @param v0 起始频率
+ * @param vt_desired 期望目标频率
+ * @param total_pulses 可用总脉冲数
+ * @param a 加速度
+ * @param d 减速度
+ * @param is_accel 是否为加速情况
+ * @return 最优频率
+ */
+uint32_t BinarySearchOptimalFreq(uint32_t v0, uint32_t vt_desired, 
+                                int64_t total_pulses, uint32_t a, uint32_t d, 
+                                uint8_t is_accel)
+{
+    uint32_t low = is_accel ? v0 : 0;
+    uint32_t high = is_accel ? (vt_desired * 2) : v0;
+    uint32_t best_vm = v0;
+    
+    for (int iterations = 0; iterations < 20; iterations++) // 限制迭代次数
+    {
+        uint32_t mid = low + (high - low) / 2;
+        
+        // 计算当前频率下的脉冲数
+        uint32_t s1, s3;
+        if (is_accel) 
+        {
+            s1 = ((uint64_t)mid * mid - (uint64_t)v0 * v0) / (2000ULL * a);
+        } 
+        else 
+        {
+            s1 = ((uint64_t)v0 * v0 - (uint64_t)mid * mid) / (2000ULL * d);
+        }
+        s3 = ((uint64_t)mid * mid) / (2000ULL * d);
+        
+        int64_t total_calc = s1 + s3;
+        
+        if (total_calc == total_pulses) {
+            return mid; // 找到精确解
+        } else if (total_calc < total_pulses) {
+            best_vm = mid;
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+        
+        if (low > high) break;
+    }
+    
+    return best_vm;
+}
+
+
+uint64_t square_u32(uint32_t x) 
+{
+    return (uint64_t)x * (uint64_t)x;
+}
+
+static inline int clzll(uint64_t x) {
+    if (x == 0) return 64;
+    uint32_t hi = (uint32_t)(x >> 32);
+    if (hi) return __CLZ(hi);
+    else return 32 + __CLZ((uint32_t)x);
+}
+
+uint64_t integer_sqrt_64(uint64_t n)
+{
+    if (n == 0 || n == 1) return n;
+
+    int bitlen = 64 - clzll(n);
+    uint64_t x = 1ULL << ((bitlen + 1) / 2);
+
+    for (int i = 0; i < 6; i++) {
+        uint64_t y = (x + n / x) >> 1;
+        if (y >= x) break;
+        x = y;
+    }
+
+    // 修正
+    while ((x+1) > 0 && (x+1) <= UINT64_MAX / (x+1) && (x+1)*(x+1) <= n) x++;
+    while (x*x > n) x--;
+
+    return x;
+}
+
+/**
+ * @brief  更新加减速度
+ * @param  route: 路径控制结构体指针
+ * @retval None
+ * @note   根据默认频率和加减速时间重新计算加减速度
+ *         计算得到的加速度单位为Hz/ms，在PLSR_Calculate_FreqByPosition函数中
+ *         会将其转换为Hz/s^2以符合物理公式要求
+ */
+void PLSR_Accel_UpdateRates(PLSR_RouteConfig_t* route)
+{
+    if (route == NULL) return;
+    
+    // 计算加速度 (Hz/ms)
+    if (route->default_accel_time_ms > 0) 
+    {
+        route->accel_rate = route->default_freq / route->default_accel_time_ms;
+    } 
+    else 
+    {
+        route->accel_rate = 0;  // 避免除零错误
+    }
+    
+    // 计算减速度 (Hz/ms)
+    if (route->default_decel_time_ms > 0) 
+    {
+        route->decel_rate = route->default_freq / route->default_decel_time_ms;
+    } 
+    else 
+    {
+        route->decel_rate = 0;  // 避免除零错误
+    }
+}
+
+/**
+ * @brief S曲线加减速参数初始化
+ * @param route 路径配置结构体指针
+ * @param accel_time_ms 加速时间（毫秒）
+ * @param decel_time_ms 减速时间（毫秒）
+ */
+void SCurve_InitializeParameters(PLSR_RouteConfig_t* route, uint32_t accel_time_ms, uint32_t decel_time_ms) 
+{
+    if (route == NULL) return;
+    
+    /* ============ 加速段参数计算 ============ */
+    if (accel_time_ms > 0) 
+    {
+        uint32_t vel_start = route->initial_freq;  // V0
+        uint32_t vel_target = route->part1_target_freq;  // Vt
+        
+        if (vel_target > vel_start) 
+        {
+            uint32_t delta_v = vel_target - vel_start;
+            uint32_t Tj = accel_time_ms / 2;  // 到达最大加速度的时间（加速时间的一半）
+            
+            // 加加速度计算：J = 4*Vt/(Tt^2) = 4*delta_v/(accel_time_ms^2)
+            uint64_t jerk_numerator = 4ULL * delta_v * 1000ULL;  // 乘1000进行单位换算
+            uint64_t jerk_denominator = (uint64_t)accel_time_ms * accel_time_ms;
+            uint32_t jerk = (uint32_t)(jerk_numerator / jerk_denominator);  // Hz/ms²
+            
+            // 最大加速度：Amax = J * Tj
+            uint32_t max_accel = (jerk * Tj) / 1000;  // Hz/ms
+            
+            // 加加速过程的脉冲数：N1 = (1/6) * J * Tj^3
+            uint64_t Tj_cubed = (uint64_t)Tj * Tj * Tj;
+            uint64_t phase1_pulses_calc = (jerk * Tj_cubed) / (6ULL * 1000ULL * 1000ULL);  // 单位换算
+            
+            // 减加速过程的脉冲数：N2 = V0*Tj + (5/6)*J*Tj^3
+            uint64_t phase2_term2 = (5ULL * jerk * Tj_cubed) / (6ULL * 1000ULL * 1000ULL);
+            uint64_t phase2_pulses_calc = phase2_term2;
+            
+            // 存储加速段参数
+            route->scurve.accel_jerk = jerk;
+            route->scurve.accel_max = max_accel;
+            route->scurve.accel_jerk_time_ms = Tj;
+            route->scurve.accel_phase1_pulses = (uint32_t)phase1_pulses_calc;
+            route->scurve.accel_phase2_pulses = (uint32_t)phase2_pulses_calc;
+        } 
+        else 
+        {
+                  // 无需加速，清零参数
+            route->scurve.accel_jerk = 0;
+            route->scurve.accel_max = 0;
+            route->scurve.accel_jerk_time_ms = 0;
+            route->scurve.accel_phase1_pulses = 0;
+            route->scurve.accel_phase2_pulses = 0;
+        }
+    }
+    
+    /* ============ 减速段参数计算 ============ */
+    if (decel_time_ms > 0) 
+    {
+        uint32_t vel_start_decel = route->part2_target_freq;  // 减速起始速度
+        uint32_t vel_target_decel = route->part3_target_freq;  // 减速目标速度
+        
+        if (vel_start_decel > vel_target_decel) 
+        {
+            uint32_t delta_v = vel_start_decel - vel_target_decel;
+            uint32_t Tj = decel_time_ms / 2;  // 到达最大减速度的时间
+            
+            // 减加速度计算：J = 4*delta_v/(decel_time_ms^2)
+            uint64_t jerk_numerator = 4ULL * delta_v * 1000ULL;
+            uint64_t jerk_denominator = (uint64_t)decel_time_ms * decel_time_ms;
+            uint32_t jerk = (uint32_t)(jerk_numerator / jerk_denominator);
+            
+            // 最大减速度
+            uint32_t max_decel = (jerk * Tj) / 1000;
+            
+            // 减减速过程的脉冲数：N1 = (1/6) * J * Tj^3
+            uint64_t Tj_cubed = (uint64_t)Tj * Tj * Tj;
+            uint64_t phase1_pulses_calc = (jerk * Tj_cubed) / (6ULL * 1000ULL * 1000ULL);
+            
+            // 加减速过程的脉冲数：N2 = V0*Tj + (5/6)*J*Tj^3
+            uint64_t phase2_term2 = (5ULL * jerk * Tj_cubed) / (6ULL * 1000ULL * 1000ULL);
+            uint64_t phase2_pulses_calc = phase2_term2;
+            
+            // 存储减速段参数
+            route->scurve.decel_jerk = jerk;
+            route->scurve.decel_max = max_decel;
+            route->scurve.decel_jerk_time_ms = Tj;
+            route->scurve.decel_phase1_pulses = (uint32_t)phase2_pulses_calc;
+            route->scurve.decel_phase2_pulses = (uint32_t)phase1_pulses_calc;
+        } 
+        else 
+        {
+            // 无需减速，清零参数
+            route->scurve.decel_jerk = 0;
+            route->scurve.decel_max = 0;
+            route->scurve.decel_jerk_time_ms = 0;
+            route->scurve.decel_phase1_pulses = 0;
+            route->scurve.decel_phase2_pulses = 0;
+        }
+    }
+}  
+
+
+
+/**
+ * @brief 重置S曲线计算状态（用于段切换）
+ */
+void PLSR_Reset_SCurve_State(void) {
+    // 通过调用函数并传入无效参数来触发状态重置
+    // 实际使用中，在段切换时调用此函数
+}
+
+
+static double cbrt_approx(double x) {
+    if (x == 0) return 0;
+    if (x < 0) return -cbrt_approx(-x);
+    double guess = x / 3.0;
+    for (int i = 0; i < 10; i++) {
+        guess = (2.0 * guess + x / (guess * guess)) / 3.0;
+    }
+    return guess;
+}
+
+/**
+ * @brief 第一阶段：根据脉冲数计算时间（加加速段，牛顿迭代）
+ * 方程： (1/6)*J_real*t^3 - S*1000 = 0
+ * @param pulse_num 当前脉冲数
+ * @param jerk 加加速度 (Hz/ms²)
+ * @return 时间 (ms)
+ */
+static double SCurve_GetTimeFromPulses_Phase1(uint32_t pulse_num, uint32_t jerk) {
+    if (pulse_num == 0 || jerk == 0) return 0.0;
+
+    double S_cont = (double)pulse_num * 1000.0;    // 脉冲转换为连续量
+    double J_real = (double)jerk / 1000.0;         // Hz/ms²
+
+    // 初始猜测：用反函数近似值作为初始点
+    double t = cbrt_approx((6.0 * S_cont) / J_real);
+    if (t <= 0.0) t = 1.0;  // 避免负数或零
+
+    // 牛顿迭代
+    for (int i = 0; i < 40; ++i) {
+        double t2 = t * t;
+        double t3 = t2 * t;
+        double F = (1.0 / 6.0) * J_real * t3 - S_cont;
+        double dF = 0.5 * J_real * t2;
+
+        if (fabs(dF) < 1e-12) break;
+
+        double t_new = t - F / dF;
+        if (t_new <= 0.0) {
+            t_new = t * 0.5;
+        }
+        if (fabs(t_new - t) < 1e-7) {
+            t = t_new;
+            break;
+        }
+        t = t_new;
+    }
+
+    if (t < 0.0) t = 0.0;
+    return t;  // ms
+}
+
+
+/* Phase2: pulses*1000 = Vmid*t + 0.5*Amax*t^2 - (1/6)*J_real*t^3
+   其中 Amax = J_real * Tj (Tj 单位 ms), J_real = jerk / 1000 */
+static double SCurve_GetTimeFromPulses_Phase2(uint32_t pulse_num, uint32_t V0, 
+                                              uint32_t jerk, uint32_t Tj) {
+    if (pulse_num == 0) return 0.0;
+
+    double J_real = (double)jerk / 1000.0;       /* Hz / ms^2 */
+    double Tj_d = (double)Tj;                    /* ms */
+    double Amax = J_real * Tj_d;                 /* Hz / ms  (注意单位：a in Hz per ms) */
+    double Vmid = (double)V0;                    /* V0 parameter here is vmid (caller should pass vmid) */
+
+    double S_cont = (double)pulse_num * 1000.0;  /* 连续量 */
+
+    double t;
+    if (Vmid > 0.0) 
+    {
+        t = S_cont / Vmid;
+        if (t <= 0.0) t = Tj_d / 2.0;
+    } else {
+        t = Tj_d / 2.0;
+    }
+
+    /* 牛顿迭代求解 F(t) = Vmid*t + 0.5*Amax*t^2 - (1/6)*J_real*t^3 - S_cont = 0 */
+    for (int i = 0; i < 40; ++i) {
+        double t2 = t * t;
+        double t3 = t2 * t;
+        double F = Vmid * t + 0.5 * Amax * t2 - (1.0/6.0) * J_real * t3 - S_cont;
+        double dF = Vmid + Amax * t - 0.5 * J_real * t2;
+
+        if (fabs(dF) < 1e-12) break;
+        double t_new = t - F / dF;
+        if (t_new <= 0.0) {
+            t_new = t * 0.5;
+        }
+        if (fabs(t_new - t) < 1e-7) {
+            t = t_new;
+            break;
+        }
+        t = t_new;
+    }
+
+    if (t < 0.0) t = 0.0;
+    return t; /* ms */
+}
+
+/* 主函数：使用上述两个反函数，并在计算频率时用 J_real */
+uint32_t PLSR_Calculate_SCurve_FreqByPulses_Exact(PLSR_RouteConfig_t* route, uint8_t is_accel) {
+    if (route == NULL) return 0;
+
+    static uint32_t s_last_freq = 0;
+    int64_t current_tim2_count = __HAL_TIM_GET_COUNTER(&htim2);
+    uint32_t executed_pulses = current_tim2_count;
+
+    uint32_t V0, jerk, Tj, phase1_pulses, phase2_pulses;
+
+    if (is_accel) {
+        V0 = route->initial_freq;
+        jerk = route->scurve.accel_jerk;           /* NOTE: assumed scaled = J_real * 1000 */
+        Tj = route->scurve.accel_jerk_time_ms;
+        phase1_pulses = route->scurve.accel_phase1_pulses;
+        phase2_pulses = route->scurve.accel_phase2_pulses;
+    } else {
+        V0 = route->part2_target_freq;
+        jerk = route->scurve.decel_jerk;
+        Tj = route->scurve.decel_jerk_time_ms;
+        phase1_pulses = route->scurve.decel_phase1_pulses;
+        phase2_pulses = route->scurve.decel_phase2_pulses;
+    }
+
+    if (jerk == 0 || Tj == 0) return V0;
+
+    uint32_t calculated_freq = V0;
+
+    if (executed_pulses == 0) {
+        return V0;
+    } 
+    else if (executed_pulses <= phase1_pulses) 
+    {
+        /* Phase1 */
+        double t; /* ms */
+        double J_real = (double)jerk / 1000.0; /* Hz / ms^2 */
+        double vmid_double;
+        double Amax = J_real * Tj;
+        if (is_accel) {
+            vmid_double = (double)V0 + 0.5 * J_real * Tj * Tj;
+        } else 
+        {
+            vmid_double = (double)V0 - 0.5 * J_real * Tj * Tj;
+            if (vmid_double < 1.0) vmid_double = 1.0;
+        }
+        
+        if (is_accel) {
+            t = SCurve_GetTimeFromPulses_Phase1(executed_pulses, jerk);
+            double freq_double = (double)V0 + 0.5 * J_real * t * t; /* Hz */
+            calculated_freq = (uint32_t)(freq_double + 0.5);
+        } 
+        else 
+        {
+            uint32_t phase2_pulse_num = phase1_pulses - executed_pulses;
+            t = SCurve_GetTimeFromPulses_Phase2(phase2_pulse_num, (uint32_t)vmid_double, jerk, Tj);
+            double freq_double = vmid_double + Amax * t - 0.5 * J_real * t * t;
+            calculated_freq = (uint32_t)(freq_double + 0.5);
+        }
+    } 
+    else if (executed_pulses <= (phase1_pulses + phase2_pulses)) 
+    {
+        /* Phase2 */
+        double Tj_d = (double)Tj;
+        double J_real = (double)jerk / 1000.0;
+        double vmid_double;
+        if (is_accel) {
+            vmid_double = (double)V0 + 0.5 * J_real * Tj_d * Tj_d;
+        } else {
+            vmid_double = (double)V0 - 0.5 * J_real * Tj_d * Tj_d;
+            if (vmid_double < 1.0) vmid_double = 1.0;
+        }
+
+        double Amax = J_real * Tj_d; /* Hz / ms */
+
+        if (is_accel) 
+        {
+            uint32_t phase2_pulse_num = executed_pulses - phase1_pulses;
+            double t_phase2 = SCurve_GetTimeFromPulses_Phase2(phase2_pulse_num, (uint32_t)vmid_double, jerk, Tj); /* ms */
+            double freq_double = vmid_double + Amax * t_phase2 - 0.5 * J_real * t_phase2 * t_phase2;
+            calculated_freq = (uint32_t)(freq_double + 0.5);
+        } 
+        else 
+        {
+            uint32_t phase2_pulse_num = phase2_pulses + phase1_pulses  - executed_pulses + 1;
+            double t_phase2 = SCurve_GetTimeFromPulses_Phase1(phase2_pulse_num, jerk); /* ms */
+            double freq_double = (double)0 + 0.5 * J_real * t_phase2 * t_phase2; /* Hz */
+            calculated_freq = (uint32_t)(freq_double + 0.5);
+        }
+    } else {
+        calculated_freq = is_accel ? route->part1_target_freq : route->part3_target_freq;
+    }
+    if(calculated_freq != 0 && calculated_freq <PLSR_PWM_FREQ_MAX)
+    s_last_freq = calculated_freq;
+    if (calculated_freq > PLSR_PWM_FREQ_MAX) calculated_freq = PLSR_PWM_FREQ_MAX;
+    if (calculated_freq == 0) calculated_freq = s_last_freq;
+
+    return calculated_freq;
+}
+
+
+/**
+ * @brief 获取下一个脉冲的周期时间
+ * @param current_freq 当前计算得到的频率
+ * @return 下一个脉冲的周期时间（微秒）
+ */
+uint32_t PLSR_GetNextPulsePeriod_us(uint32_t current_freq) {
+    if (current_freq == 0) return 0xFFFFFFFF;  // 无效频率
+    
+    // 周期 = 1/频率，转换为微秒
+    uint32_t period_us = 1000000 / current_freq;
+    return period_us;
+}
+
+/**
+ * @brief 修改后的主控制函数，使用精确的反函数计算
+ */
+uint32_t PLSR_SCurve_Control(PLSR_RouteConfig_t* route) {
+    if (route == NULL) return 0;
+    
+    uint32_t current_freq = 0;
+    
+    switch(route->run_state) {
+        case PLSR_STATE_ACCEL:
+            // 加速阶段使用精确S曲线计算
+            current_freq = PLSR_Calculate_SCurve_FreqByPulses_Exact(route, 1);
+            break;
+            
+        case PLSR_STATE_DECEL:
+            // 减速阶段使用精确S曲线计算
+            current_freq = PLSR_Calculate_SCurve_FreqByPulses_Exact(route, 0);
+            break;
+            
+        case PLSR_STATE_CONST:
+            // 匀速阶段保持目标频率
+            current_freq = route->target_freq;
+            break;
+            
+        default:
+            current_freq = route->current_freq;
+            break;
+    }
+    return current_freq;
+}

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));
 }
 
 /**
@@ -349,10 +348,12 @@ void Modbus_Clear_Pluse(uint8_t* frame, uint16_t length)
     response[1] = MODBUS_FC_CLEAR_PLUSE;
     response[2] = 0;  // 无数据返回
 
-    g_plsr_total_pulse_count = 0;  // 假设0x100寄存器用于存储脉冲计数
-    int32_t signed_count = g_plsr_total_pulse_count;  // 使用有符号数进行计算
-    ModbusSlave.holding_regs[0x1000] = signed_count & 0xFFFF;        // 低16位
-    ModbusSlave.holding_regs[0x1001] = (signed_count >> 16) & 0xFFFF; // 高16位
+    PlsrTotalPulseCount = 0;  // 假设0x100寄存器用于存储脉冲计数
+     PlsrLocation = 0;
+     int32_t signed_count = PlsrLocation;  // 使用有符号数进行计算
+    /* 使用地址映射更新脉冲计数监控值 */
+    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);
 }
 
@@ -420,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;
@@ -434,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;
      }
@@ -458,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];
@@ -497,25 +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];
-     uint8_t byte_count = frame[6];
      
-     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

@@ -14,13 +14,13 @@
     <StLinkDriver>
         <stlinkserialNo>46232557</stlinkserialNo>
         <stlinkfoundProbes />
-        <CStepIntDis>_ 0</CStepIntDis>
-        <LeaveTargetRunning>_ 0</LeaveTargetRunning>
         <stlinkResetStyle>0</stlinkResetStyle>
         <stlinkResetStrategy>2</stlinkResetStrategy>
+        <CStepIntDis>_ 0</CStepIntDis>
+        <LeaveTargetRunning>_ 0</LeaveTargetRunning>
     </StLinkDriver>
     <DebugChecksum>
-        <Checksum>2012208745</Checksum>
+        <Checksum>1483733799</Checksum>
     </DebugChecksum>
     <Exceptions>
         <StopOnUncaught>_ 0</StopOnUncaught>
@@ -84,13 +84,6 @@
         <LogFile>_ ""</LogFile>
         <Category>_ 0</Category>
     </LogFile>
-    <DisassembleMode>
-        <mode>0</mode>
-    </DisassembleMode>
-    <Aliases>
-        <Count>0</Count>
-        <SuppressDialog>0</SuppressDialog>
-    </Aliases>
     <Trace2>
         <Enabled>0</Enabled>
         <ShowSource>0</ShowSource>
@@ -136,9 +129,6 @@
         <ShowTimeSum>1</ShowTimeSum>
         <SumSortOrder>0</SumSortOrder>
     </EventLog>
-    <Breakpoints2>
-        <Count>0</Count>
-    </Breakpoints2>
     <DriverProfiling>
         <Enabled>0</Enabled>
         <Mode>3</Mode>
@@ -152,4 +142,14 @@
     <CallStackStripe>
         <ShowTiming>1</ShowTiming>
     </CallStackStripe>
+    <DisassembleMode>
+        <mode>0</mode>
+    </DisassembleMode>
+    <Breakpoints2>
+        <Count>0</Count>
+    </Breakpoints2>
+    <Aliases>
+        <Count>0</Count>
+        <SuppressDialog>0</SuppressDialog>
+    </Aliases>
 </settings>

PLSR/PLSR/EWARM/test.1.ewp

@@ -287,7 +287,7 @@
                 <option>
                     <name>CCAllowList</name>
                     <version>1</version>
-                    <state>00000000</state>
+                    <state>11111110</state>
                 </option>
                 <option>
                     <name>CCDebugInfo</name>
@@ -374,16 +374,16 @@
                 </option>
                 <option>
                     <name>CCOptLevel</name>
-                    <state>0</state>
+                    <state>3</state>
                 </option>
                 <option>
                     <name>CCOptStrategy</name>
                     <version>0</version>
-                    <state>1</state>
+                    <state>0</state>
                 </option>
                 <option>
                     <name>CCOptLevelSlave</name>
-                    <state>0</state>
+                    <state>3</state>
                 </option>
                 <option>
                     <name>CompilerMisraRules98</name>
@@ -442,7 +442,7 @@
                 <option>
                     <name>CCOptStrategySlave</name>
                     <version>0</version>
-                    <state>1</state>
+                    <state>0</state>
                 </option>
                 <option>
                     <name>CCGuardCalls</name>
@@ -1103,6 +1103,9 @@
                 <file>
                     <name>$PROJ_DIR$\..\Core\Src\tim.c</name>
                 </file>
+                <file>
+                    <name>$PROJ_DIR$\..\Core\Src\tools.c</name>
+                </file>
                 <file>
                     <name>$PROJ_DIR$\..\Core\Src\usart.c</name>
                 </file>

PLSR/PLSR/EWARM/test.1.ewt

@@ -1227,6 +1227,9 @@
                 <file>
                     <name>$PROJ_DIR$\..\Core\Src\tim.c</name>
                 </file>
+                <file>
+                    <name>$PROJ_DIR$\..\Core\Src\tools.c</name>
+                </file>
                 <file>
                     <name>$PROJ_DIR$\..\Core\Src\usart.c</name>
                 </file>

PLSR/PLSR/EWARM/test.1/Obj/.ninja_log

@@ -1,71 +1,104 @@
 # ninja log v5
-464	505	7768536870781453	stm32f4xx_ll_rng.pbi	5e12b9ea00d0b826
-67	129	7768536866814718	stm32f4xx_ll_gpio.pbi	df8b54563945d41d
-32	67	7768536866465887	stm32f4xx_ll_tim.pbi	b88554c6464192f5
-159	513	7768536870801418	stm32f4xx_hal_flash_ex.pbi	ac2d035774fe6a2e
-931	1257	7768536878369160	stm32f4xx_hal_pwr.pbi	b347497fce55b6a8
-115	147	7768536867273193	stm32f4xx_ll_pwr.pbi	952cb4e4f4edb65b
-166	215	7768536867811386	test.1_part7.pbi	67c64030b23c9b51
-1543	2106	7768536886832096	test.1_part3.pbi	2c7780fc3f88c160
-1210	1542	7768536881070146	stm32f4xx_hal_rcc_ex.pbi	c1d751d24d77a2df
-42	122	7768536866824682	app_hooks.pbi	ffd399489d189d5a
-1652	2177	7768536887509800	test.1_part4.pbi	b15d70d6e2dea5ca
-513	867	7768536874350914	stm32f4xx_hal_pwr_ex.pbi	b84426bf5a4ce0cf
-45	114	7768536866864582	os_cpu_c.pbi	eb75b848b406ea34
-578	950	7768536875260101	stm32f4xx_hal_rcc.pbi	50976e6b18f3b8bc
-942	1346	7768536879266167	stm32f4xx_hal_tim.pbi	71840baae88d57c4
-871	1213	7768536877692971	stm32f4xx_hal_usart.pbi	b368fafd8b8b8bb9
-3553	5121	7768536916697101	test.1.pbw	f11e09b552b4c82f
+503	538	7784905999900596	stm32f4xx_ll_rng.pbi	5e12b9ea00d0b826
+40	71	7784905995236899	stm32f4xx_ll_gpio.pbi	df8b54563945d41d
+147	542	7784905999950612	stm32f4xx_hal_flash_ex.pbi	ac2d035774fe6a2e
+47	438	7784905998849550	stm32f4xx_hal_pwr.pbi	b347497fce55b6a8
+45	79	7784905995286895	stm32f4xx_ll_pwr.pbi	952cb4e4f4edb65b
+41	74	7784905995236899	stm32f4xx_ll_tim.pbi	b88554c6464192f5
+619	677	7784906001271479	test.1_part7.pbi	500429da32d98820
+1098	1738	7784906011909270	test.1_part3.pbi	351715abf331fd8f
+980	1370	7784906008199754	stm32f4xx_hal_rcc_ex.pbi	c1d751d24d77a2df
+74	141	7784905995934806	app_hooks.pbi	ffd399489d189d5a
+77	146	7784905995994802	os_cpu_c.pbi	eb75b848b406ea34
+677	1097	7784906004872212	stm32f4xx_hal_pwr_ex.pbi	b84426bf5a4ce0cf
+1374	2019	7784906014714303	test.1_part4.pbi	56a4af6f8e33d2b8
+587	980	7784906004332215	stm32f4xx_hal_rcc.pbi	50976e6b18f3b8bc
+36	425	7784905998551969	stm32f4xx_hal_usart.pbi	b368fafd8b8b8bb9
+439	950	7784906003781095	stm32f4xx_hal_tim.pbi	71840baae88d57c4
+43	76	7784905995266903	stm32f4xx_ll_dac.pbi	7dfc4be0933cdfaf
 2014	2487	7762488664073707	uart.pbi	5ce52444157923c9
-215	253	7768536868329652	stm32f4xx_ll_dac.pbi	7dfc4be0933cdfaf
-1214	1246	7768536878269490	stm32f4xx_ll_crc.pbi	dcf41d4b97590765
-126	159	7768536867392785	stm32f4xx_ll_rcc.pbi	fb9ace481decf8ab
-1669	1999	7768536885705853	stm32f4xx_hal_msp.pbi	8144db72f01a260b
-498	546	7768536871140260	stm32f4xx_ll_spi.pbi	ce805017b70a4f43
-48	118	7768536866944314	os_dbg.pbi	f7287a072fe86a55
-36	71	7768536866495790	stm32f4xx_ll_usart.pbi	783190689e783d9
-147	509	7768536870671821	stm32f4xx_hal_crc.pbi	881b29e4c80746b3
-888	930	7768536875008719	stm32f4xx_ll_dma.pbi	f9e6142ede2883b4
-1247	1281	7768536878608362	stm32f4xx_ll_exti.pbi	883a2fd463949e02
-1282	1297	7768536878777835	test.1_part5.pbi	41f12be61ce67c27
-39	166	7768536867462563	ucos_ii.pbi	4e0ab25e0060431e
-2355	2700	7768536892214098	stm32f4xx_hal.pbi	a073c739b6b34173
-71	125	7768536866854589	stm32f4xx_ll_i2c.pbi	7f1151d8874c40c9
-868	1209	7768536877633167	stm32f4xx_hal_sram.pbi	4652c5af4efd4e19
-592	942	7768536875198075	stm32f4xx_hal_flash.pbi	eccf13860e1d0c6a
-546	578	7768536871578800	test.1_part6.pbi	b9d684e502f25afa
-119	502	7768536870612013	stm32f4xx_hal_tim_ex.pbi	3c68a2e86514987f
-1205	1538	7768536881149867	stm32f4xx_hal_flash_ramfunc.pbi	ae498685b336a49c
-950	1261	7768536878369160	stm32f4xx_hal_wwdg.pbi	fca2b44f67349f99
-1257	1652	7768536881967123	stm32f4xx_hal_uart.pbi	e7ca7ebbb4330340
+3970	5650	7784906050685098	test.1.pbw	f11e09b552b4c82f
+71	103	7784905995539064	stm32f4xx_ll_crc.pbi	dcf41d4b97590765
+957	996	7784906004482217	stm32f4xx_ll_rcc.pbi	fb9ace481decf8ab
+464	502	7784905999549267	stm32f4xx_ll_spi.pbi	ce805017b70a4f43
+1854	2232	7784906016719795	stm32f4xx_hal_msp.pbi	8144db72f01a260b
+481	518	7784905999710625	stm32f4xx_ll_usart.pbi	783190689e783d9
+551	618	7784906000714119	os_dbg.pbi	f7287a072fe86a55
+538	574	7784906000256720	stm32f4xx_ll_dma.pbi	f9e6142ede2883b4
+1620	1981	7784906014335546	stm32f4xx_hal_crc.pbi	881b29e4c80746b3
+425	480	7784905999168351	stm32f4xx_ll_exti.pbi	883a2fd463949e02
+141	310	7784905997266114	ucos_ii.pbi	4e0ab25e0060431e
+575	586	7784906000398041	test.1_part5.pbi	6e09abdb5099df5f
+518	554	7784906000056714	stm32f4xx_ll_i2c.pbi	7f1151d8874c40c9
+1981	2339	7784906017916397	stm32f4xx_hal.pbi	a073c739b6b34173
+716	1094	7784906005193626	stm32f4xx_hal_sram.pbi	4652c5af4efd4e19
+996	1091	7784906004752222	test.1_part6.pbi	1f990020cfbdc2d2
+1738	2101	7784906015542605	stm32f4xx_hal_flash.pbi	eccf13860e1d0c6a
+950	1373	7784906008199754	stm32f4xx_hal_tim_ex.pbi	3c68a2e86514987f
+953	1356	7784906008069749	stm32f4xx_hal_wwdg.pbi	fca2b44f67349f99
+79	463	7784905999128352	stm32f4xx_hal_flash_ramfunc.pbi	ae498685b336a49c
+104	551	7784905999980595	stm32f4xx_hal_uart.pbi	e7ca7ebbb4330340
 35	454	7762489045860992	timer.pbi	8f8acc6a162957f
-122	464	7768536870422653	stm32f4xx_hal_i2c.pbi	74395538aa12fa10
-864	1205	7768536877762736	stm32f4xx_hal_dma.pbi	2d6aa8f3983bf80a
-2024	2359	7768536889393504	stm32f4xx_hal_timebase_tim.pbi	b6f5ce0feaca8054
-505	887	7768536874450598	stm32f4xx_hal_dma_ex.pbi	1960c5ab56ffede7
-509	871	7768536874185622	stm32f4xx_hal_i2c_ex.pbi	7798e48f8e6ef374
-253	592	7768536871708352	stm32f4xx_hal_exti.pbi	373789209d565f00
-1644	2023	7768536885964976	main.pbi	9c0a6aa02351636a
-1995	2354	7768536889343681	stm32f4xx_it.pbi	d01766022cb163bc
-130	498	7768536870532288	stm32f4xx_hal_cortex.pbi	2c6d2473a153fb5a
-2110	2461	7768536890190832	system_stm32f4xx.pbi	f50e519d7e78a5de
-1999	2335	7768536889004806	gpio.pbi	a088b5271f02118a
-3209	3553	7768536901332297	test.1.pbd	363d5d355a216cdf
-2336	2882	7768536894499702	test.1_part0.pbi	60db414ccd7a80f4
-502	863	7768536874420683	stm32f4xx_hal_gpio.pbi	53b438f48be9a8d0
-2700	3209	7768536897898329	test.1_part1.pbi	72148e63fe682e2f
-1539	2110	7768536886772270	test.1_part2.pbi	932c7a5b50912170
-1347	1669	7768536882345866	dma.pbi	4f5ebe00ac67ed57
-2177	2581	7768536891416765	tim.pbi	f07c6d790a519d93
-2106	2492	7768536890439999	usart.pbi	7c2d93866867ab60
-1297	1647	7768536882196362	modbus_log.pbi	596603da5f343c45
-1648	1995	7768536885436731	modbus_crc.pbi	9b76681ddf289794
-1261	1644	7768536881937241	flash_save.pbi	dc7405226be28cc6
-32	380	7768544283889545	tim.pbi	f07c6d790a519d93
-381	904	7768544289141477	test.1_part1.pbi	72148e63fe682e2f
-905	1273	7768544292826533	test.1.pbd	363d5d355a216cdf
-1273	2905	7768544308773033	test.1.pbw	f11e09b552b4c82f
-36	414	7768544355956471	tim.pbi	f07c6d790a519d93
-415	955	7768544361556770	test.1_part1.pbi	72148e63fe682e2f
-955	1326	7768544365284012	test.1.pbd	363d5d355a216cdf
-1327	3036	7768544381928778	test.1.pbw	f11e09b552b4c82f
+310	716	7784906001535050	stm32f4xx_hal_i2c.pbi	74395538aa12fa10
+1095	1510	7784906009628406	stm32f4xx_hal_dma.pbi	2d6aa8f3983bf80a
+2264	2623	7784906020742722	stm32f4xx_hal_timebase_tim.pbi	b6f5ce0feaca8054
+542	953	7784906003680996	stm32f4xx_hal_i2c_ex.pbi	7798e48f8e6ef374
+1511	1902	7784906013479985	stm32f4xx_hal_dma_ex.pbi	1960c5ab56ffede7
+1902	2360	7784906018132419	main.pbi	9c0a6aa02351636a
+1874	2264	7784906017054568	stm32f4xx_hal_exti.pbi	373789209d565f00
+2396	2870	7784906023223742	stm32f4xx_it.pbi	d01766022cb163bc
+2623	2999	7784906023983113	stm32f4xx_hal_cortex.pbi	2c6d2473a153fb5a
+2465	2803	7784906022507497	system_stm32f4xx.pbi	f50e519d7e78a5de
+2339	2770	7784906022184342	gpio.pbi	a088b5271f02118a
+555	956	7784906003860996	stm32f4xx_hal_gpio.pbi	53b438f48be9a8d0
+2771	3337	7784906027909005	test.1_part0.pbi	60db414ccd7a80f4
+3571	3970	7784906034025292	test.1.pbd	363d5d355a216cdf
+2871	3438	7784906028921550	test.1_part1.pbi	132c9eecf11b0e50
+3000	3570	7784906029571553	test.1_part2.pbi	9358ff0702a0a659
+2020	2395	7784906018488587	dma.pbi	4f5ebe00ac67ed57
+2360	2825	7784906022773747	tim.pbi	f07c6d790a519d93
+1371	1853	7784906012969969	usart.pbi	7c2d93866867ab60
+2232	2678	7784906021193269	modbus_log.pbi	596603da5f343c45
+1091	1619	7784906010590373	flash_save.pbi	dc7405226be28cc6
+2102	2464	7784906019147050	modbus_crc.pbi	9b76681ddf289794
+1356	1873	7784906013259981	tools.pbi	50c1b905eccec5a9
+43	582	7784915618440897	tim.pbi	f07c6d790a519d93
+583	1325	7784915625876327	test.1_part1.pbi	132c9eecf11b0e50
+1326	1767	7784915630302801	test.1.pbd	363d5d355a216cdf
+1768	3779	7784915649985852	test.1.pbw	f11e09b552b4c82f
+45	562	7784917494463934	tim.pbi	f07c6d790a519d93
+563	1285	7784917501703826	test.1_part1.pbi	132c9eecf11b0e50
+1286	1767	7784917506520187	test.1.pbd	363d5d355a216cdf
+1768	3893	7784917527374567	test.1.pbw	f11e09b552b4c82f
+39	509	7784928623168062	tim.pbi	f07c6d790a519d93
+510	1220	7784928630292184	test.1_part1.pbi	132c9eecf11b0e50
+1221	1677	7784928634860123	test.1.pbd	363d5d355a216cdf
+1677	3707	7784928654757887	test.1.pbw	f11e09b552b4c82f
+41	492	7784928682875712	tim.pbi	f07c6d790a519d93
+493	1162	7784928689567952	test.1_part1.pbi	132c9eecf11b0e50
+1163	1600	7784928693956627	test.1.pbd	363d5d355a216cdf
+1601	3646	7784928714013822	test.1.pbw	f11e09b552b4c82f
+42	507	7784929504874213	tim.pbi	f07c6d790a519d93
+508	1217	7784929511969174	test.1_part1.pbi	132c9eecf11b0e50
+1218	1691	7784929516709113	test.1.pbd	363d5d355a216cdf
+1692	4068	7784929539993199	test.1.pbw	f11e09b552b4c82f
+44	524	7784929568784599	tim.pbi	f07c6d790a519d93
+524	1252	7784929576084917	test.1_part1.pbi	132c9eecf11b0e50
+1253	1705	7784929580604105	test.1.pbd	363d5d355a216cdf
+1706	3866	7784929601822108	test.1.pbw	f11e09b552b4c82f
+48	721	7784931433466139	tim.pbi	f07c6d790a519d93
+721	1573	7784931441998409	test.1_part1.pbi	132c9eecf11b0e50
+1574	2160	7784931447880427	test.1.pbd	363d5d355a216cdf
+2161	4862	7784931474512163	test.1.pbw	f11e09b552b4c82f
+55	654	7784932500994422	tim.pbi	f07c6d790a519d93
+655	1523	7784932509680475	test.1_part1.pbi	132c9eecf11b0e50
+1524	2052	7784932514983677	test.1.pbd	363d5d355a216cdf
+2053	4809	7784932542008043	test.1.pbw	f11e09b552b4c82f
+47	543	7784933276338789	tim.pbi	f07c6d790a519d93
+544	1299	7784933283907452	test.1_part1.pbi	132c9eecf11b0e50
+1300	1771	7784933288637568	test.1.pbd	363d5d355a216cdf
+1772	4061	7784933311146536	test.1.pbw	f11e09b552b4c82f
+47	683	7784933341606110	tim.pbi	f07c6d790a519d93
+684	1547	7784933350245080	test.1_part1.pbi	132c9eecf11b0e50
+1548	1999	7784933354770500	test.1.pbd	363d5d355a216cdf
+2000	4664	7784933380938479	test.1.pbw	f11e09b552b4c82f

PLSR/PLSR/EWARM/test.1/Obj/build.ninja

@@ -30,6 +30,7 @@ build stm32f4xx_hal_msp.pbi : index stm32f4xx_hal_msp.xcl
 build stm32f4xx_hal_timebase_tim.pbi : index stm32f4xx_hal_timebase_tim.xcl
 build stm32f4xx_it.pbi : index stm32f4xx_it.xcl
 build tim.pbi : index tim.xcl
+build tools.pbi : index tools.xcl
 build usart.pbi : index usart.xcl
 build system_stm32f4xx.pbi : index system_stm32f4xx.xcl
 build stm32f4xx_hal.pbi : index stm32f4xx_hal.xcl
@@ -71,13 +72,13 @@ build os_cpu_c.pbi : index os_cpu_c.xcl
 build os_dbg.pbi : index os_dbg.xcl
 build ucos_ii.pbi : index ucos_ii.xcl
 build test.1_part0.pbi : link dma.pbi flash_save.pbi gpio.pbi main.pbi modbus_crc.pbi modbus_log.pbi stm32f4xx_hal_msp.pbi
-build test.1_part1.pbi : link stm32f4xx_hal_timebase_tim.pbi stm32f4xx_it.pbi tim.pbi usart.pbi system_stm32f4xx.pbi stm32f4xx_hal.pbi stm32f4xx_hal_cortex.pbi
-build test.1_part2.pbi : link stm32f4xx_hal_crc.pbi stm32f4xx_hal_dma.pbi stm32f4xx_hal_dma_ex.pbi stm32f4xx_hal_exti.pbi stm32f4xx_hal_flash.pbi stm32f4xx_hal_flash_ex.pbi stm32f4xx_hal_flash_ramfunc.pbi
-build test.1_part3.pbi : link stm32f4xx_hal_gpio.pbi stm32f4xx_hal_i2c.pbi stm32f4xx_hal_i2c_ex.pbi stm32f4xx_hal_pwr.pbi stm32f4xx_hal_pwr_ex.pbi stm32f4xx_hal_rcc.pbi stm32f4xx_hal_rcc_ex.pbi
-build test.1_part4.pbi : link stm32f4xx_hal_sram.pbi stm32f4xx_hal_tim.pbi stm32f4xx_hal_tim_ex.pbi stm32f4xx_hal_uart.pbi stm32f4xx_hal_usart.pbi stm32f4xx_hal_wwdg.pbi stm32f4xx_ll_crc.pbi
-build test.1_part5.pbi : link stm32f4xx_ll_dac.pbi stm32f4xx_ll_dma.pbi stm32f4xx_ll_exti.pbi stm32f4xx_ll_gpio.pbi stm32f4xx_ll_i2c.pbi stm32f4xx_ll_pwr.pbi stm32f4xx_ll_rcc.pbi
-build test.1_part6.pbi : link stm32f4xx_ll_rng.pbi stm32f4xx_ll_spi.pbi stm32f4xx_ll_tim.pbi stm32f4xx_ll_usart.pbi app_hooks.pbi os_cpu_c.pbi os_dbg.pbi
-build test.1_part7.pbi : link ucos_ii.pbi
+build test.1_part1.pbi : link stm32f4xx_hal_timebase_tim.pbi stm32f4xx_it.pbi tim.pbi tools.pbi usart.pbi system_stm32f4xx.pbi stm32f4xx_hal.pbi
+build test.1_part2.pbi : link stm32f4xx_hal_cortex.pbi stm32f4xx_hal_crc.pbi stm32f4xx_hal_dma.pbi stm32f4xx_hal_dma_ex.pbi stm32f4xx_hal_exti.pbi stm32f4xx_hal_flash.pbi stm32f4xx_hal_flash_ex.pbi
+build test.1_part3.pbi : link stm32f4xx_hal_flash_ramfunc.pbi stm32f4xx_hal_gpio.pbi stm32f4xx_hal_i2c.pbi stm32f4xx_hal_i2c_ex.pbi stm32f4xx_hal_pwr.pbi stm32f4xx_hal_pwr_ex.pbi stm32f4xx_hal_rcc.pbi
+build test.1_part4.pbi : link stm32f4xx_hal_rcc_ex.pbi stm32f4xx_hal_sram.pbi stm32f4xx_hal_tim.pbi stm32f4xx_hal_tim_ex.pbi stm32f4xx_hal_uart.pbi stm32f4xx_hal_usart.pbi stm32f4xx_hal_wwdg.pbi
+build test.1_part5.pbi : link stm32f4xx_ll_crc.pbi stm32f4xx_ll_dac.pbi stm32f4xx_ll_dma.pbi stm32f4xx_ll_exti.pbi stm32f4xx_ll_gpio.pbi stm32f4xx_ll_i2c.pbi stm32f4xx_ll_pwr.pbi
+build test.1_part6.pbi : link stm32f4xx_ll_rcc.pbi stm32f4xx_ll_rng.pbi stm32f4xx_ll_spi.pbi stm32f4xx_ll_tim.pbi stm32f4xx_ll_usart.pbi app_hooks.pbi os_cpu_c.pbi
+build test.1_part7.pbi : link os_dbg.pbi ucos_ii.pbi
 build test.1.pbd : link test.1_part0.pbi test.1_part1.pbi test.1_part2.pbi test.1_part3.pbi test.1_part4.pbi test.1_part5.pbi test.1_part6.pbi test.1_part7.pbi
 build test.1.pbw : browsedata test.1.pbd
 

PLSR/PLSR/EWARM/test.1/Obj/flash_save.pbi.dep

@@ -0,0 +1,41 @@
+flash_save.pbi: \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src\flash_save.c \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\flash_save.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\stm32f4xx_hal_conf.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_rcc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_def.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include\stm32f4xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include/stm32f407xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include\core_cm4.h \
+  E:\Software\IAR\arm\inc\c\stdint.h E:\Software\IAR\arm\inc\c\ycheck.h \
+  E:\Software\IAR\arm\inc\c\yvals.h \
+  E:\Software\IAR\arm\inc\c\DLib_Defaults.h \
+  E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/cmsis_version.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/cmsis_compiler.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include\cmsis_iccarm.h \
+  E:\Software\IAR\arm\inc\c\iccarm_builtin.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/mpu_armv7.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h \
+  E:\Software\IAR\arm\inc\c\stddef.h E:\Software\IAR\arm\inc\c\ysizet.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_rcc_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_gpio.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_gpio_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_exti.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_dma.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_dma_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_cortex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_flash.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_flash_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_flash_ramfunc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_pwr.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_pwr_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_tim.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_tim_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_uart.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\modbus_crc.h \
+  E:\Software\IAR\arm\inc\c\string.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product_string.h

PLSR/PLSR/EWARM/test.1/Obj/flash_save.xcl

@@ -0,0 +1,384 @@
+"e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src\flash_save.c"
+-std=c11
+-ferror-limit=0
+-fbracket-depth=512
+-MD
+-MF
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\test.1\Obj\flash_save.pbi.dep
+-o
+flash_save.pbi
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source
+-I
+E:\Software\IAR\arm\inc
+-I
+E:\Software\IAR\arm\inc\c
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\STM32F4xx_HAL_Driver\Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\STM32F4xx_HAL_Driver\Inc\Legacy
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\CMSIS\Device\ST\STM32F4xx\Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\CMSIS\Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Config
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Source
+-D__CHAR_BITS__=8
+-D__CHAR_MAX__=0xff
+-D__CHAR_MIN__=0
+-D__CHAR_SIZE__=1
+-D__UNSIGNED_CHAR_MAX__=0xff
+-D__SIGNED_CHAR_MAX__=127
+-D__SIGNED_CHAR_MIN__=(-__SIGNED_CHAR_MAX__-1)
+-D__CHAR_ALIGN__=1
+-D__SHORT_SIZE__=2
+-D__UNSIGNED_SHORT_MAX__=0xffff
+-D__SIGNED_SHORT_MAX__=32767
+-D__SIGNED_SHORT_MIN__=(-__SIGNED_SHORT_MAX__-1)
+-D__SHORT_ALIGN__=2
+-D__INT_SIZE__=4
+-D__UNSIGNED_INT_MAX__=0xffffffffU
+-D__SIGNED_INT_MAX__=2147483647
+-D__SIGNED_INT_MIN__=(-__SIGNED_INT_MAX__-1)
+-D__INT_ALIGN__=4
+-D__LONG_SIZE__=4
+-D__UNSIGNED_LONG_MAX__=0xffffffffUL
+-D__SIGNED_LONG_MAX__=2147483647L
+-D__SIGNED_LONG_MIN__=(-__SIGNED_LONG_MAX__-1)
+-D__LONG_ALIGN__=4
+-D__LONG_LONG_SIZE__=8
+-D__UNSIGNED_LONG_LONG_MAX__=0xffffffffffffffffULL
+-D__SIGNED_LONG_LONG_MAX__=9223372036854775807LL
+-D__SIGNED_LONG_LONG_MIN__=(-__SIGNED_LONG_LONG_MAX__-1)
+-D__LONG_LONG_ALIGN__=8
+-D__INT8_T_TYPE__=signed char
+-D__INT8_T_MAX__=127
+-D__INT8_T_MIN__=(-__INT8_T_MAX__-1)
+-D__UINT8_T_TYPE__=unsigned char
+-D__UINT8_T_MAX__=0xff
+-D__INT8_SIZE_PREFIX__="hh"
+-D__INT16_T_TYPE__=signed short int
+-D__INT16_T_MAX__=32767
+-D__INT16_T_MIN__=(-__INT16_T_MAX__-1)
+-D__UINT16_T_TYPE__=unsigned short int
+-D__UINT16_T_MAX__=0xffff
+-D__INT16_SIZE_PREFIX__="h"
+-D__INT32_T_TYPE__=signed int
+-D__INT32_T_MAX__=2147483647
+-D__INT32_T_MIN__=(-__INT32_T_MAX__-1)
+-D__UINT32_T_TYPE__=unsigned int
+-D__UINT32_T_MAX__=0xffffffffU
+-D__INT32_SIZE_PREFIX__=""
+-D__INT64_T_TYPE__=signed long long int
+-D__INT64_T_MAX__=9223372036854775807LL
+-D__INT64_T_MIN__=(-__INT64_T_MAX__-1)
+-D__UINT64_T_TYPE__=unsigned long long int
+-D__UINT64_T_MAX__=0xffffffffffffffffULL
+-D__INT64_SIZE_PREFIX__="ll"
+-D__INT_LEAST8_T_TYPE__=signed char
+-D__INT_LEAST8_T_MAX__=127
+-D__INT_LEAST8_T_MIN__=(-__INT_LEAST8_T_MAX__-1)
+-D__UINT_LEAST8_T_TYPE__=unsigned char
+-D__UINT_LEAST8_T_MAX__=0xff
+-D__INT8_C_SUFFIX__=
+-D__UINT8_C_SUFFIX__=
+-D__INT_LEAST8_SIZE_PREFIX__="hh"
+-D__INT_LEAST16_T_TYPE__=signed short int
+-D__INT_LEAST16_T_MAX__=32767
+-D__INT_LEAST16_T_MIN__=(-__INT_LEAST16_T_MAX__-1)
+-D__UINT_LEAST16_T_TYPE__=unsigned short int
+-D__UINT_LEAST16_T_MAX__=0xffff
+-D__INT16_C_SUFFIX__=
+-D__UINT16_C_SUFFIX__=
+-D__INT_LEAST16_SIZE_PREFIX__="h"
+-D__INT_LEAST32_T_TYPE__=signed int
+-D__INT_LEAST32_T_MAX__=2147483647
+-D__INT_LEAST32_T_MIN__=(-__INT_LEAST32_T_MAX__-1)
+-D__UINT_LEAST32_T_TYPE__=unsigned int
+-D__UINT_LEAST32_T_MAX__=0xffffffffU
+-D__INT32_C_SUFFIX__=
+-D__UINT32_C_SUFFIX__=U
+-D__INT_LEAST32_SIZE_PREFIX__=""
+-D__INT_LEAST64_T_TYPE__=signed long long int
+-D__INT_LEAST64_T_MAX__=9223372036854775807LL
+-D__INT_LEAST64_T_MIN__=(-__INT_LEAST64_T_MAX__-1)
+-D__UINT_LEAST64_T_TYPE__=unsigned long long int
+-D__UINT_LEAST64_T_MAX__=0xffffffffffffffffULL
+-D__INT64_C_SUFFIX__=LL
+-D__UINT64_C_SUFFIX__=ULL
+-D__INT_LEAST64_SIZE_PREFIX__="ll"
+-D__INT_FAST8_T_TYPE__=signed int
+-D__INT_FAST8_T_MAX__=2147483647
+-D__INT_FAST8_T_MIN__=(-__INT_FAST8_T_MAX__-1)
+-D__UINT_FAST8_T_TYPE__=unsigned int
+-D__UINT_FAST8_T_MAX__=0xffffffffU
+-D__INT_FAST8_SIZE_PREFIX__=""
+-D__INT_FAST16_T_TYPE__=signed int
+-D__INT_FAST16_T_MAX__=2147483647
+-D__INT_FAST16_T_MIN__=(-__INT_FAST16_T_MAX__-1)
+-D__UINT_FAST16_T_TYPE__=unsigned int
+-D__UINT_FAST16_T_MAX__=0xffffffffU
+-D__INT_FAST16_SIZE_PREFIX__=""
+-D__INT_FAST32_T_TYPE__=signed int
+-D__INT_FAST32_T_MAX__=2147483647
+-D__INT_FAST32_T_MIN__=(-__INT_FAST32_T_MAX__-1)
+-D__UINT_FAST32_T_TYPE__=unsigned int
+-D__UINT_FAST32_T_MAX__=0xffffffffU
+-D__INT_FAST32_SIZE_PREFIX__=""
+-D__INT_FAST64_T_TYPE__=signed long long int
+-D__INT_FAST64_T_MAX__=9223372036854775807LL
+-D__INT_FAST64_T_MIN__=(-__INT_FAST64_T_MAX__-1)
+-D__UINT_FAST64_T_TYPE__=unsigned long long int
+-D__UINT_FAST64_T_MAX__=0xffffffffffffffffULL
+-D__INT_FAST64_SIZE_PREFIX__="ll"
+-D__INTMAX_T_TYPE__=signed long long int
+-D__INTMAX_T_MAX__=9223372036854775807LL
+-D__INTMAX_T_MIN__=(-__INTMAX_T_MAX__-1)
+-D__UINTMAX_T_TYPE__=unsigned long long int
+-D__UINTMAX_T_MAX__=0xffffffffffffffffULL
+-D__INTMAX_C_SUFFIX__=LL
+-D__UINTMAX_C_SUFFIX__=ULL
+-D__INTMAX_SIZE_PREFIX__="ll"
+-D__ATOMIC_BOOL_LOCK_FREE=2
+-D__ATOMIC_CHAR_LOCK_FREE=2
+-D__ATOMIC_CHAR16_T_LOCK_FREE=2
+-D__ATOMIC_CHAR32_T_LOCK_FREE=2
+-D__ATOMIC_WCHAR_T_LOCK_FREE=2
+-D__ATOMIC_SHORT_LOCK_FREE=2
+-D__ATOMIC_INT_LOCK_FREE=2
+-D__ATOMIC_LONG_LOCK_FREE=2
+-D__ATOMIC_LLONG_LOCK_FREE=0
+-D__ATOMIC_POINTER_LOCK_FREE=2
+-D__FLOAT_SIZE__=4
+-D__FLOAT_ALIGN__=4
+-D__DOUBLE_SIZE__=8
+-D__DOUBLE_ALIGN__=8
+-D__LONG_DOUBLE_SIZE__=8
+-D__LONG_DOUBLE_ALIGN__=8
+-D____FP16_SIZE__=2
+-D____FP16_ALIGN__=2
+-D__NAN_HAS_HIGH_MANTISSA_BIT_SET__=0
+-D__SUBNORMAL_FLOATING_POINTS__=1
+-D__SIZE_T_TYPE__=unsigned int
+-D__SIZE_T_MAX__=0xffffffffU
+-D__PTRDIFF_T_TYPE__=signed int
+-D__PTRDIFF_T_MAX__=2147483647
+-D__PTRDIFF_T_MIN__=(-__PTRDIFF_T_MAX__-1)
+-D__INTPTR_T_TYPE__=signed int
+-D__INTPTR_T_MAX__=2147483647
+-D__INTPTR_T_MIN__=(-__INTPTR_T_MAX__-1)
+-D__UINTPTR_T_TYPE__=unsigned int
+-D__UINTPTR_T_MAX__=0xffffffffU
+-D__INTPTR_SIZE_PREFIX__=""
+-D__JMP_BUF_ELEMENT_TYPE__=unsigned long long int
+-D__JMP_BUF_NUM_ELEMENTS__=16
+-D__TID__=0xcf60
+-D__VER__=8040001
+-D__BUILD_NUMBER__=212
+-D__IAR_SYSTEMS_ICC__=9
+-D_MAX_ALIGNMENT=8
+-D__LITTLE_ENDIAN__=1
+-D__BOOL_TYPE__=unsigned char
+-D__BOOL_SIZE__=1
+-D__WCHAR_T_TYPE__=unsigned int
+-D__WCHAR_T_SIZE__=4
+-D__WCHAR_T_MAX__=0xffffffffU
+-D__DEF_PTR_MEM__=__data
+-D__DEF_PTR_SIZE__=4
+-D__DATA_MEM0__=__data
+-D__DATA_MEM0_POINTER_OK__=1
+-D__DATA_MEM0_UNIQUE_POINTER__=1
+-D__DATA_MEM0_VAR_OK__=1
+-D__DATA_MEM0_INTPTR_TYPE__=int
+-D__DATA_MEM0_UINTPTR_TYPE__=unsigned int
+-D__DATA_MEM0_INTPTR_SIZE_PREFIX__=""
+-D__DATA_MEM0_MAX_SIZE__=0x7fffffffU
+-D_RSIZE_MAX=0x7fffffffU
+-D__DATA_MEM0_HEAP_SEGMENT__="HEAP"
+-D__DATA_MEM0_PAGE_SIZE__=0
+-D__DATA_MEM0_HEAP__=0
+-D__CODE_MEM0__=__code
+-D__CODE_MEM0_POINTER_OK__=1
+-D__CODE_MEM0_UNIQUE_POINTER__=1
+-D__HEAP_MEM0__=0
+-D__HEAP_DEFAULT_MEM__=0
+-D__HEAPND_MEMORY_LIST1__()=
+-D__MULTIPLE_HEAPS__=0
+-D__DEF_HEAP_MEM__=__data
+-D__DEF_STACK_MEM_INDEX__=0
+-D__PRAGMA_PACK_ON__=1
+-D__MULTIPLE_INHERITANCE__=1
+-D__AAPCS_VFP__=1
+-D__ARM4TM__=4
+-D__ARM5TM__=5
+-D__ARM5T__=5
+-D__ARM5__=5
+-D__ARM6MEDIA__=6
+-D__ARM6M__=11
+-D__ARM6SM__=12
+-D__ARM6T2__=6
+-D__ARM6__=6
+-D__ARM7EM__=13
+-D__ARM7M__=7
+-D__ARM7__=7
+-D__ARMVFPV1__=1
+-D__ARMVFPV2__=2
+-D__ARMVFPV3_D16__=1
+-D__ARMVFPV3_FP16__=1
+-D__ARMVFPV3__=3
+-D__ARMVFPV4__=4
+-D__ARMVFP_D16__=1
+-D__ARMVFP_FP16__=1
+-D__ARMVFP_SP__=1
+-D__ARMVFP__=__ARMVFPV4__
+-D__ARM_32BIT_STATE=1
+-D__ARM_ACLE=201
+-D__ARM_ALIGN_MAX_PWR=8
+-D__ARM_ALIGN_MAX_STACK_PWR=3
+-D__ARM_ARCH=7
+-D__ARM_ARCH_ISA_THUMB=2
+-D__ARM_ARCH_PROFILE='M'
+-D__ARM_FEATURE_CLZ=1
+-D__ARM_FEATURE_COPROC=15
+-D__ARM_FEATURE_DSP=1
+-D__ARM_FEATURE_FMA=1
+-D__ARM_FEATURE_IDIV=1
+-D__ARM_FEATURE_LDREX=7
+-D__ARM_FEATURE_QBIT=1
+-D__ARM_FEATURE_SAT=1
+-D__ARM_FEATURE_SIMD32=1
+-D__ARM_FEATURE_UNALIGNED=1
+-D__ARM_FP=6
+-D__ARM_FP16_ARGS=1
+-D__ARM_FP16_FORMAT_IEEE=1
+-D__ARM_MEDIA__=1
+-D__ARM_PCS_VFP=1
+-D__ARM_PROFILE_M__=1
+-D__ARM_SIZE_MINIMAL_ENUM=1
+-D__ARM_SIZE_WCHAR_T=4
+-D__CODE_SIZE_LIMIT=0
+-D__CORE__=__ARM7EM__
+-D__CPU_MODE__=1
+-D__ICCARM_INTRINSICS_VERSION__=2
+-D__ICCARM__=1
+-D__INTERWORKING__=1
+-D__PLAIN_INT_BITFIELD_IS_SIGNED__=0
+-D__HAS_WEAK__=1
+-D__HAS_PACKED__=1
+-D__HAS_JOINED_TYPES__=1
+-D__HAS_LOCATED_DECLARATION__=1
+-D__HAS_LOCATED_WITH_INIT__=1
+-D__IAR_COMPILERBASE__=656644
+-D__IAR_COMPILERBASE_STR__=10.5.4.1177
+-D__UNICODE_SOURCE_SUPPORTED__=1
+-D__VTABLE_MEM__=
+-D__PRAGMA_REDEFINE_EXTNAME=1
+-D__STDC__=1
+-D__STDC_VERSION__=201710L
+-D__MEMORY_ORDER_RELAXED__=0
+-D__MEMORY_ORDER_CONSUME__=1
+-D__MEMORY_ORDER_ACQUIRE__=2
+-D__MEMORY_ORDER_RELEASE__=3
+-D__MEMORY_ORDER_ACQ_REL__=4
+-D__MEMORY_ORDER_SEQ_CST__=5
+-D__STDC_UTF_16__=1
+-D__STDC_UTF_32__=1
+-D__STDC_LIB_EXT1__=201112L
+-D__STDC_NO_THREADS__=1
+-D__STDC_ISO_10646__=201103L
+-D__STDC_HOSTED__=1
+-D__EDG_IA64_ABI=1
+-D__EDG_IA64_ABI_VARIANT_CTORS_AND_DTORS_RETURN_THIS=1
+-D__EDG_IA64_ABI_USE_INT_STATIC_INIT_GUARD=1
+-D__cpp_hex_float=201603L
+-D__cpp_unicode_literals=200710L
+-D__cpp_static_assert=200410L
+-D__EDG__=1
+-D__EDG_VERSION__=500
+-D__EDG_SIZE_TYPE__=unsigned int
+-D__EDG_PTRDIFF_TYPE__=int
+-D__EDG_DELTA_TYPE=int
+-D__EDG_IA64_VTABLE_ENTRY_TYPE=int
+-D__EDG_VIRTUAL_FUNCTION_INDEX_TYPE=unsigned short
+-D__EDG_LOWER_VARIABLE_LENGTH_ARRAYS=1
+-D__EDG_IA64_ABI_USE_VARIANT_ARRAY_COOKIES=1
+-D__EDG_ABI_COMPATIBILITY_VERSION=9999
+-D__EDG_ABI_CHANGES_FOR_RTTI=1
+-D__EDG_ABI_CHANGES_FOR_ARRAY_NEW_AND_DELETE=1
+-D__EDG_ABI_CHANGES_FOR_PLACEMENT_DELETE=1
+-D__EDG_BSD=0
+-D__EDG_SYSV=0
+-D__EDG_ANSIC=1
+-D__EDG_CPP11_IL_EXTENSIONS_SUPPORTED=1
+-D__EDG_FLOAT80_ENABLING_POSSIBLE=0
+-D__EDG_FLOAT128_ENABLING_POSSIBLE=0
+-D__EDG_INT128_EXTENSIONS_ALLOWED=0
+-DUSE_HAL_DRIVER=1
+-DSTM32F407xx=1
+-DHAL_UART_MODULE_ENABLED=1
+-D_DLIB_CONFIG_FILE_HEADER_NAME="E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h"
+-D_DLIB_CONFIG_FILE_STRING="E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h"
+-D__VERSION__="IAR ANSI C/C++ Compiler V8.40.1.212/W32 for ARM"
+-D_VA_DEFINED=
+-D_VA_LIST=struct __va_list
+-D__ICCARM_OLD_DEFINED_VAARGS__=1
+-D__VA_STACK_ALIGN__=8
+-D__CODE_MEMORY_LIST1__()=__CODE_MEM_HELPER1__(__code, 0 )
+-D__CODE_MEMORY_LIST2__(_P1)=__CODE_MEM_HELPER2__(__code, 0 ,  _P1 )
+-D__CODE_MEMORY_LIST3__(_P1,_P2)=__CODE_MEM_HELPER3__(__code, 0 ,  _P1 ,  _P2 )
+-D__DATA_MEMORY_LIST1__()=__DATA_MEM_HELPER1__(__data, 0 )
+-D__DATA_MEMORY_LIST2__(_P1)=__DATA_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__DATA_MEMORY_LIST3__(_P1,_P2)=__DATA_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__CODE_PTR_MEMORY_LIST1__()=__CODE_PTR_MEM_HELPER1__(__code, 0 )
+-D__CODE_PTR_MEMORY_LIST2__(_P1)=__CODE_PTR_MEM_HELPER2__(__code, 0 ,  _P1 )
+-D__CODE_PTR_MEMORY_LIST3__(_P1,_P2)=__CODE_PTR_MEM_HELPER3__(__code, 0 ,  _P1 ,  _P2 )
+-D__DATA_PTR_MEMORY_LIST1__()=__DATA_PTR_MEM_HELPER1__(__data, 0 )
+-D__DATA_PTR_MEMORY_LIST2__(_P1)=__DATA_PTR_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__DATA_PTR_MEMORY_LIST3__(_P1,_P2)=__DATA_PTR_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__VAR_MEMORY_LIST1__()=__VAR_MEM_HELPER1__(__data, 0 )
+-D__VAR_MEMORY_LIST2__(_P1)=__VAR_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__VAR_MEMORY_LIST3__(_P1,_P2)=__VAR_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__VARD_MEMORY_LIST1__()=__VARD_MEM_HELPER1__(__data, 0, _ )
+-D__HEAP_MEMORY_LIST1__()=__HEAP_MEM_HELPER1__(__data, 0 )
+-D__HEAP_MEMORY_LIST2__(_P1)=__HEAP_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__HEAP_MEMORY_LIST3__(_P1,_P2)=__HEAP_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__HVAR_MEMORY_LIST1__()=__HVAR_MEM_HELPER1__(__data, 0 )
+-D__HEAPD_MEMORY_LIST1__()=__HEAPD_MEM_HELPER1__(__data, 0, _ )
+-D__HEAPU_MEMORY_LIST1__()=__HEAPU_MEM_HELPER1__(__data, 0 )
+-D__TOPM_DATA_MEMORY_LIST1__()=
+-D__TOPM_DATA_MEMORY_LIST2__(_P1)=
+-D__TOPM_DATA_MEMORY_LIST3__(_P1,_P2)=
+-D__TOPP_DATA_MEMORY_LIST1__()=__TOPP_DATA_MEM_HELPER1__(__data, 0 )
+-D__TOPP_DATA_MEMORY_LIST2__(_P1)=__TOPP_DATA_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__TOPP_DATA_MEMORY_LIST3__(_P1,_P2)=__TOPP_DATA_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__DATA_MEM0_SIZE_TYPE__=unsigned int
+-D__DATA_MEM0_INDEX_TYPE__=signed int
+-D__iar_fp2bits32(x)=0
+-D__iar_fp2bits64(x)=0
+-D__iar_fpgethi64(x)=0
+-D__iar_atomic_add_fetch(x,y,z)=0
+-D__iar_atomic_sub_fetch(x,y,z)=0
+-D__iar_atomic_load(x,y)=0ULL
+-D__iar_atomic_compare_exchange_weak(a,b,c,d,e)=0

PLSR/PLSR/EWARM/test.1/Obj/gpio.pbi.dep

@@ -36,4 +36,24 @@ gpio.pbi: \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_pwr_ex.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_tim.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_tim_ex.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_uart.h
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_uart.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/tim.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/usart.h \
+  E:\Software\IAR\arm\inc\c\stdio.h E:\Software\IAR\arm\inc\c\string.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product_string.h \
+  E:\Software\IAR\arm\inc\c\ctype.h E:\Software\IAR\arm\inc\c\stdlib.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product_stdlib.h \
+  E:\Software\IAR\arm\inc\c\stdarg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/modbus_crc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/flash_save.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/modbus_log.h \
+  E:\Software\IAR\arm\inc\c\math.h \
+  E:\Software\IAR\arm\inc\c\DLib_float_setup.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\ucos_ii.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\app_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\os_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports\os_cpu.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source/os_trace.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/gpio.h \
+  E:\Software\IAR\arm\inc\c\intrinsics.h \
+  E:\Software\IAR\arm\inc\c\iar_intrinsics_common.h

PLSR/PLSR/EWARM/test.1/Obj/main.pbi.dep

@@ -1,23 +1,25 @@
 main.pbi: \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\dma.h \
+  E:\Software\IAR\arm\inc\c\iar_intrinsics_common.h \
+  E:\Software\IAR\arm\inc\c\intrinsics.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\gpio.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\os_trace.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports\os_cpu.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\os_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\app_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\ucos_ii.h \
   E:\Software\IAR\arm\inc\c\DLib_float_setup.h \
   E:\Software\IAR\arm\inc\c\ycheck.h E:\Software\IAR\arm\inc\c\math.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\tim.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\usart.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\modbus_log.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\flash_save.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\modbus_crc.h \
+  E:\Software\IAR\arm\inc\c\stdarg.h \
   E:\Software\IAR\arm\inc\c\DLib_Product_stdlib.h \
   E:\Software\IAR\arm\inc\c\stdlib.h E:\Software\IAR\arm\inc\c\ctype.h \
   E:\Software\IAR\arm\inc\c\DLib_Product_string.h \
-  E:\Software\IAR\arm\inc\c\string.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\tim.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\os_trace.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports\os_cpu.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\os_cfg.h \
-  E:\Software\IAR\arm\inc\c\stdio.h E:\Software\IAR\arm\inc\c\stdarg.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\app_cfg.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\ucos_ii.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Core\Inc\gpio.h \
+  E:\Software\IAR\arm\inc\c\string.h E:\Software\IAR\arm\inc\c\stdio.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Drivers\STM32F4xx_HAL_Driver\Inc\stm32f4xx_hal_uart.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Drivers\STM32F4xx_HAL_Driver\Inc\stm32f4xx_hal_tim_ex.h \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\Drivers\STM32F4xx_HAL_Driver\Inc\stm32f4xx_hal_tim.h \

PLSR/PLSR/EWARM/test.1/Obj/modbus_crc.pbi.dep

@@ -0,0 +1,38 @@
+modbus_crc.pbi: \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src\modbus_crc.c \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\modbus_crc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include\stm32f4xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include/stm32f407xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include\core_cm4.h \
+  E:\Software\IAR\arm\inc\c\stdint.h E:\Software\IAR\arm\inc\c\ycheck.h \
+  E:\Software\IAR\arm\inc\c\yvals.h \
+  E:\Software\IAR\arm\inc\c\DLib_Defaults.h \
+  E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/cmsis_version.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/cmsis_compiler.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include\cmsis_iccarm.h \
+  E:\Software\IAR\arm\inc\c\iccarm_builtin.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/mpu_armv7.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\stm32f4xx_hal_conf.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_rcc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_def.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h \
+  E:\Software\IAR\arm\inc\c\stddef.h E:\Software\IAR\arm\inc\c\ysizet.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_rcc_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_gpio.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_gpio_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_exti.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_dma.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_dma_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_cortex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_flash.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_flash_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_flash_ramfunc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_pwr.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_pwr_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_tim.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_tim_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_uart.h

PLSR/PLSR/EWARM/test.1/Obj/modbus_crc.xcl

@@ -0,0 +1,384 @@
+"e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src\modbus_crc.c"
+-std=c11
+-ferror-limit=0
+-fbracket-depth=512
+-MD
+-MF
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\test.1\Obj\modbus_crc.pbi.dep
+-o
+modbus_crc.pbi
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source
+-I
+E:\Software\IAR\arm\inc
+-I
+E:\Software\IAR\arm\inc\c
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\STM32F4xx_HAL_Driver\Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\STM32F4xx_HAL_Driver\Inc\Legacy
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\CMSIS\Device\ST\STM32F4xx\Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\CMSIS\Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Config
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Source
+-D__CHAR_BITS__=8
+-D__CHAR_MAX__=0xff
+-D__CHAR_MIN__=0
+-D__CHAR_SIZE__=1
+-D__UNSIGNED_CHAR_MAX__=0xff
+-D__SIGNED_CHAR_MAX__=127
+-D__SIGNED_CHAR_MIN__=(-__SIGNED_CHAR_MAX__-1)
+-D__CHAR_ALIGN__=1
+-D__SHORT_SIZE__=2
+-D__UNSIGNED_SHORT_MAX__=0xffff
+-D__SIGNED_SHORT_MAX__=32767
+-D__SIGNED_SHORT_MIN__=(-__SIGNED_SHORT_MAX__-1)
+-D__SHORT_ALIGN__=2
+-D__INT_SIZE__=4
+-D__UNSIGNED_INT_MAX__=0xffffffffU
+-D__SIGNED_INT_MAX__=2147483647
+-D__SIGNED_INT_MIN__=(-__SIGNED_INT_MAX__-1)
+-D__INT_ALIGN__=4
+-D__LONG_SIZE__=4
+-D__UNSIGNED_LONG_MAX__=0xffffffffUL
+-D__SIGNED_LONG_MAX__=2147483647L
+-D__SIGNED_LONG_MIN__=(-__SIGNED_LONG_MAX__-1)
+-D__LONG_ALIGN__=4
+-D__LONG_LONG_SIZE__=8
+-D__UNSIGNED_LONG_LONG_MAX__=0xffffffffffffffffULL
+-D__SIGNED_LONG_LONG_MAX__=9223372036854775807LL
+-D__SIGNED_LONG_LONG_MIN__=(-__SIGNED_LONG_LONG_MAX__-1)
+-D__LONG_LONG_ALIGN__=8
+-D__INT8_T_TYPE__=signed char
+-D__INT8_T_MAX__=127
+-D__INT8_T_MIN__=(-__INT8_T_MAX__-1)
+-D__UINT8_T_TYPE__=unsigned char
+-D__UINT8_T_MAX__=0xff
+-D__INT8_SIZE_PREFIX__="hh"
+-D__INT16_T_TYPE__=signed short int
+-D__INT16_T_MAX__=32767
+-D__INT16_T_MIN__=(-__INT16_T_MAX__-1)
+-D__UINT16_T_TYPE__=unsigned short int
+-D__UINT16_T_MAX__=0xffff
+-D__INT16_SIZE_PREFIX__="h"
+-D__INT32_T_TYPE__=signed int
+-D__INT32_T_MAX__=2147483647
+-D__INT32_T_MIN__=(-__INT32_T_MAX__-1)
+-D__UINT32_T_TYPE__=unsigned int
+-D__UINT32_T_MAX__=0xffffffffU
+-D__INT32_SIZE_PREFIX__=""
+-D__INT64_T_TYPE__=signed long long int
+-D__INT64_T_MAX__=9223372036854775807LL
+-D__INT64_T_MIN__=(-__INT64_T_MAX__-1)
+-D__UINT64_T_TYPE__=unsigned long long int
+-D__UINT64_T_MAX__=0xffffffffffffffffULL
+-D__INT64_SIZE_PREFIX__="ll"
+-D__INT_LEAST8_T_TYPE__=signed char
+-D__INT_LEAST8_T_MAX__=127
+-D__INT_LEAST8_T_MIN__=(-__INT_LEAST8_T_MAX__-1)
+-D__UINT_LEAST8_T_TYPE__=unsigned char
+-D__UINT_LEAST8_T_MAX__=0xff
+-D__INT8_C_SUFFIX__=
+-D__UINT8_C_SUFFIX__=
+-D__INT_LEAST8_SIZE_PREFIX__="hh"
+-D__INT_LEAST16_T_TYPE__=signed short int
+-D__INT_LEAST16_T_MAX__=32767
+-D__INT_LEAST16_T_MIN__=(-__INT_LEAST16_T_MAX__-1)
+-D__UINT_LEAST16_T_TYPE__=unsigned short int
+-D__UINT_LEAST16_T_MAX__=0xffff
+-D__INT16_C_SUFFIX__=
+-D__UINT16_C_SUFFIX__=
+-D__INT_LEAST16_SIZE_PREFIX__="h"
+-D__INT_LEAST32_T_TYPE__=signed int
+-D__INT_LEAST32_T_MAX__=2147483647
+-D__INT_LEAST32_T_MIN__=(-__INT_LEAST32_T_MAX__-1)
+-D__UINT_LEAST32_T_TYPE__=unsigned int
+-D__UINT_LEAST32_T_MAX__=0xffffffffU
+-D__INT32_C_SUFFIX__=
+-D__UINT32_C_SUFFIX__=U
+-D__INT_LEAST32_SIZE_PREFIX__=""
+-D__INT_LEAST64_T_TYPE__=signed long long int
+-D__INT_LEAST64_T_MAX__=9223372036854775807LL
+-D__INT_LEAST64_T_MIN__=(-__INT_LEAST64_T_MAX__-1)
+-D__UINT_LEAST64_T_TYPE__=unsigned long long int
+-D__UINT_LEAST64_T_MAX__=0xffffffffffffffffULL
+-D__INT64_C_SUFFIX__=LL
+-D__UINT64_C_SUFFIX__=ULL
+-D__INT_LEAST64_SIZE_PREFIX__="ll"
+-D__INT_FAST8_T_TYPE__=signed int
+-D__INT_FAST8_T_MAX__=2147483647
+-D__INT_FAST8_T_MIN__=(-__INT_FAST8_T_MAX__-1)
+-D__UINT_FAST8_T_TYPE__=unsigned int
+-D__UINT_FAST8_T_MAX__=0xffffffffU
+-D__INT_FAST8_SIZE_PREFIX__=""
+-D__INT_FAST16_T_TYPE__=signed int
+-D__INT_FAST16_T_MAX__=2147483647
+-D__INT_FAST16_T_MIN__=(-__INT_FAST16_T_MAX__-1)
+-D__UINT_FAST16_T_TYPE__=unsigned int
+-D__UINT_FAST16_T_MAX__=0xffffffffU
+-D__INT_FAST16_SIZE_PREFIX__=""
+-D__INT_FAST32_T_TYPE__=signed int
+-D__INT_FAST32_T_MAX__=2147483647
+-D__INT_FAST32_T_MIN__=(-__INT_FAST32_T_MAX__-1)
+-D__UINT_FAST32_T_TYPE__=unsigned int
+-D__UINT_FAST32_T_MAX__=0xffffffffU
+-D__INT_FAST32_SIZE_PREFIX__=""
+-D__INT_FAST64_T_TYPE__=signed long long int
+-D__INT_FAST64_T_MAX__=9223372036854775807LL
+-D__INT_FAST64_T_MIN__=(-__INT_FAST64_T_MAX__-1)
+-D__UINT_FAST64_T_TYPE__=unsigned long long int
+-D__UINT_FAST64_T_MAX__=0xffffffffffffffffULL
+-D__INT_FAST64_SIZE_PREFIX__="ll"
+-D__INTMAX_T_TYPE__=signed long long int
+-D__INTMAX_T_MAX__=9223372036854775807LL
+-D__INTMAX_T_MIN__=(-__INTMAX_T_MAX__-1)
+-D__UINTMAX_T_TYPE__=unsigned long long int
+-D__UINTMAX_T_MAX__=0xffffffffffffffffULL
+-D__INTMAX_C_SUFFIX__=LL
+-D__UINTMAX_C_SUFFIX__=ULL
+-D__INTMAX_SIZE_PREFIX__="ll"
+-D__ATOMIC_BOOL_LOCK_FREE=2
+-D__ATOMIC_CHAR_LOCK_FREE=2
+-D__ATOMIC_CHAR16_T_LOCK_FREE=2
+-D__ATOMIC_CHAR32_T_LOCK_FREE=2
+-D__ATOMIC_WCHAR_T_LOCK_FREE=2
+-D__ATOMIC_SHORT_LOCK_FREE=2
+-D__ATOMIC_INT_LOCK_FREE=2
+-D__ATOMIC_LONG_LOCK_FREE=2
+-D__ATOMIC_LLONG_LOCK_FREE=0
+-D__ATOMIC_POINTER_LOCK_FREE=2
+-D__FLOAT_SIZE__=4
+-D__FLOAT_ALIGN__=4
+-D__DOUBLE_SIZE__=8
+-D__DOUBLE_ALIGN__=8
+-D__LONG_DOUBLE_SIZE__=8
+-D__LONG_DOUBLE_ALIGN__=8
+-D____FP16_SIZE__=2
+-D____FP16_ALIGN__=2
+-D__NAN_HAS_HIGH_MANTISSA_BIT_SET__=0
+-D__SUBNORMAL_FLOATING_POINTS__=1
+-D__SIZE_T_TYPE__=unsigned int
+-D__SIZE_T_MAX__=0xffffffffU
+-D__PTRDIFF_T_TYPE__=signed int
+-D__PTRDIFF_T_MAX__=2147483647
+-D__PTRDIFF_T_MIN__=(-__PTRDIFF_T_MAX__-1)
+-D__INTPTR_T_TYPE__=signed int
+-D__INTPTR_T_MAX__=2147483647
+-D__INTPTR_T_MIN__=(-__INTPTR_T_MAX__-1)
+-D__UINTPTR_T_TYPE__=unsigned int
+-D__UINTPTR_T_MAX__=0xffffffffU
+-D__INTPTR_SIZE_PREFIX__=""
+-D__JMP_BUF_ELEMENT_TYPE__=unsigned long long int
+-D__JMP_BUF_NUM_ELEMENTS__=16
+-D__TID__=0xcf60
+-D__VER__=8040001
+-D__BUILD_NUMBER__=212
+-D__IAR_SYSTEMS_ICC__=9
+-D_MAX_ALIGNMENT=8
+-D__LITTLE_ENDIAN__=1
+-D__BOOL_TYPE__=unsigned char
+-D__BOOL_SIZE__=1
+-D__WCHAR_T_TYPE__=unsigned int
+-D__WCHAR_T_SIZE__=4
+-D__WCHAR_T_MAX__=0xffffffffU
+-D__DEF_PTR_MEM__=__data
+-D__DEF_PTR_SIZE__=4
+-D__DATA_MEM0__=__data
+-D__DATA_MEM0_POINTER_OK__=1
+-D__DATA_MEM0_UNIQUE_POINTER__=1
+-D__DATA_MEM0_VAR_OK__=1
+-D__DATA_MEM0_INTPTR_TYPE__=int
+-D__DATA_MEM0_UINTPTR_TYPE__=unsigned int
+-D__DATA_MEM0_INTPTR_SIZE_PREFIX__=""
+-D__DATA_MEM0_MAX_SIZE__=0x7fffffffU
+-D_RSIZE_MAX=0x7fffffffU
+-D__DATA_MEM0_HEAP_SEGMENT__="HEAP"
+-D__DATA_MEM0_PAGE_SIZE__=0
+-D__DATA_MEM0_HEAP__=0
+-D__CODE_MEM0__=__code
+-D__CODE_MEM0_POINTER_OK__=1
+-D__CODE_MEM0_UNIQUE_POINTER__=1
+-D__HEAP_MEM0__=0
+-D__HEAP_DEFAULT_MEM__=0
+-D__HEAPND_MEMORY_LIST1__()=
+-D__MULTIPLE_HEAPS__=0
+-D__DEF_HEAP_MEM__=__data
+-D__DEF_STACK_MEM_INDEX__=0
+-D__PRAGMA_PACK_ON__=1
+-D__MULTIPLE_INHERITANCE__=1
+-D__AAPCS_VFP__=1
+-D__ARM4TM__=4
+-D__ARM5TM__=5
+-D__ARM5T__=5
+-D__ARM5__=5
+-D__ARM6MEDIA__=6
+-D__ARM6M__=11
+-D__ARM6SM__=12
+-D__ARM6T2__=6
+-D__ARM6__=6
+-D__ARM7EM__=13
+-D__ARM7M__=7
+-D__ARM7__=7
+-D__ARMVFPV1__=1
+-D__ARMVFPV2__=2
+-D__ARMVFPV3_D16__=1
+-D__ARMVFPV3_FP16__=1
+-D__ARMVFPV3__=3
+-D__ARMVFPV4__=4
+-D__ARMVFP_D16__=1
+-D__ARMVFP_FP16__=1
+-D__ARMVFP_SP__=1
+-D__ARMVFP__=__ARMVFPV4__
+-D__ARM_32BIT_STATE=1
+-D__ARM_ACLE=201
+-D__ARM_ALIGN_MAX_PWR=8
+-D__ARM_ALIGN_MAX_STACK_PWR=3
+-D__ARM_ARCH=7
+-D__ARM_ARCH_ISA_THUMB=2
+-D__ARM_ARCH_PROFILE='M'
+-D__ARM_FEATURE_CLZ=1
+-D__ARM_FEATURE_COPROC=15
+-D__ARM_FEATURE_DSP=1
+-D__ARM_FEATURE_FMA=1
+-D__ARM_FEATURE_IDIV=1
+-D__ARM_FEATURE_LDREX=7
+-D__ARM_FEATURE_QBIT=1
+-D__ARM_FEATURE_SAT=1
+-D__ARM_FEATURE_SIMD32=1
+-D__ARM_FEATURE_UNALIGNED=1
+-D__ARM_FP=6
+-D__ARM_FP16_ARGS=1
+-D__ARM_FP16_FORMAT_IEEE=1
+-D__ARM_MEDIA__=1
+-D__ARM_PCS_VFP=1
+-D__ARM_PROFILE_M__=1
+-D__ARM_SIZE_MINIMAL_ENUM=1
+-D__ARM_SIZE_WCHAR_T=4
+-D__CODE_SIZE_LIMIT=0
+-D__CORE__=__ARM7EM__
+-D__CPU_MODE__=1
+-D__ICCARM_INTRINSICS_VERSION__=2
+-D__ICCARM__=1
+-D__INTERWORKING__=1
+-D__PLAIN_INT_BITFIELD_IS_SIGNED__=0
+-D__HAS_WEAK__=1
+-D__HAS_PACKED__=1
+-D__HAS_JOINED_TYPES__=1
+-D__HAS_LOCATED_DECLARATION__=1
+-D__HAS_LOCATED_WITH_INIT__=1
+-D__IAR_COMPILERBASE__=656644
+-D__IAR_COMPILERBASE_STR__=10.5.4.1177
+-D__UNICODE_SOURCE_SUPPORTED__=1
+-D__VTABLE_MEM__=
+-D__PRAGMA_REDEFINE_EXTNAME=1
+-D__STDC__=1
+-D__STDC_VERSION__=201710L
+-D__MEMORY_ORDER_RELAXED__=0
+-D__MEMORY_ORDER_CONSUME__=1
+-D__MEMORY_ORDER_ACQUIRE__=2
+-D__MEMORY_ORDER_RELEASE__=3
+-D__MEMORY_ORDER_ACQ_REL__=4
+-D__MEMORY_ORDER_SEQ_CST__=5
+-D__STDC_UTF_16__=1
+-D__STDC_UTF_32__=1
+-D__STDC_LIB_EXT1__=201112L
+-D__STDC_NO_THREADS__=1
+-D__STDC_ISO_10646__=201103L
+-D__STDC_HOSTED__=1
+-D__EDG_IA64_ABI=1
+-D__EDG_IA64_ABI_VARIANT_CTORS_AND_DTORS_RETURN_THIS=1
+-D__EDG_IA64_ABI_USE_INT_STATIC_INIT_GUARD=1
+-D__cpp_hex_float=201603L
+-D__cpp_unicode_literals=200710L
+-D__cpp_static_assert=200410L
+-D__EDG__=1
+-D__EDG_VERSION__=500
+-D__EDG_SIZE_TYPE__=unsigned int
+-D__EDG_PTRDIFF_TYPE__=int
+-D__EDG_DELTA_TYPE=int
+-D__EDG_IA64_VTABLE_ENTRY_TYPE=int
+-D__EDG_VIRTUAL_FUNCTION_INDEX_TYPE=unsigned short
+-D__EDG_LOWER_VARIABLE_LENGTH_ARRAYS=1
+-D__EDG_IA64_ABI_USE_VARIANT_ARRAY_COOKIES=1
+-D__EDG_ABI_COMPATIBILITY_VERSION=9999
+-D__EDG_ABI_CHANGES_FOR_RTTI=1
+-D__EDG_ABI_CHANGES_FOR_ARRAY_NEW_AND_DELETE=1
+-D__EDG_ABI_CHANGES_FOR_PLACEMENT_DELETE=1
+-D__EDG_BSD=0
+-D__EDG_SYSV=0
+-D__EDG_ANSIC=1
+-D__EDG_CPP11_IL_EXTENSIONS_SUPPORTED=1
+-D__EDG_FLOAT80_ENABLING_POSSIBLE=0
+-D__EDG_FLOAT128_ENABLING_POSSIBLE=0
+-D__EDG_INT128_EXTENSIONS_ALLOWED=0
+-DUSE_HAL_DRIVER=1
+-DSTM32F407xx=1
+-DHAL_UART_MODULE_ENABLED=1
+-D_DLIB_CONFIG_FILE_HEADER_NAME="E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h"
+-D_DLIB_CONFIG_FILE_STRING="E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h"
+-D__VERSION__="IAR ANSI C/C++ Compiler V8.40.1.212/W32 for ARM"
+-D_VA_DEFINED=
+-D_VA_LIST=struct __va_list
+-D__ICCARM_OLD_DEFINED_VAARGS__=1
+-D__VA_STACK_ALIGN__=8
+-D__CODE_MEMORY_LIST1__()=__CODE_MEM_HELPER1__(__code, 0 )
+-D__CODE_MEMORY_LIST2__(_P1)=__CODE_MEM_HELPER2__(__code, 0 ,  _P1 )
+-D__CODE_MEMORY_LIST3__(_P1,_P2)=__CODE_MEM_HELPER3__(__code, 0 ,  _P1 ,  _P2 )
+-D__DATA_MEMORY_LIST1__()=__DATA_MEM_HELPER1__(__data, 0 )
+-D__DATA_MEMORY_LIST2__(_P1)=__DATA_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__DATA_MEMORY_LIST3__(_P1,_P2)=__DATA_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__CODE_PTR_MEMORY_LIST1__()=__CODE_PTR_MEM_HELPER1__(__code, 0 )
+-D__CODE_PTR_MEMORY_LIST2__(_P1)=__CODE_PTR_MEM_HELPER2__(__code, 0 ,  _P1 )
+-D__CODE_PTR_MEMORY_LIST3__(_P1,_P2)=__CODE_PTR_MEM_HELPER3__(__code, 0 ,  _P1 ,  _P2 )
+-D__DATA_PTR_MEMORY_LIST1__()=__DATA_PTR_MEM_HELPER1__(__data, 0 )
+-D__DATA_PTR_MEMORY_LIST2__(_P1)=__DATA_PTR_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__DATA_PTR_MEMORY_LIST3__(_P1,_P2)=__DATA_PTR_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__VAR_MEMORY_LIST1__()=__VAR_MEM_HELPER1__(__data, 0 )
+-D__VAR_MEMORY_LIST2__(_P1)=__VAR_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__VAR_MEMORY_LIST3__(_P1,_P2)=__VAR_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__VARD_MEMORY_LIST1__()=__VARD_MEM_HELPER1__(__data, 0, _ )
+-D__HEAP_MEMORY_LIST1__()=__HEAP_MEM_HELPER1__(__data, 0 )
+-D__HEAP_MEMORY_LIST2__(_P1)=__HEAP_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__HEAP_MEMORY_LIST3__(_P1,_P2)=__HEAP_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__HVAR_MEMORY_LIST1__()=__HVAR_MEM_HELPER1__(__data, 0 )
+-D__HEAPD_MEMORY_LIST1__()=__HEAPD_MEM_HELPER1__(__data, 0, _ )
+-D__HEAPU_MEMORY_LIST1__()=__HEAPU_MEM_HELPER1__(__data, 0 )
+-D__TOPM_DATA_MEMORY_LIST1__()=
+-D__TOPM_DATA_MEMORY_LIST2__(_P1)=
+-D__TOPM_DATA_MEMORY_LIST3__(_P1,_P2)=
+-D__TOPP_DATA_MEMORY_LIST1__()=__TOPP_DATA_MEM_HELPER1__(__data, 0 )
+-D__TOPP_DATA_MEMORY_LIST2__(_P1)=__TOPP_DATA_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__TOPP_DATA_MEMORY_LIST3__(_P1,_P2)=__TOPP_DATA_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__DATA_MEM0_SIZE_TYPE__=unsigned int
+-D__DATA_MEM0_INDEX_TYPE__=signed int
+-D__iar_fp2bits32(x)=0
+-D__iar_fp2bits64(x)=0
+-D__iar_fpgethi64(x)=0
+-D__iar_atomic_add_fetch(x,y,z)=0
+-D__iar_atomic_sub_fetch(x,y,z)=0
+-D__iar_atomic_load(x,y)=0ULL
+-D__iar_atomic_compare_exchange_weak(a,b,c,d,e)=0

PLSR/PLSR/EWARM/test.1/Obj/modbus_log.pbi.dep

@@ -0,0 +1,59 @@
+modbus_log.pbi: \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src\modbus_log.c \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\modbus_log.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/usart.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/main.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc\stm32f4xx_hal_conf.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_rcc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_def.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include\stm32f4xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include/stm32f407xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include\core_cm4.h \
+  E:\Software\IAR\arm\inc\c\stdint.h E:\Software\IAR\arm\inc\c\ycheck.h \
+  E:\Software\IAR\arm\inc\c\yvals.h \
+  E:\Software\IAR\arm\inc\c\DLib_Defaults.h \
+  E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/cmsis_version.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/cmsis_compiler.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include\cmsis_iccarm.h \
+  E:\Software\IAR\arm\inc\c\iccarm_builtin.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include/mpu_armv7.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h \
+  E:\Software\IAR\arm\inc\c\stddef.h E:\Software\IAR\arm\inc\c\ysizet.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_rcc_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_gpio.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_gpio_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_exti.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_dma.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_dma_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_cortex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_flash.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_flash_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_flash_ramfunc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_pwr.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_pwr_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_tim.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_tim_ex.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc\stm32f4xx_hal_uart.h \
+  E:\Software\IAR\arm\inc\c\stdio.h E:\Software\IAR\arm\inc\c\string.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product_string.h \
+  E:\Software\IAR\arm\inc\c\ctype.h E:\Software\IAR\arm\inc\c\stdlib.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product_stdlib.h \
+  E:\Software\IAR\arm\inc\c\stdarg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/modbus_crc.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/flash_save.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/modbus_log.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/tim.h \
+  E:\Software\IAR\arm\inc\c\math.h \
+  E:\Software\IAR\arm\inc\c\DLib_float_setup.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\ucos_ii.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\app_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\os_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports\os_cpu.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source/os_trace.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc/gpio.h \
+  E:\Software\IAR\arm\inc\c\intrinsics.h \
+  E:\Software\IAR\arm\inc\c\iar_intrinsics_common.h

PLSR/PLSR/EWARM/test.1/Obj/modbus_log.xcl

@@ -0,0 +1,384 @@
+"e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src\modbus_log.c"
+-std=c11
+-ferror-limit=0
+-fbracket-depth=512
+-MD
+-MF
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\test.1\Obj\modbus_log.pbi.dep
+-o
+modbus_log.pbi
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Src
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Core/Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Device/ST/STM32F4xx/Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM/../Drivers/CMSIS/Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Ports
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source
+-I
+E:\Software\IAR\arm\inc
+-I
+E:\Software\IAR\arm\inc\c
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Core\Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\STM32F4xx_HAL_Driver\Inc
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\STM32F4xx_HAL_Driver\Inc\Legacy
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\CMSIS\Device\ST\STM32F4xx\Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\Drivers\CMSIS\Include
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Config
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports
+-I
+e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Source
+-D__CHAR_BITS__=8
+-D__CHAR_MAX__=0xff
+-D__CHAR_MIN__=0
+-D__CHAR_SIZE__=1
+-D__UNSIGNED_CHAR_MAX__=0xff
+-D__SIGNED_CHAR_MAX__=127
+-D__SIGNED_CHAR_MIN__=(-__SIGNED_CHAR_MAX__-1)
+-D__CHAR_ALIGN__=1
+-D__SHORT_SIZE__=2
+-D__UNSIGNED_SHORT_MAX__=0xffff
+-D__SIGNED_SHORT_MAX__=32767
+-D__SIGNED_SHORT_MIN__=(-__SIGNED_SHORT_MAX__-1)
+-D__SHORT_ALIGN__=2
+-D__INT_SIZE__=4
+-D__UNSIGNED_INT_MAX__=0xffffffffU
+-D__SIGNED_INT_MAX__=2147483647
+-D__SIGNED_INT_MIN__=(-__SIGNED_INT_MAX__-1)
+-D__INT_ALIGN__=4
+-D__LONG_SIZE__=4
+-D__UNSIGNED_LONG_MAX__=0xffffffffUL
+-D__SIGNED_LONG_MAX__=2147483647L
+-D__SIGNED_LONG_MIN__=(-__SIGNED_LONG_MAX__-1)
+-D__LONG_ALIGN__=4
+-D__LONG_LONG_SIZE__=8
+-D__UNSIGNED_LONG_LONG_MAX__=0xffffffffffffffffULL
+-D__SIGNED_LONG_LONG_MAX__=9223372036854775807LL
+-D__SIGNED_LONG_LONG_MIN__=(-__SIGNED_LONG_LONG_MAX__-1)
+-D__LONG_LONG_ALIGN__=8
+-D__INT8_T_TYPE__=signed char
+-D__INT8_T_MAX__=127
+-D__INT8_T_MIN__=(-__INT8_T_MAX__-1)
+-D__UINT8_T_TYPE__=unsigned char
+-D__UINT8_T_MAX__=0xff
+-D__INT8_SIZE_PREFIX__="hh"
+-D__INT16_T_TYPE__=signed short int
+-D__INT16_T_MAX__=32767
+-D__INT16_T_MIN__=(-__INT16_T_MAX__-1)
+-D__UINT16_T_TYPE__=unsigned short int
+-D__UINT16_T_MAX__=0xffff
+-D__INT16_SIZE_PREFIX__="h"
+-D__INT32_T_TYPE__=signed int
+-D__INT32_T_MAX__=2147483647
+-D__INT32_T_MIN__=(-__INT32_T_MAX__-1)
+-D__UINT32_T_TYPE__=unsigned int
+-D__UINT32_T_MAX__=0xffffffffU
+-D__INT32_SIZE_PREFIX__=""
+-D__INT64_T_TYPE__=signed long long int
+-D__INT64_T_MAX__=9223372036854775807LL
+-D__INT64_T_MIN__=(-__INT64_T_MAX__-1)
+-D__UINT64_T_TYPE__=unsigned long long int
+-D__UINT64_T_MAX__=0xffffffffffffffffULL
+-D__INT64_SIZE_PREFIX__="ll"
+-D__INT_LEAST8_T_TYPE__=signed char
+-D__INT_LEAST8_T_MAX__=127
+-D__INT_LEAST8_T_MIN__=(-__INT_LEAST8_T_MAX__-1)
+-D__UINT_LEAST8_T_TYPE__=unsigned char
+-D__UINT_LEAST8_T_MAX__=0xff
+-D__INT8_C_SUFFIX__=
+-D__UINT8_C_SUFFIX__=
+-D__INT_LEAST8_SIZE_PREFIX__="hh"
+-D__INT_LEAST16_T_TYPE__=signed short int
+-D__INT_LEAST16_T_MAX__=32767
+-D__INT_LEAST16_T_MIN__=(-__INT_LEAST16_T_MAX__-1)
+-D__UINT_LEAST16_T_TYPE__=unsigned short int
+-D__UINT_LEAST16_T_MAX__=0xffff
+-D__INT16_C_SUFFIX__=
+-D__UINT16_C_SUFFIX__=
+-D__INT_LEAST16_SIZE_PREFIX__="h"
+-D__INT_LEAST32_T_TYPE__=signed int
+-D__INT_LEAST32_T_MAX__=2147483647
+-D__INT_LEAST32_T_MIN__=(-__INT_LEAST32_T_MAX__-1)
+-D__UINT_LEAST32_T_TYPE__=unsigned int
+-D__UINT_LEAST32_T_MAX__=0xffffffffU
+-D__INT32_C_SUFFIX__=
+-D__UINT32_C_SUFFIX__=U
+-D__INT_LEAST32_SIZE_PREFIX__=""
+-D__INT_LEAST64_T_TYPE__=signed long long int
+-D__INT_LEAST64_T_MAX__=9223372036854775807LL
+-D__INT_LEAST64_T_MIN__=(-__INT_LEAST64_T_MAX__-1)
+-D__UINT_LEAST64_T_TYPE__=unsigned long long int
+-D__UINT_LEAST64_T_MAX__=0xffffffffffffffffULL
+-D__INT64_C_SUFFIX__=LL
+-D__UINT64_C_SUFFIX__=ULL
+-D__INT_LEAST64_SIZE_PREFIX__="ll"
+-D__INT_FAST8_T_TYPE__=signed int
+-D__INT_FAST8_T_MAX__=2147483647
+-D__INT_FAST8_T_MIN__=(-__INT_FAST8_T_MAX__-1)
+-D__UINT_FAST8_T_TYPE__=unsigned int
+-D__UINT_FAST8_T_MAX__=0xffffffffU
+-D__INT_FAST8_SIZE_PREFIX__=""
+-D__INT_FAST16_T_TYPE__=signed int
+-D__INT_FAST16_T_MAX__=2147483647
+-D__INT_FAST16_T_MIN__=(-__INT_FAST16_T_MAX__-1)
+-D__UINT_FAST16_T_TYPE__=unsigned int
+-D__UINT_FAST16_T_MAX__=0xffffffffU
+-D__INT_FAST16_SIZE_PREFIX__=""
+-D__INT_FAST32_T_TYPE__=signed int
+-D__INT_FAST32_T_MAX__=2147483647
+-D__INT_FAST32_T_MIN__=(-__INT_FAST32_T_MAX__-1)
+-D__UINT_FAST32_T_TYPE__=unsigned int
+-D__UINT_FAST32_T_MAX__=0xffffffffU
+-D__INT_FAST32_SIZE_PREFIX__=""
+-D__INT_FAST64_T_TYPE__=signed long long int
+-D__INT_FAST64_T_MAX__=9223372036854775807LL
+-D__INT_FAST64_T_MIN__=(-__INT_FAST64_T_MAX__-1)
+-D__UINT_FAST64_T_TYPE__=unsigned long long int
+-D__UINT_FAST64_T_MAX__=0xffffffffffffffffULL
+-D__INT_FAST64_SIZE_PREFIX__="ll"
+-D__INTMAX_T_TYPE__=signed long long int
+-D__INTMAX_T_MAX__=9223372036854775807LL
+-D__INTMAX_T_MIN__=(-__INTMAX_T_MAX__-1)
+-D__UINTMAX_T_TYPE__=unsigned long long int
+-D__UINTMAX_T_MAX__=0xffffffffffffffffULL
+-D__INTMAX_C_SUFFIX__=LL
+-D__UINTMAX_C_SUFFIX__=ULL
+-D__INTMAX_SIZE_PREFIX__="ll"
+-D__ATOMIC_BOOL_LOCK_FREE=2
+-D__ATOMIC_CHAR_LOCK_FREE=2
+-D__ATOMIC_CHAR16_T_LOCK_FREE=2
+-D__ATOMIC_CHAR32_T_LOCK_FREE=2
+-D__ATOMIC_WCHAR_T_LOCK_FREE=2
+-D__ATOMIC_SHORT_LOCK_FREE=2
+-D__ATOMIC_INT_LOCK_FREE=2
+-D__ATOMIC_LONG_LOCK_FREE=2
+-D__ATOMIC_LLONG_LOCK_FREE=0
+-D__ATOMIC_POINTER_LOCK_FREE=2
+-D__FLOAT_SIZE__=4
+-D__FLOAT_ALIGN__=4
+-D__DOUBLE_SIZE__=8
+-D__DOUBLE_ALIGN__=8
+-D__LONG_DOUBLE_SIZE__=8
+-D__LONG_DOUBLE_ALIGN__=8
+-D____FP16_SIZE__=2
+-D____FP16_ALIGN__=2
+-D__NAN_HAS_HIGH_MANTISSA_BIT_SET__=0
+-D__SUBNORMAL_FLOATING_POINTS__=1
+-D__SIZE_T_TYPE__=unsigned int
+-D__SIZE_T_MAX__=0xffffffffU
+-D__PTRDIFF_T_TYPE__=signed int
+-D__PTRDIFF_T_MAX__=2147483647
+-D__PTRDIFF_T_MIN__=(-__PTRDIFF_T_MAX__-1)
+-D__INTPTR_T_TYPE__=signed int
+-D__INTPTR_T_MAX__=2147483647
+-D__INTPTR_T_MIN__=(-__INTPTR_T_MAX__-1)
+-D__UINTPTR_T_TYPE__=unsigned int
+-D__UINTPTR_T_MAX__=0xffffffffU
+-D__INTPTR_SIZE_PREFIX__=""
+-D__JMP_BUF_ELEMENT_TYPE__=unsigned long long int
+-D__JMP_BUF_NUM_ELEMENTS__=16
+-D__TID__=0xcf60
+-D__VER__=8040001
+-D__BUILD_NUMBER__=212
+-D__IAR_SYSTEMS_ICC__=9
+-D_MAX_ALIGNMENT=8
+-D__LITTLE_ENDIAN__=1
+-D__BOOL_TYPE__=unsigned char
+-D__BOOL_SIZE__=1
+-D__WCHAR_T_TYPE__=unsigned int
+-D__WCHAR_T_SIZE__=4
+-D__WCHAR_T_MAX__=0xffffffffU
+-D__DEF_PTR_MEM__=__data
+-D__DEF_PTR_SIZE__=4
+-D__DATA_MEM0__=__data
+-D__DATA_MEM0_POINTER_OK__=1
+-D__DATA_MEM0_UNIQUE_POINTER__=1
+-D__DATA_MEM0_VAR_OK__=1
+-D__DATA_MEM0_INTPTR_TYPE__=int
+-D__DATA_MEM0_UINTPTR_TYPE__=unsigned int
+-D__DATA_MEM0_INTPTR_SIZE_PREFIX__=""
+-D__DATA_MEM0_MAX_SIZE__=0x7fffffffU
+-D_RSIZE_MAX=0x7fffffffU
+-D__DATA_MEM0_HEAP_SEGMENT__="HEAP"
+-D__DATA_MEM0_PAGE_SIZE__=0
+-D__DATA_MEM0_HEAP__=0
+-D__CODE_MEM0__=__code
+-D__CODE_MEM0_POINTER_OK__=1
+-D__CODE_MEM0_UNIQUE_POINTER__=1
+-D__HEAP_MEM0__=0
+-D__HEAP_DEFAULT_MEM__=0
+-D__HEAPND_MEMORY_LIST1__()=
+-D__MULTIPLE_HEAPS__=0
+-D__DEF_HEAP_MEM__=__data
+-D__DEF_STACK_MEM_INDEX__=0
+-D__PRAGMA_PACK_ON__=1
+-D__MULTIPLE_INHERITANCE__=1
+-D__AAPCS_VFP__=1
+-D__ARM4TM__=4
+-D__ARM5TM__=5
+-D__ARM5T__=5
+-D__ARM5__=5
+-D__ARM6MEDIA__=6
+-D__ARM6M__=11
+-D__ARM6SM__=12
+-D__ARM6T2__=6
+-D__ARM6__=6
+-D__ARM7EM__=13
+-D__ARM7M__=7
+-D__ARM7__=7
+-D__ARMVFPV1__=1
+-D__ARMVFPV2__=2
+-D__ARMVFPV3_D16__=1
+-D__ARMVFPV3_FP16__=1
+-D__ARMVFPV3__=3
+-D__ARMVFPV4__=4
+-D__ARMVFP_D16__=1
+-D__ARMVFP_FP16__=1
+-D__ARMVFP_SP__=1
+-D__ARMVFP__=__ARMVFPV4__
+-D__ARM_32BIT_STATE=1
+-D__ARM_ACLE=201
+-D__ARM_ALIGN_MAX_PWR=8
+-D__ARM_ALIGN_MAX_STACK_PWR=3
+-D__ARM_ARCH=7
+-D__ARM_ARCH_ISA_THUMB=2
+-D__ARM_ARCH_PROFILE='M'
+-D__ARM_FEATURE_CLZ=1
+-D__ARM_FEATURE_COPROC=15
+-D__ARM_FEATURE_DSP=1
+-D__ARM_FEATURE_FMA=1
+-D__ARM_FEATURE_IDIV=1
+-D__ARM_FEATURE_LDREX=7
+-D__ARM_FEATURE_QBIT=1
+-D__ARM_FEATURE_SAT=1
+-D__ARM_FEATURE_SIMD32=1
+-D__ARM_FEATURE_UNALIGNED=1
+-D__ARM_FP=6
+-D__ARM_FP16_ARGS=1
+-D__ARM_FP16_FORMAT_IEEE=1
+-D__ARM_MEDIA__=1
+-D__ARM_PCS_VFP=1
+-D__ARM_PROFILE_M__=1
+-D__ARM_SIZE_MINIMAL_ENUM=1
+-D__ARM_SIZE_WCHAR_T=4
+-D__CODE_SIZE_LIMIT=0
+-D__CORE__=__ARM7EM__
+-D__CPU_MODE__=1
+-D__ICCARM_INTRINSICS_VERSION__=2
+-D__ICCARM__=1
+-D__INTERWORKING__=1
+-D__PLAIN_INT_BITFIELD_IS_SIGNED__=0
+-D__HAS_WEAK__=1
+-D__HAS_PACKED__=1
+-D__HAS_JOINED_TYPES__=1
+-D__HAS_LOCATED_DECLARATION__=1
+-D__HAS_LOCATED_WITH_INIT__=1
+-D__IAR_COMPILERBASE__=656644
+-D__IAR_COMPILERBASE_STR__=10.5.4.1177
+-D__UNICODE_SOURCE_SUPPORTED__=1
+-D__VTABLE_MEM__=
+-D__PRAGMA_REDEFINE_EXTNAME=1
+-D__STDC__=1
+-D__STDC_VERSION__=201710L
+-D__MEMORY_ORDER_RELAXED__=0
+-D__MEMORY_ORDER_CONSUME__=1
+-D__MEMORY_ORDER_ACQUIRE__=2
+-D__MEMORY_ORDER_RELEASE__=3
+-D__MEMORY_ORDER_ACQ_REL__=4
+-D__MEMORY_ORDER_SEQ_CST__=5
+-D__STDC_UTF_16__=1
+-D__STDC_UTF_32__=1
+-D__STDC_LIB_EXT1__=201112L
+-D__STDC_NO_THREADS__=1
+-D__STDC_ISO_10646__=201103L
+-D__STDC_HOSTED__=1
+-D__EDG_IA64_ABI=1
+-D__EDG_IA64_ABI_VARIANT_CTORS_AND_DTORS_RETURN_THIS=1
+-D__EDG_IA64_ABI_USE_INT_STATIC_INIT_GUARD=1
+-D__cpp_hex_float=201603L
+-D__cpp_unicode_literals=200710L
+-D__cpp_static_assert=200410L
+-D__EDG__=1
+-D__EDG_VERSION__=500
+-D__EDG_SIZE_TYPE__=unsigned int
+-D__EDG_PTRDIFF_TYPE__=int
+-D__EDG_DELTA_TYPE=int
+-D__EDG_IA64_VTABLE_ENTRY_TYPE=int
+-D__EDG_VIRTUAL_FUNCTION_INDEX_TYPE=unsigned short
+-D__EDG_LOWER_VARIABLE_LENGTH_ARRAYS=1
+-D__EDG_IA64_ABI_USE_VARIANT_ARRAY_COOKIES=1
+-D__EDG_ABI_COMPATIBILITY_VERSION=9999
+-D__EDG_ABI_CHANGES_FOR_RTTI=1
+-D__EDG_ABI_CHANGES_FOR_ARRAY_NEW_AND_DELETE=1
+-D__EDG_ABI_CHANGES_FOR_PLACEMENT_DELETE=1
+-D__EDG_BSD=0
+-D__EDG_SYSV=0
+-D__EDG_ANSIC=1
+-D__EDG_CPP11_IL_EXTENSIONS_SUPPORTED=1
+-D__EDG_FLOAT80_ENABLING_POSSIBLE=0
+-D__EDG_FLOAT128_ENABLING_POSSIBLE=0
+-D__EDG_INT128_EXTENSIONS_ALLOWED=0
+-DUSE_HAL_DRIVER=1
+-DSTM32F407xx=1
+-DHAL_UART_MODULE_ENABLED=1
+-D_DLIB_CONFIG_FILE_HEADER_NAME="E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h"
+-D_DLIB_CONFIG_FILE_STRING="E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h"
+-D__VERSION__="IAR ANSI C/C++ Compiler V8.40.1.212/W32 for ARM"
+-D_VA_DEFINED=
+-D_VA_LIST=struct __va_list
+-D__ICCARM_OLD_DEFINED_VAARGS__=1
+-D__VA_STACK_ALIGN__=8
+-D__CODE_MEMORY_LIST1__()=__CODE_MEM_HELPER1__(__code, 0 )
+-D__CODE_MEMORY_LIST2__(_P1)=__CODE_MEM_HELPER2__(__code, 0 ,  _P1 )
+-D__CODE_MEMORY_LIST3__(_P1,_P2)=__CODE_MEM_HELPER3__(__code, 0 ,  _P1 ,  _P2 )
+-D__DATA_MEMORY_LIST1__()=__DATA_MEM_HELPER1__(__data, 0 )
+-D__DATA_MEMORY_LIST2__(_P1)=__DATA_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__DATA_MEMORY_LIST3__(_P1,_P2)=__DATA_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__CODE_PTR_MEMORY_LIST1__()=__CODE_PTR_MEM_HELPER1__(__code, 0 )
+-D__CODE_PTR_MEMORY_LIST2__(_P1)=__CODE_PTR_MEM_HELPER2__(__code, 0 ,  _P1 )
+-D__CODE_PTR_MEMORY_LIST3__(_P1,_P2)=__CODE_PTR_MEM_HELPER3__(__code, 0 ,  _P1 ,  _P2 )
+-D__DATA_PTR_MEMORY_LIST1__()=__DATA_PTR_MEM_HELPER1__(__data, 0 )
+-D__DATA_PTR_MEMORY_LIST2__(_P1)=__DATA_PTR_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__DATA_PTR_MEMORY_LIST3__(_P1,_P2)=__DATA_PTR_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__VAR_MEMORY_LIST1__()=__VAR_MEM_HELPER1__(__data, 0 )
+-D__VAR_MEMORY_LIST2__(_P1)=__VAR_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__VAR_MEMORY_LIST3__(_P1,_P2)=__VAR_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__VARD_MEMORY_LIST1__()=__VARD_MEM_HELPER1__(__data, 0, _ )
+-D__HEAP_MEMORY_LIST1__()=__HEAP_MEM_HELPER1__(__data, 0 )
+-D__HEAP_MEMORY_LIST2__(_P1)=__HEAP_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__HEAP_MEMORY_LIST3__(_P1,_P2)=__HEAP_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__HVAR_MEMORY_LIST1__()=__HVAR_MEM_HELPER1__(__data, 0 )
+-D__HEAPD_MEMORY_LIST1__()=__HEAPD_MEM_HELPER1__(__data, 0, _ )
+-D__HEAPU_MEMORY_LIST1__()=__HEAPU_MEM_HELPER1__(__data, 0 )
+-D__TOPM_DATA_MEMORY_LIST1__()=
+-D__TOPM_DATA_MEMORY_LIST2__(_P1)=
+-D__TOPM_DATA_MEMORY_LIST3__(_P1,_P2)=
+-D__TOPP_DATA_MEMORY_LIST1__()=__TOPP_DATA_MEM_HELPER1__(__data, 0 )
+-D__TOPP_DATA_MEMORY_LIST2__(_P1)=__TOPP_DATA_MEM_HELPER2__(__data, 0 ,  _P1 )
+-D__TOPP_DATA_MEMORY_LIST3__(_P1,_P2)=__TOPP_DATA_MEM_HELPER3__(__data, 0 ,  _P1 ,  _P2 )
+-D__DATA_MEM0_SIZE_TYPE__=unsigned int
+-D__DATA_MEM0_INDEX_TYPE__=signed int
+-D__iar_fp2bits32(x)=0
+-D__iar_fp2bits64(x)=0
+-D__iar_fpgethi64(x)=0
+-D__iar_atomic_add_fetch(x,y,z)=0
+-D__iar_atomic_sub_fetch(x,y,z)=0
+-D__iar_atomic_load(x,y)=0ULL
+-D__iar_atomic_compare_exchange_weak(a,b,c,d,e)=0

PLSR/PLSR/EWARM/test.1/Obj/os_cpu_c.pbi.dep

@@ -1,12 +1,13 @@
 os_cpu_c.pbi: \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\os_trace.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports\os_cpu.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\os_cfg.h \
-  E:\Software\IAR\arm\inc\c\ycheck.h E:\Software\IAR\arm\inc\c\ysizet.h \
-  E:\Software\IAR\arm\inc\c\DLib_Product.h \
-  E:\Software\IAR\arm\inc\c\DLib_Defaults.h \
-  E:\Software\IAR\arm\inc\c\yvals.h E:\Software\IAR\arm\inc\c\stdio.h \
-  E:\Software\IAR\arm\inc\c\stdarg.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\app_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports\os_cpu_c.c \
   e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source\ucos_ii.h \
-  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports\os_cpu_c.c
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\app_cfg.h \
+  E:\Software\IAR\arm\inc\c\stdarg.h E:\Software\IAR\arm\inc\c\stdio.h \
+  E:\Software\IAR\arm\inc\c\ycheck.h E:\Software\IAR\arm\inc\c\yvals.h \
+  E:\Software\IAR\arm\inc\c\DLib_Defaults.h \
+  E:\\Software\\IAR\\arm\\inc\\c\\DLib_Config_Full.h \
+  E:\Software\IAR\arm\inc\c\DLib_Product.h \
+  E:\Software\IAR\arm\inc\c\ysizet.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Config\os_cfg.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\UCOS\Ports\os_cpu.h \
+  e:\Users\Mortal\Desktop\Train_Camp_PLSR\PLSR\PLSR\EWARM\..\UCOS\Source/os_trace.h