This Function Block implements a hysteresis control logic, commonly used in thermostats to regulate temperature. It defines an upper and lower threshold based on a setpoint and a hysteresis width. The heating element is...

This Function Block implements a thermostat control using hysteresis. It calculates `UpperThreshold` as `Setpoint + HysteresisWidth / 2.0` and `LowerThreshold` as `Setpoint - HysteresisWidth / 2.0`. The `HeaterOutput` is controlled based on the `CurrentTemp` and these thresholds, using the `PreviousHeaterOutput` state to maintain the ON/OFF status. If the heater is OFF (`NOT PreviousHeaterOutput`) and `CurrentTemp < LowerThreshold`, it turns ON. If the heater is ON (`PreviousHeaterOutput`) and `CurrentTemp > UpperThreshold`, it turns OFF. Otherwise, it maintains its current state. This hysteresis band ensures that the output does not switch rapidly when the temperature hovers around the setpoint, preventing chattering. The time complexity is O(1) as it involves a fixed number of comparisons and arithmetic operations. Space complexity is O(1) for storing state variables.

FUNCTION_BLOCK Hysteresis_Control INPUTS: CurrentTemp, Setpoint, HysteresisWidth OUTPUTS: HeaterOutput // Ensure HysteresisWidth is positive IF HysteresisWidth < 0.0 THEN HysteresisWidth = 0.0 END IF // Calculate thresho...

This Function Block controls motor speed using a PID controller and generates a Pulse Width Modulation (PWM) signal. It takes a speed setpoint and current speed feedback, calculating the necessary PWM duty cycle to achie...

This Function Block implements a PID controller for motor speed regulation with PWM output. It calculates the `Error` between a `TargetSpeed` (which is dynamically adjusted for startup and deceleration) and `CurrentRPM`. The PID output is the sum of proportional (`Kp * Error`), integral (`Ki * Error * CycleTime`), and derivative (`Kd * (Error - PrevError) / CycleTime`) terms. A basic anti-windup strategy is employed by clamping the `IntegralTerm` to prevent excessive accumulation when the PID output might be saturated. The `TargetSpeed` is managed through `IsStarting` and `IsDecelerating` flags, ensuring a smooth transition from standstill to operating speed and back. The final `PWM_DutyCycle` is derived by clamping the `PID_Output` to `[MinDutyCycle, MaxDutyCycle]`. Additional logic ensures a minimum duty cycle is applied during startup or when the motor is running very slowly. Time complexity is O(1) per cycle. Space complexity is O(1) for state variables.

FUNCTION_BLOCK Motor_Speed_Control_PWM INPUTS: SetpointRPM, CurrentRPM, Kp, Ti, Td, MinSpeedRPM, MaxSpeedRPM, MinDutyCycle, MaxDutyCycle, CycleTime OUTPUTS: PWM_DutyCycle // Calculate Ki and Kd Ki = Kp / Ti (handle Ti=0)...

This Function Block scales a raw analog input signal (typically from a sensor) to a desired range of engineering units. It takes the raw input value, its corresponding minimum and maximum raw values, and the desired mini...

The algorithm implements linear scaling, a fundamental technique for converting raw sensor data into meaningful engineering units. It uses the formula: `Output = OutputMin + (Input - InputMin) * (OutputMax - OutputMin) / (InputMax - InputMin)`. The algorithm includes several checks to ensure robustness. It validates that `RawMin` is not greater than `RawMax` and `EngUnitMin` is not greater than `EngUnitMax`, defaulting to safe values if invalid ranges are provided. Crucially, it clamps the `RawInput` to the `[RawMin, RawMax]` range before calculation to handle sensor readings that might be slightly outside their nominal operating range. The final `ScaledOutput` is also clamped to `[EngUnitMin, EngUnitMax]` to guarantee it adheres to the specified output bounds, even if minor floating-point inaccuracies occur. The time complexity is O(1) as it involves a fixed number of arithmetic operations and comparisons. Space complexity is also O(1) as it uses a fixed number of variables.

FUNCTION_BLOCK Analog_Input_Scaling INPUTS: RawInput (INT), RawMin (INT), RawMax (INT), EngUnitMin (REAL), EngUnitMax (REAL) OUTPUTS: ScaledOutput (REAL) // Input validation IF RawMin >= RawMax THEN RawMin = 0 RawMax = 3...

