hanyongwei
/
TrainCamp_hanyongwei_StageTwo
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Przeglądaj źródła

改用bkp存储，存储公共参数、段参数、记录信息 

Signed-off-by: hanyongwei <2043702190@qq.com>
dev1
hanyongwei 3 tygodni temu
rodzic
4b93dd0f63
commit
fabb0f833f
22 zmienionych plików z 2667 dodań i 2485 usunięć
Widok podzielony
Opcje porównania
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania
  1. +0
    -2
      .gitignore
  2. +5
    -4
      app/main.c
  3. +3
    -3
      drivers/Source/stm32f4xx_it.c
  4. +1591
    -984
      iar/plsr.dep
  5. +24
    -34
      iar/plsr.ewp
  6. +0
    -9
      iar/plsr.ewt
  7. +10
    -403
      plsr/accel_curve/plsr_accel_curve.c
  8. +41
    -148
      plsr/accel_curve/plsr_accel_curve.h
  9. +15
    -2
      plsr/command/plsr_command.c
  10. +1
    -1
      plsr/command/plsr_command.h
  11. +7
    -7
      plsr/param/plsr_param.c
  12. +9
    -6
      plsr/param/plsr_param.h
  13. +0
    -91
      plsr/path_plan/plsr_path_plan.c
  14. +0
    -49
      plsr/path_plan/plsr_path_plan.h
  15. +24
    -48
      plsr/plsr.c
  16. +6
    -6
      plsr/plsr.h
  17. +133
    -62
      plsr/pulse_driver/plsr_pulse_driver.c
  18. +9
    -13
      plsr/pulse_driver/plsr_pulse_driver.h
  19. +610
    -375
      plsr/run_control/plsr_run_control.c
  20. +24
    -78
      plsr/run_control/plsr_run_control.h
  21. +135
    -97
      plsr/signal_io/plsr_signal_io.c
  22. +20
    -63
      plsr/signal_io/plsr_signal_io.h

+ 0
- 2
.gitignore Wyświetl plik

@@ -21,5 +21,3 @@ build-plsr_host-Desktop_Qt_5_6_3_MinGW_32bit-Debug/
plsr/test/
tools/
.cursor/
*.pdf
3. 定位控制手册.pdf

+ 5
- 4
app/main.c Wyświetl plik

@@ -118,8 +118,9 @@ int main(void)
}

/**
* @brief 系统时钟：HSE → PLL → 168MHz SYSCLK（APM32F407 / STM32F4 类）
* @note 须与 OS_CPU_SysTickInit 使用的主频常量一致
* @brief 系统时钟：HSE(12MHz) → PLL → 168MHz SYSCLK（APM32F407 / STM32F4 类）
* @note 须与 OS_CPU_SysTickInit、pulse_driver 使用的主频常量一致
* @note PLLM 须等于晶振 MHz：12MHz 用 12；误用 8 会使 SYSCLK=252MHz，脉冲频率偏 1.5 倍
*/
void SystemClock_Config(void)
{
@@ -133,10 +134,10 @@ void SystemClock_Config(void)
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 12;
RCC_OscInitStruct.PLL.PLLM = 12; /* HSE=12MHz → VCO in = 1MHz */
RCC_OscInitStruct.PLL.PLLN = 336;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
RCC_OscInitStruct.PLL.PLLQ = 4;/*不准改成7*/
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();


+ 3
- 3
drivers/Source/stm32f4xx_it.c Wyświetl plik

@@ -225,12 +225,12 @@ void TIM2_IRQHandler(void)
}

/**
* @brief TIM3：PLSR WAIT/ACT 1ms 时基
* @brief TIM5：PLSR 单次延时到期（换向 / WAIT / ACT）
*/
void TIM3_IRQHandler(void)
void TIM5_IRQHandler(void)
{
OSIntEnter();
PlsrSignalIoOnTim3Irq();
PlsrSignalIoOnTim5Irq();
OSIntExit();
}



+ 1591
- 984
iar/plsr.dep
Plik diff jest za duży
Wyświetl plik


+ 24
- 34
iar/plsr.ewp Wyświetl plik

@@ -359,7 +359,6 @@
<state>$PROJ_DIR$\..\plsr\param</state>
<state>$PROJ_DIR$\..\plsr\persist</state>
<state>$PROJ_DIR$\..\plsr\pulse_driver</state>
<state>$PROJ_DIR$\..\plsr\path_plan</state>
<state>$PROJ_DIR$\..\plsr\accel_curve</state>
<state>$PROJ_DIR$\..\plsr\run_control</state>
<state>$PROJ_DIR$\..\plsr\command</state>
@@ -2850,24 +2849,12 @@
</group>
<group>
<name>plsr</name>
<group>
<name>accel_curve</name>
<file>
<name>$PROJ_DIR$\..\plsr\accel_curve\plsr_accel_curve.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\accel_curve\plsr_accel_curve.h</name>
</file>
</group>
<group>
<name>command</name>
<file>
<name>$PROJ_DIR$\..\plsr\command\plsr_command.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\command\plsr_command.h</name>
</file>
</group>
<file>
<name>$PROJ_DIR$\..\plsr\plsr.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\plsr.h</name>
</file>
<group>
<name>param</name>
<file>
@@ -2877,15 +2864,6 @@
<name>$PROJ_DIR$\..\plsr\param\plsr_param.h</name>
</file>
</group>
<group>
<name>path_plan</name>
<file>
<name>$PROJ_DIR$\..\plsr\path_plan\plsr_path_plan.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\path_plan\plsr_path_plan.h</name>
</file>
</group>
<group>
<name>persist</name>
<file>
@@ -2904,6 +2882,15 @@
<name>$PROJ_DIR$\..\plsr\pulse_driver\plsr_pulse_driver.h</name>
</file>
</group>
<group>
<name>accel_curve</name>
<file>
<name>$PROJ_DIR$\..\plsr\accel_curve\plsr_accel_curve.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\accel_curve\plsr_accel_curve.h</name>
</file>
</group>
<group>
<name>run_control</name>
<file>
@@ -2913,6 +2900,15 @@
<name>$PROJ_DIR$\..\plsr\run_control\plsr_run_control.h</name>
</file>
</group>
<group>
<name>command</name>
<file>
<name>$PROJ_DIR$\..\plsr\command\plsr_command.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\command\plsr_command.h</name>
</file>
</group>
<group>
<name>signal_io</name>
<file>
@@ -2922,12 +2918,6 @@
<name>$PROJ_DIR$\..\plsr\signal_io\plsr_signal_io.h</name>
</file>
</group>
<file>
<name>$PROJ_DIR$\..\plsr\plsr.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\plsr.h</name>
</file>
</group>
<group>
<name>ucos</name>


+ 0
- 9
iar/plsr.ewt Wyświetl plik

@@ -3109,15 +3109,6 @@
<name>$PROJ_DIR$\..\plsr\param\plsr_param.h</name>
</file>
</group>
<group>
<name>path_plan</name>
<file>
<name>$PROJ_DIR$\..\plsr\path_plan\plsr_path_plan.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\plsr\path_plan\plsr_path_plan.h</name>
</file>
</group>
<group>
<name>persist</name>
<file>


+ 10
- 403
plsr/accel_curve/plsr_accel_curve.c Wyświetl plik

@@ -10,12 +10,18 @@
* 关键约束
* 频率钳制上限 100000Hz；运行门禁非法频率由 command/run_control 报 0x04。
* 脉冲预算不够到目标频时：降低峰值（三角，无匀速），调用方写故障 0x02。
*
* 符号约定（与 plsr_accel_curve.h 一致）
* f_cur/f_tgt/f_end — 段起/峰/止频率 Hz
* acc_n/dec_n/const_n — 加/减/匀速相脉冲预算（非时间 ms）
* a_acc/a_dec — 加/减速度 Hz/s
* pulse_rt — PlsrAccelPulseRt_t，ISR 逐拍改频状态机
*/
#include "plsr_accel_curve.h"
#include <stdint.h>

