yuwenhao
/
Modbus-rtu
1
0
複製 0
程式碼 問題 0 合併請求 0 版本發佈 0 Wiki 活動
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
37 提交
3 分支
138 MiB
 
 
 
 
 
 
目錄樹: 0b7990bc99
分支列表 標籤
${ item.name }
建立分支 ${ searchTerm }
從 '0b7990bc99'
${ noResults }
Modbus-rtu/PLSR/Src/plsr_path.c

457 line
15 KiB
原始文件 Blame 歷史記錄 

  1. #include "plsr_path.h"

  2. #include <string.h>

  3. 

  4. /* 等待寄存器类型编码（PLSR_VALUE_SOURCE）与软元件类型（PLSR_DEVICE_TYPE）

  5.  * 相差 1：D=1→D、HD=2→HD、FD=3→FD、X=4→X、M=5→M、HM=6→HM。 */

  6. static uint8_t PlsrPathDeviceFromSource(uint8_t sourceCode)

  7. {

  8.     return (uint8_t)(sourceCode - 1U);

  9. }

  10. 

  11. static uint8_t PlsrPathReadDword(const PLSR_DATA_SOURCE *source,

  12.                                  PLSR_DEVICE_TYPE device,

  13.                                  uint32_t address,

  14.                                  int32_t *value)

  15. {

  16.     uint16_t lowWord;

  17.     uint16_t highWord;

  18. 

  19.     if ((source->readWord == NULL)

  20.         || (source->readWord(source->context,

  21.                              device,

  22.                              address,

  23.                              &lowWord) == 0U)

  24.         || (source->readWord(source->context,

  25.                              device,

  26.                              address + 1U,

  27.                              &highWord) == 0U))

  28.     {

  29.         return 0U;

  30.     }

  31.     *value = (int32_t)(((uint32_t)highWord << 16U) | (uint32_t)lowWord);

  32.     return 1U;

  33. }

  34. 

  35. static uint8_t PlsrPathReadBit(const PLSR_DATA_SOURCE *source,

  36.                                PLSR_DEVICE_TYPE device,

  37.                                uint32_t address,

  38.                                uint8_t *value)

  39. {

  40.     if ((source->readBit == NULL)

  41.         || (source->readBit(source->context, device, address, value) == 0U))

  42.     {

  43.         return 0U;

  44.     }

  45.     return 1U;

  46. }

  47. 

  48. /* 求值当前段的跳转目标。

  49.  * 返回：0=顺序下一段，1~segmentCount=指定段。

  50.  * 动态来源在跳转发生时重新读取；非法值置 error。 */

  51. static int32_t PlsrPathResolveJumpTarget(const PLSR_JOB_SNAPSHOT *job,

  52.                                          uint16_t segment,

  53.                                          uint8_t *error)

  54. {

  55.     const PLSR_SEGMENT_SNAPSHOT *segmentSnapshot =

  56.         &job->segments[segment - 1U];

  57.     int32_t target;

  58. 

  59.     *error = 0U;

  60.     if (segmentSnapshot->jumpSource == PLSR_VALUE_CONSTANT)

  61.     {

  62.         target = segmentSnapshot->jumpValueOrAddress;

  63.     }

  64.     else

  65.     {

  66.         if (PlsrPathReadDword(&job->source,

  67.                               (PLSR_DEVICE_TYPE)PlsrPathDeviceFromSource(

  68.                                   segmentSnapshot->jumpSource),

  69.                               (uint32_t)segmentSnapshot->jumpValueOrAddress,

  70.                               &target) == 0U)

  71.         {

  72.             *error = 1U;

  73.             return 0;

  74.         }

  75.     }

  76.     if ((target < 0) || (target > (int32_t)job->segmentCount))

  77.     {

  78.         *error = 1U;

  79.         return 0;

  80.     }

  81.     return target;

  82. }

  83. 

  84. /* 段是否零脉冲：相对模式脉冲数为 0，或绝对模式目标等于进入段时的位置。 */

  85. static uint8_t PlsrPathSegmentIsZeroPulse(const PLSR_JOB_SNAPSHOT *job,

  86.                                           uint16_t segment,

  87.                                           int64_t logicalPosition)

  88. {

  89.     const PLSR_SEGMENT_SNAPSHOT *segmentSnapshot =

  90.         &job->segments[segment - 1U];

  91. 

  92.     if ((segmentSnapshot->flags & PLSR_SEGMENT_FLAG_ZERO_PULSE) != 0U)

  93.     {

  94.         return 1U;

  95.     }

  96.     if ((job->positioningMode == 1U)

  97.         && (segmentSnapshot->pulseOrTarget == (int32_t)logicalPosition))

  98.     {

  99.         return 1U;

  100.     }

  101.     return 0U;

  102. }

  103. 

  104. /* 进入新段时的初始化：求值 ACT 时间、EXT/等待信号地址与当前电平。 */

  105. static void PlsrPathEnterSegment(PLSR_PATH_CONTEXT *context,

  106.                                  const PLSR_JOB_SNAPSHOT *job)

  107. {

  108.     const PLSR_SEGMENT_SNAPSHOT *segmentSnapshot =

  109.         &job->segments[context->currentSegment - 1U];

  110.     int32_t actValue;

  111. 

  112.     context->segmentEnded = 0U;

  113.     context->extActive = 0U;

  114.     context->actActive = 0U;

  115.     context->waitCondition = (uint8_t)segmentSnapshot->waitCondition;

  116. 

  117.     switch (context->waitCondition)

  118.     {

  119.         case PLSR_WAIT_ACT_TIME:

  120.             context->actActive = 1U;

  121.             if (segmentSnapshot->waitSource == PLSR_VALUE_CONSTANT)

  122.             {

  123.                 actValue = segmentSnapshot->waitValueOrAddress;

  124.             }

  125.             else

  126.             {

  127.                 actValue = 0;

  128.                 (void)PlsrPathReadDword(&job->source,

  129.                                         (PLSR_DEVICE_TYPE)

  130.                                             PlsrPathDeviceFromSource(

  131.                                                 segmentSnapshot->waitSource),

  132.                                         (uint32_t)

  133.                                             segmentSnapshot->waitValueOrAddress,

  134.                                         &actValue);

  135.             }

  136.             context->waitRemainingMs =

  137.                 (actValue > 0) ? (uint32_t)actValue : 0U;

  138.             break;

  139. 

  140.         case PLSR_WAIT_SIGNAL:

  141.         case PLSR_WAIT_EXT:

  142.         case PLSR_WAIT_EXT_OR_COMPLETE:

  143.             context->waitSignalDevice =

  144.                 PlsrPathDeviceFromSource(segmentSnapshot->waitSource);

  145.             context->waitSignalAddress =

  146.                 (uint32_t)segmentSnapshot->waitValueOrAddress;

  147.             if (context->waitCondition != PLSR_WAIT_SIGNAL)

  148.             {

  149.                 /* EXT：记录段开始时的电平，已有的有效电平不算新边沿。 */

  150.                 uint8_t level = 0U;

  151. 

  152.                 (void)PlsrPathReadBit(&job->source,

  153.                                       (PLSR_DEVICE_TYPE)

  154.                                           context->waitSignalDevice,

  155.                                       context->waitSignalAddress,

  156.                                       &level);

  157.                 context->lastExtLevel = level;

  158.                 context->extActive = 1U;

  159.             }

  160.             break;

  161. 

  162.         default:

  163.             break;

  164.     }

  165. }

  166. 

  167. /* EXT 边沿检测：电平 0→1 才算新边沿。 */

  168. static uint8_t PlsrPathPollExt(PLSR_PATH_CONTEXT *context,

  169.                                const PLSR_JOB_SNAPSHOT *job)

  170. {

  171.     uint8_t level = 0U;

  172.     uint8_t triggered = 0U;

  173. 

  174.     if (PlsrPathReadBit(&job->source,

  175.                         (PLSR_DEVICE_TYPE)context->waitSignalDevice,

  176.                         context->waitSignalAddress,

  177.                         &level) != 0U)

  178.     {

  179.         if ((level != 0U) && (context->lastExtLevel == 0U))

  180.         {

  181.             triggered = 1U;

  182.         }

  183.         context->lastExtLevel = level;

  184.     }

  185.     return triggered;

  186. }

  187. 

  188. /* 推进跳转链：零脉冲段连续跳转（预算内），直到有脉冲段、结束或预算耗尽。 */

  189. static PLSR_PATH_ACTION PlsrPathAdvance(PLSR_PATH_CONTEXT *context,

  190.                                         const PLSR_JOB_SNAPSHOT *job,

  191.                                         int64_t logicalPosition)

  192. {

  193.     uint8_t error;

  194.     int32_t target;

  195.     uint16_t next;

  196. 

  197.     while (context->zeroJumpBudget > 0U)

  198.     {

  199.         target = PlsrPathResolveJumpTarget(job,

  200.                                            context->currentSegment,

  201.                                            &error);

  202.         if (error != 0U)

  203.         {

  204.             context->jobEnded = 1U;

  205.             context->phase = PLSR_PATH_ENDED;

  206.             return PLSR_PATH_ACTION_ERROR;

  207.         }

  208.         if (target == 0)

  209.         {

  210.             if (context->currentSegment >= job->segmentCount)

  211.             {

  212.                 context->jobEnded = 1U;

  213.                 context->phase = PLSR_PATH_ENDED;

  214.                 return PLSR_PATH_ACTION_JOB_COMPLETE;

  215.             }

  216.             next = (uint16_t)(context->currentSegment + 1U);

  217.         }

  218.         else

  219.         {

  220.             next = (uint16_t)target;

  221.         }

  222. 

  223.         if (PlsrPathSegmentIsZeroPulse(job, next, logicalPosition) != 0U)

  224.         {

  225.             context->zeroJumpBudget--;

  226.             context->currentSegment = next;

  227.             context->nextSegment = next;

  228.             PlsrPathEnterSegment(context, job);

  229.             continue;

  230.         }

  231. 

  232.         context->currentSegment = next;

  233.         context->nextSegment = next;

  234.         context->phase = PLSR_PATH_SEGMENT_RUNNING;

  235.         PlsrPathEnterSegment(context, job);

  236.         return PLSR_PATH_ACTION_NEXT_SEGMENT;

  237.     }

  238. 

  239.     context->jumpChainPending = 1U;

  240.     return PLSR_PATH_ACTION_YIELD;

  241. }

  242. 

  243. void PlsrPathBegin(PLSR_PATH_CONTEXT *context,

  244.                    const PLSR_JOB_SNAPSHOT *job,

  245.                    int64_t logicalPosition)

  246. {

  247.     (void)memset(context, 0, sizeof(*context));

  248.     context->currentSegment = job->startSegment;

  249.     context->nextSegment = context->currentSegment;

  250.     context->zeroJumpBudget = PLSR_PATH_ZERO_JUMP_BUDGET;

  251.     context->phase = PLSR_PATH_SEGMENT_RUNNING;

  252.     PlsrPathEnterSegment(context, job);

  253.     if (PlsrPathSegmentIsZeroPulse(job,

  254.                                    context->currentSegment,

  255.                                    logicalPosition) != 0U)

  256.     {

  257.         /* 起点段就是零脉冲：直接走跳转链。 */

  258.         (void)PlsrPathAdvance(context, job, logicalPosition);

  259.     }

  260. }

  261. 

  262. PLSR_PATH_ACTION PlsrPathOnSegmentDone(PLSR_PATH_CONTEXT *context,

  263.                                        const PLSR_JOB_SNAPSHOT *job,

  264.                                        int64_t logicalPosition)

  265. {

  266.     const PLSR_SEGMENT_SNAPSHOT *segmentSnapshot;

  267.     int32_t waitValue;

  268.     uint8_t level;

  269. 

  270.     if ((context->jobEnded != 0U) || (context->phase == PLSR_PATH_ENDED))

  271.     {

  272.         return PLSR_PATH_ACTION_NONE;

  273.     }

  274.     context->segmentEnded = 1U;

  275.     context->zeroJumpBudget = PLSR_PATH_ZERO_JUMP_BUDGET;

  276.     context->jumpChainPending = 0U;

  277.     segmentSnapshot = &job->segments[context->currentSegment - 1U];

  278. 

  279.     switch (context->waitCondition)

  280.     {

  281.         case PLSR_WAIT_PULSE_COMPLETE:

  282.         case PLSR_WAIT_EXT_OR_COMPLETE:

  283.             return PlsrPathAdvance(context, job, logicalPosition);

  284. 

  285.         case PLSR_WAIT_TIME:

  286.             /* 等待时间在段完成时求值一次。 */

  287.             if (segmentSnapshot->waitSource == PLSR_VALUE_CONSTANT)

  288.             {

  289.                 waitValue = segmentSnapshot->waitValueOrAddress;

  290.             }

  291.             else

  292.             {

  293.                 waitValue = 0;

  294.                 (void)PlsrPathReadDword(

  295.                     &job->source,

  296.                     (PLSR_DEVICE_TYPE)PlsrPathDeviceFromSource(

  297.                         segmentSnapshot->waitSource),

  298.                     (uint32_t)segmentSnapshot->waitValueOrAddress,

  299.                     &waitValue);

  300.             }

  301.             context->waitRemainingMs =

  302.                 (waitValue > 0) ? (uint32_t)waitValue : 0U;

  303.             if (context->waitRemainingMs == 0U)

  304.             {

  305.                 return PlsrPathAdvance(context, job, logicalPosition);

  306.             }

  307.             context->phase = PLSR_PATH_WAIT_TIME;

  308.             return PLSR_PATH_ACTION_ENTER_WAIT;

  309. 

  310.         case PLSR_WAIT_SIGNAL:

  311.             /* 信号地址已在进入段时求值；先立即检查一次，已有效则直接跳。 */

  312.             if (PlsrPathReadBit(&job->source,

  313.                                 (PLSR_DEVICE_TYPE)context->waitSignalDevice,

  314.                                 context->waitSignalAddress,

  315.                                 &level) != 0U)

  316.             {

  317.                 if (level != 0U)

  318.                 {

  319.                     return PlsrPathAdvance(context, job, logicalPosition);

  320.                 }

  321.             }

  322.             context->phase = PLSR_PATH_WAIT_SIGNAL;

  323.             return PLSR_PATH_ACTION_ENTER_WAIT;

  324. 

  325.         case PLSR_WAIT_ACT_TIME:

  326.             if (context->waitRemainingMs == 0U)

  327.             {

  328.                 return PlsrPathAdvance(context, job, logicalPosition);

  329.             }

  330.             /* 段已完成但 ACT 未到：停在 ACT_PENDING（core 处于 WAIT）。 */

  331.             context->phase = PLSR_PATH_ACT_PENDING;

  332.             return PLSR_PATH_ACTION_ENTER_WAIT;

  333. 

  334.         case PLSR_WAIT_EXT:

  335.             /* 段已完成但 EXT 未触发：继续等新边沿。 */

  336.             context->phase = PLSR_PATH_WAIT_SIGNAL;

  337.             return PLSR_PATH_ACTION_ENTER_WAIT;

  338. 

  339.         default:

  340.             return PlsrPathAdvance(context, job, logicalPosition);

  341.     }

  342. }

  343. 

  344. PLSR_PATH_ACTION PlsrPathTick(PLSR_PATH_CONTEXT *context,

  345.                               const PLSR_JOB_SNAPSHOT *job,

  346.                               int64_t logicalPosition)

  347. {

  348.     uint8_t level;

  349. 

  350.     if ((context->jobEnded != 0U) || (context->phase == PLSR_PATH_ENDED))

  351.     {

  352.         return PLSR_PATH_ACTION_NONE;

  353.     }

  354. 

  355.     if (context->jumpChainPending != 0U)

  356.     {

  357.         /* 上轮预算耗尽让出：本轮重置预算继续跳转链。 */

  358.         context->zeroJumpBudget = PLSR_PATH_ZERO_JUMP_BUDGET;

  359.         context->jumpChainPending = 0U;

  360.         return PlsrPathAdvance(context, job, logicalPosition);

  361.     }

  362. 

  363.     switch (context->phase)

  364.     {

  365.         case PLSR_PATH_SEGMENT_RUNNING:

  366.             if ((context->actActive != 0U)

  367.                 && (context->waitRemainingMs > 0U))

  368.             {

  369.                 context->waitRemainingMs--;

  370.                 if (context->waitRemainingMs == 0U)

  371.                 {

  372.                     /* ACT 到时：截断当前段，立即跳转。 */

  373.                     return PlsrPathAdvance(context, job, logicalPosition);

  374.                 }

  375.             }

  376.             if ((context->extActive != 0U)

  377.                 && (PlsrPathPollExt(context, job) != 0U))

  378.             {

  379.                 return PlsrPathAdvance(context, job, logicalPosition);

  380.             }

  381.             break;

  382. 

  383.         case PLSR_PATH_WAIT_TIME:

  384.             if (context->waitRemainingMs > 0U)

  385.             {

  386.                 context->waitRemainingMs--;

  387.             }

  388.             if (context->waitRemainingMs == 0U)

  389.             {

  390.                 return PlsrPathAdvance(context, job, logicalPosition);

  391.             }

  392.             break;

  393. 

  394.         case PLSR_PATH_WAIT_SIGNAL:

  395.             if (context->waitCondition == PLSR_WAIT_SIGNAL)

  396.             {

  397.                 /* H02：电平有效即触发。 */

  398.                 if (PlsrPathReadBit(&job->source,

  399.                                     (PLSR_DEVICE_TYPE)

  400.                                         context->waitSignalDevice,

  401.                                     context->waitSignalAddress,

  402.                                     &level) != 0U)

  403.                 {

  404.                     if (level != 0U)

  405.                     {

  406.                         return PlsrPathAdvance(context, job, logicalPosition);

  407.                     }

  408.                 }

  409.             }

  410.             else

  411.             {

  412.                 /* H04 段完成后的 EXT 等待：新边沿触发。 */

  413.                 if (PlsrPathPollExt(context, job) != 0U)

  414.                 {

  415.                     return PlsrPathAdvance(context, job, logicalPosition);

  416.                 }

  417.             }

  418.             break;

  419. 

  420.         case PLSR_PATH_ACT_PENDING:

  421.             if (context->waitRemainingMs > 0U)

  422.             {

  423.                 context->waitRemainingMs--;

  424.             }

  425.             if (context->waitRemainingMs == 0U)

  426.             {

  427.                 return PlsrPathAdvance(context, job, logicalPosition);

  428.             }

  429.             break;

  430. 

  431.         default:

  432.             break;

  433.     }

  434.     return PLSR_PATH_ACTION_NONE;

  435. }

  436. 

  437. uint16_t PlsrPathGetCurrentSegment(const PLSR_PATH_CONTEXT *context)

  438. {

  439.     if (context == NULL)

  440.     {

  441.         return 0U;

  442.     }

  443.     return context->currentSegment;

  444. }

  445. 

  446. void PlsrPathTerminate(PLSR_PATH_CONTEXT *context)

  447. {

  448.     if (context == NULL)

  449.     {

  450.         return;

  451.     }

  452.     context->phase = PLSR_PATH_ENDED;

  453.     context->jobEnded = 1U;

  454.     context->jumpChainPending = 0U;

  455.     context->zeroJumpBudget = 0U;

  456. }