Modbus-rtu/PLSR/Src/plsr.c

#include "plsr.h"
#include "plsr_internal.h"
#include "plsr_platform.h"
#include <stddef.h>
#include <string.h>

#if defined(__ICCARM__)
#include <intrinsics.h>
#endif

#define PLSR_COMMON_FIRST_ADDRESS      (0x1000U)
#define PLSR_COMMON_LAST_ADDRESS       (0x10FFU)
#define PLSR_SEGMENT_FIRST_ADDRESS     (0x1100U)
#define PLSR_SEGMENT_STRIDE            (0x0010U)
#define PLSR_SEGMENT_DEFINED_WORDS     (8U)

#define PLSR_WAIT_TIME                 (0U)
#define PLSR_WAIT_SIGNAL               (1U)
#define PLSR_ACT_TIME                  (2U)
#define PLSR_EXT_SIGNAL                (3U)
#define PLSR_EXT_OR_COMPLETE           (4U)

#define PLSR_SEND_COMPLETE             (0U)
#define PLSR_SEND_SUBSEQUENT           (1U)
#define PLSR_POSITION_RELATIVE         (0U)
#define PLSR_POSITION_ABSOLUTE         (1U)

#define PLSR_COMMAND_START             (0x0001U)
#define PLSR_COMMAND_STOP              (0x0002U)
#define PLSR_COMMAND_CLEAR             (0x0004U)

#define PLSR_DIAG_FLAG_MONITORING       (0x0001U)
#define PLSR_DIAG_FLAG_COUNT_CHECKED    (0x0002U)
#define PLSR_DIAG_FLAG_COUNT_PASS       (0x0004U)
#define PLSR_DIAG_FLAG_FREQUENCY_CHECKED (0x0008U)
#define PLSR_DIAG_FLAG_FREQUENCY_PASS   (0x0010U)
#define PLSR_DIAG_FLAG_CURVE_CHECKED    (0x0020U)
#define PLSR_DIAG_FLAG_CURVE_PASS       (0x0040U)
#define PLSR_DIAG_FLAG_FAULT_LATCHED    (0x0080U)

#define PLSR_DIAG_REASON_NONE           (0U)
#define PLSR_DIAG_REASON_COUNT          (1U)
#define PLSR_DIAG_REASON_FREQUENCY      (2U)
#define PLSR_DIAG_REASON_CURVE          (3U)
#define PLSR_DIAG_REASON_INVALID_SAMPLE (4U)

#define PLSR_CONFIG_SAVE_DELAY_MS      (1000U)
#define PLSR_POSITION_CHECKPOINT_MS    (10U)
#define PLSR_PROFILE_QUEUE_CAPACITY    (256U)
#define PLSR_PROFILE_QUEUE_MASK        (PLSR_PROFILE_QUEUE_CAPACITY - 1U)
#define PLSR_SHORT_PROFILE_MAX_PULSES  \
    ((uint32_t)PLSR_PROFILE_QUEUE_CAPACITY + 2UL)
#define PLSR_Q32_ONE                    (4294967296ULL)

typedef struct
{
    uint32_t fromHz;
    uint32_t toHz;
    uint32_t durationMs;
    uint32_t elapsedMs;
    uint8_t active;
} PLSR_RAMP;

typedef struct
{
    uint32_t startHz;
    uint32_t peakHz;
    uint32_t endHz;
    uint16_t pulseCount;
    uint16_t entryPulses;
    uint16_t steadyPulses;
    uint16_t exitPulses;
    volatile uint16_t nextPeriod;
    uint64_t rampBoundaryQ32;
    uint64_t rampTotalAreaQ32;
    uint64_t rampTargetAreaQ32;
    uint64_t rampAreaStepQ32;
    uint32_t rampAreaRemainder;
    uint32_t rampRemainderAccumulator;
    uint64_t lastRampPhaseStepQ32;
    uint64_t entryFirstBoundaryQ32;
    uint64_t entrySecondBoundaryQ32;
    uint64_t exitFirstBoundaryQ32;
    uint64_t exitSecondBoundaryQ32;
    uint32_t lastRampFrequencyHz;
    volatile uint8_t active;
} PLSR_SHORT_PROFILE;

typedef struct
{
    PLSR_PLATFORM_TIMER_SETTING setting;
    uint32_t requestedFrequencyHz;
} PLSR_PROFILE_ENTRY;

typedef struct
{
    PLSR_PROFILE_ENTRY entries[PLSR_PROFILE_QUEUE_CAPACITY];
    PLSR_SHORT_PROFILE producerProfile;
    volatile uint32_t readIndex;
    volatile uint32_t writeIndex;
    volatile uint32_t generation;
    uint32_t producerEpoch;
    uint8_t producerSegment;
    uint8_t preparedHandoffBank;
    volatile uint8_t active;
    volatile uint8_t generatorComplete;
} PLSR_PROFILE_QUEUE;

typedef struct
{
    uint64_t magnitude;
    uint32_t firstFrequencyHz;
    uint32_t secondFrequencyHz;
    uint32_t firstRequestedFrequencyHz;
    uint32_t secondRequestedFrequencyHz;
    PLSR_PLATFORM_TIMER_SETTING firstSetting;
    PLSR_PLATFORM_TIMER_SETTING secondSetting;
    PLSR_SHORT_PROFILE profile;
    uint8_t nextSegment;
    uint8_t positive;
    volatile uint8_t valid;
} PLSR_HANDOFF_PLAN;

typedef enum
{
    PLSR_WORD_OK = 0,
    PLSR_WORD_ILLEGAL_ADDRESS,
    PLSR_WORD_ILLEGAL_VALUE
} PLSR_WORD_RESULT;

typedef enum
{
    PLSR_COMMAND_MAILBOX_EMPTY = 0,
    PLSR_COMMAND_MAILBOX_PENDING,
    PLSR_COMMAND_MAILBOX_EXECUTING
} PLSR_COMMAND_MAILBOX_STATE;

typedef struct
{
    PLSR_CONFIG startConfig;
    uint16_t command;
    volatile uint8_t state;
} PLSR_COMMAND_MAILBOX;

typedef struct
{
    uint16_t flags;
    uint16_t reason;
    uint16_t lastSegment;
    uint16_t modeDirection;
    uint32_t expectedCycles;
    uint32_t observedCycles;
    int32_t countError;
    uint32_t requestedHz;
    uint32_t expectedTimerHz;
    uint32_t activeTimerHz;
    int32_t requestErrorHz;
    uint32_t curveSampleCount;
    uint32_t curveMismatchCount;
    uint32_t curveMaxAbsErrorHz;
    uint32_t firstMismatchSample;
} PLSR_DIAGNOSTIC;

static const uint16_t PlsrSineProgressQ16[65] =
{
    0U, 39U, 158U, 355U, 630U, 982U, 1411U, 1915U,
    2494U, 3146U, 3869U, 4662U, 5522U, 6448U, 7438U, 8488U,
    9597U, 10762U, 11980U, 13248U, 14563U, 15922U, 17321U,
    18758U, 20228U, 21728U, 23256U, 24806U, 26375U, 27960U,
    29556U, 31160U, 32767U, 34375U, 35979U, 37575U, 39160U,
    40729U, 42279U, 43807U, 45307U, 46777U, 48214U, 49613U,
    50972U, 52287U, 53555U, 54773U, 55938U, 57047U, 58097U,
    59087U, 60013U, 60873U, 61666U, 62389U, 63041U, 63620U,
    64124U, 64553U, 64905U, 65180U, 65377U, 65496U, 65535U
};

static const uint32_t PlsrSmoothIntegralQ24[65] =
{
    0UL, 64UL, 504UL, 1688UL, 3968UL, 7688UL, 13176UL, 20752UL,
    30720UL, 43376UL, 59000UL, 77864UL, 100224UL, 126328UL, 156408UL,
    190688UL, 229376UL, 272672UL, 320760UL, 373816UL, 432000UL,
    495464UL, 564344UL, 638768UL, 718848UL, 804688UL, 896376UL,
    993992UL, 1097600UL, 1207256UL, 1323000UL, 1444864UL, 1572864UL,
    1707008UL, 1847288UL, 1993688UL, 2146176UL, 2304712UL, 2469240UL,
    2639696UL, 2816000UL, 2998064UL, 3185784UL, 3379048UL, 3577728UL,
    3781688UL, 3990776UL, 4204832UL, 4423680UL, 4647136UL, 4875000UL,
    5107064UL, 5343104UL, 5582888UL, 5826168UL, 6072688UL, 6322176UL,
    6574352UL, 6828920UL, 7085576UL, 7344000UL, 7603864UL, 7864824UL,
    8126528UL, 8388608UL
};

static const uint32_t PlsrSineIntegralQ24[65] =
{
    0UL, 53UL, 421UL, 1420UL, 3362UL, 6560UL, 11321UL, 17949UL,
    26744UL, 38000UL, 52007UL, 69047UL, 89393UL, 113314UL, 141066UL,
    172899UL, 209052UL, 249753UL, 295221UL, 345662UL, 401269UL,
    462225UL, 528698UL, 600845UL, 678806UL, 762711UL, 852672UL,
    948789UL, 1051146UL, 1159812UL, 1274841UL, 1396271UL, 1524127UL,
    1658415UL, 1799129UL, 1946244UL, 2099722UL, 2259509UL, 2425536UL,
    2597719UL, 2775958UL, 2960141UL, 3150138UL, 3345809UL, 3546997UL,
    3753534UL, 3965237UL, 4181913UL, 4403356UL, 4629347UL, 4859658UL,
    5094050UL, 5332273UL, 5574071UL, 5819175UL, 6067312UL, 6318200UL,
    6571549UL, 6827065UL, 7084448UL, 7343394UL, 7603596UL, 7864741UL,
    8126517UL, 8388608UL
};

static PLSR_CONFIG PlsrShadowConfig;
static PLSR_CONFIG PlsrActiveConfig;
static PLSR_CONFIG PlsrCandidateConfig;
static volatile int32_t PlsrPosition;
static volatile uint64_t PlsrRemainingPulses;
static volatile uint8_t PlsrPulseActive;
static volatile uint8_t PlsrCutRequested;
static volatile uint8_t PlsrBoundaryPending;
static volatile uint8_t PlsrBoundaryWasCut;
static volatile uint8_t PlsrCountPositive;
static volatile uint8_t PlsrCountOverflowPending;
static volatile uint8_t PlsrPositionValid;
static volatile uint8_t PlsrPositionCheckpointDirty;
static volatile uint8_t PlsrFrequencyUpdatePending;
static volatile uint8_t PlsrFrequencyUpdateSegment;
static volatile uint8_t PlsrSeamlessHandoffPending;
static volatile uint8_t PlsrTimerErrorPending;
static volatile uint8_t PlsrDeferredFrequencyPending;
static volatile uint32_t PlsrCurrentFrequencyHz;
static volatile uint32_t PlsrQueuedFrequencyHz;
static volatile uint32_t PlsrBoundaryFrequencyHz;
static volatile uint32_t PlsrFrequencyUpdateTargetHz;
static volatile uint32_t PlsrDeferredFrequencyHz;
static volatile uint32_t PlsrSegmentEpoch;

static volatile PLSR_STATUS PlsrRunStatus = PLSR_STATUS_UNINITIALIZED;
static PLSR_ERROR PlsrError = PLSR_ERROR_NONE;
static PLSR_RAMP PlsrRamp;
static PLSR_SHORT_PROFILE PlsrShortProfile;
static PLSR_PROFILE_QUEUE PlsrProfileQueue;
static PLSR_HANDOFF_PLAN PlsrHandoffPlan;
static PLSR_HANDOFF_PLAN
    PlsrPreparedHandoffPlans[2][PLSR_SEGMENT_COUNT_MAX];
static volatile uint8_t PlsrPreparedHandoffBank;
#ifdef PLSR_HOST_TEST
static uint32_t PlsrHostTestEventSequence;
static uint32_t PlsrHostTestLastGateEvent;
static uint32_t PlsrHostTestLastDiagnosticFinishEvent;
#endif
static uint8_t PlsrInitialized;
static volatile uint8_t PlsrCurrentSegment;
static uint8_t PlsrDirectionDelayActive;
static uint16_t PlsrDirectionDelayRemainingMs;
static volatile uint8_t PlsrSegmentClockStarted;
static volatile uint32_t PlsrSegmentElapsedMs;
static volatile uint32_t PlsrWaitElapsedMs;
static volatile uint8_t PlsrExtPreviousLevel;
static volatile uint8_t PlsrExtEdgePending;
static volatile uint8_t PlsrStopRequested;
static volatile uint8_t PlsrStopPulsesRemaining;
static volatile uint8_t PlsrAbStopArmed;
static volatile uint8_t PlsrBoundaryRampStarted;
static uint8_t PlsrLastDirectionValid;
static uint8_t PlsrLastDirectionOutput;
static uint8_t PlsrLastDirectionLevel;
static uint8_t PlsrPersistenceDirty;
static uint16_t PlsrPersistenceDelayMs;
static uint8_t PlsrPositionCheckpointElapsedMs;
static PLSR_COMMAND_MAILBOX PlsrCommandMailbox;
static volatile PLSR_DIAGNOSTIC PlsrDiagnostic;
static volatile uint64_t PlsrDiagnosticSegmentCounterBase;
static volatile uint32_t PlsrDiagnosticQueuedExpectedHz;
static volatile uint16_t PlsrDiagnosticFailedChecks;

#if defined(PLSR_DEBUG_TIMING) && (PLSR_DEBUG_TIMING != 0)
volatile uint32_t PlsrProfileProducerItemCount;
volatile uint32_t PlsrProfileProducerTotalCycles;
volatile uint32_t PlsrProfileProducerMaxItemCycles;
#endif

static uint8_t PlsrIsBusy(void);
static void PlsrSetDefaults(PLSR_CONFIG *config);
static uint8_t PlsrConfigIsValid(const PLSR_CONFIG *config,
                                 uint8_t validateActivePath);
static uint16_t PlsrReadConfigWord(const PLSR_CONFIG *config,
                                   uint16_t address);
static PLSR_WORD_RESULT PlsrWriteConfigWord(PLSR_CONFIG *config,
                                            uint16_t address,
                                            uint16_t value);
static uint8_t PlsrAddressIsDwordHalf(uint16_t address,
                                      uint16_t *pairedAddress);
static PLSR_MB_RESULT PlsrQueueCommand(uint16_t command);
static uint8_t PlsrPollCommandMailbox(void);
static void PlsrExecuteStart(void);
static uint8_t PlsrExecuteStop(void);
static void PlsrExecuteClear(void);
static uint8_t PlsrStartSegment(uint8_t segmentNumber,
                                uint8_t allowCarry,
                                uint32_t carryFrequencyHz);
static uint8_t PlsrBeginSegmentOutput(uint32_t startFrequencyHz);
static void PlsrHandleBoundary(uint8_t extEdge);
static void PlsrTransitionToNext(uint8_t allowCarry);
static void PlsrFinishCompleted(void);
static void PlsrFinishStopped(void);
static void PlsrEnterError(PLSR_ERROR error);
static void PlsrMarkPersistenceDirty(uint16_t delayMs);
static void PlsrCheckpointPosition(uint8_t wasBusy);
static void PlsrPollPositionCheckpoint(void);
static PLSR_PLATFORM_QUEUE_RESULT PlsrTrySubsequentHandoff(void);
static uint8_t PlsrPrepareShortProfile(PLSR_SHORT_PROFILE *profile,
                                       uint8_t segmentNumber,
                                       uint32_t startFrequencyHz,
                                       uint32_t targetFrequencyHz,
                                       uint64_t pulseCount);
static uint32_t PlsrShortProfileTakeFrequency(PLSR_SHORT_PROFILE *profile);
static void PlsrProfileQueueReset(void);
static uint8_t PlsrProfileQueueBegin(
    const PLSR_SHORT_PROFILE *producerProfile,
    uint32_t producerEpoch,
    uint8_t producerSegment,
    uint8_t preparedHandoffBank);
static uint8_t PlsrProfileQueueFill(void);
static PLSR_PLATFORM_QUEUE_RESULT PlsrProfileQueueCommitNext(
    uint8_t pulseOutput);
static uint8_t PlsrPrepareFutureHandoffQueue(void);
static void PlsrCopyShortProfile(PLSR_SHORT_PROFILE *destination,
                                 const PLSR_SHORT_PROFILE *source);
static void PlsrInvalidateHandoffPlans(void);
static uint8_t PlsrBuildHandoffPlanBank(
    const PLSR_CONFIG *frequencyConfig);
static uint8_t PlsrSelectPreparedHandoffPlan(PLSR_HANDOFF_PLAN *plan);
static PLSR_PLATFORM_QUEUE_RESULT PlsrPrimeHandoff(void);
static uint8_t PlsrBuildHandoffPlan(uint8_t sourceSegment,
                                    const PLSR_CONFIG *frequencyConfig,
                                    PLSR_HANDOFF_PLAN *plan);
static void PlsrDiagnosticReset(void);
static void PlsrDiagnosticBeginSegment(uint8_t segmentNumber,
                                       uint64_t expectedCycles,
                                       uint8_t directionPositive);
static void PlsrDiagnosticFinishSegment(uint8_t completedNormally);
static uint8_t PlsrDiagnosticStartPulse(uint8_t pulseOutput,
                                        uint32_t requestedFirstHz,
                                        uint32_t requestedQueuedHz,
                                        uint32_t *actualFirstHz,
                                        uint32_t *actualQueuedHz);
static PLSR_PLATFORM_QUEUE_RESULT PlsrDiagnosticQueueFrequency(
    uint8_t pulseOutput,
    uint32_t requestedHz,
    uint32_t *actualHz);
static void PlsrDiagnosticCheckActiveFrequency(uint32_t activeHz);
static uint8_t PlsrArmFinalAbBoundaryLocked(void);
static uint8_t PlsrQueueFinalAbBoundaryFromIrq(void);

static uint8_t PlsrIsBusy(void)
{
    return ((PlsrRunStatus == PLSR_STATUS_ACCELERATING)
            || (PlsrRunStatus == PLSR_STATUS_RUNNING)
            || (PlsrRunStatus == PLSR_STATUS_DECELERATING)
            || (PlsrRunStatus == PLSR_STATUS_WAITING)
            || (PlsrRunStatus == PLSR_STATUS_PAUSED)) ? 1U : 0U;
}

static uint32_t PlsrJoinU32(uint16_t lowWord, uint16_t highWord)
{
    return (uint32_t)lowWord | ((uint32_t)highWord << 16U);
}

static uint16_t PlsrLowWord(uint32_t value)
{
    return (uint16_t)(value & 0xFFFFUL);
}

static uint16_t PlsrHighWord(uint32_t value)
{
    return (uint16_t)(value >> 16U);
}

static uint8_t PlsrFinalAbBoundaryRequired(void)
{
    uint8_t finalBoundary;

    if (PlsrActiveConfig.outputMode != PLSR_OUTPUT_AB)
    {
        return 0U;
    }

    finalBoundary = ((PlsrCutRequested != 0U)
                     || ((PlsrStopRequested != 0U)
                         && (PlsrStopPulsesRemaining == 1U))
                     || ((PlsrRemainingPulses == 1UL)
                         && (PlsrHandoffPlan.valid == 0U))) ? 1U : 0U;
    return ((PlsrPulseActive != 0U) && (finalBoundary != 0U)) ? 1U : 0U;
}

static uint8_t PlsrCompleteFinalAbArmLocked(void)
{
    PLSR_PLATFORM_STOP_RESULT result;
    uint8_t pulseOutput = (uint8_t)PlsrActiveConfig.pulseOutput;

    result = PlsrPlatformRequestStopLocked(pulseOutput, 1U);
    if (result == PLSR_PLATFORM_STOP_PENDING)
    {
        PlsrQueuedFrequencyHz = PlsrCurrentFrequencyHz;
        PlsrDiagnosticQueuedExpectedHz = PlsrCurrentFrequencyHz;
        PlsrDeferredFrequencyHz = PlsrCurrentFrequencyHz;
        PlsrDeferredFrequencyPending = 0U;
        PlsrFrequencyUpdatePending = 0U;
        PlsrShortProfile.active = 0U;
        PlsrHandoffPlan.valid = 0U;
        PlsrRamp.active = 0U;
        return 1U;
    }
    PlsrTimerErrorPending = 1U;
    PlsrPlatformStopPulse(pulseOutput);
    PlsrAbStopArmed = 0U;
    PlsrPulseActive = 0U;
    PlsrBoundaryFrequencyHz = PlsrCurrentFrequencyHz;
    PlsrBoundaryWasCut = (PlsrCutRequested != 0U) ? 1U : 0U;
    PlsrCutRequested = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrBoundaryPending = 1U;
    return 0U;
}

static uint8_t PlsrArmFinalAbBoundaryLocked(void)
{
    if (PlsrFinalAbBoundaryRequired() == 0U)
    {
        return 1U;
    }
    if (PlsrAbStopArmed != 0U)
    {
        return 1U;
    }
    PlsrAbStopArmed = 1U;
    return PlsrCompleteFinalAbArmLocked();
}

static uint8_t PlsrQueueFinalAbBoundaryFromIrq(void)
{
    uint32_t criticalState;

    if ((PlsrFinalAbBoundaryRequired() == 0U)
        || (PlsrAbStopArmed != 0U))
    {
        return 1U;
    }
    PlsrAbStopArmed = 1U;
    if (PlsrPlatformQueueFinalArmFromIrq(
            (uint8_t)PlsrActiveConfig.pulseOutput) != 0U)
    {
        return 1U;
    }
    criticalState = PlsrPlatformEnterCritical();
    if ((PlsrAbStopArmed == 0U)
        || (PlsrFinalAbBoundaryRequired() == 0U))
    {
        PlsrPlatformExitCritical(criticalState);
        return 1U;
    }
    {
        uint8_t result = PlsrCompleteFinalAbArmLocked();

        PlsrPlatformExitCritical(criticalState);
        return result;
    }
}

void PlsrFinalArmJobIrq(uint8_t pulseOutput)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    if ((PlsrAbStopArmed == 0U) || (PlsrPulseActive == 0U)
        || (pulseOutput != (uint8_t)PlsrActiveConfig.pulseOutput)
        || (PlsrFinalAbBoundaryRequired() == 0U))
    {
        if ((PlsrPulseActive != 0U)
            && (pulseOutput == (uint8_t)PlsrActiveConfig.pulseOutput))
        {
            PlsrAbStopArmed = 0U;
        }
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    (void)PlsrCompleteFinalAbArmLocked();
    PlsrPlatformExitCritical(criticalState);
}

static uint32_t PlsrAbsDifferenceU32(uint32_t first, uint32_t second)
{
    return (first >= second) ? (first - second) : (second - first);
}

