Rando hal component collections

component flash "Flash component to toggle output based on timing and control pins.";

function _ fp;
license "GPL";
author "Shade Technik";

description
"""
The flash component is a timed flasher with extra logic to make it suitable for many situations. The enable pin will begin flashing the output if the logic of the other pins does not hold it. The hold input pin can be used to hold the output true, which is useful to connect a separate output to in order to change the out pin from the flashing state to the held true state. The hold-prec (hold precidence) pin can be set or connected to a control pin
to switch whether the hold or flash effect takes precidence when both enable and hold are set true. The hold-prec-inv pin is used to invert the state of hold-prec internal logic so the pin controlling hold-prec can have opposing logic.
""";


pin in bit enable "Enable the output.";
pin in bit hold "Hold the output true when active.";
pin in bit hold_prec "Hold precidence. If true, hold input has precidence over the flash effect.";
pin in bit hold_prec_inv "If true, inverts the internal value of hold_prec.";
pin out bit out "The output pin.";
param rw s32 flash_rate_ms = 500 "Flash rate in milliseconds.";

variable float elapsed_time;  // Tracks elapsed time in seconds
variable hal_bit_t state;   // Internal state for blinking logic

;;

#include "rtapi.h"
#include "rtapi_app.h"
#include "hal.h"

static volatile hal_bit_t *enable_var;
static volatile hal_bit_t *hold_var;
static volatile hal_bit_t *hold_prec_var;
static volatile hal_bit_t *hold_prec_inv_var;
static volatile hal_bit_t *out_var;
static volatile hal_s32_t *flash_rate_ms_var;

FUNCTION(_)
{
    if (!enable) {
        state = 0;  // Reset internal state when not enabled
        out = 0;    // Disable output
        elapsed_time = 0.0;  // Reset elapsed time
        return;
    }

    // Calculate effective hold_prec based on hold_prec_inv
    hal_bit_t effective_hold_prec = hold_prec;
    if (hold_prec_inv) {
        effective_hold_prec = !hold_prec;  // Invert hold_prec if hold_prec_inv is true
    }

    if (hold) {
        if (effective_hold_prec) {
            // Enable flashing logic when effective_hold_prec is true and hold is active
            elapsed_time += fperiod;
            if (elapsed_time >= (flash_rate_ms / 1000.0)) {
                elapsed_time = 0.0;
                state = !state;  // Toggle internal state
            }
        } else {
            // Force output on when hold is active and effective_hold_prec is false
            state = 1;
        }
    } else {
        // Default to blinking logic when hold is not active
        elapsed_time += fperiod;
        if (elapsed_time >= (flash_rate_ms / 1000.0)) {
            elapsed_time = 0.0;
            state = !state;  // Toggle internal state
        }
    }

    out = state;  // Update output based on internal state
}

    #program-run,pause,stop
net program-btn              => run_pause.program.in
net program-toggle-run       <= run_pause.program.run
net program-toggle-run       => halui.program.run
net program-toggle-pause     <= run_pause.program.pause
net program-toggle-pause     => halui.program.pause
net program-is-running       <= halui.program.is-running
net program-is-running       => run_pause.program.running
net program-is-running       => or2.program.in0
net program-resume           <= run_pause.program.resume
net program-resume           => halui.program.resume
net program-is-paused        <= halui.program.is-paused
net program-is-paused        => run_pause.program.paused
net program-is-paused        => or2.program.in1
net program-run-or-pause     <= or2.program.out
net program-run-or-pause     => flash.program.enable
net program-is-paused        => flash.program.hold
net program-led              <= flash.program.out
net program-stop-btn         => halui.program.stop
setp flash.program.hold-prec     false
setp flash.program.hold-prec-inv false
setp flash.program.flash-rate-ms 250

component run_pause "Run-Pause, component for controlling halui program pins with 2 momentary pushbuttons";

description
"""
Run_Pause is based on the component toggle2nist. It has been specialized to work with halui program pins controlled with only 2 pushbuttons, start/resume and stop without adding a bunch of external logic.
""";

pin in bit in  "momentary button for run/pause input";
pin in bit running "running state input";
pin in bit paused "paused state input";
pin in unsigned debounce = 2 "debounce delay for 'in'-pin in cycles";
pin out bit run "run output, activates on in=true when paused=false and running=false";
pin out bit pause "pause output, activates on in=true when paused=false and running=true";
pin out bit resume "resume output, activates on in=true when paused=true and running=false";
variable int debounce_cntr;
variable unsigned debounce_set;
variable int state;

function _ nofp;
license "GPL";
author "Shade Technik";
author "Anders Wallin, David Mueller"; //Authors or toggle2nist
;;
FUNCTION(_)  {

    if (( debounce < 1 ) || ( debounce > 10000 )) {
        debounce_set = 2; /* set a sane value */
    } else {
        debounce_set = debounce;
    }

    if (in && state == 0 )  { /* input has changed from debounced 0 -> 1 */
        debounce_cntr++;
        if ( debounce_cntr >= debounce_set ) {
            if (!running && paused) { /* turn ON if it's paused */
                resume = 1;
                pause = 0;
            } else if (running && !paused) { /* turn OFF if it's running */
                resume = 0;
                pause = 1;
            }
            state = 1;
            debounce_cntr = 0;
        }
    } else if (!in && state == 1) { /* input has changed from debounced 1 -> 0 */
        debounce_cntr++;
        if ( debounce_cntr >= debounce_set ) {
            state = 0;
            debounce_cntr = 0;
        }
    } else if ((!running && pause) || (running && run)) { /* reset outputs once device has switched */
        run = 0;
        pause = 0;
        debounce_cntr = 0;
    } else {
        debounce_cntr = 0;
    }

    /* Set resume output while in is true and neither running nor paused is active */
    if (in && !running && !paused) {
        run = 1;
    } else {
        run = 0;
    }
}