/* 频率大于 100k 时暂时钳到 100k；启动门禁另报 0x04 */
uint32_t PlsrAccelCurveClampFreq(uint32_t freq_hz)
static uint32_t PlsrAccelCurveClampFreq(uint32_t freq_hz)
{
if (freq_hz > 100000U)
{
@@ -62,17 +68,12 @@ static uint32_t PlsrAccelCurveIsqrt64(uint64_t val)
return (uint32_t)x;
}

static uint32_t PlsrAccelCurveIsqrt(uint32_t val)
{
return PlsrAccelCurveIsqrt64((uint64_t)val);
}

/**
* 起跳频率：f = sqrt(f_from^2 + 2a)，a = df*1000/t_ms。
* f_from=0 → sqrt(2a)；超过 f_to 钳到 f_to。
*/
uint32_t PlsrAccelCurveJumpFreq(uint32_t f_from, uint32_t f_to,
uint32_t t_ms)
static uint32_t PlsrAccelCurveJumpFreq(uint32_t f_from, uint32_t f_to,
uint32_t t_ms)
{
uint32_t df;
uint32_t a_hz_s;
@@ -132,8 +133,6 @@ static uint32_t PlsrAccelCurveSlopeDen(uint32_t default_spd)
static uint32_t PlsrAccelCurveRampTimeMs(uint32_t f_from,
uint32_t f_to,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms)
{
@@ -142,9 +141,6 @@ static uint32_t PlsrAccelCurveRampTimeMs(uint32_t f_from,
uint32_t ref_ms;
uint32_t t;

(void)start_spd_ref;
(void)end_spd_ref;

if (f_from == f_to)
{
return 0U;
@@ -188,8 +184,6 @@ static uint32_t PlsrAccelCurveRampTimeMs(uint32_t f_from,
uint32_t PlsrAccelCurveResolveStartHz(uint32_t f_cfg,
uint32_t f_tgt,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms)
{
@@ -204,7 +198,6 @@ uint32_t PlsrAccelCurveResolveStartHz(uint32_t f_cfg,

/* 起速 0 或非 0：都用 JumpFreq = sqrt(f_cfg^2 + 2a) */
t_acc = PlsrAccelCurveRampTimeMs(f_cfg, f_tgt, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
return PlsrAccelCurveJumpFreq(f_cfg, f_tgt, t_acc);
}
@@ -212,8 +205,6 @@ uint32_t PlsrAccelCurveResolveStartHz(uint32_t f_cfg,
uint32_t PlsrAccelCurveResolveEndHz(uint32_t f_cfg,
uint32_t f_tgt,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms)
{
@@ -232,13 +223,11 @@ uint32_t PlsrAccelCurveResolveEndHz(uint32_t f_cfg,
if (f_cfg <= 1U)
{
t_dec = PlsrAccelCurveRampTimeMs(f_tgt, 0U, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
return PlsrAccelCurveJumpFreq(0U, f_tgt, t_dec);
}

t_dec = PlsrAccelCurveRampTimeMs(f_tgt, f_cfg, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
return PlsrAccelCurveJumpFreq(f_cfg, f_tgt, t_dec);
}
@@ -358,337 +347,6 @@ static uint32_t PlsrAccelCurveLerp(uint32_t a, uint32_t b, uint32_t ratio_permil
return a - ((a - b) * ratio_permille) / 1000UL;
}

/**
* 斜坡取频（µs 时间轴）。ISR 可用：O(1)。
*
* 直线模式：f = f0 + (f1−f0) · t/T（64 位运算保证精度，每个点在 f-t 直线上）。
* S / 正弦：f = f0 + (f1−f0) · shape(t/T)。
*/
uint32_t PlsrAccelCurveFreqOnRampUs(uint32_t f0,
uint32_t f1,
uint32_t t_us,
uint32_t T_us,
PlsrAccelMode_e mode)
{
uint32_t r;

if ((T_us == 0U) || (t_us >= T_us))
{
return f1;
}

if (mode == PLSR_ACCEL_LINEAR)
{
/*
* 纯代数直线：f = f0 + (f1-f0)*t/T，用 64 位避免溢出/截断。
* 不走 permille/Lerp，保证点在直线上。
*/
if (f1 >= f0)
{
return f0 + (uint32_t)(((uint64_t)(f1 - f0) * (uint64_t)t_us) / (uint64_t)T_us);
}
else
{
uint32_t drop = (uint32_t)(((uint64_t)(f0 - f1) * (uint64_t)t_us) / (uint64_t)T_us);
return (drop < f0) ? (f0 - drop) : 0U;
}
}

/* S / 正弦：shape(t/T) → Lerp */
r = (uint32_t)(((uint64_t)t_us * 1000ULL) / (uint64_t)T_us);
if (r > 1000U)
{
r = 1000U;
}
r = PlsrAccelCurveShapePermille(r, mode);
return PlsrAccelCurveLerp(f0, f1, r);
}

/**
* 斜坡取频（ms 接口；内部转 µs）。运行时相时间来自 TIM3 1ms 累加。
*/
/**
* 斜坡取频（ms 接口，内部转 µs 调 FreqOnRampUs）。
* 统一入口：直线/S/正弦均走 FreqOnRampUs，不再有额外特例分支。
*/
uint32_t PlsrAccelCurveFreqOnRampMs(uint32_t f0,
uint32_t f1,
uint32_t t_ms,
uint32_t T_ms,
PlsrAccelMode_e mode)
{
if (T_ms < 1U)
{
return f1;
}
return PlsrAccelCurveFreqOnRampUs(f0, f1, t_ms * 1000UL, T_ms * 1000UL, mode);
}

/**
* 减速落地频率：
* - f_end>=1：落地即止速
* - f_end==0：返回 0（停表）。不再用「对称首档」冒充止速——
* 那一档常算成 1Hz，示波器上会变成脉冲发完后还在 1Hz 空转。
*/
uint32_t PlsrAccelCurveLandFreq(uint32_t f_end,
uint32_t f_peak,
uint32_t T_ms,
PlsrAccelMode_e mode)
{
(void)f_peak;
(void)T_ms;
(void)mode;
if (f_end >= 1U)
{
return f_end;
}
return 0U;
}

/**
* 斜坡第一拍频率（规划/开跑共用）。
* f0>=1：第一拍即 f0。
* f0==0：t=0 曲线为 0；若强行按 1Hz 计整周期(~1s)，加速时间常被第一拍吃光，
* 表现为到不了目标频、曲线台阶/长拖尾。此处用 look-ahead 自洽点，且 ≥1Hz。
*/
/**
* 起速=0 时第一拍自洽频率。
*
* 自洽条件：f 使得 FreqOnRampUs(f0, f1, 10^6/f, T_us) = f
*
* 直线模式（f0=0）：解析解 f = sqrt(f1 * 10^6 / T_us)。
* S/正弦：迭代（取两次平均收敛）。
*/
uint32_t PlsrAccelCurveFirstPulseFreq(uint32_t f0,
uint32_t f1,
uint32_t T_us,
PlsrAccelMode_e mode)
{
uint32_t f;
uint32_t guess;
uint32_t per;
uint32_t fnew;
uint32_t i;

if (T_us == 0U)
{
f = (f1 >= 1U) ? f1 : 1U;
return f;
}

f = PlsrAccelCurveFreqOnRampUs(f0, f1, 0U, T_us, mode);
if (f >= 1U)
{
return f;
}

/* 直线 f0=0：f = sqrt(f1 * 1e6 / T_us)，用整数牛顿法求 sqrt(val) */
if ((mode == PLSR_ACCEL_LINEAR) && (f0 == 0U) && (f1 >= 1U))
{
uint64_t val = (uint64_t)f1 * 1000000ULL / (uint64_t)T_us;
uint32_t x;
if (val == 0ULL)
{
return 1U;
}
x = (uint32_t)val;
if (x > 10000U)
{
x = 10000U;
}
for (i = 0U; i < 20U; i++)
{
uint32_t x2 = (uint32_t)((x + (uint32_t)(val / (uint64_t)x)) / 2UL);
if (x2 == x || x2 == 0U)
{
break;
}
x = x2;
}
f = (x < 1U) ? 1U : x;
if (f > f1)
{
f = f1;
}
return f;
}

/* S/正弦：迭代求自洽点，用前后平均避免震荡 */
guess = (f1 >= 4U) ? (f1 / 4U) : 1U;
for (i = 0U; i < 16U; i++)
{
per = (1000000UL + (guess / 2UL)) / guess;
fnew = PlsrAccelCurveFreqOnRampUs(f0, f1, per, T_us, mode);
if (fnew < 1U)
{
fnew = 1U;
}
if (fnew == guess)
{
break;
}
/* 取平均避免震荡 */
guess = (guess + fnew) / 2U;
if (guess < 1U)
{
guess = 1U;
}
}
if (guess > f1)
{
guess = f1;
}
return guess;
}

/**
* 斜坡脉冲数：与运行时 TIM3 1ms 取频一致（t=0..T-1 每毫秒贡献 f 个脉冲）。
* 向上取整：减速段多留脉冲，才能在发完前走到 f_end。
* 梯形面积 (f0+f1)*T/2000 会少算末段减速（约 (f_peak-f_end)/2000 个），
* 匀速被拉长，最后一段脉冲在斜坡中途用完，到不了止速。
*/
static uint32_t PlsrAccelCurveEstimatePulses(uint32_t f_from,
uint32_t f_to,
uint32_t t_ms,
PlsrAccelMode_e mode)
{
uint32_t t;
uint32_t f;
uint32_t n;
uint32_t t_use;
uint64_t acc;

if ((t_ms == 0U) || (f_from == f_to))
{
return 0U;
}

t_use = t_ms;
if (t_use > 120000U)
{
t_use = 120000U;
}

acc = 0ULL;
for (t = 0U; t < t_use; t++)
{
f = PlsrAccelCurveFreqOnRampMs(f_from, f_to, t, t_ms, mode);
if (f < 1U)
{
if (f_to >= 1U)
{
f = 1U;
}
else
{
f = 0U;
}
}
acc += (uint64_t)f;
}

n = (uint32_t)((acc + 999ULL) / 1000ULL);
if ((n == 0U) && (acc > 0ULL))
{
n = 1U;
}
return n;
}

/** 匀速时间向下取整：宁可早进减速，保证斜坡走完再落到 f_end */
static uint32_t PlsrAccelCurveConstTimeMs(uint32_t const_n, uint32_t f_hz)
{
if ((const_n == 0U) || (f_hz < 1U))
{
return 0U;
}
return (const_n * 1000UL) / f_hz;
}

/**
* 拟合斜坡时间 T（任务上下文）；使离散模型脉冲数尽量等于 max_pulses。
*/
uint32_t PlsrAccelCurveFitRampTimeMs(uint32_t f_from,
uint32_t f_to,
uint32_t max_pulses,
uint32_t t_prefer_ms,
PlsrAccelMode_e mode)
{
uint32_t lo;
uint32_t hi;
uint32_t mid;
uint32_t best;
uint32_t best_err;
uint32_t n;
uint32_t err;
uint32_t guard;

if ((max_pulses == 0U) || (f_from == f_to))
{
return 0U;
}

if (max_pulses <= 1U)
{
return (t_prefer_ms > 0U) ? t_prefer_ms : 1U;
}

hi = (t_prefer_ms > 0U) ? t_prefer_ms : 1U;
guard = 0U;
n = PlsrAccelCurveEstimatePulses(f_from, f_to, hi, mode);
while ((n < max_pulses) && (hi < 120000U) && (guard < 24U))
{
if (hi > (120000U / 2U))
{
hi = 120000U;
}
else
{
hi = hi * 2U;
}
n = PlsrAccelCurveEstimatePulses(f_from, f_to, hi, mode);
guard++;
}

lo = 1U;
best = (t_prefer_ms > 0U) ? t_prefer_ms : hi;
n = PlsrAccelCurveEstimatePulses(f_from, f_to, best, mode);
best_err = (n > max_pulses) ? (n - max_pulses) : (max_pulses - n);

while (lo <= hi)
{
mid = lo + ((hi - lo) / 2UL);
n = PlsrAccelCurveEstimatePulses(f_from, f_to, mid, mode);
err = (n > max_pulses) ? (n - max_pulses) : (max_pulses - n);
if ((err < best_err) ||
((err == best_err) && (t_prefer_ms > 0U) &&
(((mid > t_prefer_ms) ? (mid - t_prefer_ms) : (t_prefer_ms - mid)) <
((best > t_prefer_ms) ? (best - t_prefer_ms) : (t_prefer_ms - mid)))))
{
best = mid;
best_err = err;
}
if (n == max_pulses)
{
return mid;
}
if (n < max_pulses)
{
lo = mid + 1UL;
}
else
{
if (mid == 0U)
{
break;
}
hi = mid - 1UL;
}
}

return best;
}

/**
* a = default_spd * 1000 / ramp_ms（Hz/s）。ramp_ms=0 → a=0（阶跃）。
*/
@@ -875,7 +533,7 @@ static uint32_t PlsrAccelCurveFitPeak(uint32_t total_pulses,
* 1. 钳频、解析 f_cur/f_end 若仍 <1；
* 2. 由 default_spd 与 accel/decel_ms 算 a_acc/a_dec（无默认速则频差回退）；
* 3. PulsesForRamp 估 acc_n/dec_n；若和 > total → FitPeak 降峰重估；
* 4. 写出 plan 三相预算与 t_* 预览字段。
* 4. 写出 plan 三相预算。
*/
void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
uint32_t total_pulses,
@@ -883,14 +541,10 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
uint32_t f_tgt,
uint32_t f_end,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms,
PlsrAccelMode_e mode)
{
uint32_t t_acc;
uint32_t t_dec;
uint32_t acc_n;
uint32_t dec_n;
uint32_t f_peak;
@@ -912,13 +566,11 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
if (f_cur < 1U)
{
f_cur = PlsrAccelCurveResolveStartHz(0U, f_tgt, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
}
if (f_end < 1U)
{
f_end = PlsrAccelCurveResolveEndHz(0U, f_tgt, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
}

@@ -943,12 +595,6 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
}

f_peak = f_tgt;
t_acc = PlsrAccelCurveRampTimeMs(f_cur, f_peak, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
t_dec = PlsrAccelCurveRampTimeMs(f_peak, f_end, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);

plan->f_cur = f_cur;
plan->f_end = f_end;
@@ -962,9 +608,6 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
if (total_pulses == 0U)
{
plan->const_n = 0U;
plan->t_acc_ms = 0U;
plan->t_dec_ms = 0U;
plan->t_decel_start_ms = 0U;
plan->f_tgt = f_peak;
plan->acc_n = 0U;
plan->dec_n = 0U;
@@ -975,9 +618,6 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
{
plan->const_n = 0U;
plan->f_tgt = f_peak;
plan->t_acc_ms = t_acc;
plan->t_dec_ms = 0U;
plan->t_decel_start_ms = t_acc;
plan->acc_n = total_pulses;
plan->dec_n = 0U;
return;
@@ -987,12 +627,6 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
{
f_peak = PlsrAccelCurveFitPeak(total_pulses, f_cur, f_tgt, f_end,
a_acc, a_dec);
t_acc = PlsrAccelCurveRampTimeMs(f_cur, f_peak, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
t_dec = PlsrAccelCurveRampTimeMs(f_peak, f_end, default_spd,
start_spd_ref, end_spd_ref,
accel_ms, decel_ms);
acc_n = PlsrAccelCurvePulsesForRamp(f_cur, f_peak, a_acc);
dec_n = PlsrAccelCurvePulsesForRamp(f_peak, f_end, a_dec);
if (acc_n > total_pulses)
@@ -1005,14 +639,6 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
dec_n = total_pulses - acc_n;
}
plan->const_n = 0U;
if ((t_acc == 0U) && (acc_n > 0U) && (f_cur != f_peak))
{
t_acc = 1U;
}
if ((t_dec == 0U) && (dec_n > 0U) && (f_peak != f_end))
{
t_dec = 1U;
}
}
else
{
@@ -1044,11 +670,8 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
}

plan->f_tgt = f_peak;
plan->t_acc_ms = t_acc;
plan->t_dec_ms = t_dec;
plan->acc_n = acc_n;
plan->dec_n = dec_n;
plan->t_decel_start_ms = t_acc + PlsrAccelCurveConstTimeMs(plan->const_n, f_peak);
}

/**
@@ -1129,22 +752,6 @@ uint32_t PlsrAccelCurveFreqAtPulse(const PlsrAccelPlan_t *plan,
return PlsrAccelCurveClampFreq(f);
}

/** 兼容旧预览：用时间估算映射到脉冲再取频 */
uint32_t PlsrAccelCurveFreqAtSegTime(const PlsrAccelPlan_t *plan,
uint32_t seg_elapsed_ms)
{
uint32_t approx_n;
uint32_t f_ref;

if (plan == (PlsrAccelPlan_t *)0)
{
return 0U;
}
f_ref = (plan->f_tgt >= 1U) ? plan->f_tgt : 1U;
approx_n = (uint32_t)(((uint64_t)seg_elapsed_ms * (uint64_t)f_ref) / 1000ULL);
return PlsrAccelCurveFreqAtPulse(plan, approx_n);
}

/*============================================================================*/
/* 逐拍运行态（ISR） */
/*============================================================================*/


+ 41
- 148
plsr/accel_curve/plsr_accel_curve.h Wyświetl plik

@@ -2,20 +2,13 @@
* @file plsr_accel_curve.h
* @brief 脉冲域加/匀/减规划与取频（运动学：v^2 - v0^2 = 2ax）
*
* @details 模块职责
* 纯算法层：根据起/峰/止频率、斜率时间与总脉冲，规划 acc_n/const_n/dec_n，
* 并在脉冲序号上取频。不读 wait_type，不碰 TIM/GPIO。
* @details 按起/峰/止频率、斜率时间与总脉冲规划三相脉冲预算，并在脉冲序号上取频。
* 不读 wait_type，不碰 TIM/GPIO。
*
* 核心约定
* - 加速度 a ≈ default_speed * 1000 / accel_ms（Hz/s）；起/止速只定端点
* - 直线：f(n) = sqrt(f0^2 ± 2*a*n)；S/正弦：按脉冲进度 shape 插值
* - 匀速仅当 acc_n+dec_n < total（真正到达目标峰）时出现
* - 脉冲不够到设定峰：FitPeak 降峰（三角），调用方可写故障 0x02
* - 开段端点由运行层 ResolveStart/EndHz 解析为真实 Hz（>=1）后再 Plan
*
* 与其它模块关系
* - plsr_run_control ：PlanSeg → Plan；ISR → PulseRtStep；Refresh → FreqAtPulse
* - plsr_param ：accel_mode / default_speed / accel_ms / decel_ms
* 术语（全模块统一）：
* acc_n / dec_n / const_n — 加速/减速/匀速相各需的脉冲个数（规划预算，非 ms）
* f_cur / f_tgt / f_end — 段入口频率、规划峰值、段出口频率（Hz）
* a_acc / a_dec — 加/减速度（Hz/s），≈ default_speed*1000/accel_ms
*/
#ifndef PLSR_ACCEL_CURVE_H
#define PLSR_ACCEL_CURVE_H
@@ -24,118 +17,38 @@
#include "plsr_param.h"

/**
* 一段脉冲域规划结果（Plan 填出，运行层只读/EnterDecel 可改写 dec_n）
* acc_n/const_n/dec_n — 三相脉冲预算
* f_cur / f_tgt / f_end — 实际起速、峰值、止速（可能已 FitPeak）
* a_acc / a_dec — Hz/s
* t_*_ms — 斜率时间估算（预览/兼容；运行热路径不依赖）
* 单段脉冲域规划结果（PlsrAccelCurvePlan 输出）
* EnterDecel 可能改写 dec_n，诊断用 run_control 另存 s_plan_dec_n。
*/
typedef struct {
uint32_t acc_n;
uint32_t const_n;
uint32_t dec_n;
uint32_t f_cur;
uint32_t f_tgt;
uint32_t f_end;
uint32_t a_acc;
uint32_t a_dec;
uint32_t t_acc_ms;
uint32_t t_dec_ms;
uint32_t t_decel_start_ms;
PlsrAccelMode_e mode;
uint32_t acc_n; /* 加速相脉冲数：从 f_cur 爬到 f_tgt */
uint32_t const_n; /* 匀速相脉冲数：保持 f_tgt */
uint32_t dec_n; /* 减速相脉冲数：从 f_tgt 到 f_end */
uint32_t f_cur; /* 段入口频率 Hz（规划后实际起点，>=1） */
uint32_t f_tgt; /* 规划峰值 Hz（FitPeak 后可能低于段表目标） */
uint32_t f_end; /* 段出口频率 Hz */
uint32_t a_acc; /* 加速相加速度 Hz/s */
uint32_t a_dec; /* 减速相加速度 Hz/s */
PlsrAccelMode_e mode; /* 直线 / S / 正弦 */
} PlsrAccelPlan_t;

/** 曲线相枚举（预留/文档；运行层用自有 RunPhase_e） */
typedef enum {
PLSR_CURVE_PHASE_ACC = 0,
PLSR_CURVE_PHASE_CONST,
PLSR_CURVE_PHASE_DEC
} PlsrCurvePhase_e;

/**
* @brief 频率钳到上限 100000Hz（不抬下限）
* @note 非法低频门禁由 command/run_control 写 0x04，本函数不做
*/
uint32_t PlsrAccelCurveClampFreq(uint32_t freq_hz);

/**
* @brief 起跳/步进频率：f = sqrt(f_from^2 + 2a)，a = |f_to-f_from|*1000/t_ms
* @note f_from=0 退化为 sqrt(2a)；超过 f_to 钳到 f_to；t_ms=0 直接返回 f_to
*/
uint32_t PlsrAccelCurveJumpFreq(uint32_t f_from, uint32_t f_to,
uint32_t t_ms);

/**
* @brief 配置起速 → 规划用真实起点：JumpFreq(f_cfg, f_tgt, t_acc)
* @note 起速 0 与非 0 统一走 Jump，避免配置 0 时从 0Hz 开跑
*/
/** 配置起速 → 规划用真实起点（Jump；起速 0 也不从 0Hz 开跑） */
uint32_t PlsrAccelCurveResolveStartHz(uint32_t f_cfg,
uint32_t f_tgt,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms);

/**
* @brief 配置止速 → 规划用真实终点
* @note f_cfg<=1：按落地频率估计（避免 1Hz 拖尾）；否则 JumpFreq
*/
/** 配置止速 → 规划用真实终点（f_cfg<=1 按落地估计） */
uint32_t PlsrAccelCurveResolveEndHz(uint32_t f_cfg,
uint32_t f_tgt,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms);

/**
* @brief 斜坡取频（µs 时间轴，O(1)）
* @note 直线：代数插值；S/正弦：shape(t/T) 再 Lerp。主要用于估计/兼容，非 ISR 主路径
*/
uint32_t PlsrAccelCurveFreqOnRampUs(uint32_t f0,
uint32_t f1,
uint32_t t_us,
uint32_t T_us,
PlsrAccelMode_e mode);

/** @brief ms 接口，内部转 µs 调 FreqOnRampUs */
uint32_t PlsrAccelCurveFreqOnRampMs(uint32_t f0,
uint32_t f1,
uint32_t t_ms,
uint32_t T_ms,
PlsrAccelMode_e mode);

/**
* @brief 斜坡第一拍自洽频率（起速=0 时避免整周期 1Hz 吃光加速时间）
*/
uint32_t PlsrAccelCurveFirstPulseFreq(uint32_t f0,
uint32_t f1,
uint32_t T_us,
PlsrAccelMode_e mode);

/**
* @brief 减速落地频率：f_end>=1 返回止速；f_end==0 返回 0（停表）
*/
uint32_t PlsrAccelCurveLandFreq(uint32_t f_end,
uint32_t f_peak,
uint32_t T_ms,
PlsrAccelMode_e mode);

/**
* @brief 拟合斜坡时间 T，使离散脉冲估计尽量等于 max_pulses（任务上下文）
*/
uint32_t PlsrAccelCurveFitRampTimeMs(uint32_t f_from,
uint32_t f_to,
uint32_t max_pulses,
uint32_t t_prefer_ms,
PlsrAccelMode_e mode);

/**
* @brief 规划一整段脉冲域三相预算与实际峰值
* @param total_pulses 本段总脉冲
* @param f_cur/f_tgt/f_end 起/目标峰/止（真实 Hz，由策略层解析）
* @note 不够爬升则 FitPeak；结果写入 *plan
* 规划一整段脉冲域三相预算与实际峰值
* 脉冲不够爬到 f_tgt 时 FitPeak 降峰（调用方可能写故障 0x02）
*/
void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
uint32_t total_pulses,
@@ -143,62 +56,42 @@ void PlsrAccelCurvePlan(PlsrAccelPlan_t *plan,
uint32_t f_tgt,
uint32_t f_end,
uint32_t default_spd,
uint32_t start_spd_ref,
uint32_t end_spd_ref,
uint32_t accel_ms,
uint32_t decel_ms,
PlsrAccelMode_e mode);

/**
* @brief 按已完成脉冲数取频（任务/预览）
* @note 运行热路径请用 PlsrAccelPulseRt（逐拍 ±1 / Q24，可进 ISR）
*/
/** 按已完成脉冲数取频（任务/预览；ISR 热路径用 PulseRtStep） */
uint32_t PlsrAccelCurveFreqAtPulse(const PlsrAccelPlan_t *plan,
uint32_t pulse_done);

/**
* @deprecated 时间轴取频；保留给旧预览，运行请用脉冲域
*/
uint32_t PlsrAccelCurveFreqAtSegTime(const PlsrAccelPlan_t *plan,
uint32_t seg_elapsed_ms);

/**
* 逐拍运行态（ISR 热路径）
* - 直线：上一拍频率 ±1 逼近 sqrt(f0^2±2an)，不全量 Isqrt64
* - S/正弦：Begin 时算 Q24 步长，逐拍商余累加，不做 index/total 除法
* 单相逐脉冲运行态（ISR 热路径，每来一个 UPDATE 调 Step 一次）
* 直线：±1Hz 逼近 sqrt(f0²±2an)；S/正弦：Q24 相位累加 + shape 表
*/
typedef struct {
uint32_t f; /* 当前命令频率 */
uint32_t f0; /* 本相起点频率 */
uint32_t f1; /* 本相终点频率 */
uint32_t a; /* Hz/s；直线用 */
uint32_t n; /* 本相已完成脉冲 */
uint32_t n_total; /* 本相总脉冲（距离只在 Begin 算） */
uint32_t phase_q24; /* S/正弦进度 0..(1<<24) */
uint32_t step_q24;
uint32_t step_rem; /* (1<<24) % n_total */
uint32_t rem_acc;
uint8_t rising;
uint8_t active; /* 0=匀速保持，不 Step */
uint32_t f; /* 当前输出频率 Hz */
uint32_t f0; /* 本相起点频率 Hz */
uint32_t f1; /* 本相终点频率 Hz */
uint32_t a; /* 本相加速度 Hz/s（直线用） */
uint32_t n; /* 本相已步进脉冲数 */
uint32_t n_total; /* 本相总步进预算（= plan 里 acc_n 或 dec_n） */
uint32_t phase_q24; /* S/正弦：形状进度 Q24 累加器 */
uint32_t step_q24; /* 每脉冲相位增量 = (1<<24)/n_total */
uint32_t step_rem; /* 相位累加余数（商余法，避免每拍除法） */
uint32_t rem_acc; /* 余数累加 */
uint8_t rising; /* 1=频率升高，0=降低 */
uint8_t active; /* 1=本相仍在步进；0=已到 f1 */
PlsrAccelMode_e mode;
} PlsrAccelPulseRt_t;

/** @brief 进入加速相运行态（n=0，active 视 acc_n） */
void PlsrAccelPulseRtBeginAcc(PlsrAccelPulseRt_t *rt,
void PlsrAccelPulseRtBeginAcc(PlsrAccelPulseRt_t *pulse_rt,
const PlsrAccelPlan_t *plan);

/** @brief 进入减速相运行态 */
void PlsrAccelPulseRtBeginDec(PlsrAccelPulseRt_t *rt,
void PlsrAccelPulseRtBeginDec(PlsrAccelPulseRt_t *pulse_rt,
const PlsrAccelPlan_t *plan);

/** @brief 进入匀速：active=0，复用 f_tgt */
void PlsrAccelPulseRtBeginConst(PlsrAccelPulseRt_t *rt,
void PlsrAccelPulseRtBeginConst(PlsrAccelPulseRt_t *pulse_rt,
const PlsrAccelPlan_t *plan);

/**
* @brief 本相前进 1 脉冲，返回下一拍命令频率
* @note 匀速直接返回缓存 f；走完 n_total 后钳到 f1 并清 active
*/
uint32_t PlsrAccelPulseRtStep(PlsrAccelPulseRt_t *rt);
/** 本相前进 1 脉冲，返回下一拍命令频率 */
uint32_t PlsrAccelPulseRtStep(PlsrAccelPulseRt_t *pulse_rt);

#endif

+ 15
- 2
plsr/command/plsr_command.c Wyświetl plik

@@ -20,6 +20,7 @@
#include "plsr_param.h"
#include "plsr_run_control.h"
#include "plsr.h"
#include "plsr_persist.h"
#include "modbus_rtu.h"

/*
@@ -63,6 +64,7 @@ void PlsrCommandSetFault(uint16_t code)
{
s_fault = code;
WriteHoldReg(PLSR_MON_ERR, code);
PlsrPersistNotifyMonitorChanged();
}

/** @brief 清故障（见 plsr_command.h） */
@@ -70,6 +72,7 @@ void PlsrCommandClearFault(void)
{
s_fault = PLSR_ERR_NONE;
WriteHoldReg(PLSR_MON_ERR, PLSR_ERR_NONE);
PlsrPersistNotifyMonitorChanged();
}

/** @brief 读故障镜像（见 plsr_command.h） */
@@ -84,7 +87,7 @@ void PlsrCommandInit(void)
WriteHoldReg(PLSR_CTRL_REG, 0U);
s_live_freq_req = 0U;
s_live_freq_hz = 0U;
PlsrCommandClearFault();
/* 不清故障：上电由 PersistRestoreMonitor 恢复；无镜像时 s_fault 默认为 0 */
PlsrCommandPublishMonitor();
}

@@ -144,6 +147,7 @@ void PlsrCommandOnSegFreqHoldWrite(uint16_t start_addr, uint16_t quantity)
if (seg != (PlsrSeg_t *)0)
{
seg->freq_hz = (int32_t)f;
PlsrPersistNotifyCommonChanged(); /* 动态改频：段表 dirty，Poll 写入 BKPSRAM */
}

s_live_freq_hz = f;
@@ -163,6 +167,7 @@ void PlsrCommandOnSegFreqHoldWrite(uint16_t start_addr, uint16_t quantity)
void PlsrCommandPoll(void)
{
uint16_t ctrl = ReadHoldReg(PLSR_CTRL_REG);
uint8_t skip_monitor = 0U;

if (ctrl != 0U)
{
@@ -188,6 +193,11 @@ void PlsrCommandPoll(void)
PlsrCommandClearFault();
PlsrStop();
(void)PlsrStart(PlsrParamGetStartSeg());
/* 已进换向/WAIT 精确等待：本周期勿再 PublishMonitor，尽快 Pend */
if (PlsrRunControlIsPreciseWait() != 0U)
{
skip_monitor = 1U;
}
}
}

@@ -199,5 +209,8 @@ void PlsrCommandPoll(void)
(void)PlsrChangeFreq(f);
}

PlsrCommandPublishMonitor();
if (skip_monitor == 0U)
{
PlsrCommandPublishMonitor();
}
}

+ 1
- 1
plsr/command/plsr_command.h Wyświetl plik

@@ -83,7 +83,7 @@ void PlsrCommandSetFault(uint16_t code);

/**
* @brief 清故障为 0
* @note 调用时机：START 前、CLR 控制位、Init
* @note 调用时机：START 前、CLR 控制位（Init 不再清，以便上电恢复）
*/
void PlsrCommandClearFault(void);



+ 7
- 7
plsr/param/plsr_param.c Wyświetl plik

@@ -23,13 +23,13 @@
#include "ucos_ii.h"
#include <string.h>

static PlsrCfg_t s_cfg;
static PlsrSeg_t s_seg[PLSR_SEG_MAX];
static PlsrCfg_t s_cfg; /* 公共运行参数映像 */
static PlsrSeg_t s_seg[PLSR_SEG_MAX]; /* 段表映像（最多 PLSR_SEG_MAX 段） */

static OS_EVENT *s_param_sem;
static volatile uint16_t s_expect_frames;
static volatile uint16_t s_recv_frames;
static volatile uint8_t s_xfer_active;
static OS_EVENT *s_param_sem; /* 分帧收齐后唤醒 ParamBlockTask */
static volatile uint16_t s_expect_frames; /* 本批期望总帧数 = 1 + 段数 */
static volatile uint16_t s_recv_frames; /* 已收帧计数 */
static volatile uint8_t s_xfer_active; /* 1=正在接收一批分帧 */

/*============================================================================*/
/* 运行映像 */
@@ -416,7 +416,7 @@ void PlsrParamBlockTask(void *pArg)

(void)pArg;

for (;;)
while(1)
{
(void)OSSemPend(s_param_sem, 0U, &err);
if (err != OS_ERR_NONE)


+ 9
- 6
plsr/param/plsr_param.h Wyświetl plik

@@ -12,14 +12,14 @@
* - modbus_rtu / modbus_data ：ReadHoldReg / WriteHoldReg
* - plsr_command ：启动前 ApplyFromHold；运行中写频改 s_seg[].freq_hz
* - plsr_run_control ：GetCfg / GetSeg / GetSegCount / GetStartSeg
* - plsr_persist ：Apply 成功后 NotifyCommonChanged，落盘仅公共参数
* - plsr_persist ：Apply 成功后 NotifyCommonChanged，落盘公共+段表+监控
* - PlsrParamBlockTask ：独立 uC/OS 任务，等信号量后 Apply + PersistPoll
*
* 关键数据流
* 上位机写公共帧@0x1000 → OnHoldWrite 开传输 expect=1+N
* 上位机写段帧@0x1100+ → recv++；收齐 → OSSemPost
* ParamBlockTask → ApplyFromHold → 结构体更新 → PersistNotify → 状态 OK
* 上电：InitDefault → PersistLoad 覆盖公共 → ExportToHold
* 上电：InitDefault → PersistLoad 覆盖公共+段表 → ExportToHold
*
* 协议概要
* - 公共帧：0x1000~0x1013（20 字），0x1009=段数 N，预期总帧=1+N
@@ -86,8 +86,9 @@ typedef enum {
} PlsrDirLogic_e;

/**
* 发送方式（影响本段终止频率 f_end 与是否允许同向不停表衔接）
* COMPLETE：段末规划到公共止速；FOLLOW：无门禁时可衔接下一段目标频
* 发送方式（与等待类型一起决定本段 f_end，并影响是否允许同向不停表衔接）
* COMPLETE：EXT_OR_DONE 同向时匀速跑完；反向或其它等待类型规划到止速
* FOLLOW：仅 EXT_OR_DONE 同向可规划到下一段目标并允许不停表衔接；反向同其它等待
*/
typedef enum {
PLSR_SEND_COMPLETE = 0,
@@ -113,7 +114,9 @@ typedef enum {

/**
* 段末/段内等待类型（由 run_control + signal_io 执行）
* TIME/SIGNAL/ACT/EXT 均会阻止 FOLLOW 不停表衔接（BlocksFollowKeep）
* TIME/SIGNAL/ACT/EXT：完成/后续均规划到止速；并阻止 FOLLOW 不停表衔接
* EXT_OR_DONE：与下一段同向时后续可接目标/完成匀速跑完并可 FOLLOW 衔接；
* 与下一段反向时规划同其它等待（减速到止速，下一段从起速再爬）
*/
typedef enum {
PLSR_WAIT_TIME = 0, /* 发完后等 wait_ms（0 按 1ms），再跳转 */
@@ -208,7 +211,7 @@ void PlsrParamBlockOnHoldWrite(uint16_t start_addr, uint16_t quantity);
/**
* @brief 保持寄存器 → s_cfg / s_seg
* @return 1=成功（当前恒为 1；完整校验/故障码待扩展）
* @note 副作用：NotifyCommonChanged 标记 Flash 待存
* @note 副作用：NotifyCommonChanged 标记 BKPSRAM 待存
*/
uint8_t PlsrParamBlockApplyFromHold(void);



+ 0
- 91
plsr/path_plan/plsr_path_plan.c Wyświetl plik

@@ -1,91 +0,0 @@
/**
* @file plsr_path_plan.c
* @brief 多段路径规划实现（只做决策，不碰 TIM/GPIO）
*
* @details 模块职责
* NextSeg / ResolveAfterSeg：按 jump_seg 决定下一段或结束；
* IsForward：相对模式看 pulse_cnt 符号，绝对模式看「目标−相对原点位置」符号；
* GetWaitMs：仅 WAIT_TIME，0 映射为 1ms。
*
* 关键数据流
* AfterSegDone / CutSeg / ActExpire → ResolveAfterSeg → BeginSeg 或 FinishAll
* WillFollowKeep / CutSeg keep 判定 → IsForward(下一段, AbsLocalPos)
*/
#include "plsr_path_plan.h"
#include "plsr_param.h"

/**
* @brief 解析下一段（见 plsr_path_plan.h）
*/
int16_t PlsrPathPlanNextSeg(uint16_t cur_seg_0based)
{
PlsrSeg_t *seg = PlsrParamGetSeg(cur_seg_0based);
uint16_t n = PlsrParamGetSegCount();
uint16_t jump = seg->jump_seg;

/*
* 跳转目标（1-based）：
* 0 → 末段：结束；非末段：顺序下一段（cur+1）
* 1..N → 跳到对应段（可顺序、回跳循环、任意段）
* 其它 → 结束
*/
if (jump == 0U)
{
/* 非末段写 0：视为顺序下一档，不是停机 */
if ((n >= 1U) && (cur_seg_0based + 1U < n))
{
return (int16_t)(cur_seg_0based + 1U);
}
return -1;
}
if ((jump >= 1U) && (jump <= n))
{
return (int16_t)(jump - 1U);
}
return -1;
}

/**
* @brief 判断段方向（见 plsr_path_plan.h）
*/
uint8_t PlsrPathPlanIsForward(uint16_t seg_0based, int32_t acc_pulse)
{
PlsrSeg_t *seg = PlsrParamGetSeg(seg_0based);
PlsrCfg_t *cfg = PlsrParamGetCfg();
int32_t move;

if (cfg->run_mode == PLSR_POS_ABSOLUTE)
{
/* move = 段目标 − 相对本次启动原点的位置 */
move = seg->pulse_cnt - acc_pulse;
}
else
{
move = seg->pulse_cnt;
}
return (move >= 0) ? 1U : 0U;
}

/**
* @brief 段后 WAIT 时间（见 plsr_path_plan.h）
*/
uint16_t PlsrPathPlanGetWaitMs(uint16_t seg_0based)
{
PlsrSeg_t *seg = PlsrParamGetSeg(seg_0based);

/* 仅段后 WAIT 时间；0 按 1ms（手册）；信号/ACT/EXT 由 run_control 处理 */
if (seg->wait_type == PLSR_WAIT_TIME)
{
return (seg->wait_ms == 0U) ? 1U : seg->wait_ms;
}
(void)seg_0based;
return 0U;
}

/**
* @brief 段后解析下一段（见 plsr_path_plan.h）
*/
int16_t PlsrPathPlanResolveAfterSeg(uint16_t cur_seg_0based)
{
return PlsrPathPlanNextSeg(cur_seg_0based);
}

+ 0
- 49
plsr/path_plan/plsr_path_plan.h Wyświetl plik

@@ -1,49 +0,0 @@
/**
* @file plsr_path_plan.h
* @brief 多段路径规划：段序、跳转、相对/绝对方向判定
*
* @details 模块职责
* 只读段表与公共定位模式，回答「下一段是谁」「这一段正还是反」「段后 WAIT 多久」。
* 不驱动 TIM/GPIO；等待类型的具体执行由 run_control + signal_io 完成。
*
* 与其它模块关系
* - plsr_param ：GetSeg / GetSegCount / GetCfg
* - plsr_run_control ：GotoNext、CutSeg、WillFollowKeep、BeginSeg 方向
*/
#ifndef PLSR_PATH_PLAN_H
#define PLSR_PATH_PLAN_H

#include <stdint.h>

/**
* @brief 解析下一段索引
* @param cur_seg_0based 当前段 0-based
* @return 下一段 0-based；无下一段或非法跳转返回 -1
* @note jump=0：末段→结束；非末段→顺序下一段
* jump=1~N：跳到对应段（可循环）
* 其它：结束
*/
int16_t PlsrPathPlanNextSeg(uint16_t cur_seg_0based);

/**
* @brief 判断该段运动方向
* @param seg_0based 段索引
* @param acc_pulse 相对本次启动原点的位置（绝对模式算位移用）
* @return 1=正向，0=反向
* @note 相对：看 pulse_cnt 符号；绝对：看 (目标−相对原点位置) 符号
*/
uint8_t PlsrPathPlanIsForward(uint16_t seg_0based, int32_t acc_pulse);

/**
* @brief 段结束后 WAIT 时间(ms)
* @note 仅 WAIT_TIME 有效；0 按 1ms；其它等待类型返回 0（由 run_control 处理）
*/
uint16_t PlsrPathPlanGetWaitMs(uint16_t seg_0based);

/**
* @brief 段结束（或等待结束）后解析下一段
* @note 当前语义同 NextSeg；保留独立符号便于日后插入后处理
*/
int16_t PlsrPathPlanResolveAfterSeg(uint16_t cur_seg_0based);

#endif

+ 24
- 48
plsr/plsr.c Wyświetl plik

@@ -10,9 +10,10 @@
* 本文件仅依赖 plsr.h 及各子模块头文件，不被其它 plsr 模块反向引用。
*
* 关键数据流
* PlsrInit 顺序：Param 默认 → Persist 加载 → PulseDriver → SignalIo →
* RunControl → ExportToHold → CommandInit
* PlsrTask 循环：CommandPoll → PersistPoll → RunControlTickMs → OSTimeDly(1)
* PlsrInit 顺序：Param 默认 → PersistLoad → PulseDriver → SignalIo →
* RunControl → PersistRestoreRuntime → ExportToHold →
* CommandInit → PersistRestoreMonitor → PersistPoll
* PlsrTask 循环：TickMs → DebouncePoll → CommandPoll → PersistPoll → WakePend
*/
#include "plsr.h"
#include "plsr_pulse_driver.h"
@@ -29,12 +30,15 @@
void PlsrInit(void)
{
PlsrParamInitDefault();
PlsrPersistLoad(); /* 有 Flash 记录则覆盖公共参数；段表仍用默认/上位机下发 */
PlsrPersistLoad(); /* BKPSRAM：覆盖公共+段表；累计/故障暂存 */
PlsrPulseDriverInit();
PlsrSignalIoInit();
PlsrRunControlInit();
PlsrParamBlockExportToHold(); /* 上电把运行映像摊到保持寄存器，供 Modbus 0x03 读 */
PlsrPersistRestoreRuntime(); /* 写回累计脉冲 */
PlsrParamBlockExportToHold(); /* 上电把运行映像摊到保持寄存器，供 Modbus 0x03 读取 */
PlsrCommandInit();
PlsrPersistRestoreMonitor(); /* 恢复故障码；0x3000/运行态强制空闲 */
PlsrPersistPoll(); /* 消费 Restore 置的 dirty */
}

/**
@@ -97,14 +101,12 @@ void PlsrOnPulseIsr(void)
void PlsrTask(void *pArg)
{
static uint8_t s_booted = 0U;
#if (PLSR_LOOP_TEST_EN != 0)
static uint8_t s_was_busy = 0U;
static uint16_t s_idle_ticks = 0U;
#endif

(void)pArg;

for (;;)
PlsrRunControlWakeInit(); /* OS 已启动，创建 WAIT/ACT 到期唤醒信号量 */

while(1)
{
/*
* 首次进入：Modbus 从站上电常会清零保持寄存器。
@@ -115,52 +117,26 @@ void PlsrTask(void *pArg)
OSTimeDly(30U); /* ~300ms @ 100Hz tick */
PlsrParamBlockExportToHold();
PlsrCommandInit();
PlsrPersistRestoreMonitor(); /* 若仍有 pending；无则空操作 */
s_booted = 1U;
#if (PLSR_LOOP_TEST_EN != 0)
s_was_busy = 0U;
s_idle_ticks = 0U;
#endif
}

PlsrRunControlTickMs(); /* 优先：WAIT/换向到期立刻开表 */
PlsrSignalIoDebouncePoll(); /* OS 节拍消抖确认 */
PlsrCommandPoll(); /* 收 START/STOP/CLR，回写 0x2000~0x2006 监控 */
PlsrPersistPoll(); /* 公共参数有改且空闲则追加写入 Flash */
PlsrRunControlTickMs(); /* ACT/WAIT/EXT、换向延时、ApplyPending */
PlsrPersistPoll(); /* BKPSRAM：消费 dirty（累计脉冲限频落盘） */

#if (PLSR_LOOP_TEST_EN != 0)
/*
* 调试循环：检测到 busy→idle 边沿后，空闲满 1s 自动从第 1 段再启。
* 正式产品 PLSR_LOOP_TEST_EN=0 时本段不参与编译。
* 换向 / WAIT 时间：WakePend(0) 只等 TIM5 Post（墙钟≈设定 ms）。
* 其它：超时 1 OS tick，兼顾 EXT 轮询。
*/
if (s_booted != 0U)
if (PlsrRunControlIsPreciseWait() != 0U)
{
uint8_t busy = PlsrIsBusy();

if ((s_was_busy != 0U) && (busy == 0U))
{
s_idle_ticks = 0U;
}

if (busy == 0U)
{
s_idle_ticks++;
if (s_idle_ticks >= (uint16_t)OS_TICKS_PER_SEC)
{
s_idle_ticks = 0U;
if (PlsrParamGetSegCount() >= 1U)
{
(void)PlsrStart(1U);
}
}
}
else
{
s_idle_ticks = 0U;
}

s_was_busy = busy;
PlsrRunControlWakePend(0U);
}
else
{
PlsrRunControlWakePend(1U);
}
#endif

OSTimeDly(1U); /* 约 1ms 任务节拍，与 TIM3 独立 */
}
}

+ 6
- 6
plsr/plsr.h Wyświetl plik

@@ -13,15 +13,15 @@
* - plsr_command ：Modbus 监控区 0x2000~0x2006、控制区 0x3000 指令解析
* - plsr_run_control：段状态机、等待策略、加减速执行、故障诊断
* - plsr_pulse_driver：TIM PWM 脉冲 + Y3 方向 GPIO
* - plsr_signal_io ：WAIT/EXT 外部输入、TIM3 1ms 时基
* - plsr_signal_io ：WAIT/EXT 外部输入、TIM5 延时
*
* 关键数据流
* 上电：PlsrInit → 默认参数 → Flash 覆盖公共参数 → 驱动/IO/运行控制初始化
* → 参数导出到保持寄存器 → 指令模块初始化
* 周期：PlsrTask → CommandPoll（START/STOP/CLR、监控回写）
* → PersistPoll（空闲时 Flash 落盘）→ RunControlTickMs（等待/切段）
* 周期：PlsrTask → CommandPoll → PersistPoll → RunControlTickMs
* → WakePend(1)（TIM5 WAIT/ACT 到期 SemPost 可立刻唤醒）
* 脉冲：TIM UPDATE 中断 → PlsrOnPulseIsr → RunControl 计数 + 逐拍改频
* 启动：PlsrStart → RunControlStart → 路径规划 + 曲线规划 + PWM 输出
* 启动：PlsrStart → RunControlStart → 段序/方向 + 曲线规划 + PWM 输出
*/
#ifndef PLSR_H
#define PLSR_H
@@ -47,7 +47,7 @@ void PlsrInit(void);
/**
* @brief uC/OS-II 周期任务入口
* @param pArg 任务参数（未使用，传 NULL）
* @note 调用时机：创建后永久循环，建议 1ms 节拍（OSTimeDly(1)）
* @note 调用时机：创建后永久循环；WAIT/ACT 到期由信号量立刻唤醒，否则最多 1 个 OS tick
* @note 副作用：轮询 Modbus 控制位、刷新监控寄存器、推进运行控制状态机、
* 空闲时触发 Flash 持久化；首次进入延迟 ~300ms 再导出参数（避免 Modbus 清零冲掉）
*/
@@ -93,7 +93,7 @@ int32_t PlsrGetAccPulse(void);
/**
* @brief 清零累计脉冲与绝对坐标原点
* @note 调用时机：CommandPoll 收到 CLR 控制位
* @note 副作用：s_acc_pulse=0、s_abs_origin=0，同步清故障码
* @note 副作用：s_acc_pulse=0、s_abs_origin=0，下次 Start 重新锁定原点
*/
void PlsrClearAccPulse(void);



+ 133
- 62
plsr/pulse_driver/plsr_pulse_driver.c Wyświetl plik

@@ -4,9 +4,10 @@
*
* @details 模块职责
* 实现 plsr_pulse_driver.h 全部 API。核心约束：
* - 空闲不关 CC1E：Forced active 主动拉高，避免 AF 高阻耦合假脉冲；
* - 空闲不关 CC1E：Forced inactive 主动拉低，避免 AF 高阻耦合假脉冲；
* - ARR/CCR 预装载：改频写影子寄存器，下一 UPDATE 生效，减少毛刺/多计；
* - ISR 内禁止停表换 PSC：挂起 s_req_*，任务 ApplyPending。
* - 波形：空闲/开跑起点低；运行中 PWM1+极性高 → 每周期先高后低。
*
* 关键数据流
* PlanSeg → LockPscRange → DIR_WAIT → Start → ISR SetFreqIsr（只改 ARR）
@@ -35,14 +36,14 @@ TIM_HandleTypeDef htim13;
/*
* ---------- 模块静态状态 ----------
* s_last_freq/psc/arr — 上次量化结果；匀速热路径比较后可跳过写寄存器
* s_active_y / htim — 当前选中脉冲路
* s_active_htim — 当前选中脉冲路 HAL 句柄
* s_psc_locked / locked_psc — 段内 PSC 锁；跨度过大时 locked=0
* s_req_freq / pending — ISR 无法换 PSC 时的挂起改频
*/
static uint32_t s_last_freq;
static uint32_t s_last_psc = 0xFFFFFFFFUL;
static uint32_t s_last_arr = 0xFFFFFFFFUL;
static uint8_t s_active_y;
static uint32_t s_last_ccr;
static TIM_HandleTypeDef *s_active_htim;

static uint8_t s_psc_locked;
@@ -50,6 +51,10 @@ static uint32_t s_locked_psc;

static volatile uint32_t s_req_freq;
static volatile uint8_t s_req_pending;
/*
* 1=DIR_WAIT 已装载寄存器且 CEN 关：到期 Commit 前必须 CNT=0 再开 PWM。
*/
static uint8_t s_regs_prepared;

/*============================================================================*/
/* 路选择 / 时钟 / GPIO */
@@ -114,9 +119,9 @@ static void PlsrPulseDriverDirGpioInit(void)
/**
* 停表：不关复用、不关 CC1E。
* HAL_TIM_PWM_Stop 会清 CC1E，脚变成 AF 高阻，飞线接地的沿会耦合出极短脉冲。
* Forced active + 通道保持使能：TIM 推挽把脚主动拉高（段间空闲高）。
* Forced inactive + 通道保持使能：TIM 推挽把脚主动拉低（段间空闲低）。
*/
static void PlsrPulseDriverOcHoldHigh(TIM_HandleTypeDef *htim)
static void PlsrPulseDriverOcHoldLow(TIM_HandleTypeDef *htim)
{
uint32_t ccmr;

@@ -130,7 +135,7 @@ static void PlsrPulseDriverOcHoldHigh(TIM_HandleTypeDef *htim)

ccmr = htim->Instance->CCMR1;
ccmr &= (uint32_t)(~TIM_CCMR1_OC1M);
ccmr |= TIM_OCMODE_FORCED_ACTIVE;
ccmr |= TIM_OCMODE_FORCED_INACTIVE;
htim->Instance->CCMR1 = ccmr;
htim->Instance->CCER |= TIM_CCER_CC1E;

@@ -139,17 +144,6 @@ static void PlsrPulseDriverOcHoldHigh(TIM_HandleTypeDef *htim)
TIM_CHANNEL_STATE_SET(htim, TIM_CHANNEL_1, HAL_TIM_CHANNEL_STATE_READY);
}

/** @brief 比较通道切回 PWM1 模式（开跑前） */
static void PlsrPulseDriverOcPwm1(TIM_HandleTypeDef *htim)
{
uint32_t ccmr;

ccmr = htim->Instance->CCMR1;
ccmr &= (uint32_t)(~TIM_CCMR1_OC1M);
ccmr |= TIM_OCMODE_PWM1;
htim->Instance->CCMR1 = ccmr;
}

/**
* @brief HAL MSP：为 TIM10/11/13 配 AF GPIO 与 NVIC
* @note 由 HAL_TIM_PWM_Init 回调；优先级 5，低于 EXTI/TIM3 之外的系统中断惯例
@@ -161,7 +155,8 @@ void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
__HAL_RCC_GPIOF_CLK_ENABLE();

gpio.Mode = GPIO_MODE_AF_PP;
gpio.Pull = GPIO_PULLUP;
/* 下拉：通道若短暂高阻时保持低，避免上拉把「已高」盖住导致看不到开表上升沿 */
gpio.Pull = GPIO_PULLDOWN;
gpio.Speed = GPIO_SPEED_FREQ_HIGH;

if (htim->Instance == TIM10)
@@ -196,7 +191,7 @@ void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
}

/**
* @brief 初始化单路脉冲 TIM：PWM1 + ARR/CCR 预装载 + 空闲 Forced 拉高
* @brief 初始化单路脉冲 TIM：PWM1 + ARR/CCR 预装载 + 空闲 Forced 拉低
* @param htim HAL 句柄
* @param inst TIM10 / TIM11 / TIM13
*/
@@ -229,8 +224,8 @@ static void PlsrPulseDriverTimInitOne(TIM_HandleTypeDef *htim, TIM_TypeDef *inst
Error_Handler();
}
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
/* 复用保持：比较通道强制有效，推挽把脚拉高 */
PlsrPulseDriverOcHoldHigh(htim);
/* 复用保持：强制无效，推挽空闲拉低；开跑后 PWM1 每周期仍先高后低 */
PlsrPulseDriverOcHoldLow(htim);
}

/** @brief 驱动初始化（见 plsr_pulse_driver.h） */
@@ -239,14 +234,14 @@ void PlsrPulseDriverInit(void)
s_last_freq = 0U;
s_last_psc = 0xFFFFFFFFUL;
s_last_arr = 0xFFFFFFFFUL;
s_last_ccr = 0U;
s_psc_locked = 0U;
s_locked_psc = 0U;
s_req_pending = 0U;
s_req_freq = 0U;
s_active_y = 0U;
s_active_htim = &htim10;
PlsrPulseDriverDirGpioInit();
/* 三路都 Init + 空闲拉高，计数器关闭；出脉冲时只 Start 选中那路 */
/* 三路都 Init + 空闲拉低，计数器关闭；出脉冲时只 Start 选中那路 */
PlsrPulseDriverTimInitOne(&htim10, TIM10);
PlsrPulseDriverTimInitOne(&htim11, TIM11);
PlsrPulseDriverTimInitOne(&htim13, TIM13);
@@ -286,9 +281,13 @@ uint8_t PlsrPulseDriverIsPulseTim(TIM_TypeDef *instance)
/* PSC / ARR 量化 */
/*============================================================================*/

/**
* @brief 在给定 PSC 下计算 ARR/CCR（约 50% 占空比）
* @note freq 钳到 [1,100000]；ARR 落在 16 位合法范围
/*
* STM32 定时器频率换算（本模块约定）
* clk_hz — TIM 计数时钟（APB2=168MHz 或 APB1=84MHz）
* psc — 预分频寄存器值，实际分频 = PSC+1
* arr — 自动重装载，一个 PWM 周期 = (ARR+1)×(PSC+1) 个计数
* ccr — 比较值，PWM1 模式下高电平宽度 ≈ CCR 个计数（本驱动约 50% 占空）
* 目标频率：ticks = clk_hz / freq_hz ≈ (PSC+1)×(ARR+1)
*/
static void PlsrPulseDriverCalcArrWithPsc(uint32_t clk_hz, uint32_t freq_hz, uint32_t psc,
uint32_t *arr, uint32_t *ccr)
@@ -452,10 +451,10 @@ void PlsrPulseDriverUnlockPsc(void)
s_locked_psc = 0U;
}

/** @brief 停单路：Forced active 拉高，关 CEN/UPDATE */
/** @brief 停单路：Forced inactive 拉低，关 CEN/UPDATE */
static void PlsrPulseDriverStopHtim(TIM_HandleTypeDef *htim)
{
PlsrPulseDriverOcHoldHigh(htim);
PlsrPulseDriverOcHoldLow(htim);
}

/*============================================================================*/
@@ -463,11 +462,28 @@ static void PlsrPulseDriverStopHtim(TIM_HandleTypeDef *htim)
/*============================================================================*/

/**
* @brief Start / StartFreeRun 公共路径
* @param freq_hz 0=停表；>0 开跑
* @param enable_update_it 1=开 UPDATE 中断（计数脉冲）；0=自由跑
* 关预装载后直写 ARR/CCR 工作寄存器，再打开预装载并复写影子。
* 仅 UG 不可靠时（首拍 CCR 工作值仍为 0）：CNT=0 也会整拍无高电平，
* 示波器上与「CNT>CCR 空等近一周期」无法区分。
*/
static void PlsrPulseDriverForceArrCcr(TIM_HandleTypeDef *htim,
uint32_t arr, uint32_t ccr)
{
htim->Instance->CR1 &= (uint32_t)(~TIM_CR1_ARPE);
htim->Instance->CCMR1 &= (uint32_t)(~TIM_CCMR1_OC1PE);
htim->Instance->ARR = arr;
htim->Instance->CCR1 = ccr;
htim->Instance->CR1 |= TIM_CR1_ARPE;
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
htim->Instance->ARR = arr;
htim->Instance->CCR1 = ccr;
}

/**
* @brief 装载 PSC/ARR/CCR，Forced 拉低，CEN=0、IT=0
* @note 换向延时期间禁止开 CEN，避免 CNT 空转。
*/
static void PlsrPulseDriverStartCommon(uint32_t freq_hz, uint8_t enable_update_it)
static void PlsrPulseDriverLoadRegs(uint32_t freq_hz)
{
uint32_t psc;
uint32_t arr;
@@ -482,7 +498,6 @@ static void PlsrPulseDriverStartCommon(uint32_t freq_hz, uint8_t enable_update_i
{
PlsrPulseDriverStopHtim(s_active_htim);
}
s_active_y = y;
s_active_htim = htim;
clk_hz = PlsrPulseDriverTimClkHz(htim);

@@ -492,6 +507,8 @@ static void PlsrPulseDriverStartCommon(uint32_t freq_hz, uint8_t enable_update_i
s_last_freq = 0U;
s_last_psc = 0xFFFFFFFFUL;
s_last_arr = 0xFFFFFFFFUL;
s_last_ccr = 0U;
s_regs_prepared = 0U;
return;
}

@@ -505,43 +522,109 @@ static void PlsrPulseDriverStartCommon(uint32_t freq_hz, uint8_t enable_update_i
PlsrPulseDriverCalcPscArr(clk_hz, freq_hz, &psc, &arr, &ccr);
}

if (ccr < 1U)
{
ccr = 1U;
}

s_last_freq = freq_hz;
s_last_psc = psc;
s_last_arr = arr;
s_last_ccr = ccr;

__HAL_TIM_DISABLE(htim);
__HAL_TIM_DISABLE_IT(htim, TIM_IT_UPDATE);

/* 清 one-pulse，保证连续发脉冲 */
htim->Instance->CR1 &= (uint32_t)(~TIM_CR1_OPM);

__HAL_TIM_SET_PRESCALER(htim, psc);
__HAL_TIM_SET_AUTORELOAD(htim, arr);
__HAL_TIM_SET_COMPARE(htim, TIM_CHANNEL_1, ccr);
__HAL_TIM_SET_COUNTER(htim, 0U);
PlsrPulseDriverForceArrCcr(htim, arr, ccr);

/*
* UG 在 Forced active 下做：脚保持高，避免 UG 在 PWM 复用脚上打出针。
* 再切回 PWM1 并开计数。
*/
PlsrPulseDriverOcHoldHigh(htim);
PlsrPulseDriverOcHoldLow(htim);
/* UG：PSC 生效；随后再钉 ARR/CCR/CNT，避免只进影子 */
htim->Instance->EGR = TIM_EGR_UG;
__HAL_TIM_CLEAR_FLAG(htim, TIM_FLAG_UPDATE);
__HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
PlsrPulseDriverForceArrCcr(htim, arr, ccr);
htim->Instance->CNT = 0U;

s_regs_prepared = 1U;
}

/**
* @brief 开沿：先 Forced Active 出首上升沿，再切 PWM1 连续发脉冲
*
* @note WAIT/换向后若首拍 CCR 工作值为 0，PWM1 会整拍低电平，示波器上就是
* 「延时 + 本段第一脉冲周期」。Forced Active 与 CNT/CCR 无关，首沿必须出现。
* Commit 内不再 UG，避免预装载影子把 CCR 又打回旧值/0。
*/
static void PlsrPulseDriverCommitOutput(void)
{
TIM_HandleTypeDef *htim = s_active_htim;
uint32_t ccmr;

PlsrPulseDriverOcPwm1(htim);
if ((htim == (TIM_HandleTypeDef *)0) || (htim->Instance == (TIM_TypeDef *)0))
{
return;
}

__HAL_TIM_DISABLE(htim);
__HAL_TIM_DISABLE_IT(htim, TIM_IT_UPDATE);

/* 关预装载，直写工作寄存器 */
htim->Instance->CR1 &= (uint32_t)(~TIM_CR1_ARPE);
htim->Instance->CCMR1 &= (uint32_t)(~TIM_CCMR1_OC1PE);
htim->Instance->ARR = s_last_arr;
htim->Instance->CCR1 = (s_last_ccr < 1U) ? 1U : s_last_ccr;
htim->Instance->CNT = 0U;

/*
* 唯一的脉冲启动入口。通道必须在 CEN 前使能；TIM10/11/13 在
* 运行中由 CC1E=0 -> 1 不保证重新建立当前 PWM1 电平，会保持无输出。
* CNT 从 ARR 开始，下一计数节拍产生真实 UPDATE：该 UPDATE 同时建立
* PWM1 首上升沿并进入现有脉冲 ISR 计数，边沿与 s_done 保持一一对应。
*/
ccmr = htim->Instance->CCMR1;
ccmr &= (uint32_t)(~TIM_CCMR1_OC1M);
ccmr |= TIM_OCMODE_PWM1;
htim->Instance->CCMR1 = ccmr;
htim->Instance->CCER |= TIM_CCER_CC1E;
__HAL_TIM_ENABLE(htim);

htim->Instance->CNT = s_last_arr;
__HAL_TIM_CLEAR_FLAG(htim, TIM_FLAG_UPDATE);
__HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
__HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
__HAL_TIM_ENABLE(htim);

/* 运行期改频仍走预装载 */
htim->Instance->CR1 |= TIM_CR1_ARPE;
htim->Instance->CCMR1 |= TIM_CCMR1_OC1PE;
htim->Instance->ARR = s_last_arr;
htim->Instance->CCR1 = (s_last_ccr < 1U) ? 1U : s_last_ccr;

s_regs_prepared = 0U;
}

if (enable_update_it != 0U)
/**
* @brief Start 公共路径（每次开沿都走 Commit，不依赖 prepared 捷径）
*/
static void PlsrPulseDriverStartCommon(uint32_t freq_hz)
{
if ((s_regs_prepared == 0U) || (freq_hz != s_last_freq) || (freq_hz == 0U))
{
__HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);
PlsrPulseDriverLoadRegs(freq_hz);
}
if (freq_hz != 0U)
{
PlsrPulseDriverCommitOutput();
}
}

/** @brief 换向延时期间预装寄存器、CEN 保持关（见 plsr_pulse_driver.h） */
void PlsrPulseDriverPrepare(uint32_t freq_hz)
{
PlsrPulseDriverLoadRegs(freq_hz);
}

/** @brief 任务上下文改频（见 plsr_pulse_driver.h） */
void PlsrPulseDriverSetFreq(uint32_t freq_hz)
{
@@ -676,13 +759,6 @@ void PlsrPulseDriverSetFreqIsr(uint32_t freq_hz)
s_last_arr = arr;
}

/** @brief 挂起改频请求（见 plsr_pulse_driver.h） */
void PlsrPulseDriverRequestFreq(uint32_t freq_hz)
{
s_req_freq = freq_hz;
s_req_pending = 1U;
}

/** @brief 丢弃挂起（见 plsr_pulse_driver.h） */
void PlsrPulseDriverClearPending(void)
{
@@ -711,19 +787,14 @@ void PlsrPulseDriverApplyPending(void)
/** @brief 开 PWM + UPDATE 中断（见 plsr_pulse_driver.h） */
void PlsrPulseDriverStart(uint32_t freq_hz)
{
PlsrPulseDriverStartCommon(freq_hz, 1U);
}

/** @brief 开 PWM 不使能 UPDATE（见 plsr_pulse_driver.h） */
void PlsrPulseDriverStartFreeRun(uint32_t freq_hz)
{
PlsrPulseDriverStartCommon(freq_hz, 0U);
PlsrPulseDriverStartCommon(freq_hz);
}

/** @brief 停三路（见 plsr_pulse_driver.h） */
void PlsrPulseDriverStop(void)
{
s_req_pending = 0U;
s_regs_prepared = 0U;
PlsrPulseDriverStopHtim(&htim10);
PlsrPulseDriverStopHtim(&htim11);
PlsrPulseDriverStopHtim(&htim13);
@@ -741,7 +812,7 @@ void PlsrPulseDriverArmOnePulseStop(void)
{
return;
}
/* 下一 UPDATE 后计数器停止，不再多开一拍 */
/* 下一 UPDATE 后计数器停止；须在倒数第二拍尽早武装（见 run_control ISR） */
htim->Instance->CR1 |= TIM_CR1_OPM;
}



+ 9
- 13
plsr/pulse_driver/plsr_pulse_driver.h Wyświetl plik

@@ -19,8 +19,9 @@
* Y3 → PF9 GPIO 方向（固定，不可选）
*
* 频率约定
* 0 ：停止该路 PWM（空闲 Forced active 拉高）
* 0 ：停止该路 PWM（空闲 Forced inactive 拉低）
* 1~100k：按 Hz 输出；超出由 Calc 路径钳到 100k
* 波形：空闲/开跑起点低；运行中 PWM1 每周期先高后低
*/
#ifndef PLSR_PULSE_DRIVER_H
#define PLSR_PULSE_DRIVER_H
@@ -36,7 +37,7 @@ extern TIM_HandleTypeDef htim13;
/**
* @brief 初始化三路脉冲 TIM + 方向 GPIO
* @note 调用时机：PlsrInit，在 RunControl 之前
* @note 副作用：Y0/Y1/Y2 空闲拉高、计数器关；Y3 输出低
* @note 副作用：Y0/Y1/Y2 空闲拉低、计数器关；Y3 输出低
*/
void PlsrPulseDriverInit(void);

@@ -60,15 +61,16 @@ void PlsrPulseDriverLockPscRange(uint32_t f_min_hz, uint32_t f_max_hz);
void PlsrPulseDriverUnlockPsc(void);

/**
* @brief 以指定频率启动选中路 PWM，并打开 UPDATE 中断
* @param freq_hz 0=停表；>0 开跑
* @brief 开沿顺序：ARR/CCR → CNT=0 → UG → CCxE → CEN（CEN 后立刻有效电平）
* @note 换向延时到期应在 TIM5 延时中断内调用；勿经任务调度再开表
*/
void PlsrPulseDriverStart(uint32_t freq_hz);

/**
* @brief 同 Start，但不使能 UPDATE 中断（自由跑，不计入脉冲 ISR）
* @brief 换向延时期间装载 ARR/CCR，Forced 低且 CEN 关
* @note 到期在 ISR 里 Start：CNT=0+UG+CEN，首沿对齐延时结束
*/
void PlsrPulseDriverStartFreeRun(uint32_t freq_hz);
void PlsrPulseDriverPrepare(uint32_t freq_hz);

/**
* @brief 任务上下文改频：PSC 不变则预装载 ARR；须换 PSC 则停表重装
@@ -83,12 +85,6 @@ void PlsrPulseDriverSetFreq(uint32_t freq_hz);
*/
void PlsrPulseDriverSetFreqIsr(uint32_t freq_hz);

/**
* @brief 请求改频（挂起），在周期边界或任务里落到硬件
* @param freq_hz 目标 Hz；0 表示挂起停表
*/
void PlsrPulseDriverRequestFreq(uint32_t freq_hz);

/**
* @brief 消费挂起改频（TickMs / 更新路径）
* @note s_req_freq==0 时 Stop；否则 SetFreq
@@ -99,7 +95,7 @@ void PlsrPulseDriverApplyPending(void);
void PlsrPulseDriverClearPending(void);

/**
* @brief 停止三路脉冲 TIM，空闲 Forced active 拉高
* @brief 停止三路脉冲 TIM，空闲 Forced inactive 拉低
* @note 不清方向脚；不清 PSC 锁（由上层 Unlock）
*/
void PlsrPulseDriverStop(void);


+ 610
- 375
plsr/run_control/plsr_run_control.c
Plik diff jest za duży
Wyświetl plik


+ 24
- 78
plsr/run_control/plsr_run_control.h Wyświetl plik

@@ -1,103 +1,49 @@
/**
* @file plsr_run_control.h
* @brief 运行控制模块：多段脉冲执行状态机
* @brief 运行控制：多段脉冲状态机（开段 → 发脉冲 → 等待/跳转 → 收尾）
*
* @details 模块职责
* 协调路径规划、加减速曲线、脉冲驱动与外部信号，完成「开段 → 发脉冲 →
* 段后等待/跳转 → 收尾」全流程。负责解析发送模式（完成/后续）、等待类型
* （时间/信号/ACT/EXT）及段间频率衔接策略。
* @details 解析发送模式、等待类型与段间频率衔接；协调 accel_curve /
* pulse_driver / signal_io / param。状态：IDLE / DIR_WAIT / RUN / WAIT_COND。
*
* 与其它模块关系
* - plsr_path_plan ：下一段索引、正反向判定（只读决策，不碰硬件）
* - plsr_accel_curve ：段内梯形/三角/S/正弦脉冲域规划与 ISR 逐拍取频
* - plsr_param ：段表与公共参数只读访问
* - plsr_pulse_driver：PWM 启停、方向、ARR/PSC 改频
* - plsr_command ：故障码 0x01~0x04 上报（PlsrCommandSetFault）
* - plsr_signal_io ：TIM3 1ms、WAIT/EXT 下降沿、ACT/WAIT 超时
*
* 关键数据流
* Start → BeginSeg → PlanSeg → DIR_WAIT → RUN（脉冲 ISR 驱动）
* 段末 → AfterSegDone → EnterPostWaitOrNext / GotoNextOrFinish / FinishAll
* 运行中 EXT/ACT → CutSegToNext / ActExpire（可能不停表衔接下一段）
*
* 状态机概要（RcState_e）
* RC_IDLE ：无段执行，可 Start
* RC_DIR_WAIT ：方向已设，等 dir_delay_ms 后开 PWM
* RC_RUN ：脉冲 ISR 推进 s_done，逐拍改频
* RC_WAIT_COND ：段后等待（时间到期或 WAIT/EXT 沿）
* 与 accel_curve 对齐的符号：
* f_tgt — 段表目标频率 Hz；s_done/s_target — 本段已发/目标脉冲数
*/
#ifndef PLSR_RUN_CONTROL_H
#define PLSR_RUN_CONTROL_H

#include <stdint.h>

/**
* @brief 运行控制模块初始化
* @note 调用时机：PlsrInit 中，PulseDriver 初始化之后
* @note 副作用：全部静态状态复位为 RC_IDLE / 非 busy
*/
void PlsrRunControlInit(void);

/**
* @brief 从指定段启动多段序列
* @param start_seg_1based 起始段号 1-based，越界则回退到参数 start_seg
* @return 1=已开段；0=忙、无段或首段频率非法
* @note 调用时机：PlsrStart 转发；启动前做 0x04 频率门禁
* @note 副作用：记录绝对坐标原点、清外部沿、进入 BeginSeg
*/
uint8_t PlsrRunControlStart(uint16_t start_seg_1based);

/**
* @brief 急停
* @note 副作用：关 PWM、清方向/链式频率/ACT/WAIT 全部标志
*/
void PlsrRunControlStop(void);

/**
* @brief 运行中重规划剩余脉冲的目标频率
* @param new_tgt_hz 新目标 Hz，[1, 100000]
* @return 1=成功；0=非 RUN、非法频率或本段已完成
* @note 副作用：remain=s_target-s_done 作为新总长，f_from=s_cur_freq 重 PlanSeg
*/
uint8_t PlsrRunControlChangeFreq(uint32_t new_tgt_hz);

/**
* @brief TIM3 1ms 回调（由 signal_io 转发）
* @note 调用时机：TIM3 UPDATE 中断，仅处理 ACT 到期置位、WAIT 时间到期置位
* @note 副作用：置 s_act_cut_pending / s_wait_expire_req，实际切段在 TickMs
*/
void PlsrRunControlOn1ms(void);

/**
* @brief 脉冲 UPDATE 中断回调
* @note 调用时机：每发一个脉冲；仅在 RC_RUN 有效
* @note 副作用：s_done++、累计坐标、逐拍 Step 改频、段末 AfterSegDone
*/
uint8_t PlsrRunControlIsBusy(void);
uint16_t PlsrRunControlGetCurSeg(void);
int32_t PlsrRunControlGetAccPulse(void);
void PlsrRunControlClearAccPulse(void);
/** @brief 上电从 BKPSRAM 恢复累计脉冲（不清绝对原点锁以外的运行态） */
void PlsrRunControlRestoreAccPulse(int32_t acc_pulse);
uint32_t PlsrRunControlGetCurFreq(void);
void PlsrRunControlTickMs(void);
/** @brief TIM5 单次延时到期（换向 / WAIT / ACT 剩余） */
void PlsrRunControlOnDelayTimer(void);
void PlsrRunControlOnPulseIsr(void);
uint8_t PlsrRunControlChangeFreq(uint32_t freq_hz);

/**
* @brief 毫秒级任务节拍（PlsrTask 中调用）
* @note 处理：ACT/WAIT 到期切段、DIR_WAIT 超时开跑、EXT 沿 CutSeg、ApplyPending
* @brief 创建任务唤醒信号量（须在 OSInit 之后、首次 Pend/Post 之前）
*/
void PlsrRunControlTickMs(void);

/** @return 1=运动中（s_busy） */
uint8_t PlsrRunControlIsBusy(void);

/** @return 累计脉冲有符号计数 */
int32_t PlsrRunControlGetAccPulse(void);

/** 清零累计脉冲与绝对原点 */
void PlsrRunControlClearAccPulse(void);
void PlsrRunControlWakeInit(void);

/**
* @return 当前段号 1-based；空闲时返回 0
* @brief PlsrTask 休眠：被 ISR Post 立刻醒，或最多等 timeout_ticks 个 OS 节拍
* @param timeout_ticks 与 OSSemPend 相同；0=一直等到 Post；常用 1
*/
uint16_t PlsrRunControlGetCurSeg(void);
void PlsrRunControlWakePend(uint16_t timeout_ticks);

/**
* @return 当前输出/profile 频率 Hz（监控 0x2002 数据源）
* @brief 是否在 TIM5 单次延时等待（换向 / WAIT 时间）
* @note 此时 WakePend(0) 只等到期 Post
*/
uint32_t PlsrRunControlGetCurFreq(void);
uint8_t PlsrRunControlIsPreciseWait(void);

#endif

+ 135
- 97
plsr/signal_io/plsr_signal_io.c Wyświetl plik

@@ -1,105 +1,104 @@
/**
* @file plsr_signal_io.c
* @brief WAIT/EXT 输入与 TIM3 1ms 时基实现
* @brief WAIT/EXT 输入 + TIM5 单次延时 + OS 节拍消抖
*
* @details 模块职责
* EXTI 下降沿 → pending → TIM3 每 ms 累加 wait_ms，满 20ms 且口线仍低 → fell。
* 触发只认「确认后的 fell」，不靠平时扫口，避免脉冲耦合尖峰误切段。
*
* 硬件
* X4=PB5 / EXTI9_5；X5=PG12 / EXTI15_10；上拉，空闲高。
* TIM3：PSC=83、ARR=999 → 约 1ms @ 84MHz APB1 定时器时钟惯例。
*
* 静态状态
* s_ms — 自由运行毫秒
* s_db_x4/x5 — 每口 pending / wait_ms / fell
* s_htim3 — 时基句柄
* @details
* EXTI 下降沿 → pending；DebouncePoll 满约 20ms 且仍低 → fell。
* TIM5（32 位，APB1 84MHz）：有延时才开表。
* PSC=8399 → 10kHz（1 次计数 = 100µs）
* ARR = delay_ms×10 − 1 → 一次溢出 = 设定的 ms（分辨率 0.1ms，够用）
*/
#include "plsr_signal_io.h"
#include "plsr_param.h"
#include "plsr_run_control.h"
#include "main.h"
#include "ucos_ii.h"

#define PLSR_X4_PORT GPIOB
#define PLSR_X4_PIN GPIO_PIN_5
#define PLSR_X5_PORT GPIOG
#define PLSR_X5_PIN GPIO_PIN_12

#define PLSR_TIM3_PSC 83U
#define PLSR_TIM3_ARR 999U
/*
* 84MHz / 8400 = 10kHz → 100µs/格。
* PSC=8399 落在 16 位内；不必用 1µs（那只是为了硬凑，ms 延时用不上）。
*/
#define PLSR_TIM5_PSC_100US 8399U
#define PLSR_TIM5_TICKS_PER_MS 10U /* 10×100µs = 1ms */
#define PLSR_DELAY_MS_MAX 65535U

#define PLSR_SIGNAL_DEBOUNCE_MS 20U

/**
* 单路输入消抖状态
* pending — EXTI 已见下降沿，等待 20ms 确认
* wait_ms — 消抖累计 ms（TIM3 递增）
* fell — 确认有效，供 Take* 读清
*/
typedef struct {
volatile uint8_t pending;
volatile uint8_t wait_ms;
volatile uint8_t stamp_ok;
volatile INT32U arm_tick;
volatile uint8_t fell;
GPIO_TypeDef *port;
uint16_t pin;
} PlsrEdge_t;

static volatile uint32_t s_ms;
static PlsrEdge_t s_db_x4;
static PlsrEdge_t s_db_x5;
static PlsrEdge_t s_db_x4; /* X4 输入消抖状态（WAIT/EXT 共用） */
static PlsrEdge_t s_db_x5; /* X5 输入消抖状态 */
static volatile uint8_t s_delay_armed; /* 1=TIM5 单次延时正在计时 */

static TIM_HandleTypeDef s_htim3;
static INT32U PlsrSignalIoMsToTicks(uint32_t ms)
{
INT32U t;

/*============================================================================*/
/* 消抖辅助 */
/*============================================================================*/
if (ms == 0U)
{
return 1U;
}
t = ((INT32U)ms * (INT32U)OS_TICKS_PER_SEC + 999U) / 1000U;
if (t < 1U)
{
t = 1U;
}
return t;
}

/** @return 1=口线当前为低（接地） */
static uint8_t PlsrSignalIoPinIsLow(const PlsrEdge_t *db)
{
return (HAL_GPIO_ReadPin(db->port, db->pin) == GPIO_PIN_RESET) ? 1U : 0U;
}

/** @brief EXTI 入口：置 pending，清消抖计时，等待 TIM3 确认 */
static void PlsrSignalIoOnFalling(PlsrEdge_t *db)
{
db->pending = 1U;
db->wait_ms = 0U;
db->stamp_ok = 0U;
}

/**
* @brief TIM3 每 ms 调用：pending 满 20ms 后读电平
* @note 仍为低才置 fell；已回高则丢弃（滤耦合尖峰）
*/
static void PlsrSignalIoDebounceConfirm(PlsrEdge_t *db)
{
INT32U need;

if (db->pending == 0U)
{
return;
}

if (db->wait_ms < 0xFFU)
if (db->stamp_ok == 0U)
{
db->wait_ms++;
db->arm_tick = OSTimeGet();
db->stamp_ok = 1U;
return;
}
if (db->wait_ms < PLSR_SIGNAL_DEBOUNCE_MS)

need = PlsrSignalIoMsToTicks(PLSR_SIGNAL_DEBOUNCE_MS);
if ((OSTimeGet() - db->arm_tick) < need)
{
return;
}

db->pending = 0U;
/* 尖峰/耦合在 20ms 后已回到高，不算触发；飞线接地保持为低才算 */
db->stamp_ok = 0U;
if (PlsrSignalIoPinIsLow(db) != 0U)
{
db->fell = 1U;
}
}

/*============================================================================*/
/* 硬件初始化 */
/*============================================================================*/

/** @brief X4/X5 下降沿 EXTI + NVIC（优先级 8） */
static void PlsrSignalIoGpioExtiInit(void)
{
GPIO_InitTypeDef gpio = {0};
@@ -117,7 +116,6 @@ static void PlsrSignalIoGpioExtiInit(void)

gpio.Pin = PLSR_X4_PIN;
HAL_GPIO_Init(PLSR_X4_PORT, &gpio);

gpio.Pin = PLSR_X5_PIN;
HAL_GPIO_Init(PLSR_X5_PORT, &gpio);

@@ -132,45 +130,44 @@ static void PlsrSignalIoGpioExtiInit(void)
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}

/** @brief TIM3 约 1ms 基时 + UPDATE 中断（优先级 9） */
static void PlsrSignalIoTim3Init(void)
static void PlsrSignalIoTim5Init(void)
{
__HAL_RCC_TIM3_CLK_ENABLE();
s_htim3.Instance = TIM3;
s_htim3.Init.Prescaler = PLSR_TIM3_PSC;
s_htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
s_htim3.Init.Period = PLSR_TIM3_ARR;
s_htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
s_htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
(void)HAL_TIM_Base_Init(&s_htim3);
HAL_NVIC_SetPriority(TIM3_IRQn, 9, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
(void)HAL_TIM_Base_Start_IT(&s_htim3);
__HAL_RCC_TIM5_CLK_ENABLE();
TIM5->CR1 = 0U;
TIM5->DIER = 0U;
TIM5->SR = 0U;
TIM5->PSC = PLSR_TIM5_PSC_100US;
TIM5->ARR = 0xFFFFFFFFUL;
TIM5->CNT = 0U;
TIM5->EGR = TIM_EGR_UG;
TIM5->SR = 0U;
HAL_NVIC_SetPriority(TIM5_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(TIM5_IRQn);
}

/** @brief 模块初始化（见 plsr_signal_io.h） */
void PlsrSignalIoInit(void)
{
s_ms = 0U;
s_delay_armed = 0U;

s_db_x4.port = PLSR_X4_PORT;
s_db_x4.pin = PLSR_X4_PIN;
s_db_x4.pending = 0U;
s_db_x4.wait_ms = 0U;
s_db_x4.stamp_ok = 0U;
s_db_x4.arm_tick = 0U;
s_db_x4.fell = 0U;

s_db_x5.port = PLSR_X5_PORT;
s_db_x5.pin = PLSR_X5_PIN;
s_db_x5.pending = 0U;
s_db_x5.wait_ms = 0U;
s_db_x5.stamp_ok = 0U;
s_db_x5.arm_tick = 0U;
s_db_x5.fell = 0U;

PlsrSignalIoGpioExtiInit();
PlsrSignalIoTim3Init();
PlsrSignalIoTim5Init();

/* 配置 EXTI 时可能打出假沿，丢掉 */
__HAL_GPIO_EXTI_CLEAR_IT(PLSR_X4_PIN);
__HAL_GPIO_EXTI_CLEAR_IT(PLSR_X5_PIN);
s_db_x4.fell = 0U;
@@ -179,55 +176,98 @@ void PlsrSignalIoInit(void)
s_db_x5.pending = 0U;
}

/*============================================================================*/
/* 时基 / 沿 API */
/*============================================================================*/
void PlsrSignalIoScheduleDelayMs(uint32_t delay_ms)
{
uint32_t ticks;

if (delay_ms < 1U)
{
delay_ms = 1U;
}
if (delay_ms > PLSR_DELAY_MS_MAX)
{
delay_ms = PLSR_DELAY_MS_MAX;
}

/* N ms → N×10 个 100µs 格 */
ticks = delay_ms * PLSR_TIM5_TICKS_PER_MS;

TIM5->CR1 = 0U;
TIM5->DIER = 0U;
TIM5->SR = 0U;
TIM5->PSC = PLSR_TIM5_PSC_100US;
TIM5->ARR = ticks - 1U;
TIM5->CR1 = TIM_CR1_URS;
TIM5->EGR = TIM_EGR_UG;
TIM5->SR = 0U;
TIM5->CNT = 0U;
TIM5->DIER = TIM_DIER_UIE;
s_delay_armed = 1U;
TIM5->CR1 = (uint32_t)(TIM_CR1_CEN | TIM_CR1_OPM | TIM_CR1_URS);
}

uint32_t PlsrSignalIoGetMs(void)
void PlsrSignalIoCancelDelay(void)
{
return s_ms;
TIM5->CR1 = 0U;
TIM5->DIER = 0U;
TIM5->SR = 0U;
s_delay_armed = 0U;
}

uint32_t PlsrSignalIoDeadlineFromNow(uint32_t ms)
uint32_t PlsrSignalIoDelayRemainMs(void)
{
if (ms == 0U)
uint32_t arr;
uint32_t cnt;
uint32_t left_ticks;

if (s_delay_armed == 0U)
{
return s_ms;
return 0U;
}
return s_ms + ms;
if ((TIM5->CR1 & TIM_CR1_CEN) == 0U)
{
return 0U;
}

arr = TIM5->ARR;
cnt = TIM5->CNT;
if (cnt >= (arr + 1U))
{
return 0U;
}
left_ticks = (arr + 1U) - cnt;
return left_ticks / PLSR_TIM5_TICKS_PER_MS;
}

uint8_t PlsrSignalIoMsReached(uint32_t deadline_ms)
void PlsrSignalIoDebouncePoll(void)
{
return ((int32_t)(s_ms - deadline_ms) >= 0) ? 1U : 0U;
PlsrSignalIoDebounceConfirm(&s_db_x4);
PlsrSignalIoDebounceConfirm(&s_db_x5);
}

void PlsrSignalIoClearEdges(void)
{
s_db_x4.fell = 0U;
s_db_x4.pending = 0U;
s_db_x4.stamp_ok = 0U;
s_db_x5.fell = 0U;
s_db_x5.pending = 0U;
s_db_x5.stamp_ok = 0U;
}

void PlsrSignalIoClearPending(void)
{
s_db_x4.pending = 0U;
s_db_x4.stamp_ok = 0U;
s_db_x5.pending = 0U;
s_db_x5.stamp_ok = 0U;
}

/** @brief sel 0=X4，非 0=X5 */
static PlsrEdge_t *PlsrSignalIoDbBySel(uint16_t sel_01)
{
return (sel_01 != 0U) ? &s_db_x5 : &s_db_x4;
}

uint8_t PlsrSignalIoWaitIsOn(void)
{
PlsrCfg_t *cfg = PlsrParamGetCfg();
return PlsrSignalIoPinIsLow(PlsrSignalIoDbBySel(cfg->wait_x_sel));
}

uint8_t PlsrSignalIoTakeWaitFalling(void)
{
PlsrCfg_t *cfg = PlsrParamGetCfg();
@@ -254,20 +294,18 @@ uint8_t PlsrSignalIoTakeExtFalling(void)
return 0U;
}

/*============================================================================*/
/* 中断入口（由 stm32f4xx_it 转发） */
/*============================================================================*/

/** @brief TIM3：清 UIF → s_ms++ → 消抖 → RunControlOn1ms */
void PlsrSignalIoOnTim3Irq(void)
void PlsrSignalIoOnTim5Irq(void)
{
if ((TIM3->SR & TIM_SR_UIF) != 0U)
if ((TIM5->SR & TIM_SR_UIF) != 0U)
{
TIM3->SR = (uint32_t)~TIM_SR_UIF;
s_ms++;
PlsrSignalIoDebounceConfirm(&s_db_x4);
PlsrSignalIoDebounceConfirm(&s_db_x5);
PlsrRunControlOn1ms();
TIM5->SR = (uint32_t)~TIM_SR_UIF;
TIM5->DIER = 0U;
TIM5->CR1 = 0U;
if (s_delay_armed != 0U)
{
s_delay_armed = 0U;
PlsrRunControlOnDelayTimer();
}
}
}



+ 20
- 63
plsr/signal_io/plsr_signal_io.h Wyświetl plik

@@ -1,93 +1,50 @@
/**
* @file plsr_signal_io.h
* @brief WAIT/EXT 外部输入与 TIM3 1ms 时基
* @brief WAIT/EXT 外部输入与 TIM5 单次延时
*
* @details 模块职责
* 1. 配置 X4=PB5、X5=PG12 为下降沿 EXTI（上拉空闲高，飞线接地出沿）；
* 2. 20ms 消抖确认后锁存 fell，供 run_control 消费；
* 3. TIM3 自由运行毫秒计数，驱动 ACT/WAIT 到期与消抖确认，并转发 On1ms。
* 2. 消抖：EXTI 置 pending，任务侧按 OS 节拍确认 20ms 仍低 → fell；
* 3. TIM5（32 位）仅在有延时时开启：100µs 时基，ARR=ms×10−1，
* 一次计满 = 设定 ms（最长 65535ms），到期 UPDATE → OnDelayTimer。
*
* 与其它模块关系
* - plsr_param ：wait_x_sel / ext_x_sel 选择 X4 或 X5
* - plsr_run_control ：TakeWait/ExtFalling、GetMs/Deadline/MsReached、On1ms
* - stm32f4xx_it ：TIM3 / EXTI9_5 / EXTI15_10 转发到本模块 On* 入口
*
* 关键约定
* ClearEdges — 清 pending+fell（开跑 EXT、Start）
* ClearPending— 只清消抖中假沿，保留已确认 fell（纯 EXT 发完后过滤耦合）
* Take* — 读清 fell，一次按压只切一次段
* - plsr_param ：wait_x_sel / ext_x_sel
* - plsr_run_control ：TakeWait/ExtFalling、ScheduleDelayMs、OnDelayTimer
* - plsr.c ：周期调用 DebouncePoll
* - stm32f4xx_it ：TIM5 / EXTI 转发
*/
#ifndef PLSR_SIGNAL_IO_H
#define PLSR_SIGNAL_IO_H

#include <stdint.h>

/**
* @brief 初始化 GPIO EXTI + TIM3 1ms
* @note 调用时机：PlsrInit；配置后清假沿
*/
void PlsrSignalIoInit(void);

/**
* @brief 读取 TIM3 毫秒计数（自由运行，约 1ms/格）
* @return 自 Init 起累加的 ms；可能无符号环绕
* @brief 武装 TIM5 单次延时（ms），到期进 OnDelayTimer
* @param delay_ms 0 按 1ms；上限 65535ms
*/
uint32_t PlsrSignalIoGetMs(void);
void PlsrSignalIoScheduleDelayMs(uint32_t delay_ms);

/**
* @brief 从当前 ms 起算 deadline
* @param ms 延时；0 表示立即到期（deadline=当前）
*/
uint32_t PlsrSignalIoDeadlineFromNow(uint32_t ms);
void PlsrSignalIoCancelDelay(void);

/**
* @brief 判断是否已到或过期
* @return 1=已到（含无符号环绕比较）；0=未到
* @brief 读 TIM5 单次延时剩余 ms（未武装或已停表返回 0；向下取整）
*/
uint8_t PlsrSignalIoMsReached(uint32_t deadline_ms);
uint32_t PlsrSignalIoDelayRemainMs(void);

/**
* @brief 清 WAIT/EXT 下降沿锁存（含已确认 fell 与 pending）
* @note Start / EXT 开跑时调用，避免旧沿立刻切段
*/
void PlsrSignalIoClearEdges(void);
void PlsrSignalIoDebouncePoll(void);

/**
* @brief 只清消抖 pending，保留已确认 fell
* @note 纯 EXT 脉冲发完后过滤 Y 口耦合假沿，同时保留真沿供 TakeExt
*/
void PlsrSignalIoClearEdges(void);
void PlsrSignalIoClearPending(void);

/**
* @brief WAIT 口当前是否为低（已接地）
* @note 仅段末判断等场景读一次；不作周期轮询触发（触发只认 EXTI+消抖）
*/
uint8_t PlsrSignalIoWaitIsOn(void);

/**
* @brief 消耗一次已确认的 WAIT 口下降沿
* @return 1=有沿并已清；0=无
* @note ※2 段中接地保持 → 发完立刻下一段；※3 未触发则 RC_WAIT_COND 一直等
*/
uint8_t PlsrSignalIoTakeWaitFalling(void);

/**
* @brief 消耗一次已确认的 EXT 口下降沿
* @return 1=有沿并已清；0=无
* @note 运行中 EXT / EXT_OR_DONE 切段；一次按压只切一次
*/
uint8_t PlsrSignalIoTakeExtFalling(void);

/**
* @brief TIM3 UPDATE 中断入口
* @note s_ms++、消抖确认、转发 PlsrRunControlOn1ms
*/
void PlsrSignalIoOnTim3Irq(void);

/** @brief EXTI9_5：处理 X4=PB5 下降沿 → 置 pending */
void PlsrSignalIoOnExti9_5(void);
/** @brief TIM5 UPDATE：单次延时到期 */
void PlsrSignalIoOnTim5Irq(void);

/** @brief EXTI15_10：处理 X5=PG12 下降沿 → 置 pending */
void PlsrSignalIoOnExti15_10(void);
void PlsrSignalIoOnExti9_5(void);
void PlsrSignalIoOnExti15_10(void);

#endif

Napisz Podgląd
Ładowanie…
Anuluj
Zapisz