yuwenhao
/
Modbus-rtu
1
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
39 Commits
3 Branches
138 MiB
 
 
 
 
 
 
Struktur: c776438bcd
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „c776438bcd“
${ noResults }
Modbus-rtu/PLSR/Src/plc_device.c

760 Zeilen
20 KiB
Originalformat Blame Verlauf 

  1. #include "plc_device.h"

  2. #include <string.h>

  3. 

  4. #ifndef PLSR_HOST_TEST

  5. #include "stm32f4xx.h"

  6. #endif

  7. 

  8. #define PLC_SM_PULSE_ACTIVE_MASK       (0x01U)

  9. #define PLC_SM_DIRECTION_MASK          (0x02U)

  10. 

  11. const PLSR_AXIS_ADDRESS_MAP PlsrAxisAddressMap[PLSR_AXIS_COUNT] =

  12. {

  13.     {0U, 1000U, 1001U, 1000U, 6000U},

  14.     {4U, 1020U, 1021U, 1020U, 6100U},

  15.     {8U, 1040U, 1041U, 1040U, 6200U},

  16.     {12U, 1060U, 1061U, 1060U, 6300U}

  17. };

  18. 

  19. static PLSR_HSD_DATA PlcHsdData;

  20. static PLSR_SFD_DATA PlcSfdData;

  21. static int32_t PlcSdRuntime[PLSR_AXIS_COUNT][PLSR_SD_AXIS_ITEM_COUNT];

  22. static uint8_t PlcSmFlags[PLSR_AXIS_COUNT];

  23. static PLC_DEVICE_EVENT_RECORD

  24.     PlcEventRecords[PLSR_AXIS_COUNT][PLSR_EVENT_AXIS_ITEM_COUNT];

  25. static uint8_t PlcHsdDirty;

  26. static uint8_t PlcSfdDirty;

  27. static uint8_t PlcSfdOperationActive;

  28. static uint32_t PlcHsdChangeCounter;

  29. static PLSR_PERSISTENCE_RESULT PlcLastHsdLoadResult;

  30. static PLSR_PERSISTENCE_RESULT PlcLastSfdLoadResult;

  31. static uint8_t PlcRestoredHsdPositionValid;

  32. static uint8_t PlcRestoredHsdLastBusy;

  33. 

  34. static uint32_t PlcDeviceEnterCritical(void)

  35. {

  36. #ifdef PLSR_HOST_TEST

  37.     return 0UL;

  38. #else

  39.     uint32_t interruptState = __get_PRIMASK();

  40.     __disable_irq();

  41.     __DMB();

  42.     return interruptState;

  43. #endif

  44. }

  45. 

  46. static void PlcDeviceExitCritical(uint32_t interruptState)

  47. {

  48. #ifdef PLSR_HOST_TEST

  49.     (void)interruptState;

  50. #else

  51.     __DMB();

  52.     if (interruptState == 0UL)

  53.     {

  54.         __enable_irq();

  55.     }

  56. #endif

  57. }

  58. 

  59. static uint8_t PlcDeviceBeginSfdOperation(void)

  60. {

  61.     uint8_t axis;

  62.     uint8_t busy;

  63.     uint32_t interruptState;

  64. 

  65. #ifndef PLSR_HOST_TEST

  66.     if (__get_IPSR() != 0UL)

  67.     {

  68.         return 0U;

  69.     }

  70. #endif

  71. 

  72.     interruptState = PlcDeviceEnterCritical();

  73.     busy = PlcSfdOperationActive;

  74.     for (axis = 0U; axis < PLSR_AXIS_COUNT; axis++)

  75.     {

  76.         if ((PlcSmFlags[axis] & PLC_SM_PULSE_ACTIVE_MASK) != 0U)

  77.         {

  78.             busy = 1U;

  79.         }

  80.     }

  81.     if (busy == 0U)

  82.     {

  83.         PlcSfdOperationActive = 1U;

  84.     }

  85.     PlcDeviceExitCritical(interruptState);

  86.     return (busy == 0U) ? 1U : 0U;

  87. }

  88. 

  89. static void PlcDeviceEndSfdOperation(void)

  90. {

  91.     uint32_t interruptState = PlcDeviceEnterCritical();

  92. 

  93.     PlcSfdOperationActive = 0U;

  94.     PlcDeviceExitCritical(interruptState);

  95. }

  96. 

  97. static uint16_t *PlcDeviceResolveHsd(uint16_t address)

  98. {

  99.     if (address < PLSR_HSD_RUNTIME_START + PLSR_HSD_RUNTIME_COUNT)

  100.     {

  101.         return &PlcHsdData.runtime[address - PLSR_HSD_RUNTIME_START];

  102.     }

  103.     if ((address >= PLSR_HSD_CONFIG_START)

  104.         && (address < PLSR_HSD_CONFIG_START + PLSR_HSD_CONFIG_COUNT))

  105.     {

  106.         return &PlcHsdData.config[address - PLSR_HSD_CONFIG_START];

  107.     }

  108. 

  109.     return NULL;

  110. }

  111. 

  112. static int32_t *PlcDeviceResolveSd(uint16_t address,

  113.                                   uint8_t *axis,

  114.                                   uint8_t *item)

  115. {

  116.     uint8_t axisIndex;

  117.     uint16_t base;

  118. 

  119.     for (axisIndex = 0U; axisIndex < PLSR_AXIS_COUNT; axisIndex++)

  120.     {

  121.         base = PlsrAxisAddressMap[axisIndex].sdRuntimeBase;

  122.         if ((address >= base)

  123.             && (address < base + PLSR_SD_AXIS_ITEM_COUNT))

  124.         {

  125.             if (axis != NULL)

  126.             {

  127.                 *axis = axisIndex;

  128.             }

  129.             if (item != NULL)

  130.             {

  131.                 *item = (uint8_t)(address - base);

  132.             }

  133.             return &PlcSdRuntime[axisIndex][address - base];

  134.         }

  135.     }

  136. 

  137.     return NULL;

  138. }

  139. 

  140. static PLC_DEVICE_RESULT PlcDeviceResolveSm(uint16_t address,

  141.                                            uint8_t *axis,

  142.                                            uint8_t *mask)

  143. {

  144.     uint8_t axisIndex;

  145. 

  146.     if ((axis == NULL) || (mask == NULL))

  147.     {

  148.         return PLC_DEVICE_NULL_POINTER;

  149.     }

  150. 

  151.     for (axisIndex = 0U; axisIndex < PLSR_AXIS_COUNT; axisIndex++)

  152.     {

  153.         if (address == PlsrAxisAddressMap[axisIndex].smPulseActiveAddress)

  154.         {

  155.             *axis = axisIndex;

  156.             *mask = PLC_SM_PULSE_ACTIVE_MASK;

  157.             return PLC_DEVICE_OK;

  158.         }

  159.         if (address == PlsrAxisAddressMap[axisIndex].smDirectionAddress)

  160.         {

  161.             *axis = axisIndex;

  162.             *mask = PLC_SM_DIRECTION_MASK;

  163.             return PLC_DEVICE_OK;

  164.         }

  165.     }

  166. 

  167.     return PLC_DEVICE_INVALID_ADDRESS;

  168. }

  169. 

  170. static PLC_DEVICE_EVENT_RECORD *PlcDeviceResolveEvent(uint16_t address)

  171. {

  172.     uint8_t axis;

  173.     uint16_t base;

  174. 

  175.     for (axis = 0U; axis < PLSR_AXIS_COUNT; axis++)

  176.     {

  177.         base = PlsrAxisAddressMap[axis].eventBase;

  178.         if ((address >= base)

  179.             && (address < base + PLSR_EVENT_AXIS_ITEM_COUNT))

  180.         {

  181.             return &PlcEventRecords[axis][address - base];

  182.         }

  183.     }

  184.     return NULL;

  185. }

  186. 

  187. PLC_DEVICE_RESULT PlcDeviceInit(void)

  188. {

  189.     (void)memset(&PlcHsdData, 0, sizeof(PlcHsdData));

  190.     (void)memset(&PlcSfdData, 0, sizeof(PlcSfdData));

  191.     (void)memset(PlcSdRuntime, 0, sizeof(PlcSdRuntime));

  192.     (void)memset(PlcSmFlags, 0, sizeof(PlcSmFlags));

  193.     (void)memset(PlcEventRecords, 0, sizeof(PlcEventRecords));

  194.     PlcSfdOperationActive = 0U;

  195.     PlcHsdChangeCounter = 0UL;

  196.     PlcRestoredHsdPositionValid = 0U;

  197.     PlcRestoredHsdLastBusy = 0U;

  198. 

  199.     PlcLastHsdLoadResult = PlsrPersistenceLoadHsd(&PlcHsdData);

  200.     PlcHsdDirty = (PlcLastHsdLoadResult == PLSR_PERSISTENCE_DEFAULTED)

  201.                       ? 1U

  202.                       : 0U;

  203.     if ((PlcLastHsdLoadResult != PLSR_PERSISTENCE_OK)

  204.         && (PlcLastHsdLoadResult != PLSR_PERSISTENCE_DEFAULTED))

  205.     {

  206.         return PLC_DEVICE_PERSISTENCE_ERROR;

  207.     }

  208.     PlcRestoredHsdPositionValid =

  209.         ((PlcHsdData.metadata & PLSR_HSD_META_POSITION_VALID) != 0UL)

  210.             ? 1U

  211.             : 0U;

  212.     PlcRestoredHsdLastBusy =

  213.         ((PlcHsdData.metadata & PLSR_HSD_META_LAST_BUSY) != 0UL) ? 1U : 0U;

  214. 

  215.     PlcLastSfdLoadResult = PlsrPersistenceLoadSfd(&PlcSfdData);

  216.     PlcSfdDirty = (PlcLastSfdLoadResult == PLSR_PERSISTENCE_OK) ? 0U : 1U;

  217.     if ((PlcLastSfdLoadResult != PLSR_PERSISTENCE_OK)

  218.         && (PlcLastSfdLoadResult != PLSR_PERSISTENCE_DEFAULTED))

  219.     {

  220.         return PLC_DEVICE_PERSISTENCE_ERROR;

  221.     }

  222. 

  223.     return PLC_DEVICE_OK;

  224. }

  225. 

  226. PLC_DEVICE_RESULT PlcDeviceReadHsd(uint16_t address, uint16_t *value)

  227. {

  228.     uint16_t *source;

  229. 

  230.     if (value == NULL)

  231.     {

  232.         return PLC_DEVICE_NULL_POINTER;

  233.     }

  234.     source = PlcDeviceResolveHsd(address);

  235.     if (source == NULL)

  236.     {

  237.         return PLC_DEVICE_INVALID_ADDRESS;

  238.     }

  239. 

  240.     *value = *source;

  241.     return PLC_DEVICE_OK;

  242. }

  243. 

  244. PLC_DEVICE_RESULT PlcDeviceWriteHsdConfig(uint16_t address, uint16_t value)

  245. {

  246.     if ((address < PLSR_HSD_CONFIG_START)

  247.         || (address >= PLSR_HSD_CONFIG_START + PLSR_HSD_CONFIG_COUNT))

  248.     {

  249.         return (address < PLSR_HSD_RUNTIME_START

  250.                             + PLSR_HSD_RUNTIME_COUNT)

  251.                    ? PLC_DEVICE_READ_ONLY

  252.                    : PLC_DEVICE_INVALID_ADDRESS;

  253.     }

  254. 

  255.     PlcHsdData.config[address - PLSR_HSD_CONFIG_START] = value;

  256.     PlcHsdChangeCounter++;

  257.     PlcHsdDirty = 1U;

  258.     return PLC_DEVICE_OK;

  259. }

  260. 

  261. PLC_DEVICE_RESULT PlcDevicePublishHsdRuntime(uint16_t address, uint16_t value)

  262. {

  263.     if (address >= PLSR_HSD_RUNTIME_START + PLSR_HSD_RUNTIME_COUNT)

  264.     {

  265.         return PLC_DEVICE_INVALID_ADDRESS;

  266.     }

  267. 

  268.     PlcHsdData.runtime[address - PLSR_HSD_RUNTIME_START] = value;

  269.     PlcHsdChangeCounter++;

  270.     PlcHsdDirty = 1U;

  271.     return PLC_DEVICE_OK;

  272. }

  273. 

  274. /* 两个相邻 WORD 组成一个 32 位值：低地址=低16位，高地址=高16位（信捷兼容布局）。 */

  275. PLC_DEVICE_RESULT PlcDeviceReadHsdDword(uint16_t lowAddress, int32_t *value)

  276. {

  277.     uint32_t combined;

  278.     uint32_t interruptState;

  279.     uint16_t offset;

  280. 

  281.     if (value == NULL)

  282.     {

  283.         return PLC_DEVICE_NULL_POINTER;

  284.     }

  285.     if ((lowAddress >= PLSR_HSD_RUNTIME_COUNT)

  286.         || ((lowAddress & 1U) != 0U)

  287.         || ((uint16_t)(lowAddress + 1U) >= PLSR_HSD_RUNTIME_COUNT))

  288.     {

  289.         return PLC_DEVICE_INVALID_ADDRESS;

  290.     }

  291. 

  292.     offset = (uint16_t)(lowAddress - PLSR_HSD_RUNTIME_START);

  293.     interruptState = PlcDeviceEnterCritical();

  294.     combined = (uint32_t)PlcHsdData.runtime[offset];

  295.     combined |= ((uint32_t)PlcHsdData.runtime[offset + 1U]) << 16U;

  296.     PlcDeviceExitCritical(interruptState);

  297.     *value = (int32_t)combined;

  298.     return PLC_DEVICE_OK;

  299. }

  300. 

  301. PLC_DEVICE_RESULT PlcDevicePublishHsdDword(uint16_t lowAddress, int32_t value)

  302. {

  303.     uint32_t rawValue;

  304.     uint32_t interruptState;

  305.     uint16_t offset;

  306. 

  307.     if ((lowAddress >= PLSR_HSD_RUNTIME_COUNT)

  308.         || ((lowAddress & 1U) != 0U)

  309.         || ((uint16_t)(lowAddress + 1U) >= PLSR_HSD_RUNTIME_COUNT))

  310.     {

  311.         return PLC_DEVICE_INVALID_ADDRESS;

  312.     }

  313. 

  314.     rawValue = (uint32_t)value;

  315.     offset = (uint16_t)(lowAddress - PLSR_HSD_RUNTIME_START);

  316.     interruptState = PlcDeviceEnterCritical();

  317.     PlcHsdData.runtime[offset] = (uint16_t)(rawValue & 0xFFFFUL);

  318.     PlcHsdData.runtime[offset + 1U] = (uint16_t)(rawValue >> 16U);

  319.     PlcHsdChangeCounter++;

  320.     PlcHsdDirty = 1U;

  321.     PlcDeviceExitCritical(interruptState);

  322.     return PLC_DEVICE_OK;

  323. }

  324. 

  325. PLC_DEVICE_RESULT PlcDeviceSetHsdCheckpointMeta(uint8_t positionValid,

  326.                                                uint8_t lastBusy)

  327. {

  328.     uint32_t interruptState = PlcDeviceEnterCritical();

  329. 

  330.     PlcHsdData.metadata &= ~(PLSR_HSD_META_POSITION_VALID

  331.                              | PLSR_HSD_META_LAST_BUSY);

  332.     if (positionValid != 0U)

  333.     {

  334.         PlcHsdData.metadata |= PLSR_HSD_META_POSITION_VALID;

  335.     }

  336.     if (lastBusy != 0U)

  337.     {

  338.         PlcHsdData.metadata |= PLSR_HSD_META_LAST_BUSY;

  339.     }

  340.     PlcHsdChangeCounter++;

  341.     PlcHsdDirty = 1U;

  342.     PlcDeviceExitCritical(interruptState);

  343.     return PLC_DEVICE_OK;

  344. }

  345. 

  346. uint8_t PlcDeviceGetRestoredHsdPositionValid(void)

  347. {

  348.     return PlcRestoredHsdPositionValid;

  349. }

  350. 

  351. uint8_t PlcDeviceGetRestoredHsdLastBusy(void)

  352. {

  353.     return PlcRestoredHsdLastBusy;

  354. }

  355. 

  356. PLC_DEVICE_RESULT PlcDeviceCheckpointHsd(void)

  357. {

  358.     PLSR_HSD_DATA snapshot;

  359.     PLSR_PERSISTENCE_RESULT result;

  360.     uint32_t snapshotCounter;

  361.     uint32_t interruptState;

  362. 

  363.     if (PlcHsdDirty == 0U)

  364.     {

  365.         return PLC_DEVICE_OK;

  366.     }

  367. 

  368.     interruptState = PlcDeviceEnterCritical();

  369.     snapshot = PlcHsdData;

  370.     snapshotCounter = PlcHsdChangeCounter;

  371.     PlcDeviceExitCritical(interruptState);

  372. 

  373.     result = PlsrPersistenceSaveHsd(&snapshot);

  374.     if (result != PLSR_PERSISTENCE_OK)

  375.     {

  376.         return PLC_DEVICE_PERSISTENCE_ERROR;

  377.     }

  378. 

  379.     interruptState = PlcDeviceEnterCritical();

  380.     if (PlcHsdChangeCounter == snapshotCounter)

  381.     {

  382.         PlcHsdDirty = 0U;

  383.     }

  384.     PlcDeviceExitCritical(interruptState);

  385.     return PLC_DEVICE_OK;

  386. }

  387. 

  388. PLC_DEVICE_RESULT PlcDeviceReadSfd(uint16_t address, uint16_t *value)

  389. {

  390.     uint32_t interruptState;

  391. 

  392.     if (value == NULL)

  393.     {

  394.         return PLC_DEVICE_NULL_POINTER;

  395.     }

  396.     if ((address < PLSR_SFD_CONFIG_START)

  397.         || (address >= PLSR_SFD_CONFIG_START + PLSR_SFD_CONFIG_COUNT))

  398.     {

  399.         return PLC_DEVICE_INVALID_ADDRESS;

  400.     }

  401. 

  402.     interruptState = PlcDeviceEnterCritical();

  403.     if (PlcSfdOperationActive != 0U)

  404.     {

  405.         PlcDeviceExitCritical(interruptState);

  406.         return PLC_DEVICE_BUSY;

  407.     }

  408.     *value = PlcSfdData.config[address - PLSR_SFD_CONFIG_START];

  409.     PlcDeviceExitCritical(interruptState);

  410.     return PLC_DEVICE_OK;

  411. }

  412. 

  413. PLC_DEVICE_RESULT PlcDeviceWriteSfd(uint16_t address, uint16_t value)

  414. {

  415.     uint32_t interruptState;

  416. 

  417.     if ((address < PLSR_SFD_CONFIG_START)

  418.         || (address >= PLSR_SFD_CONFIG_START + PLSR_SFD_CONFIG_COUNT))

  419.     {

  420.         return PLC_DEVICE_INVALID_ADDRESS;

  421.     }

  422. 

  423.     interruptState = PlcDeviceEnterCritical();

  424.     if (PlcSfdOperationActive != 0U)

  425.     {

  426.         PlcDeviceExitCritical(interruptState);

  427.         return PLC_DEVICE_BUSY;

  428.     }

  429.     PlcSfdData.config[address - PLSR_SFD_CONFIG_START] = value;

  430.     PlcSfdDirty = 1U;

  431.     PlcDeviceExitCritical(interruptState);

  432.     return PLC_DEVICE_OK;

  433. }

  434. 

  435. PLC_DEVICE_RESULT PlcDeviceLoadSfd(void)

  436. {

  437.     if (PlcDeviceBeginSfdOperation() == 0U)

  438.     {

  439.         return PLC_DEVICE_BUSY;

  440.     }

  441. 

  442.     PlcLastSfdLoadResult = PlsrPersistenceLoadSfd(&PlcSfdData);

  443.     if ((PlcLastSfdLoadResult != PLSR_PERSISTENCE_OK)

  444.         && (PlcLastSfdLoadResult != PLSR_PERSISTENCE_DEFAULTED))

  445.     {

  446.         PlcDeviceEndSfdOperation();

  447.         return PLC_DEVICE_PERSISTENCE_ERROR;

  448.     }

  449. 

  450.     PlcSfdDirty = (PlcLastSfdLoadResult == PLSR_PERSISTENCE_OK) ? 0U : 1U;

  451.     PlcDeviceEndSfdOperation();

  452.     return PLC_DEVICE_OK;

  453. }

  454. 

  455. PLC_DEVICE_RESULT PlcDeviceSaveSfd(void)

  456. {

  457.     PLSR_PERSISTENCE_RESULT result;

  458. 

  459.     if (PlcDeviceBeginSfdOperation() == 0U)

  460.     {

  461.         return PLC_DEVICE_BUSY;

  462.     }

  463.     if (PlcSfdDirty == 0U)

  464.     {

  465.         PlcDeviceEndSfdOperation();

  466.         return PLC_DEVICE_OK;

  467.     }

  468. 

  469.     result = PlsrPersistenceSaveSfd(&PlcSfdData);

  470.     if (result != PLSR_PERSISTENCE_OK)

  471.     {

  472.         PlcDeviceEndSfdOperation();

  473.         return PLC_DEVICE_PERSISTENCE_ERROR;

  474.     }

  475. 

  476.     PlcSfdDirty = 0U;

  477.     PlcDeviceEndSfdOperation();

  478.     return PLC_DEVICE_OK;

  479. }

  480. 

  481. PLC_DEVICE_RESULT PlcDeviceResetSfdDefaults(void)

  482. {

  483.     PLSR_PERSISTENCE_RESULT result;

  484.     if (PlcDeviceBeginSfdOperation() == 0U)

  485.     {

  486.         return PLC_DEVICE_BUSY;

  487.     }

  488. 

  489.     result = PlsrPersistenceEraseSfd();

  490.     if (result != PLSR_PERSISTENCE_OK)

  491.     {

  492.         PlcDeviceEndSfdOperation();

  493.         return PLC_DEVICE_PERSISTENCE_ERROR;

  494.     }

  495. 

  496.     PlcLastSfdLoadResult = PlsrPersistenceLoadSfd(&PlcSfdData);

  497.     if (PlcLastSfdLoadResult != PLSR_PERSISTENCE_DEFAULTED)

  498.     {

  499.         PlcDeviceEndSfdOperation();

  500.         return PLC_DEVICE_PERSISTENCE_ERROR;

  501.     }

  502.     PlcSfdDirty = 1U;

  503.     PlcDeviceEndSfdOperation();

  504.     return PLC_DEVICE_OK;

  505. }

  506. 

  507. PLC_DEVICE_RESULT PlcDeviceReadSm(uint16_t address, uint8_t *state)

  508. {

  509.     uint8_t axis;

  510.     uint8_t mask;

  511.     PLC_DEVICE_RESULT result;

  512. 

  513.     if (state == NULL)

  514.     {

  515.         return PLC_DEVICE_NULL_POINTER;

  516.     }

  517.     result = PlcDeviceResolveSm(address, &axis, &mask);

  518.     if (result != PLC_DEVICE_OK)

  519.     {

  520.         return result;

  521.     }

  522. 

  523.     *state = ((PlcSmFlags[axis] & mask) != 0U) ? 1U : 0U;

  524.     return PLC_DEVICE_OK;

  525. }

  526. 

  527. PLC_DEVICE_RESULT PlcDeviceWriteSm(uint16_t address, uint8_t state)

  528. {

  529.     uint8_t axis;

  530.     uint8_t mask;

  531.     PLC_DEVICE_RESULT result;

  532. 

  533.     (void)state;

  534.     result = PlcDeviceResolveSm(address, &axis, &mask);

  535.     return (result == PLC_DEVICE_OK) ? PLC_DEVICE_READ_ONLY : result;

  536. }

  537. 

  538. PLC_DEVICE_RESULT PlcDevicePublishSm(uint8_t axis,

  539.                                     uint8_t pulseActive,

  540.                                     uint8_t direction)

  541. {

  542.     uint8_t flags = 0U;

  543.     uint32_t interruptState;

  544. 

  545.     if (axis >= PLSR_AXIS_COUNT)

  546.     {

  547.         return PLC_DEVICE_INVALID_ARGUMENT;

  548.     }

  549.     if (pulseActive != 0U)

  550.     {

  551.         flags |= PLC_SM_PULSE_ACTIVE_MASK;

  552.     }

  553.     if (direction != 0U)

  554.     {

  555.         flags |= PLC_SM_DIRECTION_MASK;

  556.     }

  557. 

  558.     interruptState = PlcDeviceEnterCritical();

  559.     if ((pulseActive != 0U) && (PlcSfdOperationActive != 0U))

  560.     {

  561.         PlcDeviceExitCritical(interruptState);

  562.         return PLC_DEVICE_BUSY;

  563.     }

  564.     PlcSmFlags[axis] = flags;

  565.     PlcDeviceExitCritical(interruptState);

  566.     return PLC_DEVICE_OK;

  567. }

  568. 

  569. PLC_DEVICE_RESULT PlcDeviceReadSd(uint16_t address, int32_t *value)

  570. {

  571.     int32_t *source;

  572.     uint32_t interruptState;

  573. 

  574.     if (value == NULL)

  575.     {

  576.         return PLC_DEVICE_NULL_POINTER;

  577.     }

  578.     source = PlcDeviceResolveSd(address, NULL, NULL);

  579.     if (source == NULL)

  580.     {

  581.         return PLC_DEVICE_INVALID_ADDRESS;

  582.     }

  583. 

  584.     interruptState = PlcDeviceEnterCritical();

  585.     *value = *source;

  586.     PlcDeviceExitCritical(interruptState);

  587.     return PLC_DEVICE_OK;

  588. }

  589. 

  590. PLC_DEVICE_RESULT PlcDeviceWriteSd(uint16_t address, int32_t value)

  591. {

  592.     (void)value;

  593.     return (PlcDeviceResolveSd(address, NULL, NULL) != NULL)

  594.                ? PLC_DEVICE_READ_ONLY

  595.                : PLC_DEVICE_INVALID_ADDRESS;

  596. }

  597. 

  598. PLC_DEVICE_RESULT PlcDevicePublishSd(uint8_t axis,

  599.                                     uint8_t item,

  600.                                     int32_t value)

  601. {

  602.     uint32_t interruptState;

  603. 

  604.     if ((axis >= PLSR_AXIS_COUNT) || (item >= PLSR_SD_AXIS_ITEM_COUNT))

  605.     {

  606.         return PLC_DEVICE_INVALID_ARGUMENT;

  607.     }

  608. 

  609.     interruptState = PlcDeviceEnterCritical();

  610.     PlcSdRuntime[axis][item] = value;

  611.     PlcDeviceExitCritical(interruptState);

  612.     return PLC_DEVICE_OK;

  613. }

  614. 

  615. PLC_DEVICE_RESULT PlcDeviceReadSdDword(uint16_t lowAddress, int32_t *value)

  616. {

  617.     int32_t *source;

  618.     uint32_t rawValue;

  619.     uint32_t interruptState;

  620.     uint8_t axis;

  621.     uint8_t item;

  622. 

  623.     if (value == NULL)

  624.     {

  625.         return PLC_DEVICE_NULL_POINTER;

  626.     }

  627.     source = PlcDeviceResolveSd(lowAddress, &axis, &item);

  628.     if ((source == NULL) || ((item & 1U) != 0U)

  629.         || (item > PLSR_SD_ITEM_SPEED))

  630.     {

  631.         return PLC_DEVICE_INVALID_ADDRESS;

  632.     }

  633.     interruptState = PlcDeviceEnterCritical();

  634.     rawValue = (uint32_t)PlcSdRuntime[axis][item] & 0xFFFFUL;

  635.     rawValue |= ((uint32_t)PlcSdRuntime[axis][item + 1U] & 0xFFFFUL)

  636.                 << 16U;

  637.     PlcDeviceExitCritical(interruptState);

  638.     *value = (int32_t)rawValue;

  639.     return PLC_DEVICE_OK;

  640. }

  641. 

  642. PLC_DEVICE_RESULT PlcDevicePublishSdDword(uint8_t axis,

  643.                                          uint8_t lowItem,

  644.                                          int32_t value)

  645. {

  646.     uint32_t rawValue;

  647.     uint32_t interruptState;

  648. 

  649.     if ((axis >= PLSR_AXIS_COUNT) || ((lowItem & 1U) != 0U)

  650.         || (lowItem > PLSR_SD_ITEM_SPEED))

  651.     {

  652.         return PLC_DEVICE_INVALID_ARGUMENT;

  653.     }

  654.     rawValue = (uint32_t)value;

  655.     interruptState = PlcDeviceEnterCritical();

  656.     PlcSdRuntime[axis][lowItem] = (int32_t)(rawValue & 0xFFFFUL);

  657.     PlcSdRuntime[axis][lowItem + 1U] = (int32_t)(rawValue >> 16U);

  658.     PlcDeviceExitCritical(interruptState);

  659.     return PLC_DEVICE_OK;

  660. }

  661. 

  662. PLC_DEVICE_RESULT PlcDeviceGetEventAddress(uint8_t axis,

  663.                                           uint16_t segmentNumber,

  664.                                           uint16_t *eventAddress)

  665. {

  666.     if (eventAddress == NULL)

  667.     {

  668.         return PLC_DEVICE_NULL_POINTER;

  669.     }

  670.     if ((axis >= PLSR_AXIS_COUNT) || (segmentNumber == 0U)

  671.         || (segmentNumber > PLSR_EVENT_AXIS_ITEM_COUNT))

  672.     {

  673.         return PLC_DEVICE_INVALID_ARGUMENT;

  674.     }

  675. 

  676.     *eventAddress = (uint16_t)(PlsrAxisAddressMap[axis].eventBase

  677.                                + segmentNumber - 1U);

  678.     return PLC_DEVICE_OK;

  679. }

  680. 

  681. PLC_DEVICE_RESULT PlcDevicePublishEvent(uint8_t axis,

  682.                                        uint16_t segmentNumber,

  683.                                        uint16_t reason)

  684. {

  685.     PLC_DEVICE_EVENT_RECORD *record;

  686.     uint32_t interruptState;

  687. 

  688.     if ((axis >= PLSR_AXIS_COUNT) || (segmentNumber == 0U)

  689.         || (segmentNumber > PLSR_EVENT_AXIS_ITEM_COUNT))

  690.     {

  691.         return PLC_DEVICE_INVALID_ARGUMENT;

  692.     }

  693.     record = &PlcEventRecords[axis][segmentNumber - 1U];

  694.     interruptState = PlcDeviceEnterCritical();

  695.     if (record->count != UINT32_MAX)

  696.     {

  697.         record->count++;

  698.     }

  699.     record->lastReason = reason;

  700.     record->pending = 1U;

  701.     PlcDeviceExitCritical(interruptState);

  702.     return PLC_DEVICE_OK;

  703. }

  704. 

  705. PLC_DEVICE_RESULT PlcDeviceReadEvent(uint16_t eventAddress,

  706.                                     PLC_DEVICE_EVENT_RECORD *record)

  707. {

  708.     PLC_DEVICE_EVENT_RECORD *source;

  709.     uint32_t interruptState;

  710. 

  711.     if (record == NULL)

  712.     {

  713.         return PLC_DEVICE_NULL_POINTER;

  714.     }

  715.     source = PlcDeviceResolveEvent(eventAddress);

  716.     if (source == NULL)

  717.     {

  718.         return PLC_DEVICE_INVALID_ADDRESS;

  719.     }

  720.     interruptState = PlcDeviceEnterCritical();

  721.     *record = *source;

  722.     PlcDeviceExitCritical(interruptState);

  723.     return PLC_DEVICE_OK;

  724. }

  725. 

  726. PLC_DEVICE_RESULT PlcDeviceAcknowledgeEvent(uint16_t eventAddress)

  727. {

  728.     PLC_DEVICE_EVENT_RECORD *record = PlcDeviceResolveEvent(eventAddress);

  729.     uint32_t interruptState;

  730. 

  731.     if (record == NULL)

  732.     {

  733.         return PLC_DEVICE_INVALID_ADDRESS;

  734.     }

  735.     interruptState = PlcDeviceEnterCritical();

  736.     record->pending = 0U;

  737.     PlcDeviceExitCritical(interruptState);

  738.     return PLC_DEVICE_OK;

  739. }

  740. 

  741. uint8_t PlcDeviceIsHsdDirty(void)

  742. {

  743.     return PlcHsdDirty;

  744. }

  745. 

  746. uint8_t PlcDeviceIsSfdDirty(void)

  747. {

  748.     return PlcSfdDirty;

  749. }

  750. 

  751. PLSR_PERSISTENCE_RESULT PlcDeviceGetLastHsdLoadResult(void)

  752. {

  753.     return PlcLastHsdLoadResult;

  754. }

  755. 

  756. PLSR_PERSISTENCE_RESULT PlcDeviceGetLastSfdLoadResult(void)

  757. {

  758.     return PlcLastSfdLoadResult;

  759. }