static int32_t PlsrDifferenceI32(uint32_t first, uint32_t second)
{
    int64_t difference = (int64_t)first - (int64_t)second;

    if (difference > INT32_MAX)
    {
        return INT32_MAX;
    }
    if (difference < INT32_MIN)
    {
        return INT32_MIN;
    }
    return (int32_t)difference;
}

static void PlsrDiagnosticLatch(uint16_t reason)
{
    PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_FAULT_LATCHED;
    if (PlsrDiagnostic.reason == PLSR_DIAG_REASON_NONE)
    {
        PlsrDiagnostic.reason = reason;
    }
}

static void PlsrDiagnosticReset(void)
{
    (void)memset((void *)&PlsrDiagnostic, 0, sizeof(PlsrDiagnostic));
    PlsrDiagnostic.firstMismatchSample = 0xFFFFFFFFUL;
    PlsrDiagnosticSegmentCounterBase = 0UL;
    PlsrDiagnosticQueuedExpectedHz = 0UL;
    PlsrDiagnosticFailedChecks = 0U;
}

static void PlsrDiagnosticBeginSegment(uint8_t segmentNumber,
                                       uint64_t expectedCycles,
                                       uint8_t directionPositive)
{
    if (expectedCycles > 0xFFFFFFFFUL)
    {
        PlsrDiagnostic.expectedCycles = 0xFFFFFFFFUL;
        PlsrDiagnosticLatch(PLSR_DIAG_REASON_INVALID_SAMPLE);
    }
    else
    {
        PlsrDiagnostic.expectedCycles = (uint32_t)expectedCycles;
    }
    PlsrDiagnostic.flags &= (uint16_t)~(PLSR_DIAG_FLAG_COUNT_CHECKED
                                        | PLSR_DIAG_FLAG_COUNT_PASS);
    PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_MONITORING;
    PlsrDiagnostic.lastSegment = segmentNumber;
    PlsrDiagnostic.modeDirection =
        (uint16_t)(PlsrActiveConfig.outputMode
                   | ((uint16_t)directionPositive << 8U));
    PlsrDiagnostic.observedCycles = 0UL;
    PlsrDiagnostic.countError = 0L;
    PlsrDiagnosticSegmentCounterBase = PlsrPlatformObservedPulses(
        (uint8_t)PlsrActiveConfig.pulseOutput);
}

static void PlsrDiagnosticFinishSegment(uint8_t completedNormally)
{
    uint64_t now;
    uint64_t observed;
    uint32_t observedCycles;
    uint32_t expectedCycles;

    if ((PlsrDiagnostic.flags & PLSR_DIAG_FLAG_MONITORING) == 0U)
    {
        return;
    }
#ifdef PLSR_HOST_TEST
    PlsrHostTestEventSequence++;
    PlsrHostTestLastDiagnosticFinishEvent = PlsrHostTestEventSequence;
#endif
    now = PlsrPlatformObservedPulses(
        (uint8_t)PlsrActiveConfig.pulseOutput);
    observed = (now >= PlsrDiagnosticSegmentCounterBase)
                   ? (now - PlsrDiagnosticSegmentCounterBase) : 0UL;
    if (observed > 0xFFFFFFFFUL)
    {
        PlsrDiagnostic.observedCycles = 0xFFFFFFFFUL;
        PlsrDiagnosticFailedChecks |= PLSR_DIAG_FLAG_COUNT_PASS;
        PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_COUNT_PASS;
        PlsrDiagnosticLatch(PLSR_DIAG_REASON_INVALID_SAMPLE);
    }
    else
    {
        PlsrDiagnostic.observedCycles = (uint32_t)observed;
    }
    PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_MONITORING;
    if (completedNormally == 0U)
    {
        PlsrDiagnostic.countError = 0L;
        PlsrDiagnostic.flags &= (uint16_t)~(PLSR_DIAG_FLAG_COUNT_CHECKED
                                            | PLSR_DIAG_FLAG_COUNT_PASS);
        return;
    }

    observedCycles = PlsrDiagnostic.observedCycles;
    expectedCycles = PlsrDiagnostic.expectedCycles;
    PlsrDiagnostic.countError =
        PlsrDifferenceI32(observedCycles, expectedCycles);
    PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_COUNT_CHECKED;
    if (PlsrDiagnostic.countError != 0L)
    {
        PlsrDiagnosticFailedChecks |= PLSR_DIAG_FLAG_COUNT_PASS;
        PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_COUNT_PASS;
        PlsrDiagnosticLatch(PLSR_DIAG_REASON_COUNT);
    }
    else if ((PlsrDiagnosticFailedChecks & PLSR_DIAG_FLAG_COUNT_PASS) == 0U)
    {
        PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_COUNT_PASS;
    }
}

static void PlsrDiagnosticRecordFrequency(uint32_t requestedHz,
                                          uint32_t expectedHz,
                                          uint32_t actualHz)
{
    uint32_t error = PlsrAbsDifferenceU32(actualHz, expectedHz);

    PlsrDiagnostic.requestedHz = requestedHz;
    PlsrDiagnostic.expectedTimerHz = expectedHz;
    PlsrDiagnostic.activeTimerHz = actualHz;
    /* Request error is divider quantization, not a diagnostic deviation. */
    PlsrDiagnostic.requestErrorHz = PlsrDifferenceI32(expectedHz, requestedHz);
    PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_FREQUENCY_CHECKED;
    if (actualHz != expectedHz)
    {
        PlsrDiagnosticFailedChecks |= PLSR_DIAG_FLAG_FREQUENCY_PASS;
        PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_FREQUENCY_PASS;
        PlsrDiagnosticLatch(PLSR_DIAG_REASON_FREQUENCY);
    }
    else if ((PlsrDiagnosticFailedChecks
              & PLSR_DIAG_FLAG_FREQUENCY_PASS) == 0U)
    {
        PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_FREQUENCY_PASS;
    }
    if (error > PlsrDiagnostic.curveMaxAbsErrorHz)
    {
        PlsrDiagnostic.curveMaxAbsErrorHz = error;
    }
}

static void PlsrDiagnosticRecordCurveSample(uint32_t expectedHz,
                                            uint32_t actualHz)
{
    uint32_t error = PlsrAbsDifferenceU32(expectedHz, actualHz);

    if (PlsrDiagnostic.curveSampleCount != 0xFFFFFFFFUL)
    {
        PlsrDiagnostic.curveSampleCount++;
    }
    PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_CURVE_CHECKED;
    if (error == 0UL)
    {
        if ((PlsrDiagnosticFailedChecks & PLSR_DIAG_FLAG_CURVE_PASS) == 0U)
        {
            PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_CURVE_PASS;
        }
    }
    else
    {
        PlsrDiagnosticFailedChecks |= PLSR_DIAG_FLAG_CURVE_PASS;
        PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_CURVE_PASS;
        if (PlsrDiagnostic.curveMismatchCount != 0xFFFFFFFFUL)
        {
            PlsrDiagnostic.curveMismatchCount++;
        }
        if (PlsrDiagnostic.firstMismatchSample == 0xFFFFFFFFUL)
        {
            PlsrDiagnostic.firstMismatchSample =
                PlsrDiagnostic.curveSampleCount;
        }
        if (error > PlsrDiagnostic.curveMaxAbsErrorHz)
        {
            PlsrDiagnostic.curveMaxAbsErrorHz = error;
        }
        PlsrDiagnosticLatch(PLSR_DIAG_REASON_CURVE);
    }
}

static uint8_t PlsrDiagnosticStartPulse(uint8_t pulseOutput,
                                        uint32_t requestedFirstHz,
                                        uint32_t requestedQueuedHz,
                                        uint32_t *actualFirstHz,
                                        uint32_t *actualQueuedHz)
{
    PLSR_PLATFORM_TIMER_SETTING firstSetting;
    PLSR_PLATFORM_TIMER_SETTING queuedSetting;

    if ((PlsrPlatformBuildTimerSetting(
             pulseOutput, (uint8_t)PlsrActiveConfig.outputMode,
             requestedFirstHz, &firstSetting) == 0U)
        || (PlsrPlatformBuildTimerSetting(
                pulseOutput, (uint8_t)PlsrActiveConfig.outputMode,
                requestedQueuedHz, &queuedSetting) == 0U)
        || (PlsrPlatformStartPrepared(pulseOutput, &firstSetting,
                                      &queuedSetting, actualFirstHz,
                                      actualQueuedHz) == 0U))
    {
        PlsrDiagnosticFinishSegment(0U);
        return 0U;
    }
    PlsrDiagnosticRecordFrequency(requestedFirstHz,
                                  firstSetting.actualFrequencyHz,
                                  *actualFirstHz);
    PlsrDiagnosticRecordCurveSample(firstSetting.actualFrequencyHz,
                                    *actualFirstHz);
    PlsrDiagnosticQueuedExpectedHz = queuedSetting.actualFrequencyHz;
    return 1U;
}

static PLSR_PLATFORM_QUEUE_RESULT PlsrDiagnosticQueueFrequency(
    uint8_t pulseOutput,
    uint32_t requestedHz,
    uint32_t *actualHz)
{
    uint32_t expectedHz;
    PLSR_PLATFORM_QUEUE_RESULT result;

    if (PlsrPlatformExpectedFrequency(
            pulseOutput, (uint8_t)PlsrActiveConfig.outputMode,
            requestedHz, &expectedHz) == 0U)
    {
        PlsrDiagnosticFinishSegment(0U);
        return PLSR_PLATFORM_QUEUE_FAILED;
    }
    result = PlsrPlatformQueueFrequency(pulseOutput, requestedHz, actualHz);
    if (result == PLSR_PLATFORM_QUEUE_FAILED)
    {
        PlsrDiagnosticFinishSegment(0U);
        return result;
    }
    if (result == PLSR_PLATFORM_QUEUE_STALE)
    {
        return result;
    }

    PlsrDiagnosticRecordFrequency(requestedHz, expectedHz, *actualHz);
    PlsrDiagnosticQueuedExpectedHz = expectedHz;
    return PLSR_PLATFORM_QUEUE_APPLIED;
}

static void PlsrDiagnosticCheckActiveFrequency(uint32_t activeHz)
{
    uint16_t platformFault = PlsrPlatformDiagnosticFault();
    uint32_t observedHz = activeHz;

    if (platformFault == PLSR_DIAG_REASON_FREQUENCY)
    {
        observedHz = PlsrPlatformActiveFrequency(
            (uint8_t)PlsrActiveConfig.pulseOutput);
        if (observedHz == 0UL)
        {
            observedHz = activeHz;
        }
        PlsrDiagnosticFailedChecks |= PLSR_DIAG_FLAG_FREQUENCY_PASS;
        PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_FREQUENCY_CHECKED;
        PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_FREQUENCY_PASS;
        PlsrDiagnosticLatch(PLSR_DIAG_REASON_FREQUENCY);
    }
    if ((platformFault != PLSR_DIAG_REASON_NONE)
        && (PlsrDiagnosticQueuedExpectedHz != 0UL))
    {
        PlsrDiagnostic.activeTimerHz = observedHz;
        if (platformFault == PLSR_DIAG_REASON_CURVE)
        {
            if (PlsrDiagnostic.curveSampleCount != 0xFFFFFFFFUL)
            {
                PlsrDiagnostic.curveSampleCount++;
            }
            PlsrDiagnostic.flags |= PLSR_DIAG_FLAG_CURVE_CHECKED;
            PlsrDiagnostic.flags &= (uint16_t)~PLSR_DIAG_FLAG_CURVE_PASS;
            PlsrDiagnosticFailedChecks |= PLSR_DIAG_FLAG_CURVE_PASS;
            if (PlsrDiagnostic.curveMismatchCount != 0xFFFFFFFFUL)
            {
                PlsrDiagnostic.curveMismatchCount++;
            }
            if (PlsrDiagnostic.firstMismatchSample == 0xFFFFFFFFUL)
            {
                PlsrDiagnostic.firstMismatchSample =
                    PlsrDiagnostic.curveSampleCount;
            }
            PlsrDiagnosticLatch(PLSR_DIAG_REASON_CURVE);
        }
        else if (platformFault == PLSR_DIAG_REASON_FREQUENCY)
        {
            PlsrDiagnosticRecordCurveSample(PlsrDiagnosticQueuedExpectedHz,
                                            observedHz);
        }
    }
}

static void PlsrSetDefaults(PLSR_CONFIG *config)
{
    uint8_t index;

    (void)memset(config, 0, sizeof(*config));
    config->pulseOutput = 0U;
    config->directionOutput = 0U;
    config->waitInput = 0U;
    config->extInput = 0U;
    config->sendMode = PLSR_SEND_COMPLETE;
    config->directionDelayMs = 10U;
    config->directionNegativeLogic = 0U;
    config->curveMode = 0U;
    config->positionMode = PLSR_POSITION_RELATIVE;
    config->segmentCount = 1U;
    config->startSegment = 1U;
    config->defaultSpeedHz = 1000UL;
    config->startSpeedHz = 100UL;
    config->stopSpeedHz = 100UL;
    config->accelerationTimeMs = 100U;
    config->decelerationTimeMs = 100U;
    config->outputMode = PLSR_OUTPUT_PULSE_DIR;

    for (index = 0U; index < PLSR_SEGMENT_COUNT_MAX; index++)
    {
        config->segments[index].frequencyHz = 1000UL;
        config->segments[index].pulses = (index == 0U) ? 1000L : 0L;
        config->segments[index].waitType = PLSR_EXT_OR_COMPLETE;
        config->segments[index].waitTimeMs = 0U;
        config->segments[index].actTimeMs = 0U;
        config->segments[index].jumpSegment = 0U;
    }
}

static uint8_t PlsrConfigIsValid(const PLSR_CONFIG *config,
                                 uint8_t validateActivePath)
{
    uint8_t index;

    if ((config->pulseOutput > 3U) || (config->directionOutput > 3U)
        || (config->waitInput > 1U) || (config->extInput > 1U)
        || (config->sendMode > PLSR_SEND_SUBSEQUENT)
        || (config->directionNegativeLogic > 1U)
        || (config->curveMode > 2U)
        || (config->positionMode > PLSR_POSITION_ABSOLUTE)
        || (config->outputMode > PLSR_OUTPUT_AB)
        || ((config->outputMode == PLSR_OUTPUT_AB)
            && ((config->pulseOutput & 1U) != 0U))
        || (config->segmentCount == 0U)
        || (config->segmentCount > PLSR_SEGMENT_COUNT_MAX)
        || (config->startSegment == 0U)
        || (config->startSegment > PLSR_SEGMENT_COUNT_MAX)
        || (config->defaultSpeedHz == 0UL)
        || (config->defaultSpeedHz > PLSR_FREQUENCY_MAX_HZ)
        || (config->startSpeedHz > PLSR_FREQUENCY_MAX_HZ)
        || (config->stopSpeedHz > PLSR_FREQUENCY_MAX_HZ))
    {
        return 0U;
    }

    if ((validateActivePath != 0U)
        && (config->startSegment > config->segmentCount))
    {
        return 0U;
    }

    for (index = 0U; index < PLSR_SEGMENT_COUNT_MAX; index++)
    {
        const PLSR_SEGMENT_CONFIG *segment = &config->segments[index];

        if ((segment->frequencyHz == 0UL)
            || (segment->frequencyHz > PLSR_FREQUENCY_MAX_HZ)
            || (segment->waitType > PLSR_EXT_OR_COMPLETE)
            || (segment->jumpSegment > PLSR_SEGMENT_COUNT_MAX))
        {
            return 0U;
        }

        if ((validateActivePath != 0U)
            && (index < config->segmentCount)
            && (segment->jumpSegment > config->segmentCount))
        {
            return 0U;
        }
    }

    return 1U;
}

static uint16_t PlsrReadConfigWord(const PLSR_CONFIG *config,
                                   uint16_t address)
{
    uint16_t offset;
    uint8_t segmentIndex;
    const PLSR_SEGMENT_CONFIG *segment;

    switch (address)
    {
        case 0x1000U: return config->pulseOutput;
        case 0x1001U: return config->directionOutput;
        case 0x1002U: return config->waitInput;
        case 0x1003U: return config->extInput;
        case 0x1004U: return config->sendMode;
        case 0x1005U: return config->directionDelayMs;
        case 0x1006U: return config->directionNegativeLogic;
        case 0x1007U: return config->curveMode;
        case 0x1008U: return config->positionMode;
        case 0x1009U: return config->segmentCount;
        case 0x100AU: return config->startSegment;
        case 0x100BU: return PlsrLowWord(config->defaultSpeedHz);
        case 0x100CU: return PlsrHighWord(config->defaultSpeedHz);
        case 0x100DU: return PlsrLowWord(config->startSpeedHz);
        case 0x100EU: return PlsrHighWord(config->startSpeedHz);
        case 0x1010U: return PlsrLowWord(config->stopSpeedHz);
        case 0x1011U: return PlsrHighWord(config->stopSpeedHz);
        case 0x1012U: return config->accelerationTimeMs;
        case 0x1013U: return config->decelerationTimeMs;
        default: break;
    }

    if ((address >= PLSR_SEGMENT_FIRST_ADDRESS)
        && (address <= PLSR_CONFIG_LAST_ADDRESS))
    {
        offset = (uint16_t)(address - PLSR_SEGMENT_FIRST_ADDRESS);
        segmentIndex = (uint8_t)(offset / PLSR_SEGMENT_STRIDE);
        offset = (uint16_t)(offset % PLSR_SEGMENT_STRIDE);
        segment = &config->segments[segmentIndex];

        switch (offset)
        {
            case 0U: return PlsrLowWord(segment->frequencyHz);
            case 1U: return PlsrHighWord(segment->frequencyHz);
            case 2U: return PlsrLowWord((uint32_t)segment->pulses);
            case 3U: return PlsrHighWord((uint32_t)segment->pulses);
            case 4U: return segment->waitType;
            case 5U: return segment->waitTimeMs;
            case 6U: return segment->actTimeMs;
            case 7U: return segment->jumpSegment;
            default: return 0U;
        }
    }

    /* 0x100F, 0x1014..0x10FF, and segment padding read as zero. */
    return 0U;
}

static PLSR_WORD_RESULT PlsrWriteConfigWord(PLSR_CONFIG *config,
                                            uint16_t address,
                                            uint16_t value)
{
    uint16_t offset;
    uint8_t segmentIndex;
    PLSR_SEGMENT_CONFIG *segment;

    switch (address)
    {
        case 0x1000U: config->pulseOutput = value; return PLSR_WORD_OK;
        case 0x1001U: config->directionOutput = value; return PLSR_WORD_OK;
        case 0x1002U: config->waitInput = value; return PLSR_WORD_OK;
        case 0x1003U: config->extInput = value; return PLSR_WORD_OK;
        case 0x1004U: config->sendMode = value; return PLSR_WORD_OK;
        case 0x1005U: config->directionDelayMs = value; return PLSR_WORD_OK;
        case 0x1006U:
            config->directionNegativeLogic = value;
            return PLSR_WORD_OK;
        case 0x1007U: config->curveMode = value; return PLSR_WORD_OK;
        case 0x1008U: config->positionMode = value; return PLSR_WORD_OK;
        case 0x1009U: config->segmentCount = value; return PLSR_WORD_OK;
        case 0x100AU: config->startSegment = value; return PLSR_WORD_OK;
        case 0x100BU:
            config->defaultSpeedHz =
                PlsrJoinU32(value, PlsrHighWord(config->defaultSpeedHz));
            return PLSR_WORD_OK;
        case 0x100CU:
            config->defaultSpeedHz =
                PlsrJoinU32(PlsrLowWord(config->defaultSpeedHz), value);
            return PLSR_WORD_OK;
        case 0x100DU:
            config->startSpeedHz =
                PlsrJoinU32(value, PlsrHighWord(config->startSpeedHz));
            return PLSR_WORD_OK;
        case 0x100EU:
            config->startSpeedHz =
                PlsrJoinU32(PlsrLowWord(config->startSpeedHz), value);
            return PLSR_WORD_OK;
        case 0x100FU:
            return (value == 0U) ? PLSR_WORD_OK : PLSR_WORD_ILLEGAL_VALUE;
        case 0x1010U:
            config->stopSpeedHz =
                PlsrJoinU32(value, PlsrHighWord(config->stopSpeedHz));
            return PLSR_WORD_OK;
        case 0x1011U:
            config->stopSpeedHz =
                PlsrJoinU32(PlsrLowWord(config->stopSpeedHz), value);
            return PLSR_WORD_OK;
        case 0x1012U:
            config->accelerationTimeMs = value;
            return PLSR_WORD_OK;
        case 0x1013U:
            config->decelerationTimeMs = value;
            return PLSR_WORD_OK;
        default: break;
    }

    if ((address >= 0x1014U) && (address <= PLSR_COMMON_LAST_ADDRESS))
    {
        return (value == 0U) ? PLSR_WORD_OK : PLSR_WORD_ILLEGAL_VALUE;
    }

    if ((address < PLSR_SEGMENT_FIRST_ADDRESS)
        || (address > PLSR_CONFIG_LAST_ADDRESS))
    {
        return PLSR_WORD_ILLEGAL_ADDRESS;
    }

    offset = (uint16_t)(address - PLSR_SEGMENT_FIRST_ADDRESS);
    segmentIndex = (uint8_t)(offset / PLSR_SEGMENT_STRIDE);
    offset = (uint16_t)(offset % PLSR_SEGMENT_STRIDE);
    segment = &config->segments[segmentIndex];

    switch (offset)
    {
        case 0U:
            segment->frequencyHz =
                PlsrJoinU32(value, PlsrHighWord(segment->frequencyHz));
            return PLSR_WORD_OK;
        case 1U:
            segment->frequencyHz =
                PlsrJoinU32(PlsrLowWord(segment->frequencyHz), value);
            return PLSR_WORD_OK;
        case 2U:
            segment->pulses = (int32_t)PlsrJoinU32(
                value, PlsrHighWord((uint32_t)segment->pulses));
            return PLSR_WORD_OK;
        case 3U:
            segment->pulses = (int32_t)PlsrJoinU32(
                PlsrLowWord((uint32_t)segment->pulses), value);
            return PLSR_WORD_OK;
        case 4U: segment->waitType = value; return PLSR_WORD_OK;
        case 5U: segment->waitTimeMs = value; return PLSR_WORD_OK;
        case 6U: segment->actTimeMs = value; return PLSR_WORD_OK;
        case 7U: segment->jumpSegment = value; return PLSR_WORD_OK;
        default:
            return (value == 0U) ? PLSR_WORD_OK : PLSR_WORD_ILLEGAL_VALUE;
    }
}