This Function Block implements the outer loop of a cascade control system, commonly used in process industries to improve control performance. The outer loop (e.g., controlling temperature) adjusts the setpoint of an inn...

This Function Block implements a PI controller for the outer loop of a cascade system. The core logic calculates the `OuterError` (`OuterSetpoint - PrimaryPV`), then computes `OuterPropTerm` (`OuterKp * OuterError`) and `OuterIntegralTerm` (`integral of OuterError over time`). The `OuterIntegralTerm` is updated using the trapezoidal rule for better accuracy in discrete systems, scaled by `OuterKi` and `CycleTime`. A key aspect is the anti-windup logic: `IntegralActive` is set to `FALSE` if `InnerLoopManualMode` is `TRUE` or if the `InnerLoopOutput` is at its `InnerLoopMinOutput` or `InnerLoopMaxOutput`. This prevents integral windup. When `IntegralActive` is `FALSE`, the integral term is not updated, preserving its last valid value. The final `InnerSetpoint` is the sum of the proportional and integral terms, clamped to the `[InnerLoopMinOutput, InnerLoopMaxOutput]` range to ensure it's a valid setpoint for the inner loop. The time complexity is O(1) due to fixed operations. Space complexity is O(1) for storing state variables.

FUNCTION_BLOCK Cascade_Outer_Loop INPUTS: PrimaryPV, OuterSetpoint, OuterKp, OuterTi, InnerLoopOutput, InnerLoopManualMode, InnerLoopMinOutput, InnerLoopMaxOutput, CycleTime OUTPUTS: InnerSetpoint // Calculate integral g...

This FBD program simulates the proportional component of a PID controller. It calculates the proportional term based on the error between the setpoint and the process variable, multiplied by the proportional gain (Kp). T...

The algorithm calculates the proportional term of a PID controller, which is directly proportional to the current error. The `Clamp` helper function is used twice: first to ensure the input signal to the controller logic stays within its defined physical range, and second to ensure the final output signal does not exceed the actuator's limits. This prevents unrealistic control actions. The proportional term is calculated as `Kp * Error`. The `Kp` gain determines the responsiveness; a higher `Kp` leads to a faster response but can also cause instability. The algorithm's correctness relies on the accurate calculation of the error and the proper application of clamping to respect system boundaries. Edge cases include negative `Kp` values, which are handled by setting `Kp` to 0, and inputs/outputs that fall outside their respective min/max bounds.

PROGRAM PID_P_Gain_Tuning INPUTS: Setpoint, ProcessVariable, InputSignal, Kp, MinOutput, MaxOutput, MinInput, MaxInput OUTPUTS: OutputSignal IF Kp < 0.0 THEN Kp = 0.0 END IF Error = Setpoint - ProcessVariable Proportiona...

This program implements a chain of digital filters to smooth an incoming signal, reducing noise and transient fluctuations. It sequentially applies a Moving Average filter, a Simple Low-Pass Filter, and a Median Filter....

This program chains three common digital filters: Moving Average (MA), Low-Pass Filter (LPF), and Median Filter. The MA filter averages the last `MA_WindowSize` samples, providing smoothing. Its time complexity is O(1) per sample due to efficient sum update. The LPF is a first-order filter `y[n] = y[n-1] + alpha * (x[n] - y[n-1])`, where `alpha = CycleTime / (Tau + CycleTime)`. It attenuates high frequencies. Its complexity is O(1). The Median filter finds the median value within a sliding window of `Median_WindowSize` samples, effectively removing spikes. Its complexity is O(W log W) or O(W^2) depending on the sort algorithm used, where W is the window size; here, it's O(3 log 3) or O(9), effectively constant. Initialization for each filter handles the first few samples to avoid incorrect calculations. Edge cases include zero `CycleTime` or `Tau` for LPF, and ensuring `Median_WindowSize` is odd. The overall complexity is dominated by the median filter's sort, but for small, fixed window sizes, it's effectively O(1) per sample. Space complexity is O(W) for storing filter histories.

PROGRAM Digital_Filter_Chain INPUTS: InputSignal, MA_WindowSize, LPF_Tau, Median_WindowSize, CycleTime OUTPUTS: FilteredOutput // Initialize filters if needed IF NOT MA_Initialized THEN ... END IF IF NOT LPF_Initialized...