static uint8_t PlsrAddressIsDwordHalf(uint16_t address,
                                      uint16_t *pairedAddress)
{
    uint16_t offset;

    switch (address)
    {
        case 0x100BU: case 0x100DU: case 0x1010U:
            *pairedAddress = (uint16_t)(address + 1U);
            return 1U;
        case 0x100CU: case 0x100EU: case 0x1011U:
            *pairedAddress = (uint16_t)(address - 1U);
            return 1U;
        default: break;
    }

    if ((address >= PLSR_SEGMENT_FIRST_ADDRESS)
        && (address <= PLSR_CONFIG_LAST_ADDRESS))
    {
        offset = (uint16_t)((address - PLSR_SEGMENT_FIRST_ADDRESS)
                            % PLSR_SEGMENT_STRIDE);
        if ((offset == 0U) || (offset == 2U))
        {
            *pairedAddress = (uint16_t)(address + 1U);
            return 1U;
        }
        if ((offset == 1U) || (offset == 3U))
        {
            *pairedAddress = (uint16_t)(address - 1U);
            return 1U;
        }
    }

    return 0U;
}

static uint8_t PlsrAddressIsProduct(uint16_t address)
{
    return (((address >= PLSR_CONFIG_FIRST_ADDRESS)
             && (address <= PLSR_CONFIG_LAST_ADDRESS))
            || (address == PLSR_OUTPUT_MODE_ADDRESS)
            || ((address >= PLSR_STATUS_FIRST_ADDRESS)
                && (address <= PLSR_STATUS_LAST_ADDRESS))
            || ((address >= PLSR_DIAGNOSTIC_FIRST_ADDRESS)
                && (address <= PLSR_DIAGNOSTIC_LAST_ADDRESS))
            || (address == PLSR_CONTROL_ADDRESS)
            || (address == PLSR_DIAGNOSTIC_CONTROL_ADDRESS)) ? 1U : 0U;
}

static PLSR_MB_RESULT PlsrClassifyRange(uint16_t startAddress,
                                        uint16_t quantity)
{
    uint32_t address;
    uint32_t endAddress;
    uint8_t foundProduct = 0U;
    uint8_t foundOther = 0U;

    if (quantity == 0U)
    {
        return PLSR_MB_ILLEGAL_VALUE;
    }

    endAddress = (uint32_t)startAddress + (uint32_t)quantity - 1UL;
    if (endAddress > 0xFFFFUL)
    {
        return PLSR_MB_ILLEGAL_ADDRESS;
    }

    for (address = startAddress; address <= endAddress; address++)
    {
        if (PlsrAddressIsProduct((uint16_t)address) != 0U)
        {
            foundProduct = 1U;
        }
        else
        {
            foundOther = 1U;
        }
    }

    if (foundProduct == 0U)
    {
        return PLSR_MB_NOT_HANDLED;
    }
    return (foundOther != 0U) ? PLSR_MB_ILLEGAL_ADDRESS : PLSR_MB_OK;
}

static uint32_t PlsrCurveProgressQ16(uint32_t elapsed,
                                     uint32_t duration,
                                     uint16_t curveMode)
{
    uint32_t linear;

    if ((duration == 0UL) || (elapsed >= duration))
    {
        return 65535UL;
    }

    linear = (uint32_t)(((uint64_t)elapsed * 65535UL) / duration);
    if (curveMode == 1U)
    {
        uint64_t x = linear;
        uint64_t x2 = (x * x) / 65535UL;
        return (uint32_t)((x2 * (196605UL - 2UL * x)) / 65535UL);
    }
    if (curveMode == 2U)
    {
        uint32_t scaled = linear * 64UL;
        uint32_t index = scaled / 65535UL;
        uint32_t fraction = scaled % 65535UL;
        uint32_t first;
        uint32_t second;

        if (index >= 64UL)
        {
            return 65535UL;
        }
        first = PlsrSineProgressQ16[index];
        second = PlsrSineProgressQ16[index + 1UL];
        return first + (uint32_t)(((uint64_t)(second - first) * fraction)
                                  / 65535UL);
    }
    return linear;
}

static uint32_t PlsrRampDurationMs(uint32_t fromHz, uint32_t toHz)
{
    uint32_t gap;
    uint32_t baseTimeMs;
    uint64_t duration;

    if (fromHz == toHz)
    {
        return 0UL;
    }
    gap = (fromHz > toHz) ? (fromHz - toHz) : (toHz - fromHz);
    baseTimeMs = (toHz > fromHz) ? PlsrActiveConfig.accelerationTimeMs
                                 : PlsrActiveConfig.decelerationTimeMs;
    if (baseTimeMs == 0UL)
    {
        return 0UL;
    }

    duration = ((uint64_t)gap * baseTimeMs
                + PlsrActiveConfig.defaultSpeedHz - 1UL)
               / PlsrActiveConfig.defaultSpeedHz;
    if (duration > 0xFFFFFFFFUL)
    {
        return 0xFFFFFFFFUL;
    }
    return (uint32_t)duration;
}

static void PlsrRampStart(uint32_t fromHz, uint32_t toHz)
{
    PlsrRamp.fromHz = fromHz;
    PlsrRamp.toHz = toHz;
    PlsrRamp.durationMs = PlsrRampDurationMs(fromHz, toHz);
    PlsrRamp.elapsedMs = 0UL;
    PlsrRamp.active = (PlsrRamp.durationMs != 0UL) ? 1U : 0U;

    if (toHz > fromHz)
    {
        PlsrRunStatus = PLSR_STATUS_ACCELERATING;
    }
    else if (toHz < fromHz)
    {
        PlsrRunStatus = PLSR_STATUS_DECELERATING;
    }
    else
    {
        PlsrRunStatus = PLSR_STATUS_RUNNING;
    }
}

static uint8_t PlsrApplyFrequencyPair(uint32_t requestedFirstFrequencyHz,
                                      uint32_t requestedQueuedFrequencyHz,
                                      uint32_t expectedEpoch)
{
    uint32_t criticalState;
    uint32_t actualFirstFrequencyHz;
    uint32_t actualQueuedFrequencyHz;
    uint32_t hardwareFirstFrequencyHz = requestedFirstFrequencyHz;
    uint32_t hardwareQueuedFrequencyHz = requestedQueuedFrequencyHz;
    PLSR_HANDOFF_PLAN candidatePlan;
    uint8_t haveCandidatePlan = 0U;

    criticalState = PlsrPlatformEnterCritical();
    if ((PlsrSegmentEpoch != expectedEpoch)
        || (PlsrBoundaryPending != 0U) || (PlsrRemainingPulses == 0UL))
    {
        PlsrPlatformExitCritical(criticalState);
        return 1U;
    }

    if (hardwareFirstFrequencyHz == 0UL)
    {
        if (PlsrPulseActive == 0U)
        {
            PlsrCurrentFrequencyHz = 0UL;
            PlsrQueuedFrequencyHz = 0UL;
            PlsrPlatformExitCritical(criticalState);
            return 1U;
        }
        hardwareFirstFrequencyHz = 1UL;
    }
    if (hardwareQueuedFrequencyHz == 0UL)
    {
        hardwareQueuedFrequencyHz = 1UL;
    }

    if (PlsrPulseActive != 0U)
    {
        if (PlsrAbStopArmed != 0U)
        {
            PlsrPlatformExitCritical(criticalState);
            return 1U;
        }
        if (PlsrHandoffPlan.valid != 0U)
        {
            PlsrPlatformExitCritical(criticalState);
            return 1U;
        }
        PlsrDeferredFrequencyHz = hardwareQueuedFrequencyHz;
        PlsrDeferredFrequencyPending = 1U;
        PlsrPlatformExitCritical(criticalState);
        return 1U;
    }
    else
    {
        if (PlsrSelectPreparedHandoffPlan(&candidatePlan) != 0U)
        {
            hardwareQueuedFrequencyHz = candidatePlan.firstFrequencyHz;
            haveCandidatePlan = 1U;
        }
        if (PlsrDiagnosticStartPulse(
                (uint8_t)PlsrActiveConfig.pulseOutput,
                hardwareFirstFrequencyHz, hardwareQueuedFrequencyHz,
                &actualFirstFrequencyHz, &actualQueuedFrequencyHz) == 0U)
        {
            PlsrPlatformExitCritical(criticalState);
            return 0U;
        }
        PlsrPulseActive = 1U;
        PlsrCurrentFrequencyHz = actualFirstFrequencyHz;
        PlsrHandoffPlan.valid = 0U;
        if (haveCandidatePlan != 0U)
        {
            PlsrHandoffPlan.magnitude = candidatePlan.magnitude;
            PlsrHandoffPlan.firstFrequencyHz = actualQueuedFrequencyHz;
            PlsrHandoffPlan.secondFrequencyHz =
                candidatePlan.secondFrequencyHz;
            PlsrHandoffPlan.firstRequestedFrequencyHz =
                candidatePlan.firstRequestedFrequencyHz;
            PlsrHandoffPlan.secondRequestedFrequencyHz =
                candidatePlan.secondRequestedFrequencyHz;
            PlsrHandoffPlan.firstSetting = candidatePlan.firstSetting;
            PlsrHandoffPlan.secondSetting = candidatePlan.secondSetting;
            PlsrCopyShortProfile(&PlsrHandoffPlan.profile,
                                 &candidatePlan.profile);
            PlsrHandoffPlan.nextSegment = candidatePlan.nextSegment;
            PlsrHandoffPlan.positive = candidatePlan.positive;
            PlsrHandoffPlan.valid = 1U;
        }
    }

    PlsrQueuedFrequencyHz = actualQueuedFrequencyHz;
    if (PlsrArmFinalAbBoundaryLocked() == 0U)
    {
        PlsrPlatformExitCritical(criticalState);
        return 0U;
    }
    PlsrPlatformExitCritical(criticalState);
    return 1U;
}

static uint8_t PlsrApplyFrequency(uint32_t requestedFrequencyHz,
                                  uint32_t expectedEpoch)
{
    return PlsrApplyFrequencyPair(requestedFrequencyHz,
                                  requestedFrequencyHz,
                                  expectedEpoch);
}

static uint8_t PlsrStopDrainPulseCount(void)
{
    uint8_t deferredPending = PlsrDeferredFrequencyPending;
    uint32_t deferredFrequencyHz = PlsrDeferredFrequencyHz;
    uint32_t queuedFrequencyHz = PlsrQueuedFrequencyHz;
    uint32_t currentFrequencyHz = PlsrCurrentFrequencyHz;

    if ((deferredPending != 0U)
        && (deferredFrequencyHz != queuedFrequencyHz))
    {
        return 3U;
    }
    PlsrDeferredFrequencyPending = 0U;
    return (currentFrequencyHz == queuedFrequencyHz) ? 1U : 2U;
}

static PLSR_PLATFORM_QUEUE_RESULT PlsrCommitDeferredFrequency(
    uint8_t pulseOutput)
{
    uint32_t requestedFrequencyHz;
    uint32_t actualFrequencyHz;
    PLSR_PLATFORM_QUEUE_RESULT result;

    if (PlsrDeferredFrequencyPending == 0U)
    {
        return PLSR_PLATFORM_QUEUE_APPLIED;
    }
    requestedFrequencyHz = PlsrDeferredFrequencyHz;
    result = PlsrDiagnosticQueueFrequency(pulseOutput, requestedFrequencyHz,
                                          &actualFrequencyHz);
    if (result != PLSR_PLATFORM_QUEUE_APPLIED)
    {
        return result;
    }
    if ((PlsrDeferredFrequencyPending != 0U)
        && (PlsrDeferredFrequencyHz == requestedFrequencyHz))
    {
        PlsrDeferredFrequencyPending = 0U;
    }
    PlsrQueuedFrequencyHz = actualFrequencyHz;
    return PLSR_PLATFORM_QUEUE_APPLIED;
}

static uint8_t PlsrRampAdvance(uint32_t expectedEpoch)
{
    uint32_t progress;
    uint32_t frequency;
    uint32_t gap;
    uint32_t criticalState;
    uint32_t fromHz;
    uint32_t toHz;
    uint32_t durationMs;
    uint32_t elapsedMs;

    criticalState = PlsrPlatformEnterCritical();
    if ((PlsrSegmentEpoch != expectedEpoch) || (PlsrRamp.active == 0U))
    {
        PlsrPlatformExitCritical(criticalState);
        return 1U;
    }
    PlsrRamp.elapsedMs++;
    fromHz = PlsrRamp.fromHz;
    toHz = PlsrRamp.toHz;
    durationMs = PlsrRamp.durationMs;
    elapsedMs = PlsrRamp.elapsedMs;
    PlsrPlatformExitCritical(criticalState);

    progress = PlsrCurveProgressQ16(elapsedMs,
                                    durationMs,
                                    PlsrActiveConfig.curveMode);
    if (toHz >= fromHz)
    {
        gap = toHz - fromHz;
        frequency = fromHz
                    + (uint32_t)(((uint64_t)gap * progress) / 65535UL);
    }
    else
    {
        gap = fromHz - toHz;
        frequency = fromHz
                    - (uint32_t)(((uint64_t)gap * progress) / 65535UL);
    }

    if (PlsrApplyFrequency(frequency, expectedEpoch) == 0U)
    {
        return 0U;
    }

    criticalState = PlsrPlatformEnterCritical();
    if (PlsrSegmentEpoch != expectedEpoch)
    {
        PlsrPlatformExitCritical(criticalState);
        return 1U;
    }
    if (elapsedMs >= durationMs)
    {
        PlsrRamp.active = 0U;
        if (PlsrStopRequested == 0U)
        {
            PlsrRunStatus = PLSR_STATUS_RUNNING;
        }
        else
        {
            PlsrStopPulsesRemaining = PlsrStopDrainPulseCount();
            (void)PlsrArmFinalAbBoundaryLocked();
        }
    }
    PlsrPlatformExitCritical(criticalState);
    return 1U;
}

static uint8_t PlsrGetNextSegment(uint8_t *nextSegment)
{
    const PLSR_SEGMENT_CONFIG *segment =
        &PlsrActiveConfig.segments[PlsrCurrentSegment - 1U];

    if (segment->jumpSegment != 0U)
    {
        *nextSegment = (uint8_t)segment->jumpSegment;
        return 1U;
    }
    if (PlsrCurrentSegment < PlsrActiveConfig.segmentCount)
    {
        *nextSegment = (uint8_t)(PlsrCurrentSegment + 1U);
        return 1U;
    }
    return 0U;
}

static int64_t PlsrSegmentDisplacement(uint8_t segmentNumber,
                                       int32_t referencePosition)
{
    int32_t configured =
        PlsrActiveConfig.segments[segmentNumber - 1U].pulses;

    if (PlsrActiveConfig.positionMode == PLSR_POSITION_ABSOLUTE)
    {
        return (int64_t)configured - (int64_t)referencePosition;
    }
    return configured;
}

static uint8_t PlsrPredictNextDirection(uint8_t nextSegment,
                                        uint8_t *positive)
{
    uint32_t criticalState;
    uint64_t remaining;
    int32_t position;
    uint32_t predictedBits;
    int32_t predictedPosition;
    int64_t displacement;

    criticalState = PlsrPlatformEnterCritical();
    remaining = PlsrRemainingPulses;
    position = PlsrPosition;
    PlsrPlatformExitCritical(criticalState);

    predictedBits = (uint32_t)position;
    if (PlsrCountPositive != 0U)
    {
        predictedBits += (uint32_t)remaining;
    }
    else
    {
        predictedBits -= (uint32_t)remaining;
    }
    predictedPosition = (int32_t)predictedBits;
    displacement = PlsrSegmentDisplacement(nextSegment, predictedPosition);
    if (displacement == 0)
    {
        return 0U;
    }
    *positive = (displacement > 0) ? 1U : 0U;
    return 1U;
}

static uint64_t PlsrRemainingSnapshot(void)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();
    uint64_t remaining = PlsrRemainingPulses;
    PlsrPlatformExitCritical(criticalState);
    return remaining;
}

static uint64_t PlsrRampPulseEstimate(uint32_t fromHz,
                                      uint32_t toHz,
                                      uint32_t rateBoundHz)
{
    uint32_t duration = PlsrRampDurationMs(fromHz, toHz);
    uint64_t sum = (uint64_t)fromHz + toHz;
    uint64_t estimate = (sum * duration + 1999UL) / 2000UL + 2UL;
    uint64_t reserve = ((uint64_t)rateBoundHz + 999UL) / 1000UL;

    if ((duration != 0UL) && (fromHz > toHz))
    {
        /* A 1 ms held deceleration step can exceed the ideal ramp area. */
        reserve += ((uint64_t)(fromHz - toHz) + 999UL) / 1000UL;
    }
    if (UINT64_MAX - estimate < reserve)
    {
        return UINT64_MAX;
    }

    return estimate + reserve;
}

static uint16_t PlsrShortProfileRampTime(uint32_t fromHz, uint32_t toHz)
{
    if (toHz > fromHz)
    {
        return PlsrActiveConfig.accelerationTimeMs;
    }
    if (toHz < fromHz)
    {
        return PlsrActiveConfig.decelerationTimeMs;
    }
    return 0U;
}

static uint64_t PlsrShortProfileRampWeight(uint32_t fromHz,
                                            uint32_t toHz,
                                            uint16_t timeMs)
{
    uint64_t fromSquared = (uint64_t)fromHz * fromHz;
    uint64_t toSquared = (uint64_t)toHz * toHz;
    uint64_t difference = (fromSquared > toSquared)
                              ? (fromSquared - toSquared)
                              : (toSquared - fromSquared);

    return difference * timeMs;
}

static uint32_t PlsrIntegerSquareRoot(uint64_t value)
{
    uint64_t bit = (uint64_t)1U << 62U;
    uint64_t root = 0UL;

    while (bit > value)
    {
        bit >>= 2U;
    }
    while (bit != 0UL)
    {
        if (value >= (root + bit))
        {
            value -= root + bit;
            root = (root >> 1U) + bit;
        }
        else
        {
            root >>= 1U;
        }
        bit >>= 2U;
    }
    return (uint32_t)root;
}

static uint32_t PlsrShortProfilePeak(uint32_t startHz,
                                     uint32_t targetHz,
                                     uint32_t endHz,
                                     uint16_t pulseCount)
{
    uint32_t upperEndpoint = (startHz > endHz) ? startHz : endHz;
    uint32_t lowerEndpoint = (startHz < endHz) ? startHz : endHz;
    uint16_t entryTime;
    uint16_t exitTime;
    uint32_t timeSum;
    uint64_t weightedEndpoints;
    uint64_t availableArea;
    uint64_t peakSquared;
    uint32_t peakHz;

    if (targetHz > upperEndpoint)
    {
        entryTime = PlsrShortProfileRampTime(startHz, targetHz);
        exitTime = PlsrShortProfileRampTime(targetHz, endHz);
        timeSum = (uint32_t)entryTime + exitTime;
        if (timeSum == 0UL)
        {
            return targetHz;
        }
        weightedEndpoints = ((uint64_t)startHz * startHz * entryTime)
                            + ((uint64_t)endHz * endHz * exitTime);
        availableArea = (uint64_t)2U * pulseCount
                        * PlsrActiveConfig.defaultSpeedHz * 1000UL;
        peakSquared = (availableArea + weightedEndpoints) / timeSum;
        peakHz = PlsrIntegerSquareRoot(peakSquared);
        if (peakHz < upperEndpoint)
        {
            peakHz = upperEndpoint;
        }
        if (peakHz > targetHz)
        {
            peakHz = targetHz;
        }
        return peakHz;
    }

    if (targetHz < lowerEndpoint)
    {
        entryTime = PlsrShortProfileRampTime(startHz, targetHz);
        exitTime = PlsrShortProfileRampTime(targetHz, endHz);
        timeSum = (uint32_t)entryTime + exitTime;
        if (timeSum == 0UL)
        {
            return targetHz;
        }
        weightedEndpoints = ((uint64_t)startHz * startHz * entryTime)
                            + ((uint64_t)endHz * endHz * exitTime);
        availableArea = (uint64_t)2U * pulseCount
                        * PlsrActiveConfig.defaultSpeedHz * 1000UL;
        if (availableArea >= weightedEndpoints)
        {
            return targetHz;
        }
        peakSquared = (weightedEndpoints - availableArea) / timeSum;
        peakHz = PlsrIntegerSquareRoot(peakSquared);
        if (peakHz < targetHz)
        {
            peakHz = targetHz;
        }
        if (peakHz > lowerEndpoint)
        {
            peakHz = lowerEndpoint;
        }
        return peakHz;
    }

    return targetHz;
}

static uint64_t PlsrShortProfileRequiredSteps(uint64_t rampWeight)
{
    uint64_t denominator = (uint64_t)2U
                           * PlsrActiveConfig.defaultSpeedHz * 1000UL;

    if (rampWeight == 0UL)
    {
        return 0UL;
    }
    return (rampWeight + denominator - 1UL) / denominator;
}

static uint32_t PlsrShortProfileReachableFrequency(uint32_t fromHz,
                                                    uint32_t towardHz,
                                                    uint16_t pulseCount)
{
    uint16_t baseTime = PlsrShortProfileRampTime(fromHz, towardHz);
    uint64_t frequencySquared = (uint64_t)fromHz * fromHz;
    uint64_t changeSquared;
    uint32_t reachableHz;

    if ((baseTime == 0U) || (fromHz == towardHz))
    {
        return towardHz;
    }
    changeSquared = (uint64_t)2U * pulseCount
                    * PlsrActiveConfig.defaultSpeedHz * 1000UL / baseTime;
    if (towardHz > fromHz)
    {
        reachableHz = PlsrIntegerSquareRoot(frequencySquared + changeSquared);
        return (reachableHz > towardHz) ? towardHz : reachableHz;
    }

    frequencySquared = (changeSquared >= frequencySquared)
                           ? 0UL : (frequencySquared - changeSquared);
    reachableHz = PlsrIntegerSquareRoot(frequencySquared);
    if (((uint64_t)reachableHz * reachableHz) < frequencySquared)
    {
        reachableHz++;
    }
    return (reachableHz < towardHz) ? towardHz : reachableHz;
}

static uint64_t PlsrCurveIntegralQ32(uint64_t progressQ32,
                                     uint16_t curveMode)
{
    uint64_t scaled;
    uint32_t index;
    uint32_t fraction;
    uint64_t first;
    uint64_t second;
    const uint32_t *table;

    if (progressQ32 >= PLSR_Q32_ONE)
    {
        return PLSR_Q32_ONE / 2ULL;
    }
    if (curveMode == 0U)
    {
        return (progressQ32 * progressQ32) >> 33U;
    }

    table = (curveMode == 1U) ? PlsrSmoothIntegralQ24
                              : PlsrSineIntegralQ24;
    scaled = progressQ32 * 64ULL;
    index = (uint32_t)(scaled >> 32U);
    fraction = (uint32_t)scaled;
    first = (uint64_t)table[index] << 8U;
    second = (uint64_t)table[index + 1UL] << 8U;
    return first + (((second - first) * fraction) >> 32U);
}

static uint64_t PlsrRampAreaQ32(uint32_t fromHz,
                                uint32_t toHz,
                                uint64_t progressQ32)
{
    int64_t delta = (int64_t)toHz - (int64_t)fromHz;
    int64_t area = (int64_t)((uint64_t)fromHz * progressQ32)
                   + delta * (int64_t)PlsrCurveIntegralQ32(
                       progressQ32, PlsrActiveConfig.curveMode);
    return (uint64_t)area;
}

static uint32_t PlsrRampInstantFrequency(uint32_t fromHz,
                                         uint32_t toHz,
                                         uint64_t progressQ32)
{
    uint64_t curveProgressQ32;
    uint64_t scaled;
    uint32_t index;
    uint32_t tableSlopeQ32;
    uint32_t gap;
    const uint32_t *integralTable;

    if (progressQ32 >= PLSR_Q32_ONE)
    {
        return toHz;
    }
    if (PlsrActiveConfig.curveMode != 0U)
    {
        scaled = progressQ32 * 64ULL;
        index = (uint32_t)(scaled >> 32U);
        integralTable = (PlsrActiveConfig.curveMode == 1U)
                            ? PlsrSmoothIntegralQ24
                            : PlsrSineIntegralQ24;
        tableSlopeQ32 =
            (integralTable[index + 1UL] - integralTable[index]) << 14U;
        curveProgressQ32 = tableSlopeQ32;
    }
    else
    {
        curveProgressQ32 = progressQ32;
    }

    if (toHz >= fromHz)
    {
        gap = toHz - fromHz;
        return fromHz
               + (uint32_t)(((uint64_t)gap * curveProgressQ32) >> 32U);
    }
    gap = fromHz - toHz;
    return fromHz
           - (uint32_t)(((uint64_t)gap * curveProgressQ32) >> 32U);
}

static uint64_t PlsrExactRampBoundaryQ32(uint32_t fromHz,
                                         uint32_t toHz,
                                         uint64_t previousBoundaryQ32,
                                         uint64_t targetAreaQ32)
{
    uint64_t lowerQ32 = previousBoundaryQ32;
    uint64_t upperQ32 = PLSR_Q32_ONE;
    uint64_t middleQ32;
    uint32_t iteration;

    /* The Q32 domain is 2^32 units wide, so 32 fixed bisections are exact. */
    for (iteration = 0UL; iteration < 32UL; iteration++)
    {
        middleQ32 = lowerQ32 + ((upperQ32 - lowerQ32) >> 1U);
        if (PlsrRampAreaQ32(fromHz, toHz, middleQ32) < targetAreaQ32)
        {
            lowerQ32 = middleQ32;
        }
        else
        {
            upperQ32 = middleQ32;
        }
    }
    return upperQ32;
}

static uint32_t PlsrCountLeadingZeros32(uint32_t value)
{
#if defined(__ICCARM__)
    return __CLZ(value);
#else
    uint32_t count = 0U;

    if ((value & 0xFFFF0000UL) == 0UL)
    {
        count += 16U;
        value <<= 16U;
    }
    if ((value & 0xFF000000UL) == 0UL)
    {
        count += 8U;
        value <<= 8U;
    }
    if ((value & 0xF0000000UL) == 0UL)
    {
        count += 4U;
        value <<= 4U;
    }
    if ((value & 0xC0000000UL) == 0UL)
    {
        count += 2U;
        value <<= 2U;
    }
    if ((value & 0x80000000UL) == 0UL)
    {
        count++;
    }
    return count;
#endif
}

static uint32_t PlsrDivideU64Low(uint32_t highWord,
                                  uint32_t lowWord,
                                  uint32_t divisor,
                                  uint32_t *remainder)
{
    const uint32_t halfBase = 0x10000UL;
    uint32_t shift = PlsrCountLeadingZeros32(divisor);
    uint32_t normalizedDivisor = divisor << shift;
    uint32_t divisorHigh = normalizedDivisor >> 16U;
    uint32_t divisorLow = normalizedDivisor & 0xFFFFUL;
    uint32_t normalizedHigh;
    uint32_t normalizedLow = lowWord << shift;
    uint32_t lowHigh = normalizedLow >> 16U;
    uint32_t lowLow = normalizedLow & 0xFFFFUL;
    uint32_t quotientHigh;
    uint32_t quotientLow;
    uint32_t partialRemainder;
    uint32_t middle;
    uint32_t normalizedRemainder;

    if (shift == 0U)
    {
        normalizedHigh = highWord;
    }
    else
    {
        normalizedHigh = (highWord << shift)
                         | (lowWord >> (32U - shift));
    }

    quotientHigh = normalizedHigh / divisorHigh;
    partialRemainder = normalizedHigh - quotientHigh * divisorHigh;
    while ((quotientHigh >= halfBase)
           || (quotientHigh * divisorLow
               > (partialRemainder << 16U) + lowHigh))
    {
        quotientHigh--;
        partialRemainder += divisorHigh;
        if (partialRemainder >= halfBase)
        {
            break;
        }
    }

    middle = normalizedHigh * halfBase + lowHigh
             - quotientHigh * normalizedDivisor;
    quotientLow = middle / divisorHigh;
    partialRemainder = middle - quotientLow * divisorHigh;
    while ((quotientLow >= halfBase)
           || (quotientLow * divisorLow
               > (partialRemainder << 16U) + lowLow))
    {
        quotientLow--;
        partialRemainder += divisorHigh;
        if (partialRemainder >= halfBase)
        {
            break;
        }
    }

    normalizedRemainder = middle * halfBase + lowLow
                          - quotientLow * normalizedDivisor;
    if (remainder != NULL)
    {
        *remainder = normalizedRemainder >> shift;
    }
    return quotientHigh * halfBase + quotientLow;
}

static uint64_t PlsrDivideU64ByU32(uint64_t dividend,
                                    uint32_t divisor,
                                    uint32_t *remainder)
{
    uint32_t highWord = (uint32_t)(dividend >> 32U);
    uint32_t lowWord = (uint32_t)dividend;
    uint32_t quotientHigh = highWord / divisor;
    uint32_t highRemainder = highWord - quotientHigh * divisor;
    uint32_t quotientLow = PlsrDivideU64Low(highRemainder, lowWord,
                                             divisor, remainder);

    return ((uint64_t)quotientHigh << 32U) | quotientLow;
}

static void PlsrPrepareShortProfileBoundaries(PLSR_SHORT_PROFILE *profile)
{
    uint64_t totalAreaQ32;
    uint64_t areaStepQ32;
    uint64_t targetAreaQ32;
    uint32_t areaRemainder;

    if (profile->entryPulses != 0U)
    {
        totalAreaQ32 = PlsrRampAreaQ32(
            profile->startHz, profile->peakHz, PLSR_Q32_ONE);
        areaStepQ32 = totalAreaQ32 / profile->entryPulses;
        areaRemainder = (uint32_t)(totalAreaQ32 % profile->entryPulses);
        profile->entryFirstBoundaryQ32 = PlsrExactRampBoundaryQ32(
            profile->startHz, profile->peakHz, 0ULL, areaStepQ32);
        if (profile->entryPulses > 1U)
        {
            targetAreaQ32 = areaStepQ32 * 2ULL
                + (((uint64_t)areaRemainder * 2ULL)
                   / profile->entryPulses);
            profile->entrySecondBoundaryQ32 = PlsrExactRampBoundaryQ32(
                profile->startHz, profile->peakHz,
                profile->entryFirstBoundaryQ32, targetAreaQ32);
        }
    }
    if (profile->exitPulses != 0U)
    {
        totalAreaQ32 = PlsrRampAreaQ32(
            profile->peakHz, profile->endHz, PLSR_Q32_ONE);
        areaStepQ32 = totalAreaQ32 / profile->exitPulses;
        areaRemainder = (uint32_t)(totalAreaQ32 % profile->exitPulses);
        profile->exitFirstBoundaryQ32 = PlsrExactRampBoundaryQ32(
            profile->peakHz, profile->endHz, 0ULL, areaStepQ32);
        if (profile->exitPulses > 1U)
        {
            targetAreaQ32 = areaStepQ32 * 2ULL
                + (((uint64_t)areaRemainder * 2ULL)
                   / profile->exitPulses);
            profile->exitSecondBoundaryQ32 = PlsrExactRampBoundaryQ32(
                profile->peakHz, profile->endHz,
                profile->exitFirstBoundaryQ32, targetAreaQ32);
        }
    }
}

static uint64_t PlsrRampBoundaryQ32(uint32_t fromHz,
                                    uint32_t toHz,
                                    uint64_t previousBoundaryQ32,
                                    uint64_t targetAreaQ32,
                                    uint64_t predictedStepQ32)
{
    uint64_t currentAreaQ32;
    uint64_t candidateQ32;
    uint64_t candidateAreaQ32;
    uint64_t differenceQ32;
    uint64_t correctionQ32;
    uint32_t derivativeHz;

    currentAreaQ32 = (previousBoundaryQ32 == 0ULL)
                         ? 0ULL
                         : PlsrRampAreaQ32(fromHz, toHz,
                                           previousBoundaryQ32);
    if (targetAreaQ32 <= currentAreaQ32)
    {
        return previousBoundaryQ32 + 1ULL;
    }

    if (predictedStepQ32 != 0ULL)
    {
        if (predictedStepQ32 >= PLSR_Q32_ONE - previousBoundaryQ32)
        {
            candidateQ32 = PLSR_Q32_ONE;
        }
        else
        {
            candidateQ32 = previousBoundaryQ32 + predictedStepQ32;
        }
    }
    else
    {
        derivativeHz = PlsrRampInstantFrequency(fromHz, toHz,
                                                 previousBoundaryQ32);
        if (derivativeHz == 0UL)
        {
            derivativeHz = 1UL;
        }
        differenceQ32 = targetAreaQ32 - currentAreaQ32;
        correctionQ32 =
            PlsrDivideU64ByU32(differenceQ32 + derivativeHz - 1UL,
                               derivativeHz, NULL);
        if (correctionQ32 >= PLSR_Q32_ONE - previousBoundaryQ32)
        {
            candidateQ32 = PLSR_Q32_ONE;
        }
        else
        {
            candidateQ32 = previousBoundaryQ32 + correctionQ32;
        }
    }

    candidateAreaQ32 = PlsrRampAreaQ32(fromHz, toHz, candidateQ32);
    derivativeHz = PlsrRampInstantFrequency(fromHz, toHz, candidateQ32);
    if (derivativeHz == 0UL)
    {
        derivativeHz = 1UL;
    }
    if (candidateAreaQ32 < targetAreaQ32)
    {
        differenceQ32 = targetAreaQ32 - candidateAreaQ32;
        correctionQ32 =
            PlsrDivideU64ByU32(differenceQ32 + derivativeHz - 1UL,
                               derivativeHz, NULL);
        if (correctionQ32 >= PLSR_Q32_ONE - candidateQ32)
        {
            candidateQ32 = PLSR_Q32_ONE;
        }
        else
        {
            candidateQ32 += correctionQ32;
        }
    }
    else if (candidateAreaQ32 > targetAreaQ32)
    {
        differenceQ32 = candidateAreaQ32 - targetAreaQ32;
        correctionQ32 = PlsrDivideU64ByU32(differenceQ32, derivativeHz,
                                            NULL);
        if (correctionQ32 == 0ULL)
        {
            correctionQ32 = 1ULL;
        }
        if (correctionQ32 >= candidateQ32 - previousBoundaryQ32)
        {
            candidateQ32 = previousBoundaryQ32 + 1ULL;
        }
        else
        {
            candidateQ32 -= correctionQ32;
        }
    }

    /* The corrected phase step seeds the next pulse and keeps ISR work fixed. */
    return candidateQ32;
}

static uint32_t PlsrRampAverageFrequency(uint64_t areaIncrementQ32,
                                         uint64_t firstBoundaryQ32,
                                         uint64_t secondBoundaryQ32)
{
    uint64_t denominator;
    uint64_t frequencyHz;

    if (secondBoundaryQ32 <= firstBoundaryQ32)
    {
        return 1UL;
    }
    denominator = secondBoundaryQ32 - firstBoundaryQ32;
    if (denominator == PLSR_Q32_ONE)
    {
        frequencyHz = (areaIncrementQ32 + denominator / 2ULL) >> 32U;
    }
    else
    {
        frequencyHz = PlsrDivideU64ByU32(
            areaIncrementQ32 + denominator / 2ULL,
            (uint32_t)denominator, NULL);
    }
    if (frequencyHz == 0UL)
    {
        return 1UL;
    }
    if (frequencyHz > PLSR_FREQUENCY_MAX_HZ)
    {
        return PLSR_FREQUENCY_MAX_HZ;
    }
    return (uint32_t)frequencyHz;
}

static uint8_t PlsrPrepareShortProfile(PLSR_SHORT_PROFILE *profile,
                                       uint8_t segmentNumber,
                                       uint32_t startFrequencyHz,
                                       uint32_t targetFrequencyHz,
                                       uint64_t pulseCount)
{
    const PLSR_SEGMENT_CONFIG *segment;
    uint32_t endFrequencyHz;
    uint32_t peakFrequencyHz;
    uint16_t entryTime;
    uint16_t exitTime;
    uint16_t totalPulses;
    uint64_t entryWeight;
    uint64_t exitWeight;
    uint64_t entryRequired;
    uint64_t exitRequired;
    uint64_t totalWeight;
    uint64_t scaledEntry;

    uint64_t durationWeight;
    uint64_t singleFrequencyHz;
    uint16_t directTime;
    uint64_t directWeight;
    uint64_t directRequired;

    (void)memset(profile, 0, sizeof(*profile));
    if ((pulseCount == 0UL)
        || (pulseCount > PLSR_SHORT_PROFILE_MAX_PULSES)
        || (segmentNumber != PlsrActiveConfig.segmentCount))
    {
        return 0U;
    }

    segment = &PlsrActiveConfig.segments[segmentNumber - 1U];
    if (segment->jumpSegment != 0U)
    {
        return 0U;
    }

    endFrequencyHz = PlsrActiveConfig.stopSpeedHz;
    totalPulses = (uint16_t)pulseCount;
    directTime = PlsrShortProfileRampTime(startFrequencyHz, endFrequencyHz);
    directWeight = PlsrShortProfileRampWeight(startFrequencyHz,
                                               endFrequencyHz,
                                               directTime);
    directRequired = PlsrShortProfileRequiredSteps(directWeight);
    if (directRequired > totalPulses)
    {
        profile->startHz = startFrequencyHz;
        profile->peakHz = PlsrShortProfileReachableFrequency(
            startFrequencyHz, endFrequencyHz, totalPulses);
        profile->endHz = profile->peakHz;
        profile->pulseCount = totalPulses;
        profile->entryPulses = totalPulses;
        profile->active = 1U;
        PlsrPrepareShortProfileBoundaries(profile);
        return 1U;
    }

    peakFrequencyHz = PlsrShortProfilePeak(startFrequencyHz,
                                            targetFrequencyHz,
                                            endFrequencyHz,
                                            (uint16_t)pulseCount);
    entryTime = PlsrShortProfileRampTime(startFrequencyHz, peakFrequencyHz);
    exitTime = PlsrShortProfileRampTime(peakFrequencyHz, endFrequencyHz);
    entryWeight = PlsrShortProfileRampWeight(startFrequencyHz,
                                              peakFrequencyHz,
                                              entryTime);
    exitWeight = PlsrShortProfileRampWeight(peakFrequencyHz,
                                             endFrequencyHz,
                                             exitTime);
    entryRequired = PlsrShortProfileRequiredSteps(entryWeight);
    exitRequired = PlsrShortProfileRequiredSteps(exitWeight);
    if ((entryRequired == 0UL) && (exitRequired == 0UL))
    {
        return 0U;
    }

    profile->startHz = startFrequencyHz;
    profile->peakHz = peakFrequencyHz;
    profile->endHz = endFrequencyHz;
    profile->pulseCount = totalPulses;

    if (totalPulses == 1U)
    {
        durationWeight =
            (uint64_t)((peakFrequencyHz > startFrequencyHz)
                           ? (peakFrequencyHz - startFrequencyHz)
                           : (startFrequencyHz - peakFrequencyHz)) * entryTime
            + (uint64_t)((peakFrequencyHz > endFrequencyHz)
                             ? (peakFrequencyHz - endFrequencyHz)
                             : (endFrequencyHz - peakFrequencyHz)) * exitTime;
        if (durationWeight == 0UL)
        {
            return 0U;
        }
        singleFrequencyHz =
            ((uint64_t)PlsrActiveConfig.defaultSpeedHz * 1000UL
             + durationWeight / 2UL) / durationWeight;
        if (singleFrequencyHz == 0UL)
        {
            singleFrequencyHz = 1UL;
        }
        if (singleFrequencyHz > PLSR_FREQUENCY_MAX_HZ)
        {
            singleFrequencyHz = PLSR_FREQUENCY_MAX_HZ;
        }
        profile->peakHz = (uint32_t)singleFrequencyHz;
        profile->steadyPulses = 1U;
        profile->active = 1U;
        return 1U;
    }

    if ((exitRequired == 0UL) && (peakFrequencyHz != endFrequencyHz))
    {
        exitRequired = 1UL;
        exitWeight = (uint64_t)2U
                     * PlsrActiveConfig.defaultSpeedHz * 1000UL;
    }

    if ((entryRequired + exitRequired) <= totalPulses)
    {
        profile->entryPulses = (uint16_t)entryRequired;
        profile->exitPulses = (uint16_t)exitRequired;
        profile->steadyPulses =
            (uint16_t)(totalPulses - profile->entryPulses
                       - profile->exitPulses);
    }
    else if (entryRequired == 0UL)
    {
        profile->exitPulses = totalPulses;
    }
    else if (exitRequired == 0UL)
    {
        profile->entryPulses = totalPulses;
    }
    else
    {
        totalWeight = entryWeight + exitWeight;
        /* Peak planning bounds both weights by this move's pulse budget. */
        scaledEntry = ((uint64_t)totalPulses * entryWeight
                       + totalWeight / 2UL) / totalWeight;
        if (scaledEntry == 0UL)
        {
            scaledEntry = 1UL;
        }
        if (scaledEntry >= totalPulses)
        {
            scaledEntry = totalPulses - 1U;
        }
        profile->entryPulses = (uint16_t)scaledEntry;
        profile->exitPulses =
            (uint16_t)(totalPulses - profile->entryPulses);
    }

    profile->active = 1U;
    PlsrPrepareShortProfileBoundaries(profile);
    return 1U;
}

static uint32_t PlsrShortProfileTakeFrequency(PLSR_SHORT_PROFILE *profile)
{
    uint16_t period = profile->nextPeriod;
    uint16_t relativePeriod;
    uint16_t rampPulseCount;
    uint32_t fromHz;
    uint32_t toHz;
    uint64_t firstBoundaryQ32;
    uint64_t secondBoundaryQ32;
    uint64_t previousTargetAreaQ32;
    uint64_t areaIncrementQ32;
    uint64_t firstCachedBoundaryQ32;
    uint64_t secondCachedBoundaryQ32;
    uint32_t frequencyHz;

    if ((profile->active == 0U) || (period >= profile->pulseCount))
    {
        return (profile->endHz == 0UL) ? 1UL : profile->endHz;
    }
    profile->nextPeriod = (uint16_t)(period + 1U);

    if (period < profile->entryPulses)
    {
        relativePeriod = period;
        rampPulseCount = profile->entryPulses;
        fromHz = profile->startHz;
        toHz = profile->peakHz;
        firstCachedBoundaryQ32 = profile->entryFirstBoundaryQ32;
        secondCachedBoundaryQ32 = profile->entrySecondBoundaryQ32;
        firstBoundaryQ32 = (relativePeriod == 0U)
                               ? 0ULL : profile->rampBoundaryQ32;
    }
    else if (period < (uint16_t)(profile->entryPulses
                                 + profile->steadyPulses))
    {
        profile->lastRampFrequencyHz = 0UL;
        return (profile->peakHz == 0UL) ? 1UL : profile->peakHz;
    }
    else
    {
        relativePeriod =
            (uint16_t)(period - profile->entryPulses
                       - profile->steadyPulses);
        rampPulseCount = profile->exitPulses;
        fromHz = profile->peakHz;
        toHz = profile->endHz;
        firstCachedBoundaryQ32 = profile->exitFirstBoundaryQ32;
        secondCachedBoundaryQ32 = profile->exitSecondBoundaryQ32;
        firstBoundaryQ32 = (relativePeriod == 0U)
                               ? 0ULL : profile->rampBoundaryQ32;
    }

    if (relativePeriod == 0U)
    {
        profile->rampTotalAreaQ32 =
            PlsrRampAreaQ32(fromHz, toHz, PLSR_Q32_ONE);
        profile->rampAreaStepQ32 =
            PlsrDivideU64ByU32(profile->rampTotalAreaQ32,
                               rampPulseCount,
                               &profile->rampAreaRemainder);
        profile->rampRemainderAccumulator = 0UL;
        profile->rampTargetAreaQ32 = 0ULL;
        profile->rampBoundaryQ32 = 0ULL;
        profile->lastRampPhaseStepQ32 = 0ULL;
        profile->lastRampFrequencyHz = 0UL;
    }
    previousTargetAreaQ32 = profile->rampTargetAreaQ32;
    profile->rampTargetAreaQ32 += profile->rampAreaStepQ32;
    profile->rampRemainderAccumulator += profile->rampAreaRemainder;
    if (profile->rampRemainderAccumulator >= rampPulseCount)
    {
        profile->rampTargetAreaQ32++;
        profile->rampRemainderAccumulator -= rampPulseCount;
    }
    if ((uint16_t)(relativePeriod + 1U) >= rampPulseCount)
    {
        profile->rampTargetAreaQ32 = profile->rampTotalAreaQ32;
        secondBoundaryQ32 = PLSR_Q32_ONE;
    }
    else if (relativePeriod == 0U)
    {
        secondBoundaryQ32 = firstCachedBoundaryQ32;
    }
    else if (relativePeriod == 1U)
    {
        secondBoundaryQ32 = secondCachedBoundaryQ32;
    }
    else
    {
        secondBoundaryQ32 = PlsrRampBoundaryQ32(
            fromHz, toHz, firstBoundaryQ32,
            profile->rampTargetAreaQ32,
            (relativePeriod < 2U) ? 0ULL
                                  : profile->lastRampPhaseStepQ32);
    }
    areaIncrementQ32 =
        profile->rampTargetAreaQ32 - previousTargetAreaQ32;
    profile->rampBoundaryQ32 = secondBoundaryQ32;
    profile->lastRampPhaseStepQ32 =
        secondBoundaryQ32 - firstBoundaryQ32;
    frequencyHz = PlsrRampAverageFrequency(areaIncrementQ32, firstBoundaryQ32,
                                           secondBoundaryQ32);
    if ((profile->lastRampFrequencyHz != 0UL)
        && (((toHz > fromHz)
             && (frequencyHz < profile->lastRampFrequencyHz))
            || ((toHz < fromHz)
                && (frequencyHz > profile->lastRampFrequencyHz))))
    {
        frequencyHz = profile->lastRampFrequencyHz;
    }
    profile->lastRampFrequencyHz = frequencyHz;
    return frequencyHz;
}

static void PlsrCopyShortProfile(PLSR_SHORT_PROFILE *destination,
                                 const PLSR_SHORT_PROFILE *source)
{
    destination->active = 0U;
    destination->startHz = source->startHz;
    destination->peakHz = source->peakHz;
    destination->endHz = source->endHz;
    destination->pulseCount = source->pulseCount;
    destination->entryPulses = source->entryPulses;
    destination->steadyPulses = source->steadyPulses;
    destination->exitPulses = source->exitPulses;
    destination->nextPeriod = source->nextPeriod;
    destination->rampBoundaryQ32 = source->rampBoundaryQ32;
    destination->rampTotalAreaQ32 = source->rampTotalAreaQ32;
    destination->rampTargetAreaQ32 = source->rampTargetAreaQ32;
    destination->rampAreaStepQ32 = source->rampAreaStepQ32;
    destination->rampAreaRemainder = source->rampAreaRemainder;
    destination->rampRemainderAccumulator =
        source->rampRemainderAccumulator;
    destination->lastRampPhaseStepQ32 = source->lastRampPhaseStepQ32;
    destination->entryFirstBoundaryQ32 = source->entryFirstBoundaryQ32;
    destination->entrySecondBoundaryQ32 = source->entrySecondBoundaryQ32;
    destination->exitFirstBoundaryQ32 = source->exitFirstBoundaryQ32;
    destination->exitSecondBoundaryQ32 = source->exitSecondBoundaryQ32;
    destination->lastRampFrequencyHz = source->lastRampFrequencyHz;
    destination->active = source->active;
}

static uint16_t PlsrProfileQueueCount(void)
{
    uint32_t writeIndex = PlsrProfileQueue.writeIndex;
    uint32_t readIndex = PlsrProfileQueue.readIndex;

    return (uint16_t)(writeIndex - readIndex);
}

static void PlsrProfileQueueReset(void)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    PlsrProfileQueue.generation++;
    PlsrProfileQueue.readIndex = 0U;
    PlsrProfileQueue.writeIndex = 0U;
    PlsrProfileQueue.active = 0U;
    PlsrProfileQueue.generatorComplete = 0U;
    PlsrProfileQueue.producerEpoch = 0UL;
    PlsrProfileQueue.producerSegment = 0U;
    PlsrProfileQueue.preparedHandoffBank = 0U;
    PlsrProfileQueue.producerProfile.active = 0U;
    PlsrPlatformExitCritical(criticalState);
}

static uint8_t PlsrProfileQueueBegin(
    const PLSR_SHORT_PROFILE *producerProfile,
    uint32_t producerEpoch,
    uint8_t producerSegment,
    uint8_t preparedHandoffBank)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    PlsrProfileQueue.generation++;
    PlsrProfileQueue.readIndex = 0U;
    PlsrProfileQueue.writeIndex = 0U;
    PlsrProfileQueue.producerEpoch = producerEpoch;
    PlsrProfileQueue.producerSegment = producerSegment;
    PlsrProfileQueue.preparedHandoffBank = preparedHandoffBank;
    PlsrProfileQueue.generatorComplete = 0U;
    PlsrCopyShortProfile(&PlsrProfileQueue.producerProfile,
                         producerProfile);
    PlsrProfileQueue.active =
        ((producerProfile->active != 0U)
         && (producerProfile->nextPeriod < producerProfile->pulseCount))
            ? 1U : 0U;
    if (PlsrProfileQueue.active == 0U)
    {
        PlsrProfileQueue.generatorComplete = 1U;
    }
    PlsrPlatformExitCritical(criticalState);
    return 1U;
}

static void PlsrProfileQueueInvalidateGeneration(void)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    PlsrProfileQueue.generation++;
    PlsrProfileQueue.active = 0U;
    PlsrProfileQueue.generatorComplete = 0U;
    PlsrProfileQueue.readIndex = 0U;
    PlsrProfileQueue.writeIndex = 0U;
    PlsrPlatformExitCritical(criticalState);
}

#if defined(PLSR_DEBUG_TIMING) && (PLSR_DEBUG_TIMING != 0) \
    && !defined(PLSR_HOST_TEST)
static uint32_t PlsrProfileTimingNow(void)
{
    return *((volatile uint32_t *)0xE0001004UL);
}

static void PlsrProfileRecordProducerCycles(uint32_t startCycles)
{
    uint32_t elapsed = PlsrProfileTimingNow() - startCycles;
    uint32_t total = PlsrProfileProducerTotalCycles;

    if (PlsrProfileProducerItemCount != 0xFFFFFFFFUL)
    {
        PlsrProfileProducerItemCount++;
    }
    PlsrProfileProducerTotalCycles =
        (elapsed > (0xFFFFFFFFUL - total)) ? 0xFFFFFFFFUL
                                           : total + elapsed;
    if (elapsed > PlsrProfileProducerMaxItemCycles)
    {
        PlsrProfileProducerMaxItemCycles = elapsed;
    }
}
#endif

static uint8_t PlsrProfileQueueFill(void)
{
    PLSR_SHORT_PROFILE candidate;
    PLSR_PROFILE_ENTRY entry;
    uint32_t generation;
    uint32_t producerEpoch;
    uint32_t criticalState;
    uint32_t writeIndex;
#if defined(PLSR_DEBUG_TIMING) && (PLSR_DEBUG_TIMING != 0) \
    && !defined(PLSR_HOST_TEST)
    uint32_t startCycles;
#endif

    while (1)
    {
        criticalState = PlsrPlatformEnterCritical();
        if ((PlsrProfileQueue.active == 0U)
            || (PlsrProfileQueue.generatorComplete != 0U)
            || (PlsrProfileQueueCount() >= PLSR_PROFILE_QUEUE_CAPACITY))
        {
            PlsrPlatformExitCritical(criticalState);
            return 1U;
        }
        generation = PlsrProfileQueue.generation;
        producerEpoch = PlsrProfileQueue.producerEpoch;
        PlsrCopyShortProfile(&candidate,
                             &PlsrProfileQueue.producerProfile);
        PlsrPlatformExitCritical(criticalState);

#if defined(PLSR_DEBUG_TIMING) && (PLSR_DEBUG_TIMING != 0) \
        && !defined(PLSR_HOST_TEST)
        startCycles = PlsrProfileTimingNow();
#endif
        entry.requestedFrequencyHz =
            PlsrShortProfileTakeFrequency(&candidate);
        if (PlsrPlatformBuildTimerSetting(
                (uint8_t)PlsrActiveConfig.pulseOutput,
                (uint8_t)PlsrActiveConfig.outputMode,
                entry.requestedFrequencyHz, &entry.setting) == 0U)
        {
            return 0U;
        }

        criticalState = PlsrPlatformEnterCritical();
        if ((PlsrProfileQueue.active == 0U)
            || (PlsrProfileQueue.generation != generation)
            || (PlsrProfileQueue.producerEpoch != producerEpoch)
            || (PlsrProfileQueueCount() >= PLSR_PROFILE_QUEUE_CAPACITY))
        {
            PlsrPlatformExitCritical(criticalState);
            continue;
        }
        writeIndex = PlsrProfileQueue.writeIndex;
        PlsrProfileQueue.entries[writeIndex & PLSR_PROFILE_QUEUE_MASK] = entry;
        PlsrCopyShortProfile(&PlsrProfileQueue.producerProfile, &candidate);
        PlsrProfileQueue.writeIndex = writeIndex + 1UL;
        if ((candidate.active == 0U)
            || (candidate.nextPeriod >= candidate.pulseCount))
        {
            PlsrProfileQueue.generatorComplete = 1U;
        }
        PlsrPlatformExitCritical(criticalState);
#if defined(PLSR_DEBUG_TIMING) && (PLSR_DEBUG_TIMING != 0) \
        && !defined(PLSR_HOST_TEST)
        PlsrProfileRecordProducerCycles(startCycles);
#endif
    }
}

static PLSR_PLATFORM_QUEUE_RESULT PlsrProfileQueueCommitNext(
    uint8_t pulseOutput)
{
    const PLSR_PROFILE_ENTRY *entry;
    uint32_t readIndex;
    uint32_t nextReadIndex;
    uint32_t writeIndex;
    uint32_t actualFrequencyHz;
    PLSR_PLATFORM_QUEUE_RESULT result;

    if (PlsrProfileQueue.active == 0U)
    {
        return PLSR_PLATFORM_QUEUE_APPLIED;
    }
    readIndex = PlsrProfileQueue.readIndex;
    if (readIndex == PlsrProfileQueue.writeIndex)
    {
        if (PlsrProfileQueue.generatorComplete != 0U)
        {
            PlsrProfileQueue.active = 0U;
            PlsrShortProfile.active = 0U;
            return PLSR_PLATFORM_QUEUE_APPLIED;
        }
        return PLSR_PLATFORM_QUEUE_FAILED;
    }

    entry = &PlsrProfileQueue.entries[readIndex & PLSR_PROFILE_QUEUE_MASK];
    result = PlsrPlatformLoadPreparedFromIrq(pulseOutput, &entry->setting,
                                              &actualFrequencyHz);
    if (result != PLSR_PLATFORM_QUEUE_APPLIED)
    {
        return result;
    }
    nextReadIndex = readIndex + 1UL;
    PlsrProfileQueue.readIndex = nextReadIndex;
    PlsrDeferredFrequencyPending = 0U;
    PlsrQueuedFrequencyHz = actualFrequencyHz;
    PlsrDiagnosticRecordFrequency(entry->requestedFrequencyHz,
                                  entry->setting.actualFrequencyHz,
                                  actualFrequencyHz);
    PlsrDiagnosticQueuedExpectedHz = entry->setting.actualFrequencyHz;
    if (actualFrequencyHz > PlsrCurrentFrequencyHz)
    {
        PlsrRunStatus = PLSR_STATUS_ACCELERATING;
    }
    else if (actualFrequencyHz < PlsrCurrentFrequencyHz)
    {
        PlsrRunStatus = PLSR_STATUS_DECELERATING;
    }
    else
    {
        PlsrRunStatus = PLSR_STATUS_RUNNING;
    }
    writeIndex = PlsrProfileQueue.writeIndex;
    if ((nextReadIndex == writeIndex)
        && (PlsrProfileQueue.generatorComplete != 0U))
    {
        PlsrProfileQueue.active = 0U;
    }
    return PLSR_PLATFORM_QUEUE_APPLIED;
}

static void PlsrInvalidateHandoffPlans(void)
{
    uint8_t bank;
    uint8_t index;
    uint32_t criticalState = PlsrPlatformEnterCritical();

    PlsrHandoffPlan.valid = 0U;
    for (bank = 0U; bank < 2U; bank++)
    {
        for (index = 0U; index < PLSR_SEGMENT_COUNT_MAX; index++)
        {
            PlsrPreparedHandoffPlans[bank][index].valid = 0U;
        }
    }
    PlsrPlatformExitCritical(criticalState);
}

static void PlsrMaybePlanBoundaryRamp(uint32_t expectedEpoch)
{
    const PLSR_SEGMENT_CONFIG *segment;
    uint8_t nextSegment;
    uint8_t nextPositive;
    uint8_t hasNext;
    uint32_t targetHz;
    uint32_t criticalState;
    uint32_t currentHz;
    uint32_t queuedHz;
    uint32_t deferredHz;
    uint32_t rateBoundHz;
    uint8_t deferredPending;
    uint64_t estimate;
    uint64_t candidateEstimate;
    uint64_t remaining;

    if ((PlsrPulseActive == 0U) || (PlsrBoundaryRampStarted != 0U)
        || (PlsrShortProfile.active != 0U)
        || (PlsrHandoffPlan.valid != 0U)
        || (PlsrStopRequested != 0U) || (PlsrCurrentSegment == 0U))
    {
        return;
    }

    segment = &PlsrActiveConfig.segments[PlsrCurrentSegment - 1U];
    hasNext = PlsrGetNextSegment(&nextSegment);
    targetHz = PlsrActiveConfig.stopSpeedHz;

    if ((PlsrActiveConfig.sendMode == PLSR_SEND_SUBSEQUENT)
        && (hasNext != 0U)
        && (segment->waitType == PLSR_EXT_OR_COMPLETE))
    {
        if ((PlsrPredictNextDirection(nextSegment, &nextPositive) != 0U)
            && (nextPositive == PlsrCountPositive))
        {
            targetHz = PlsrActiveConfig.segments[nextSegment - 1U].frequencyHz;
        }
    }

    criticalState = PlsrPlatformEnterCritical();
    currentHz = PlsrCurrentFrequencyHz;
    queuedHz = PlsrQueuedFrequencyHz;
    deferredHz = PlsrDeferredFrequencyHz;
    deferredPending = PlsrDeferredFrequencyPending;
    if ((PlsrSegmentEpoch != expectedEpoch)
        || (PlsrBoundaryPending != 0U)
        || (PlsrPulseActive == 0U)
        || (PlsrBoundaryRampStarted != 0U)
        || (PlsrShortProfile.active != 0U)
        || (PlsrHandoffPlan.valid != 0U)
        || (PlsrStopRequested != 0U)
        || (PlsrAbStopArmed != 0U))
    {
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    PlsrPlatformExitCritical(criticalState);

    rateBoundHz = (currentHz > queuedHz) ? currentHz : queuedHz;
    if ((deferredPending != 0U) && (deferredHz > rateBoundHz))
    {
        rateBoundHz = deferredHz;
    }
    estimate = PlsrRampPulseEstimate(currentHz, targetHz, rateBoundHz);
    candidateEstimate = PlsrRampPulseEstimate(queuedHz, targetHz,
                                              rateBoundHz);
    if (candidateEstimate > estimate)
    {
        estimate = candidateEstimate;
    }
    if (deferredPending != 0U)
    {
        candidateEstimate = PlsrRampPulseEstimate(deferredHz, targetHz,
                                                  rateBoundHz);
        if (candidateEstimate > estimate)
        {
            estimate = candidateEstimate;
        }
    }

    criticalState = PlsrPlatformEnterCritical();
    remaining = PlsrRemainingPulses;
    if ((PlsrSegmentEpoch != expectedEpoch)
        || (PlsrBoundaryPending != 0U)
        || (PlsrPulseActive == 0U)
        || (PlsrBoundaryRampStarted != 0U)
        || (PlsrShortProfile.active != 0U)
        || (PlsrHandoffPlan.valid != 0U)
        || (PlsrStopRequested != 0U)
        || (PlsrAbStopArmed != 0U))
    {
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    if (remaining > estimate)
    {
        PlsrPlatformExitCritical(criticalState);
        return;
    }

    PlsrBoundaryRampStarted = 1U;
    PlsrRampStart(PlsrCurrentFrequencyHz, targetHz);
    PlsrPlatformExitCritical(criticalState);
    if (PlsrRamp.active == 0U)
    {
        (void)PlsrApplyFrequency(targetHz, expectedEpoch);
    }
}

static uint8_t PlsrBeginSegmentOutput(uint32_t startFrequencyHz)
{
    uint32_t targetFrequencyHz =
        PlsrActiveConfig.segments[PlsrCurrentSegment - 1U].frequencyHz;
    uint32_t firstFrequencyHz;
    uint32_t secondFrequencyHz;
    uint32_t profileEpoch;
    uint8_t profileSegment;
    uint8_t profileHandoffBank;

    PlsrSegmentClockStarted = 1U;
    PlsrSegmentElapsedMs = 0UL;
    if (PlsrPrepareShortProfile(&PlsrShortProfile,
                                PlsrCurrentSegment, startFrequencyHz,
                                targetFrequencyHz,
                                PlsrRemainingSnapshot()) != 0U)
    {
        PlsrRamp.active = 0U;
        firstFrequencyHz =
            PlsrShortProfileTakeFrequency(&PlsrShortProfile);
        secondFrequencyHz =
            (PlsrShortProfile.nextPeriod < PlsrShortProfile.pulseCount)
                ? PlsrShortProfileTakeFrequency(&PlsrShortProfile)
                : firstFrequencyHz;
        profileEpoch = PlsrSegmentEpoch;
        profileSegment = PlsrCurrentSegment;
        profileHandoffBank = PlsrPreparedHandoffBank;
        (void)PlsrProfileQueueBegin(&PlsrShortProfile,
                                    profileEpoch,
                                    profileSegment,
                                    profileHandoffBank);
        if (PlsrProfileQueueFill() == 0U)
        {
            PlsrProfileQueueReset();
            PlsrShortProfile.active = 0U;
            return 0U;
        }
        if (secondFrequencyHz > firstFrequencyHz)
        {
            PlsrRunStatus = PLSR_STATUS_ACCELERATING;
        }
        else if (secondFrequencyHz < firstFrequencyHz)
        {
            PlsrRunStatus = PLSR_STATUS_DECELERATING;
        }
        else
        {
            PlsrRunStatus = PLSR_STATUS_RUNNING;
        }
        if (PlsrApplyFrequencyPair(firstFrequencyHz,
                                   secondFrequencyHz,
                                   PlsrSegmentEpoch) == 0U)
        {
            PlsrProfileQueueReset();
            PlsrShortProfile.active = 0U;
            return 0U;
        }
        return 1U;
    }

    PlsrProfileQueueReset();

    PlsrRampStart(startFrequencyHz, targetFrequencyHz);

    if (PlsrRamp.active == 0U)
    {
        if (PlsrApplyFrequency(targetFrequencyHz, PlsrSegmentEpoch) == 0U)
        {
            return 0U;
        }
        PlsrRunStatus = PLSR_STATUS_RUNNING;
    }
    else if ((startFrequencyHz != 0UL)
             && (PlsrApplyFrequency(startFrequencyHz,
                                    PlsrSegmentEpoch) == 0U))
    {
        return 0U;
    }
    if (PlsrPrepareFutureHandoffQueue() == 0U)
    {
        return 0U;
    }
    return 1U;
}

static uint8_t PlsrStartSegment(uint8_t segmentNumber,
                                uint8_t allowCarry,
                                uint32_t carryFrequencyHz)
{
    uint32_t criticalState;
    int32_t position;
    int64_t displacement;
    uint64_t magnitude;
    uint8_t positive;
    uint8_t directionLevel;
    uint8_t directionChanged;
    uint32_t startFrequencyHz;

    if ((segmentNumber == 0U)
        || (segmentNumber > PlsrActiveConfig.segmentCount))
    {
        return 0U;
    }

    criticalState = PlsrPlatformEnterCritical();
    position = PlsrPosition;
    PlsrPlatformExitCritical(criticalState);
    displacement = PlsrSegmentDisplacement(segmentNumber, position);
    positive = (displacement >= 0) ? 1U : 0U;
    magnitude = (displacement < 0) ? (uint64_t)(-displacement)
                                   : (uint64_t)displacement;

    PlsrSegmentEpoch++;
    PlsrCurrentSegment = segmentNumber;
    PlsrSegmentClockStarted = 0U;
    PlsrSegmentElapsedMs = 0UL;
    PlsrWaitElapsedMs = 0UL;
    PlsrBoundaryRampStarted = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrCutRequested = 0U;
    PlsrStopPulsesRemaining = 0U;
    PlsrAbStopArmed = 0U;
    PlsrFrequencyUpdatePending = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrHandoffPlan.valid = 0U;
    PlsrShortProfile.active = 0U;
    PlsrShortProfile.nextPeriod = 0U;
    if ((allowCarry == 0U) || (PlsrProfileQueue.active == 0U)
        || (PlsrProfileQueue.producerEpoch != PlsrSegmentEpoch)
        || (PlsrProfileQueue.producerSegment != segmentNumber))
    {
        PlsrProfileQueueReset();
    }
    PlsrDirectionDelayActive = 0U;
    PlsrDirectionDelayRemainingMs = 0U;
    PlsrExtEdgePending = 0U;
    PlsrExtPreviousLevel =
        PlsrPlatformReadInput((uint8_t)PlsrActiveConfig.extInput);

    criticalState = PlsrPlatformEnterCritical();
    PlsrRemainingPulses = magnitude;
    PlsrCountPositive = positive;
    PlsrPlatformExitCritical(criticalState);

    if ((PlsrActiveConfig.segments[segmentNumber - 1U].waitType
         == PLSR_ACT_TIME)
        && (PlsrActiveConfig.segments[segmentNumber - 1U].actTimeMs == 0U))
    {
        PlsrSegmentClockStarted = 1U;
        PlsrRunStatus = PLSR_STATUS_RUNNING;
        PlsrBoundaryFrequencyHz = (allowCarry != 0U) ? carryFrequencyHz : 0UL;
        PlsrBoundaryWasCut = 1U;
        PlsrBoundaryPending = 1U;
        PlsrDiagnosticBeginSegment(segmentNumber, 0UL, positive);
        PlsrDiagnosticFinishSegment(1U);
        return 1U;
    }

    if (magnitude == 0UL)
    {
        PlsrSegmentClockStarted = 1U;
        PlsrRunStatus = PLSR_STATUS_RUNNING;
        PlsrBoundaryFrequencyHz = 0UL;
        PlsrBoundaryPending = 1U;
        PlsrDiagnosticBeginSegment(segmentNumber, 0UL, positive);
        PlsrDiagnosticFinishSegment(1U);
        return 1U;
    }

    directionLevel = positive;
    if ((PlsrActiveConfig.outputMode == PLSR_OUTPUT_PULSE_DIR)
        && (PlsrActiveConfig.directionNegativeLogic != 0U))
    {
        directionLevel ^= 1U;
    }
    directionChanged = ((PlsrLastDirectionValid == 0U)
                        || (PlsrLastDirectionOutput
                            != (uint8_t)PlsrActiveConfig.directionOutput)
                        || (PlsrLastDirectionLevel != directionLevel)) ? 1U : 0U;

    if (PlsrPlatformPrepare((uint8_t)PlsrActiveConfig.pulseOutput,
                            (uint8_t)PlsrActiveConfig.directionOutput,
                            directionLevel,
                            (uint8_t)PlsrActiveConfig.outputMode,
                            positive) == 0U)
    {
        return 0U;
    }
    PlsrDiagnosticBeginSegment(segmentNumber, magnitude, positive);
    PlsrLastDirectionValid = 1U;
    PlsrLastDirectionOutput = (uint8_t)PlsrActiveConfig.directionOutput;
    PlsrLastDirectionLevel = directionLevel;

    if ((allowCarry != 0U) && (directionChanged == 0U)
        && (carryFrequencyHz != 0UL))
    {
        startFrequencyHz = carryFrequencyHz;
    }
    else
    {
        startFrequencyHz = PlsrActiveConfig.startSpeedHz;
    }

    if ((PlsrActiveConfig.outputMode == PLSR_OUTPUT_PULSE_DIR)
        && (directionChanged != 0U)
        && (PlsrActiveConfig.directionDelayMs != 0U))
    {
        PlsrDirectionDelayActive = 1U;
        PlsrDirectionDelayRemainingMs = PlsrActiveConfig.directionDelayMs;
        PlsrRunStatus = PLSR_STATUS_ACCELERATING;
        return 1U;
    }

    PlsrDirectionDelayActive = 0U;
    return PlsrBeginSegmentOutput(startFrequencyHz);
}

static void PlsrMarkPersistenceDirty(uint16_t delayMs)
{
    PlsrPersistenceDirty = 1U;
    PlsrPersistenceDelayMs = delayMs;
}

static void PlsrCheckpointPosition(uint8_t wasBusy)
{
    uint32_t criticalState;
    int32_t position;
    uint8_t positionValid;

    criticalState = PlsrPlatformEnterCritical();
    position = PlsrPosition;
    positionValid = PlsrPositionValid;
    PlsrPositionCheckpointDirty = 0U;
    PlsrPlatformExitCritical(criticalState);
    PlsrPlatformCheckpointPosition(position, positionValid, wasBusy);
    PlsrPositionCheckpointElapsedMs = 0U;
}

static void PlsrPollPositionCheckpoint(void)
{
    if (PlsrPositionCheckpointDirty == 0U)
    {
        PlsrPositionCheckpointElapsedMs = 0U;
        return;
    }
    if (PlsrPositionCheckpointElapsedMs < PLSR_POSITION_CHECKPOINT_MS)
    {
        PlsrPositionCheckpointElapsedMs++;
    }
    if (PlsrPositionCheckpointElapsedMs >= PLSR_POSITION_CHECKPOINT_MS)
    {
        PlsrCheckpointPosition(1U);
    }
}

static void PlsrFinishCompleted(void)
{
    PlsrPlatformStopPulse((uint8_t)PlsrActiveConfig.pulseOutput);
    PlsrRemainingPulses = 0UL;
    PlsrPulseActive = 0U;
    PlsrCutRequested = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrCurrentSegment = 0U;
    PlsrSegmentClockStarted = 0U;
    PlsrDirectionDelayActive = 0U;
    PlsrDirectionDelayRemainingMs = 0U;
    PlsrExtEdgePending = 0U;
    PlsrStopRequested = 0U;
    PlsrStopPulsesRemaining = 0U;
    PlsrAbStopArmed = 0U;
    PlsrSeamlessHandoffPending = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrShortProfile.active = 0U;
    PlsrProfileQueueReset();
    PlsrHandoffPlan.valid = 0U;
    PlsrTimerErrorPending = 0U;
    PlsrRamp.active = 0U;
    PlsrInvalidateHandoffPlans();
    PlsrRunStatus = PLSR_STATUS_COMPLETED;
    PlsrError = PLSR_ERROR_NONE;
    PlsrCheckpointPosition(0U);
    PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
}

static void PlsrFinishStopped(void)
{
    PlsrDiagnosticFinishSegment(0U);
    PlsrPlatformStopPulse((uint8_t)PlsrActiveConfig.pulseOutput);
    PlsrRemainingPulses = 0UL;
    PlsrPulseActive = 0U;
    PlsrCutRequested = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrCurrentSegment = 0U;
    PlsrSegmentClockStarted = 0U;
    PlsrDirectionDelayActive = 0U;
    PlsrDirectionDelayRemainingMs = 0U;
    PlsrExtEdgePending = 0U;
    PlsrStopRequested = 0U;
    PlsrStopPulsesRemaining = 0U;
    PlsrAbStopArmed = 0U;
    PlsrSeamlessHandoffPending = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrShortProfile.active = 0U;
    PlsrProfileQueueReset();
    PlsrHandoffPlan.valid = 0U;
    PlsrTimerErrorPending = 0U;
    PlsrRamp.active = 0U;
    PlsrInvalidateHandoffPlans();
    PlsrRunStatus = PLSR_STATUS_STOPPED;
    PlsrError = PLSR_ERROR_NONE;
    PlsrCheckpointPosition(0U);
    PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
}

static void PlsrEnterError(PLSR_ERROR error)
{
    PlsrDiagnosticFinishSegment(0U);
    PlsrPlatformStopPulse((uint8_t)PlsrActiveConfig.pulseOutput);
    PlsrRemainingPulses = 0UL;
    PlsrPulseActive = 0U;
    PlsrCutRequested = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrCurrentSegment = 0U;
    PlsrSegmentClockStarted = 0U;
    PlsrDirectionDelayActive = 0U;
    PlsrDirectionDelayRemainingMs = 0U;
    PlsrExtEdgePending = 0U;
    PlsrStopRequested = 0U;
    PlsrStopPulsesRemaining = 0U;
    PlsrAbStopArmed = 0U;
    PlsrSeamlessHandoffPending = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrShortProfile.active = 0U;
    PlsrProfileQueueReset();
    PlsrHandoffPlan.valid = 0U;
    PlsrTimerErrorPending = 0U;
    PlsrRamp.active = 0U;
    PlsrInvalidateHandoffPlans();
    PlsrRunStatus = PLSR_STATUS_ERROR;
    PlsrError = error;
    PlsrCheckpointPosition(0U);
    PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
}

static void PlsrTransitionToNext(uint8_t allowCarry)
{
    uint8_t nextSegment;
    uint32_t carryFrequencyHz = PlsrBoundaryFrequencyHz;

    if (PlsrGetNextSegment(&nextSegment) == 0U)
    {
        PlsrFinishCompleted();
        return;
    }

    if (PlsrStartSegment(nextSegment, allowCarry, carryFrequencyHz) == 0U)
    {
        PlsrEnterError(PLSR_ERROR_INVALID_RESOURCE);
    }
}

static uint8_t PlsrBuildHandoffPlan(uint8_t sourceSegment,
                                    const PLSR_CONFIG *frequencyConfig,
                                    PLSR_HANDOFF_PLAN *plan)
{
    const PLSR_SEGMENT_CONFIG *segment;
    uint8_t nextSegment;
    int64_t displacement;
    uint8_t positive;

    plan->valid = 0U;
    if ((PlsrActiveConfig.sendMode != PLSR_SEND_SUBSEQUENT)
        || (sourceSegment == 0U)
        || (sourceSegment > PlsrActiveConfig.segmentCount))
    {
        return 0U;
    }

    segment = &PlsrActiveConfig.segments[sourceSegment - 1U];
    if (segment->waitType != PLSR_EXT_OR_COMPLETE)
    {
        return 0U;
    }
    if (segment->jumpSegment != 0U)
    {
        nextSegment = (uint8_t)segment->jumpSegment;
    }
    else if (sourceSegment < PlsrActiveConfig.segmentCount)
    {
        nextSegment = (uint8_t)(sourceSegment + 1U);
    }
    else
    {
        return 0U;
    }

    if (PlsrActiveConfig.positionMode == PLSR_POSITION_ABSOLUTE)
    {
        displacement = (int64_t)PlsrActiveConfig.segments[nextSegment - 1U].pulses
                       - (int64_t)segment->pulses;
    }
    else
    {
        displacement = PlsrActiveConfig.segments[nextSegment - 1U].pulses;
    }
    if (displacement == 0)
    {
        return 0U;
    }
    positive = (displacement > 0) ? 1U : 0U;

    plan->magnitude = (displacement < 0) ? (uint64_t)(-displacement)
                                         : (uint64_t)displacement;
    plan->firstFrequencyHz =
        frequencyConfig->segments[nextSegment - 1U].frequencyHz;
    if (PlsrPrepareShortProfile(&plan->profile, nextSegment,
                                plan->firstFrequencyHz,
                                plan->firstFrequencyHz,
                                plan->magnitude) != 0U)
    {
        plan->firstFrequencyHz =
            PlsrShortProfileTakeFrequency(&plan->profile);
    }
    plan->secondFrequencyHz = plan->firstFrequencyHz;
    if ((plan->profile.active != 0U)
        && (plan->profile.nextPeriod < plan->profile.pulseCount))
    {
        plan->secondFrequencyHz =
            PlsrShortProfileTakeFrequency(&plan->profile);
    }
    plan->firstRequestedFrequencyHz = plan->firstFrequencyHz;
    plan->secondRequestedFrequencyHz = plan->secondFrequencyHz;
    if ((PlsrPlatformBuildTimerSetting(
             (uint8_t)PlsrActiveConfig.pulseOutput,
             (uint8_t)PlsrActiveConfig.outputMode,
             plan->firstFrequencyHz, &plan->firstSetting) == 0U)
        || (PlsrPlatformBuildTimerSetting(
                (uint8_t)PlsrActiveConfig.pulseOutput,
                (uint8_t)PlsrActiveConfig.outputMode,
                plan->secondFrequencyHz, &plan->secondSetting) == 0U))
    {
        return 0U;
    }
    plan->firstFrequencyHz = plan->firstSetting.actualFrequencyHz;
    plan->secondFrequencyHz = plan->secondSetting.actualFrequencyHz;
    plan->nextSegment = nextSegment;
    plan->positive = positive;
    plan->valid = 1U;
    return 1U;
}

static uint8_t PlsrBuildHandoffPlanBank(
    const PLSR_CONFIG *frequencyConfig)
{
    uint8_t buildBank = (uint8_t)(PlsrPreparedHandoffBank ^ 1U);
    uint8_t sourceSegment;
    PLSR_HANDOFF_PLAN *destination;

    for (sourceSegment = 0U;
         sourceSegment < PLSR_SEGMENT_COUNT_MAX;
         sourceSegment++)
    {
        PlsrPreparedHandoffPlans[buildBank][sourceSegment].valid = 0U;
    }
    for (sourceSegment = 1U;
         sourceSegment <= PlsrActiveConfig.segmentCount;
         sourceSegment++)
    {
        destination =
            &PlsrPreparedHandoffPlans[buildBank][sourceSegment - 1U];
        (void)PlsrBuildHandoffPlan(sourceSegment, frequencyConfig,
                                   destination);
    }
    return buildBank;
}

static uint8_t PlsrSelectPreparedHandoffPlan(PLSR_HANDOFF_PLAN *plan)
{
    const PLSR_HANDOFF_PLAN *prepared;
    uint8_t preparedBank;
    uint8_t currentSegment;

    plan->valid = 0U;
    currentSegment = PlsrCurrentSegment;
    if ((PlsrRemainingPulses != 1UL)
        || (PlsrActiveConfig.sendMode != PLSR_SEND_SUBSEQUENT)
        || (PlsrStopRequested != 0U)
        || (PlsrCountOverflowPending != 0U)
        || (PlsrCutRequested != 0U)
        || (PlsrAbStopArmed != 0U)
        || (currentSegment == 0U)
        || (currentSegment > PlsrActiveConfig.segmentCount))
    {
        return 0U;
    }
    preparedBank = PlsrPreparedHandoffBank;
    prepared = &PlsrPreparedHandoffPlans[preparedBank][currentSegment - 1U];
    if ((prepared->valid == 0U)
        || (prepared->positive != PlsrCountPositive))
    {
        return 0U;
    }

    plan->magnitude = prepared->magnitude;
    plan->firstFrequencyHz = prepared->firstFrequencyHz;
    plan->secondFrequencyHz = prepared->secondFrequencyHz;
    plan->firstRequestedFrequencyHz = prepared->firstRequestedFrequencyHz;
    plan->secondRequestedFrequencyHz = prepared->secondRequestedFrequencyHz;
    plan->firstSetting = prepared->firstSetting;
    plan->secondSetting = prepared->secondSetting;
    PlsrCopyShortProfile(&plan->profile, &prepared->profile);
    plan->nextSegment = prepared->nextSegment;
    plan->positive = prepared->positive;
    plan->valid = 1U;
    return 1U;
}

static uint8_t PlsrPrepareFutureHandoffQueue(void)
{
    const PLSR_HANDOFF_PLAN *prepared;
    uint8_t currentSegment = PlsrCurrentSegment;
    uint8_t preparedBank = PlsrPreparedHandoffBank;

    PlsrProfileQueueReset();
    if ((currentSegment == 0U)
        || (currentSegment > PlsrActiveConfig.segmentCount)
        || (PlsrActiveConfig.sendMode != PLSR_SEND_SUBSEQUENT))
    {
        return 1U;
    }
    prepared = &PlsrPreparedHandoffPlans[preparedBank][currentSegment - 1U];
    if ((prepared->valid == 0U) || (prepared->profile.active == 0U)
        || (prepared->profile.nextPeriod >= prepared->profile.pulseCount))
    {
        return 1U;
    }
    (void)PlsrProfileQueueBegin(&prepared->profile,
                                PlsrSegmentEpoch + 1UL,
                                prepared->nextSegment,
                                preparedBank);
    if (PlsrProfileQueueFill() == 0U)
    {
        PlsrProfileQueueReset();
        return 0U;
    }
    return 1U;
}

static PLSR_PLATFORM_QUEUE_RESULT PlsrPrimeHandoff(void)
{
    PLSR_HANDOFF_PLAN candidatePlan;
    uint32_t actualFrequencyHz;
    PLSR_PLATFORM_QUEUE_RESULT result;

    PlsrHandoffPlan.valid = 0U;
    if (PlsrAbStopArmed != 0U)
    {
        return PLSR_PLATFORM_QUEUE_FAILED;
    }
    if (PlsrSelectPreparedHandoffPlan(&candidatePlan) == 0U)
    {
        return PLSR_PLATFORM_QUEUE_FAILED;
    }
    PlsrDeferredFrequencyPending = 0U;
    result = PlsrPlatformLoadPreparedFromIrq(
        (uint8_t)PlsrActiveConfig.pulseOutput,
        &candidatePlan.firstSetting, &actualFrequencyHz);
    if (result != PLSR_PLATFORM_QUEUE_APPLIED)
    {
        if (result == PLSR_PLATFORM_QUEUE_FAILED)
        {
            PlsrTimerErrorPending = 1U;
        }
        return result;
    }

    PlsrDiagnosticRecordFrequency(candidatePlan.firstRequestedFrequencyHz,
                                  candidatePlan.firstSetting.actualFrequencyHz,
                                  actualFrequencyHz);
    PlsrDiagnosticQueuedExpectedHz =
        candidatePlan.firstSetting.actualFrequencyHz;
    PlsrQueuedFrequencyHz = actualFrequencyHz;
    PlsrHandoffPlan.magnitude = candidatePlan.magnitude;
    PlsrHandoffPlan.firstFrequencyHz = actualFrequencyHz;
    PlsrHandoffPlan.secondFrequencyHz = candidatePlan.secondFrequencyHz;
    PlsrHandoffPlan.firstRequestedFrequencyHz =
        candidatePlan.firstRequestedFrequencyHz;
    PlsrHandoffPlan.secondRequestedFrequencyHz =
        candidatePlan.secondRequestedFrequencyHz;
    PlsrHandoffPlan.firstSetting = candidatePlan.firstSetting;
    PlsrHandoffPlan.secondSetting = candidatePlan.secondSetting;
    PlsrCopyShortProfile(&PlsrHandoffPlan.profile,
                         &candidatePlan.profile);
    PlsrHandoffPlan.nextSegment = candidatePlan.nextSegment;
    PlsrHandoffPlan.positive = candidatePlan.positive;
    PlsrHandoffPlan.valid = 1U;
    return PLSR_PLATFORM_QUEUE_APPLIED;
}

static PLSR_PLATFORM_QUEUE_RESULT PlsrTrySubsequentHandoff(void)
{
    uint32_t actualQueuedFrequencyHz;
    uint32_t currentFrequencyHz;
    uint32_t queuedFrequencyHz;
    uint8_t nextSegment = PlsrHandoffPlan.nextSegment;
    uint64_t magnitude = PlsrHandoffPlan.magnitude;
    uint8_t positive = PlsrHandoffPlan.positive;
    PLSR_PLATFORM_QUEUE_RESULT result;

    if ((PlsrHandoffPlan.valid == 0U)
        || (PlsrActiveConfig.sendMode != PLSR_SEND_SUBSEQUENT)
        || (PlsrStopRequested != 0U)
        || (PlsrCountOverflowPending != 0U)
        || (PlsrCutRequested != 0U)
        || (PlsrAbStopArmed != 0U)
        || (PlsrCurrentFrequencyHz != PlsrHandoffPlan.firstFrequencyHz)
        || (nextSegment == 0U)
        || (nextSegment > PlsrActiveConfig.segmentCount))
    {
        return PLSR_PLATFORM_QUEUE_FAILED;
    }
    if ((PlsrHandoffPlan.profile.active != 0U)
        && ((PlsrProfileQueue.active == 0U)
            || (PlsrProfileQueue.producerEpoch != PlsrSegmentEpoch + 1UL)
            || (PlsrProfileQueue.producerSegment != nextSegment)
            || (PlsrProfileQueue.preparedHandoffBank
                != PlsrPreparedHandoffBank)))
    {
        PlsrTimerErrorPending = 1U;
        return PLSR_PLATFORM_QUEUE_FAILED;
    }

    PlsrDeferredFrequencyPending = 0U;
    result = PlsrPlatformLoadPreparedFromIrq(
        (uint8_t)PlsrActiveConfig.pulseOutput,
        &PlsrHandoffPlan.secondSetting, &actualQueuedFrequencyHz);
    if (result == PLSR_PLATFORM_QUEUE_STALE)
    {
        return result;
    }
    if (result == PLSR_PLATFORM_QUEUE_FAILED)
    {
        PlsrShortProfile.active = 0U;
        PlsrHandoffPlan.valid = 0U;
        PlsrTimerErrorPending = 1U;
        return result;
    }

    PlsrCopyShortProfile(&PlsrShortProfile,
                         &PlsrHandoffPlan.profile);
    PlsrDiagnosticRecordFrequency(
        PlsrHandoffPlan.secondRequestedFrequencyHz,
        PlsrHandoffPlan.secondSetting.actualFrequencyHz,
        actualQueuedFrequencyHz);
    PlsrDiagnosticQueuedExpectedHz =
        PlsrHandoffPlan.secondSetting.actualFrequencyHz;
    PlsrQueuedFrequencyHz = actualQueuedFrequencyHz;
    PlsrDiagnosticFinishSegment(1U);
    PlsrSegmentEpoch++;
    PlsrCurrentSegment = nextSegment;
    PlsrRemainingPulses = magnitude;
    PlsrCountPositive = positive;
    PlsrBoundaryFrequencyHz = PlsrCurrentFrequencyHz;
    PlsrSegmentClockStarted = 1U;
    PlsrSegmentElapsedMs = 0UL;
    PlsrWaitElapsedMs = 0UL;
    PlsrBoundaryRampStarted = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrCutRequested = 0U;
    PlsrFrequencyUpdatePending = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrExtEdgePending = 0U;
    PlsrExtPreviousLevel =
        PlsrPlatformReadInput((uint8_t)PlsrActiveConfig.extInput);
    PlsrDiagnosticBeginSegment(nextSegment, magnitude, positive);
    PlsrSeamlessHandoffPending = 1U;
    PlsrHandoffPlan.valid = 0U;
    if (PlsrRemainingPulses == 1UL)
    {
        result = PlsrPrimeHandoff();
        if (result == PLSR_PLATFORM_QUEUE_STALE)
        {
            return result;
        }
    }
    (void)PlsrQueueFinalAbBoundaryFromIrq();
    queuedFrequencyHz = PlsrQueuedFrequencyHz;
    currentFrequencyHz = PlsrCurrentFrequencyHz;
    if (PlsrShortProfile.active != 0U)
    {
        if (queuedFrequencyHz > currentFrequencyHz)
        {
            PlsrRunStatus = PLSR_STATUS_ACCELERATING;
        }
        else if (queuedFrequencyHz < currentFrequencyHz)
        {
            PlsrRunStatus = PLSR_STATUS_DECELERATING;
        }
        else
        {
            PlsrRunStatus = PLSR_STATUS_RUNNING;
        }
    }
    else
    {
        PlsrRunStatus = PLSR_STATUS_RUNNING;
    }
    return PLSR_PLATFORM_QUEUE_APPLIED;
}

static void PlsrHandleBoundary(uint8_t extEdge)
{
    const PLSR_SEGMENT_CONFIG *segment;
    uint8_t wasCut = PlsrBoundaryWasCut;

    PlsrPlatformStopPulse((uint8_t)PlsrActiveConfig.pulseOutput);
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrPulseActive = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrShortProfile.active = 0U;
    PlsrProfileQueueReset();
    PlsrHandoffPlan.valid = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrAbStopArmed = 0U;
    PlsrCheckpointPosition(1U);

    if (PlsrTimerErrorPending != 0U)
    {
        PlsrTimerErrorPending = 0U;
        PlsrEnterError(PLSR_ERROR_TIMER);
        return;
    }
    if (PlsrCountOverflowPending != 0U)
    {
        PlsrCountOverflowPending = 0U;
        PlsrEnterError(PLSR_ERROR_COUNT);
        return;
    }

    if (PlsrStopRequested != 0U)
    {
        PlsrFinishStopped();
        return;
    }
    if ((PlsrCurrentSegment == 0U)
        || (PlsrCurrentSegment > PlsrActiveConfig.segmentCount))
    {
        PlsrEnterError(PLSR_ERROR_INTERNAL);
        return;
    }

    segment = &PlsrActiveConfig.segments[PlsrCurrentSegment - 1U];
    if (wasCut != 0U)
    {
        PlsrTransitionToNext(
            (PlsrActiveConfig.sendMode == PLSR_SEND_SUBSEQUENT) ? 1U : 0U);
        return;
    }

    switch (segment->waitType)
    {
        case PLSR_WAIT_TIME:
            PlsrWaitElapsedMs = 0UL;
            PlsrRunStatus = PLSR_STATUS_WAITING;
            break;

        case PLSR_WAIT_SIGNAL:
            if (PlsrPlatformReadInput((uint8_t)PlsrActiveConfig.waitInput) != 0U)
            {
                PlsrTransitionToNext(0U);
            }
            else
            {
                PlsrRunStatus = PLSR_STATUS_WAITING;
            }
            break;

        case PLSR_ACT_TIME:
            if (PlsrSegmentElapsedMs >= segment->actTimeMs)
            {
                PlsrTransitionToNext(0U);
            }
            else
            {
                PlsrRunStatus = PLSR_STATUS_WAITING;
            }
            break;

        case PLSR_EXT_SIGNAL:
            if (extEdge != 0U)
            {
                PlsrTransitionToNext(0U);
            }
            else
            {
                PlsrRunStatus = PLSR_STATUS_WAITING;
            }
            break;

        case PLSR_EXT_OR_COMPLETE:
            PlsrTransitionToNext(
                (PlsrActiveConfig.sendMode == PLSR_SEND_SUBSEQUENT) ? 1U : 0U);
            break;

        default:
            PlsrEnterError(PLSR_ERROR_INTERNAL);
            break;
    }
}

static void PlsrRequestCut(uint32_t expectedEpoch)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    if (PlsrSegmentEpoch != expectedEpoch)
    {
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    if (PlsrBoundaryPending != 0U)
    {
        PlsrBoundaryWasCut = 1U;
    }
    else if (PlsrPulseActive != 0U)
    {
        PlsrCutRequested = 1U;
        (void)PlsrArmFinalAbBoundaryLocked();
    }
    else
    {
        PlsrBoundaryFrequencyHz = PlsrCurrentFrequencyHz;
        PlsrBoundaryWasCut = 1U;
        PlsrBoundaryPending = 1U;
    }
    PlsrPlatformExitCritical(criticalState);
}

static void PlsrPollWaiting(uint8_t extEdge)
{
    const PLSR_SEGMENT_CONFIG *segment =
        &PlsrActiveConfig.segments[PlsrCurrentSegment - 1U];

    switch (segment->waitType)
    {
        case PLSR_WAIT_TIME:
            PlsrWaitElapsedMs++;
            if (PlsrWaitElapsedMs >= segment->waitTimeMs)
            {
                PlsrTransitionToNext(0U);
            }
            break;
        case PLSR_WAIT_SIGNAL:
            if (PlsrPlatformReadInput((uint8_t)PlsrActiveConfig.waitInput) != 0U)
            {
                PlsrTransitionToNext(0U);
            }
            break;
        case PLSR_ACT_TIME:
            if (PlsrSegmentElapsedMs >= segment->actTimeMs)
            {
                PlsrTransitionToNext(0U);
            }
            break;
        case PLSR_EXT_SIGNAL:
            if (extEdge != 0U)
            {
                PlsrTransitionToNext(0U);
            }
            break;
        default:
            PlsrEnterError(PLSR_ERROR_INTERNAL);
            break;
    }
}

static void PlsrPollPersistenceDelay(void)
{
    if ((PlsrPersistenceDirty != 0U)
        && (PlsrIsBusy() == 0U)
        && (PlsrPersistenceDelayMs != 0U))
    {
        PlsrPersistenceDelayMs--;
    }
}

void PlsrServicePersistence(void)
{
    PLSR_PERSIST_PAYLOAD payload;
    PLSR_PLATFORM_SERVICE_RESULT serviceResult;
    uint32_t criticalState;

    if (PlsrIsBusy() != 0U)
    {
        return;
    }
    serviceResult = PlsrPlatformServicePersistence();
    if (serviceResult == PLSR_PLATFORM_SERVICE_FAILED)
    {
        PlsrRunStatus = PLSR_STATUS_ERROR;
        PlsrError = PLSR_ERROR_INTERNAL;
        return;
    }
    if ((serviceResult == PLSR_PLATFORM_SERVICE_DEFERRED)
        || (PlsrPersistenceDirty == 0U))
    {
        return;
    }
    if (PlsrPersistenceDelayMs != 0U)
    {
        return;
    }

    payload.config = PlsrShadowConfig;
    criticalState = PlsrPlatformEnterCritical();
    payload.position = PlsrPosition;
    payload.positionValid = PlsrPositionValid;
    PlsrPlatformExitCritical(criticalState);
    payload.wasBusy = 0U;
    payload.reserved = 0U;
    if (PlsrPlatformSave(&payload) != 0U)
    {
        PlsrPersistenceDirty = 0U;
    }
    else
    {
        PlsrRunStatus = PLSR_STATUS_ERROR;
        PlsrError = PLSR_ERROR_INTERNAL;
    }
}

uint8_t PlsrInit(void)
{
    PLSR_PERSIST_PAYLOAD payload;

    PlsrInitialized = 0U;
    PlsrRunStatus = PLSR_STATUS_UNINITIALIZED;
    if (PlsrPlatformInit() == 0U)
    {
        return 0U;
    }

    if ((PlsrPlatformLoad(&payload) == 0U)
        || (PlsrConfigIsValid(&payload.config, 0U) == 0U)
        || (payload.positionValid > 1U) || (payload.wasBusy > 1U))
    {
        PlsrSetDefaults(&PlsrShadowConfig);
        PlsrPosition = 0L;
        PlsrPositionValid = 1U;
        PlsrPlatformCheckpointConfig(&PlsrShadowConfig);
        PlsrPlatformCheckpointPosition(0L, 1U, 0U);
        PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
    }
    else
    {
        PlsrShadowConfig = payload.config;
        PlsrPosition = payload.position;
        PlsrPositionValid = ((payload.positionValid != 0U)
                             && (payload.wasBusy == 0U)) ? 1U : 0U;
        PlsrPersistenceDirty = 0U;
        PlsrPersistenceDelayMs = 0U;
    }

    (void)memset(&PlsrActiveConfig, 0, sizeof(PlsrActiveConfig));
    (void)memset(&PlsrRamp, 0, sizeof(PlsrRamp));
    (void)memset(&PlsrShortProfile, 0, sizeof(PlsrShortProfile));
    (void)memset(&PlsrProfileQueue, 0, sizeof(PlsrProfileQueue));
    (void)memset(&PlsrHandoffPlan, 0, sizeof(PlsrHandoffPlan));
    (void)memset(PlsrPreparedHandoffPlans, 0,
                 sizeof(PlsrPreparedHandoffPlans));
    PlsrPreparedHandoffBank = 0U;
    PlsrRemainingPulses = 0UL;
    PlsrPulseActive = 0U;
    PlsrCutRequested = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrCountOverflowPending = 0U;
    PlsrPositionCheckpointDirty = 0U;
    PlsrFrequencyUpdatePending = 0U;
    PlsrDeferredFrequencyPending = 0U;
    PlsrFrequencyUpdateSegment = 0U;
    PlsrSeamlessHandoffPending = 0U;
    PlsrTimerErrorPending = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrBoundaryFrequencyHz = 0UL;
    PlsrFrequencyUpdateTargetHz = 0UL;
    PlsrDeferredFrequencyHz = 0UL;
    PlsrSegmentEpoch = 0UL;
    PlsrCurrentSegment = 0U;
    PlsrDirectionDelayActive = 0U;
    PlsrDirectionDelayRemainingMs = 0U;
    PlsrSegmentClockStarted = 0U;
    PlsrExtPreviousLevel = 0U;
    PlsrExtEdgePending = 0U;
    PlsrStopRequested = 0U;
    PlsrStopPulsesRemaining = 0U;
    PlsrAbStopArmed = 0U;
    PlsrLastDirectionValid = 0U;
    PlsrPositionCheckpointElapsedMs = 0U;
    PlsrCommandMailbox.command = 0U;
    PlsrCommandMailbox.state = PLSR_COMMAND_MAILBOX_EMPTY;
    PlsrDiagnosticReset();
#ifdef PLSR_HOST_TEST
    PlsrHostTestEventSequence = 0UL;
    PlsrHostTestLastGateEvent = 0UL;
    PlsrHostTestLastDiagnosticFinishEvent = 0UL;
#endif
#if defined(PLSR_DEBUG_TIMING) && (PLSR_DEBUG_TIMING != 0)
    PlsrProfileProducerItemCount = 0UL;
    PlsrProfileProducerTotalCycles = 0UL;
    PlsrProfileProducerMaxItemCycles = 0UL;
#endif
    PlsrError = PLSR_ERROR_NONE;
    PlsrRunStatus = PLSR_STATUS_IDLE;
    PlsrInitialized = 1U;
    return 1U;
}

static PLSR_MB_RESULT PlsrQueueCommand(uint16_t command)
{
    uint32_t criticalState;
    PLSR_MB_RESULT result = PLSR_MB_OK;

    if (PlsrInitialized == 0U)
    {
        return PLSR_MB_SERVER_FAILURE;
    }

    criticalState = PlsrPlatformEnterCritical();
    /* Capacity one: repeats acknowledge the first command; conflicts wait. */
    if (PlsrCommandMailbox.state != PLSR_COMMAND_MAILBOX_EMPTY)
    {
        result = (PlsrCommandMailbox.command == command)
                     ? PLSR_MB_OK : PLSR_MB_DEVICE_BUSY;
        PlsrPlatformExitCritical(criticalState);
        return result;
    }

    if (command == PLSR_COMMAND_START)
    {
        if ((PlsrIsBusy() != 0U)
            || (PlsrRunStatus == PLSR_STATUS_ERROR))
        {
            result = PLSR_MB_DEVICE_BUSY;
        }
        else if ((PlsrRunStatus != PLSR_STATUS_IDLE)
                 && (PlsrRunStatus != PLSR_STATUS_COMPLETED)
                 && (PlsrRunStatus != PLSR_STATUS_STOPPED))
        {
            result = PLSR_MB_ILLEGAL_VALUE;
        }
        else if ((PlsrConfigIsValid(&PlsrShadowConfig, 1U) == 0U)
                 || ((PlsrShadowConfig.positionMode
                      == PLSR_POSITION_ABSOLUTE)
                     && (PlsrPositionValid == 0U)))
        {
            result = PLSR_MB_ILLEGAL_VALUE;
        }
        else
        {
            PlsrCommandMailbox.startConfig = PlsrShadowConfig;
        }
    }
    else if ((command == PLSR_COMMAND_CLEAR) && (PlsrIsBusy() != 0U))
    {
        result = PLSR_MB_DEVICE_BUSY;
    }

    if (result == PLSR_MB_OK)
    {
        PlsrCommandMailbox.command = command;
        PlsrCommandMailbox.state = PLSR_COMMAND_MAILBOX_PENDING;
    }
    PlsrPlatformExitCritical(criticalState);
    return result;
}

static void PlsrExecuteStart(void)
{
    uint32_t criticalState;
    uint8_t handoffBank;

    PlsrActiveConfig = PlsrCommandMailbox.startConfig;
    handoffBank = PlsrBuildHandoffPlanBank(&PlsrActiveConfig);
    criticalState = PlsrPlatformEnterCritical();
    PlsrPreparedHandoffBank = handoffBank;
    PlsrHandoffPlan.valid = 0U;
    PlsrPlatformExitCritical(criticalState);
    PlsrStopRequested = 0U;
    PlsrTimerErrorPending = 0U;
    PlsrShortProfile.active = 0U;
    PlsrError = PLSR_ERROR_NONE;
    PlsrLastDirectionValid = 0U;
    PlsrCheckpointPosition(1U);
    if (PlsrStartSegment((uint8_t)PlsrActiveConfig.startSegment, 0U, 0UL)
        == 0U)
    {
        PlsrEnterError((PlsrTimerErrorPending != 0U)
                           ? PLSR_ERROR_TIMER
                           : PLSR_ERROR_INVALID_RESOURCE);
    }
}

static uint8_t PlsrExecuteStop(void)
{
    uint32_t criticalState;
    uint32_t stopTargetHz;

    if (PlsrIsBusy() == 0U)
    {
        return 0U;
    }
    criticalState = PlsrPlatformEnterCritical();
    if (PlsrStopRequested != 0U)
    {
        PlsrPlatformExitCritical(criticalState);
        return 0U;
    }

    PlsrStopRequested = 1U;
    PlsrStopPulsesRemaining = 0U;
    PlsrShortProfile.active = 0U;
    PlsrProfileQueueInvalidateGeneration();
    PlsrHandoffPlan.valid = 0U;
    PlsrInvalidateHandoffPlans();
    if (PlsrBoundaryPending != 0U)
    {
        PlsrPlatformExitCritical(criticalState);
        return 1U;
    }
    if (PlsrPulseActive == 0U)
    {
        PlsrPlatformExitCritical(criticalState);
        PlsrFinishStopped();
        return 1U;
    }

    stopTargetHz = PlsrActiveConfig.stopSpeedHz;
    if (stopTargetHz > PlsrCurrentFrequencyHz)
    {
        stopTargetHz = PlsrCurrentFrequencyHz;
    }
    PlsrRampStart(PlsrCurrentFrequencyHz, stopTargetHz);
    PlsrRunStatus = PLSR_STATUS_DECELERATING;
    if (PlsrRamp.active == 0U)
    {
        if (PlsrApplyFrequency(stopTargetHz, PlsrSegmentEpoch) == 0U)
        {
            PlsrPlatformExitCritical(criticalState);
            PlsrEnterError(PLSR_ERROR_TIMER);
            return 1U;
        }
        PlsrStopPulsesRemaining = PlsrStopDrainPulseCount();
        (void)PlsrArmFinalAbBoundaryLocked();
    }
    PlsrPlatformExitCritical(criticalState);
    return 1U;
}

static void PlsrExecuteClear(void)
{
    uint32_t criticalState;

    criticalState = PlsrPlatformEnterCritical();
    PlsrPosition = 0L;
    PlsrPositionValid = 1U;
    PlsrRemainingPulses = 0UL;
    PlsrPlatformExitCritical(criticalState);
    PlsrPlatformCheckpointPosition(0L, 1U, 0U);
    PlsrCountOverflowPending = 0U;
    PlsrPositionCheckpointDirty = 0U;
    PlsrPositionCheckpointElapsedMs = 0U;
    PlsrCurrentSegment = 0U;
    PlsrCurrentFrequencyHz = 0UL;
    PlsrQueuedFrequencyHz = 0UL;
    PlsrCutRequested = 0U;
    PlsrBoundaryPending = 0U;
    PlsrBoundaryWasCut = 0U;
    PlsrDirectionDelayActive = 0U;
    PlsrDirectionDelayRemainingMs = 0U;
    PlsrExtEdgePending = 0U;
    PlsrShortProfile.active = 0U;
    PlsrProfileQueueReset();
    PlsrHandoffPlan.valid = 0U;
    PlsrInvalidateHandoffPlans();
    PlsrDeferredFrequencyPending = 0U;
    PlsrTimerErrorPending = 0U;
    PlsrRamp.active = 0U;
    PlsrError = PLSR_ERROR_NONE;
    PlsrRunStatus = PLSR_STATUS_IDLE;
    PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
}

static uint8_t PlsrPollCommandMailbox(void)
{
    uint16_t command;
    uint8_t endPoll = 1U;
    uint32_t criticalState;

    criticalState = PlsrPlatformEnterCritical();
    if (PlsrCommandMailbox.state != PLSR_COMMAND_MAILBOX_PENDING)
    {
        PlsrPlatformExitCritical(criticalState);
        return 0U;
    }
    PlsrCommandMailbox.state = PLSR_COMMAND_MAILBOX_EXECUTING;
    command = PlsrCommandMailbox.command;
    PlsrPlatformExitCritical(criticalState);

    switch (command)
    {
        case PLSR_COMMAND_START: PlsrExecuteStart(); break;
        case PLSR_COMMAND_STOP: endPoll = PlsrExecuteStop(); break;
        case PLSR_COMMAND_CLEAR: PlsrExecuteClear(); break;
        default: PlsrEnterError(PLSR_ERROR_INTERNAL); break;
    }

    criticalState = PlsrPlatformEnterCritical();
    PlsrCommandMailbox.command = 0U;
    PlsrCommandMailbox.state = PLSR_COMMAND_MAILBOX_EMPTY;
    PlsrPlatformExitCritical(criticalState);
    return endPoll;
}

static void PlsrEnterErrorIfEpoch(PLSR_ERROR error, uint32_t expectedEpoch)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    if (PlsrSegmentEpoch == expectedEpoch)
    {
        PlsrEnterError(error);
    }
    PlsrPlatformExitCritical(criticalState);
}

void PlsrPoll1ms(void)
{
    uint8_t extLevel;
    uint8_t extEdge;
    uint8_t activeSegmentNumber;
    uint8_t applyDynamicFrequency = 0U;
    PLSR_SEGMENT_CONFIG *activeSegment;
    uint32_t criticalState;
    uint32_t newTargetHz;
    uint32_t pollEpoch;

    if (PlsrInitialized == 0U)
    {
        return;
    }

    if (PlsrPollCommandMailbox() != 0U)
    {
        return;
    }

    PlsrPollPositionCheckpoint();

    criticalState = PlsrPlatformEnterCritical();
    pollEpoch = PlsrSegmentEpoch;
    extLevel = PlsrPlatformReadInput((uint8_t)PlsrActiveConfig.extInput);
    extEdge = ((extLevel != 0U) && (PlsrExtPreviousLevel == 0U)) ? 1U : 0U;
    PlsrExtPreviousLevel = extLevel;
    if (PlsrExtEdgePending != 0U)
    {
        extEdge = 1U;
    }
    PlsrPlatformExitCritical(criticalState);

    if (PlsrBoundaryPending != 0U)
    {
        PlsrExtEdgePending = 0U;
        PlsrHandleBoundary(extEdge);
        PlsrPollPersistenceDelay();
        return;
    }

    if (PlsrIsBusy() == 0U)
    {
        PlsrExtEdgePending = 0U;
        PlsrPollPersistenceDelay();
        return;
    }

    if (PlsrSegmentEpoch != pollEpoch)
    {
        return;
    }

    if (PlsrDirectionDelayActive != 0U)
    {
        if (extEdge != 0U)
        {
            PlsrExtEdgePending = 1U;
        }
        if (PlsrDirectionDelayRemainingMs != 0U)
        {
            PlsrDirectionDelayRemainingMs--;
        }
        if (PlsrDirectionDelayRemainingMs == 0U)
        {
            PlsrDirectionDelayActive = 0U;
            if (PlsrBeginSegmentOutput(PlsrActiveConfig.startSpeedHz) == 0U)
            {
                PlsrEnterError(PLSR_ERROR_TIMER);
            }
        }
        return;
    }

    criticalState = PlsrPlatformEnterCritical();
    if (PlsrSegmentEpoch != pollEpoch)
    {
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    PlsrExtEdgePending = 0U;
    if (PlsrSegmentClockStarted != 0U)
    {
        PlsrSegmentElapsedMs++;
    }
    if (PlsrRunStatus == PLSR_STATUS_WAITING)
    {
        PlsrPlatformExitCritical(criticalState);
        PlsrPollWaiting(extEdge);
        return;
    }

    activeSegmentNumber = PlsrCurrentSegment;
    if ((activeSegmentNumber == 0U)
        || (activeSegmentNumber > PlsrActiveConfig.segmentCount))
    {
        PlsrPlatformExitCritical(criticalState);
        PlsrEnterError(PLSR_ERROR_INTERNAL);
        return;
    }
    activeSegment = &PlsrActiveConfig.segments[activeSegmentNumber - 1U];
    if (PlsrSeamlessHandoffPending != 0U)
    {
        PlsrSeamlessHandoffPending = 0U;
        if ((PlsrStopRequested == 0U)
            && (PlsrShortProfile.active == 0U)
            && (PlsrFrequencyUpdatePending == 0U))
        {
            PlsrRamp.active = 0U;
            PlsrRunStatus = PLSR_STATUS_RUNNING;
        }
    }
    newTargetHz = PlsrFrequencyUpdateTargetHz;
    if ((PlsrStopRequested == 0U)
        && (PlsrFrequencyUpdatePending != 0U)
        && (PlsrAbStopArmed == 0U)
        && (PlsrFrequencyUpdateSegment == activeSegmentNumber))
    {
        PlsrFrequencyUpdatePending = 0U;
        activeSegment->frequencyHz = newTargetHz;
        PlsrShortProfile.active = 0U;
        PlsrProfileQueueInvalidateGeneration();
        PlsrBoundaryRampStarted = 0U;
        PlsrRampStart(PlsrCurrentFrequencyHz, newTargetHz);
        if (PlsrRamp.active == 0U)
        {
            applyDynamicFrequency = 1U;
        }
    }
    PlsrPlatformExitCritical(criticalState);

    if (applyDynamicFrequency != 0U)
    {
        if (PlsrApplyFrequency(newTargetHz, pollEpoch) == 0U)
        {
            PlsrEnterErrorIfEpoch(PLSR_ERROR_TIMER, pollEpoch);
            return;
        }
        criticalState = PlsrPlatformEnterCritical();
        if (PlsrSegmentEpoch == pollEpoch)
        {
            PlsrRunStatus = PLSR_STATUS_RUNNING;
        }
        PlsrPlatformExitCritical(criticalState);
    }

    if ((PlsrShortProfile.active == 0U)
        && (PlsrRamp.active != 0U)
        && (PlsrRampAdvance(pollEpoch) == 0U))
    {
        PlsrEnterErrorIfEpoch(PLSR_ERROR_TIMER, pollEpoch);
        return;
    }

    criticalState = PlsrPlatformEnterCritical();
    if (PlsrSegmentEpoch != pollEpoch)
    {
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    if ((PlsrStopRequested != 0U) && (PlsrRamp.active == 0U))
    {
        if (PlsrStopPulsesRemaining == 0U)
        {
            PlsrStopPulsesRemaining = PlsrStopDrainPulseCount();
        }
        (void)PlsrArmFinalAbBoundaryLocked();
        PlsrPlatformExitCritical(criticalState);
        return;
    }
    PlsrPlatformExitCritical(criticalState);

    if ((activeSegment->waitType == PLSR_ACT_TIME)
        && (PlsrSegmentElapsedMs >= activeSegment->actTimeMs))
    {
        PlsrRequestCut(pollEpoch);
        return;
    }
    if (((activeSegment->waitType == PLSR_EXT_SIGNAL)
         || (activeSegment->waitType == PLSR_EXT_OR_COMPLETE))
        && (extEdge != 0U))
    {
        PlsrRequestCut(pollEpoch);
        return;
    }

    PlsrMaybePlanBoundaryRamp(pollEpoch);
}

void PlsrPulseTimerIrq(uint8_t pulseOutput)
{
    uint32_t positionBits;
    uint32_t completedFrequencyHz;
    uint64_t remainingPulses;
    PLSR_PLATFORM_QUEUE_RESULT queueResult;

    if ((PlsrPulseActive == 0U)
        || (pulseOutput != (uint8_t)PlsrActiveConfig.pulseOutput))
    {
        return;
    }

    completedFrequencyHz = PlsrCurrentFrequencyHz;
    PlsrDiagnosticCheckActiveFrequency(completedFrequencyHz);
    PlsrCurrentFrequencyHz = PlsrPlatformActiveFrequency(pulseOutput);
    if (PlsrCurrentFrequencyHz == 0UL)
    {
        PlsrCurrentFrequencyHz = PlsrQueuedFrequencyHz;
    }
    if ((PlsrStopRequested != 0U) && (PlsrRamp.active == 0U)
        && (PlsrStopPulsesRemaining != 0U))
    {
        PlsrStopPulsesRemaining--;
        if (PlsrStopPulsesRemaining == 0U)
        {
            PlsrCutRequested = 1U;
        }
    }
    positionBits = (uint32_t)PlsrPosition;
    if (PlsrCountPositive != 0U)
    {
        if (positionBits == (uint32_t)INT32_MAX)
        {
            PlsrPositionValid = 0U;
            PlsrCountOverflowPending = 1U;
        }
        positionBits++;
    }
    else
    {
        if (positionBits == (uint32_t)INT32_MIN)
        {
            PlsrPositionValid = 0U;
            PlsrCountOverflowPending = 1U;
        }
        positionBits--;
    }
    PlsrPosition = (int32_t)positionBits;
    PlsrPositionCheckpointDirty = 1U;

    remainingPulses = PlsrRemainingPulses;
    if (remainingPulses != 0UL)
    {
        remainingPulses--;
        PlsrRemainingPulses = remainingPulses;
    }

    if ((remainingPulses == 0UL) || (PlsrCutRequested != 0U)
        || (PlsrCountOverflowPending != 0U))
    {
        if (remainingPulses == 0UL)
        {
            queueResult = PlsrTrySubsequentHandoff();
            if (queueResult != PLSR_PLATFORM_QUEUE_FAILED)
            {
                return;
            }
        }
        PlsrPlatformGateFromIrq(pulseOutput);
#ifdef PLSR_HOST_TEST
        PlsrHostTestEventSequence++;
        PlsrHostTestLastGateEvent = PlsrHostTestEventSequence;
#endif
        PlsrDiagnosticFinishSegment(
            ((remainingPulses == 0UL)
             && (PlsrCutRequested == 0U)
             && (PlsrCountOverflowPending == 0U)) ? 1U : 0U);
        PlsrShortProfile.active = 0U;
        PlsrHandoffPlan.valid = 0U;
        PlsrBoundaryFrequencyHz = completedFrequencyHz;
        PlsrBoundaryWasCut = (PlsrCutRequested != 0U) ? 1U : 0U;
        PlsrCutRequested = 0U;
        PlsrAbStopArmed = 0U;
        PlsrPulseActive = 0U;
        PlsrCurrentFrequencyHz = 0UL;
        PlsrQueuedFrequencyHz = 0UL;
        PlsrBoundaryPending = 1U;
        return;
    }

    if (PlsrShortProfile.active != 0U)
    {
        queueResult = PlsrProfileQueueCommitNext(pulseOutput);
        if (queueResult == PLSR_PLATFORM_QUEUE_STALE)
        {
            return;
        }
        if (queueResult == PLSR_PLATFORM_QUEUE_FAILED)
        {
            PlsrDiagnosticFinishSegment(0U);
            PlsrTimerErrorPending = 1U;
            PlsrShortProfile.active = 0U;
            PlsrHandoffPlan.valid = 0U;
            PlsrBoundaryFrequencyHz = completedFrequencyHz;
            PlsrBoundaryWasCut = 0U;
            PlsrCutRequested = 0U;
            PlsrPlatformGateFromIrq(pulseOutput);
            PlsrAbStopArmed = 0U;
            PlsrPulseActive = 0U;
            PlsrCurrentFrequencyHz = 0UL;
            PlsrQueuedFrequencyHz = 0UL;
            PlsrBoundaryPending = 1U;
            return;
        }
    }

    if ((PlsrShortProfile.active == 0U)
        && (remainingPulses == 1UL)
        && (PlsrActiveConfig.sendMode == PLSR_SEND_SUBSEQUENT))
    {
        if (PlsrPrimeHandoff() == PLSR_PLATFORM_QUEUE_STALE)
        {
            return;
        }
    }
    if ((PlsrShortProfile.active == 0U)
        && (PlsrHandoffPlan.valid == 0U)
        && (PlsrDeferredFrequencyPending != 0U))
    {
        queueResult = PlsrCommitDeferredFrequency(pulseOutput);
        if (queueResult == PLSR_PLATFORM_QUEUE_STALE)
        {
            return;
        }
        if (queueResult == PLSR_PLATFORM_QUEUE_FAILED)
        {
            PlsrDiagnosticFinishSegment(0U);
            PlsrTimerErrorPending = 1U;
            PlsrBoundaryFrequencyHz = completedFrequencyHz;
            PlsrBoundaryWasCut = 0U;
            PlsrCutRequested = 0U;
            PlsrPlatformGateFromIrq(pulseOutput);
            PlsrAbStopArmed = 0U;
            PlsrPulseActive = 0U;
            PlsrCurrentFrequencyHz = 0UL;
            PlsrQueuedFrequencyHz = 0UL;
            PlsrBoundaryPending = 1U;
            return;
        }
    }
    if ((PlsrActiveConfig.outputMode == PLSR_OUTPUT_AB)
        && (PlsrQueueFinalAbBoundaryFromIrq() == 0U))
    {
        return;
    }

}

PLSR_MB_RESULT PlsrModbusReadHolding(uint16_t startAddress,
                                     uint16_t quantity,
                                     uint16_t *values)
{
    PLSR_MB_RESULT classification;
    uint16_t index;
    uint32_t criticalState;
    int32_t position;
    uint32_t frequency;
    uint16_t statusWords[7];
    uint16_t diagnosticWords[26];

    if (values == NULL)
    {
        return PLSR_MB_ILLEGAL_VALUE;
    }
    classification = PlsrClassifyRange(startAddress, quantity);
    if (classification != PLSR_MB_OK)
    {
        return classification;
    }

    criticalState = PlsrPlatformEnterCritical();
    position = PlsrPosition;
    frequency = PlsrCurrentFrequencyHz;
    statusWords[0] = PlsrLowWord((uint32_t)position);
    statusWords[1] = PlsrHighWord((uint32_t)position);
    statusWords[2] = PlsrLowWord(frequency);
    statusWords[3] = PlsrHighWord(frequency);
    statusWords[4] = (uint16_t)PlsrRunStatus;
    statusWords[5] = PlsrCurrentSegment;
    statusWords[6] = (uint16_t)PlsrError;
    diagnosticWords[0] = PlsrDiagnostic.flags;
    diagnosticWords[1] = PlsrDiagnostic.reason;
    diagnosticWords[2] = PlsrDiagnostic.lastSegment;
    diagnosticWords[3] = PlsrDiagnostic.modeDirection;
    diagnosticWords[4] = PlsrLowWord(PlsrDiagnostic.expectedCycles);
    diagnosticWords[5] = PlsrHighWord(PlsrDiagnostic.expectedCycles);
    diagnosticWords[6] = PlsrLowWord(PlsrDiagnostic.observedCycles);
    diagnosticWords[7] = PlsrHighWord(PlsrDiagnostic.observedCycles);
    diagnosticWords[8] = PlsrLowWord((uint32_t)PlsrDiagnostic.countError);
    diagnosticWords[9] = PlsrHighWord((uint32_t)PlsrDiagnostic.countError);
    diagnosticWords[10] = PlsrLowWord(PlsrDiagnostic.requestedHz);
    diagnosticWords[11] = PlsrHighWord(PlsrDiagnostic.requestedHz);
    diagnosticWords[12] = PlsrLowWord(PlsrDiagnostic.expectedTimerHz);
    diagnosticWords[13] = PlsrHighWord(PlsrDiagnostic.expectedTimerHz);
    diagnosticWords[14] = PlsrLowWord(PlsrDiagnostic.activeTimerHz);
    diagnosticWords[15] = PlsrHighWord(PlsrDiagnostic.activeTimerHz);
    diagnosticWords[16] =
        PlsrLowWord((uint32_t)PlsrDiagnostic.requestErrorHz);
    diagnosticWords[17] =
        PlsrHighWord((uint32_t)PlsrDiagnostic.requestErrorHz);
    diagnosticWords[18] = PlsrLowWord(PlsrDiagnostic.curveSampleCount);
    diagnosticWords[19] = PlsrHighWord(PlsrDiagnostic.curveSampleCount);
    diagnosticWords[20] = PlsrLowWord(PlsrDiagnostic.curveMismatchCount);
    diagnosticWords[21] = PlsrHighWord(PlsrDiagnostic.curveMismatchCount);
    diagnosticWords[22] = PlsrLowWord(PlsrDiagnostic.curveMaxAbsErrorHz);
    diagnosticWords[23] = PlsrHighWord(PlsrDiagnostic.curveMaxAbsErrorHz);
    diagnosticWords[24] = PlsrLowWord(PlsrDiagnostic.firstMismatchSample);
    diagnosticWords[25] = PlsrHighWord(PlsrDiagnostic.firstMismatchSample);
    PlsrPlatformExitCritical(criticalState);

    for (index = 0U; index < quantity; index++)
    {
        uint16_t address = (uint16_t)(startAddress + index);

        if ((address >= PLSR_CONFIG_FIRST_ADDRESS)
            && (address <= PLSR_CONFIG_LAST_ADDRESS))
        {
            values[index] = PlsrReadConfigWord(&PlsrShadowConfig, address);
        }
        else if (address == PLSR_OUTPUT_MODE_ADDRESS)
        {
            values[index] = PlsrShadowConfig.outputMode;
        }
        else if ((address >= PLSR_STATUS_FIRST_ADDRESS)
                 && (address <= PLSR_STATUS_LAST_ADDRESS))
        {
            values[index] = statusWords[address - PLSR_STATUS_FIRST_ADDRESS];
        }
        else if ((address >= PLSR_DIAGNOSTIC_FIRST_ADDRESS)
                 && (address <= PLSR_DIAGNOSTIC_LAST_ADDRESS))
        {
            values[index] =
                diagnosticWords[address - PLSR_DIAGNOSTIC_FIRST_ADDRESS];
        }
        else if (address == PLSR_CONTROL_ADDRESS)
        {
            values[index] = 0U;
        }
        else if (address == PLSR_DIAGNOSTIC_CONTROL_ADDRESS)
        {
            values[index] = 0U;
        }
        else
        {
            return PLSR_MB_ILLEGAL_ADDRESS;
        }
    }
    return PLSR_MB_OK;
}

PLSR_MB_RESULT PlsrModbusWriteHolding(uint16_t startAddress,
                                      uint16_t quantity,
                                      const uint16_t *values)
{
    PLSR_MB_RESULT classification;
    PLSR_WORD_RESULT wordResult;
    uint16_t index;
    uint16_t pairedAddress;
    uint32_t requestEnd;
    uint32_t criticalState;
    uint8_t handoffBank = 0U;
    uint8_t updateActiveFrequencies = 0U;
    uint8_t drainedToDifferentSegment = 0U;
    uint8_t segmentBeforeDrain;
    uint32_t drainedSegmentTargetHz = 0UL;
    PLSR_PLATFORM_QUEUE_RESULT queueResult;

    if (values == NULL)
    {
        return PLSR_MB_ILLEGAL_VALUE;
    }
    classification = PlsrClassifyRange(startAddress, quantity);
    if (classification != PLSR_MB_OK)
    {
        return classification;
    }

    if ((startAddress >= PLSR_STATUS_FIRST_ADDRESS)
        && (startAddress <= PLSR_STATUS_LAST_ADDRESS))
    {
        return PLSR_MB_ILLEGAL_ADDRESS;
    }

    if ((startAddress >= PLSR_DIAGNOSTIC_FIRST_ADDRESS)
        && (startAddress <= PLSR_DIAGNOSTIC_LAST_ADDRESS))
    {
        return PLSR_MB_ILLEGAL_ADDRESS;
    }

    if (startAddress == PLSR_DIAGNOSTIC_CONTROL_ADDRESS)
    {
        if (quantity != 1U)
        {
            return PLSR_MB_ILLEGAL_ADDRESS;
        }
        if ((values[0] != 0U) && (values[0] != 1U))
        {
            return PLSR_MB_ILLEGAL_VALUE;
        }
        if ((values[0] != 0U) && (PlsrIsBusy() != 0U))
        {
            return PLSR_MB_DEVICE_BUSY;
        }
        if (values[0] != 0U)
        {
            criticalState = PlsrPlatformEnterCritical();
            PlsrDiagnosticReset();
            PlsrPlatformExitCritical(criticalState);
        }
        return PLSR_MB_OK;
    }

    if (startAddress == PLSR_CONTROL_ADDRESS)
    {
        if (quantity != 1U)
        {
            return PLSR_MB_ILLEGAL_ADDRESS;
        }
        switch (values[0])
        {
            case 0U: return PLSR_MB_OK;
            case PLSR_COMMAND_START:
            case PLSR_COMMAND_STOP:
            case PLSR_COMMAND_CLEAR:
                return PlsrQueueCommand(values[0]);
            default: return PLSR_MB_ILLEGAL_VALUE;
        }
    }

    if (startAddress == PLSR_OUTPUT_MODE_ADDRESS)
    {
        if (quantity != 1U)
        {
            return PLSR_MB_ILLEGAL_ADDRESS;
        }
        if (PlsrIsBusy() != 0U)
        {
            return PLSR_MB_DEVICE_BUSY;
        }
        PlsrCandidateConfig = PlsrShadowConfig;
        PlsrCandidateConfig.outputMode = values[0];
        if (PlsrConfigIsValid(&PlsrCandidateConfig, 0U) == 0U)
        {
            return PLSR_MB_ILLEGAL_VALUE;
        }
        criticalState = PlsrPlatformEnterCritical();
        PlsrShadowConfig = PlsrCandidateConfig;
        PlsrPlatformExitCritical(criticalState);
        PlsrPlatformCheckpointConfig(&PlsrShadowConfig);
        PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
        return PLSR_MB_OK;
    }

    if ((startAddress < PLSR_CONFIG_FIRST_ADDRESS)
        || ((uint32_t)startAddress + quantity - 1UL
            > PLSR_CONFIG_LAST_ADDRESS))
    {
        return PLSR_MB_ILLEGAL_ADDRESS;
    }
    if ((PlsrIsBusy() != 0U)
        && (startAddress <= 0x1001U)
        && ((uint32_t)startAddress + quantity - 1UL >= 0x1000UL))
    {
        return PLSR_MB_DEVICE_BUSY;
    }

    requestEnd = (uint32_t)startAddress + quantity;
    for (index = 0U; index < quantity; index++)
    {
        uint16_t address = (uint16_t)(startAddress + index);
        if (PlsrAddressIsDwordHalf(address, &pairedAddress) != 0U)
        {
            if (((uint32_t)pairedAddress < startAddress)
                || ((uint32_t)pairedAddress >= requestEnd))
            {
                return PLSR_MB_ILLEGAL_ADDRESS;
            }
        }
    }

    PlsrCandidateConfig = PlsrShadowConfig;
    for (index = 0U; index < quantity; index++)
    {
        wordResult = PlsrWriteConfigWord(&PlsrCandidateConfig,
                                         (uint16_t)(startAddress + index),
                                         values[index]);
        if (wordResult == PLSR_WORD_ILLEGAL_ADDRESS)
        {
            return PLSR_MB_ILLEGAL_ADDRESS;
        }
        if (wordResult == PLSR_WORD_ILLEGAL_VALUE)
        {
            return PLSR_MB_ILLEGAL_VALUE;
        }
    }

    if (PlsrConfigIsValid(&PlsrCandidateConfig, 0U) == 0U)
    {
        return PLSR_MB_ILLEGAL_VALUE;
    }

    if (PlsrIsBusy() != 0U)
    {
        for (index = 0U; index < PlsrActiveConfig.segmentCount; index++)
        {
            if (PlsrCandidateConfig.segments[index].frequencyHz
                != PlsrShadowConfig.segments[index].frequencyHz)
            {
                updateActiveFrequencies = 1U;
            }
        }
    }
    if (updateActiveFrequencies != 0U)
    {
        handoffBank = PlsrBuildHandoffPlanBank(&PlsrCandidateConfig);
    }

    criticalState = PlsrPlatformEnterCritical();
    segmentBeforeDrain = PlsrCurrentSegment;
    if ((updateActiveFrequencies != 0U) && (PlsrPulseActive != 0U))
    {
        PlsrPlatformDrainPendingPulse(
            (uint8_t)PlsrActiveConfig.pulseOutput);
        drainedToDifferentSegment =
            (PlsrCurrentSegment != segmentBeforeDrain) ? 1U : 0U;
        if ((drainedToDifferentSegment != 0U)
            && (PlsrCurrentSegment != 0U)
            && (PlsrCurrentSegment <= PlsrCandidateConfig.segmentCount))
        {
            drainedSegmentTargetHz =
                PlsrCandidateConfig.segments[PlsrCurrentSegment - 1U].frequencyHz;
        }
    }
    PlsrShadowConfig = PlsrCandidateConfig;
    if (updateActiveFrequencies != 0U)
    {
        for (index = 0U; index < PlsrActiveConfig.segmentCount; index++)
        {
            uint8_t frequencyChanged =
                (PlsrActiveConfig.segments[index].frequencyHz
                 != PlsrCandidateConfig.segments[index].frequencyHz)
                    ? 1U : 0U;

            PlsrActiveConfig.segments[index].frequencyHz =
                PlsrCandidateConfig.segments[index].frequencyHz;
            if ((frequencyChanged != 0U)
                && (index + 1U == PlsrCurrentSegment)
                && (PlsrStopRequested == 0U)
                && (PlsrAbStopArmed == 0U)
                && (PlsrRunStatus != PLSR_STATUS_WAITING))
            {
                PlsrFrequencyUpdateTargetHz =
                    PlsrCandidateConfig.segments[index].frequencyHz;
                PlsrFrequencyUpdateSegment = (uint8_t)(index + 1U);
                PlsrFrequencyUpdatePending = 1U;
            }
        }
        PlsrPreparedHandoffBank = handoffBank;
        PlsrHandoffPlan.valid = 0U;
        PlsrProfileQueueInvalidateGeneration();
        if ((drainedToDifferentSegment == 0U)
            && (PlsrPulseActive != 0U)
            && (PlsrAbStopArmed == 0U)
            && (PlsrShortProfile.active == 0U)
            && (PlsrRemainingPulses == 1UL))
        {
            (void)PlsrPrimeHandoff();
        }
        if ((drainedToDifferentSegment != 0U)
            && (PlsrPulseActive != 0U)
            && (PlsrCurrentSegment != 0U)
            && (PlsrCurrentSegment <= PlsrActiveConfig.segmentCount)
            && (PlsrStopRequested == 0U)
            && (PlsrAbStopArmed == 0U)
            && (PlsrRunStatus != PLSR_STATUS_WAITING)
            && (PlsrCurrentFrequencyHz != drainedSegmentTargetHz))
        {
            PlsrFrequencyUpdateTargetHz =
                drainedSegmentTargetHz;
            PlsrFrequencyUpdateSegment = PlsrCurrentSegment;
            PlsrFrequencyUpdatePending = 1U;
        }
    }
    PlsrPlatformExitCritical(criticalState);

    if ((updateActiveFrequencies != 0U)
        && (PlsrPulseActive != 0U)
        && (PlsrAbStopArmed == 0U)
        && (PlsrFrequencyUpdatePending == 0U)
        && (PlsrPrepareFutureHandoffQueue() == 0U))
    {
        PlsrTimerErrorPending = 1U;
    }
    if ((drainedToDifferentSegment != 0U)
        && (PlsrAbStopArmed == 0U)
        && (PlsrFrequencyUpdatePending != 0U))
    {
        uint32_t drainEpoch = PlsrSegmentEpoch;
        uint32_t actualDrainFrequencyHz;

        queueResult = PlsrDiagnosticQueueFrequency(
            (uint8_t)PlsrActiveConfig.pulseOutput,
            drainedSegmentTargetHz, &actualDrainFrequencyHz);
        if (queueResult == PLSR_PLATFORM_QUEUE_FAILED)
        {
            PlsrTimerErrorPending = 1U;
        }
        else if (queueResult == PLSR_PLATFORM_QUEUE_APPLIED)
        {
            uint32_t currentEpoch;
            uint8_t updateSegment;
            uint8_t currentSegment;

            criticalState = PlsrPlatformEnterCritical();
            currentEpoch = PlsrSegmentEpoch;
            updateSegment = PlsrFrequencyUpdateSegment;
            currentSegment = PlsrCurrentSegment;
            if ((currentEpoch == drainEpoch)
                && (updateSegment == currentSegment))
            {
                PlsrQueuedFrequencyHz = actualDrainFrequencyHz;
                PlsrFrequencyUpdatePending = 0U;
                PlsrRamp.active = 0U;
                PlsrRunStatus = PLSR_STATUS_RUNNING;
            }
            PlsrPlatformExitCritical(criticalState);
        }
    }
    PlsrPlatformCheckpointConfig(&PlsrShadowConfig);
    PlsrMarkPersistenceDirty(PLSR_CONFIG_SAVE_DELAY_MS);
    return PLSR_MB_OK;
}

#ifdef PLSR_HOST_TEST
uint64_t PlsrTestDivideU64ByU32(uint64_t dividend,
                                uint32_t divisor,
                                uint32_t *remainder)
{
    return PlsrDivideU64ByU32(dividend, divisor, remainder);
}

void PlsrTestSetPosition(int32_t position, uint8_t positionValid)
{
    uint32_t criticalState = PlsrPlatformEnterCritical();

    PlsrPosition = position;
    PlsrPositionValid = (positionValid != 0U) ? 1U : 0U;
    PlsrRemainingPulses = 0UL;
    PlsrPositionCheckpointDirty = 0U;
    PlsrPlatformExitCritical(criticalState);
    PlsrPlatformCheckpointPosition(position, PlsrPositionValid, 0U);
}

void PlsrTestSetDiagnosticCurveCounts(uint32_t sampleCount,
                                      uint32_t mismatchCount)
{
    PlsrDiagnostic.curveSampleCount = sampleCount;
    PlsrDiagnostic.curveMismatchCount = mismatchCount;
}

void PlsrTestForceProfileQueueEmpty(void)
{
    PlsrProfileQueue.readIndex = PlsrProfileQueue.writeIndex;
    PlsrProfileQueue.generatorComplete = 0U;
    PlsrProfileQueue.active = 1U;
}

uint16_t PlsrTestProfileQueueCount(void)
{
    return PlsrProfileQueueCount();
}

uint32_t PlsrTestProfileQueueGeneration(void)
{
    return PlsrProfileQueue.generation;
}

uint32_t PlsrTestProfileQueueReadIndex(void)
{
    return PlsrProfileQueue.readIndex;
}

uint32_t PlsrTestProfileQueueWriteIndex(void)
{
    return PlsrProfileQueue.writeIndex;
}

uint32_t PlsrTestProfileQueueHeadFrequency(void)
{
    uint32_t readIndex = PlsrProfileQueue.readIndex;

    if (readIndex == PlsrProfileQueue.writeIndex)
    {
        return 0UL;
    }
    return PlsrProfileQueue
        .entries[readIndex & PLSR_PROFILE_QUEUE_MASK].requestedFrequencyHz;
}

uint16_t PlsrTestProfileProducerNextPeriod(void)
{
    return PlsrProfileQueue.producerProfile.nextPeriod;
}

uint16_t PlsrTestActiveProfileNextPeriod(void)
{
    return PlsrShortProfile.nextPeriod;
}

uint32_t PlsrTestLastGateEvent(void)
{
    return PlsrHostTestLastGateEvent;
}

uint32_t PlsrTestLastDiagnosticFinishEvent(void)
{
    return PlsrHostTestLastDiagnosticFinishEvent;
}
#endif