I2C, SPI, and GPIO#

use pamoja_core::{Actuator, Sensor};
use pamoja_gpio::i2c::{Address, Direction, RESERVED_FROM};
use pamoja_gpio::pin::{Edge, Level};
use pamoja_gpio::spi::Mode;
use pamoja_gpio::switch::{Contact, Switch};
use pamoja_hal::digital::PinState;
use pamoja_hal::script::PinScript;

// Most relay boards energize when their input is pulled low, and a float switch wired
// to ground closes the same way. Saying "active low" once, here, is what keeps the
// inversion out of every line below it.
let mut pump = Switch::active_low(PinScript::new([]));
let mut float = Contact::active_low(PinScript::new([PinState::High, PinState::Low]));
let runs_on = pump.polarity().level(true);
println!("a pump on an active-low relay runs when its line is {runs_on:?}");

// The pump runs while the tank fills. The scripted line answers open and then closed,
// so this is the real loop with nothing plugged in; on a board the same two lines take
// a pin from the board's GPIO library instead.
pump.apply(true).await.expect("the relay takes it");
let while_filling = float.read().await.expect("the line reads");
let once_filled = float.read().await.expect("the line reads");
let full = |closed: bool| if closed { "full" } else { "not full" };
println!(
    "the float reads {}, then {}",
    full(while_filling),
    full(once_filled)
);

// The moment the float closes is that line going low, which is a falling edge. A watch
// armed for the rising one would sleep through the tank filling.
let closing = Edge::Falling.triggered_by(Level::High, Level::Low);
let edge = if closing {
    "a falling edge"
} else {
    "not a falling edge"
};
println!("the float closing is {edge} on that line");

// Full, so the pump stops. Releasing the switch hands the line back, and the levels it
// was driven to are the whole conversation the board saw.
pump.apply(false).await.expect("the relay takes it");
let line = pump.release();
let (ran, stopped) = (line.driven()[0], line.driven()[1]);
println!("running drove the line {ran:?} and stopping drove it {stopped:?}");

// A part on a shared bus answers to an address, and the byte on the wire is not the
// address the datasheet prints: it shifts up one and the low bit says read or write.
let sensor = Address::seven_bit(0x76).expect("a 7-bit address");
let to_write = sensor.frame(Direction::Write).as_bytes()[0];
let to_read = sensor.frame(Direction::Read).as_bytes()[0];
println!("a part at 0x76 is written to as {to_write:#04X} and read from as {to_read:#04X}");

// Two ranges belong to the specification itself, so a part answering in either is a
// wiring mistake rather than a device.
let reserved = Address::seven_bit(RESERVED_FROM)
    .expect("in range")
    .is_reserved();
let owner = if reserved {
    "reserved by the specification"
} else {
    "free for a device"
};
println!("{RESERVED_FROM:#04X} is {owner}");

// And a datasheet quotes SPI's clock polarity and phase as one mode number.
let (idles_high, trailing_edge) = Mode::Mode3.cpol_cpha();
let idle = if idles_high { "high" } else { "low" };
let edge = if trailing_edge { "trailing" } else { "leading" };
println!("SPI mode 3 idles {idle} and samples on the {edge} edge");

import { Contact, GpioLine, PinEdge, PinLevel, PinScript, Switch, i2c, pin, spi } from '@pamoja/gpio'

// Most relay boards energize when their input is pulled low, and a float switch wired to
// ground closes the same way. Saying "active low" once, here, is what keeps the inversion
// out of every line below it.
const pump = Switch.activeLow(new PinScript())
const float = Contact.activeLow(new PinScript([PinLevel.High, PinLevel.Low]))
const runsOn = pin.levelFor(pump.polarity, true)
console.log(`a pump on an active-low relay runs when its line is ${runsOn}`)

// The pump runs while the tank fills. The scripted line answers open and then closed, so
// this is the real loop with nothing plugged in; on a board the same two lines take a pin
// from the board's GPIO library instead.
pump.set(true)
const whileFilling = float.isAsserted()
const onceFilled = float.isAsserted()
const full = (closed: boolean) => (closed ? 'full' : 'not full')
console.log(`the float reads ${full(whileFilling)}, then ${full(onceFilled)}`)

// The moment the float closes is that line going low, which is a falling edge. A watch
// armed for the rising one would sleep through the tank filling.
const closing = pin.triggers(PinEdge.Falling, PinLevel.High, PinLevel.Low)
console.log(`the float closing is ${closing ? 'a falling edge' : 'not a falling edge'} on that line`)

// Full, so the pump stops. Releasing the switch hands the line back, and the levels it was
// driven to are the whole conversation the board saw.
pump.set(false)
const [ran, stopped] = pump.release().driven
console.log(`running drove the line ${ran} and stopping drove it ${stopped}`)

// A part on a shared bus answers to an address, and the byte on the wire is not the
// address the datasheet prints: it shifts up one and the low bit says read or write.
const hex = (byte: number) => `0x${byte.toString(16).toUpperCase().padStart(2, '0')}`
const toWrite = i2c.addressFrame(0x76)[0]!
const toRead = i2c.addressFrame(0x76, { read: true })[0]!
console.log(`a part at 0x76 is written to as ${hex(toWrite)} and read from as ${hex(toRead)}`)

// Two ranges belong to the specification itself, so a part answering in either is a wiring
// mistake rather than a device.
const reserved = i2c.isReserved(i2c.RESERVED_FROM)
console.log(`${hex(i2c.RESERVED_FROM)} is ${reserved ? 'reserved by the specification' : 'free for a device'}`)

// And a datasheet quotes SPI's clock polarity and phase as one mode number.
const clock = spi.clockFor(3)
const idle = clock.cpol ? 'high' : 'low'
const edge = clock.cpha ? 'trailing' : 'leading'
console.log(`SPI mode 3 idles ${idle} and samples on the ${edge} edge`)

from pamoja.gpio import Contact, Edge, GpioLine, Level, PinScript, Switch, i2c, pin, spi

# Most relay boards energize when their input is pulled low, and a float switch wired to
# ground closes the same way. Saying "active low" once, here, is what keeps the inversion
# out of every line below it.
pump = Switch.active_low(PinScript())
float_switch = Contact.active_low(PinScript([Level.HIGH, Level.LOW]))
runs_on = pin.level_for(pump.polarity, True)
print(f"a pump on an active-low relay runs when its line is {runs_on.value}")

# The pump runs while the tank fills. The scripted line answers open and then closed, so
# this is the real loop with nothing plugged in; on a board the same two lines take a pin
# from the board's GPIO library instead.
pump.set(True)
while_filling = float_switch.is_asserted()
once_filled = float_switch.is_asserted()
full = {True: "full", False: "not full"}
print(f"the float reads {full[while_filling]}, then {full[once_filled]}")

# The moment the float closes is that line going low, which is a falling edge. A watch
# armed for the rising one would sleep through the tank filling.
closing = pin.triggers(Edge.FALLING, Level.HIGH, Level.LOW)
edge = "a falling edge" if closing else "not a falling edge"
print(f"the float closing is {edge} on that line")

# Full, so the pump stops. Releasing the switch hands the line back, and the levels it was
# driven to are the whole conversation the board saw.
pump.set(False)
ran, stopped = pump.release().driven
print(f"running drove the line {ran.value} and stopping drove it {stopped.value}")

# A part on a shared bus answers to an address, and the byte on the wire is not the
# address the datasheet prints: it shifts up one and the low bit says read or write.
to_write = i2c.address_frame(0x76)[0]
to_read = i2c.address_frame(0x76, read=True)[0]
print(f"a part at 0x76 is written to as 0x{to_write:02X} and read from as 0x{to_read:02X}")

# Two ranges belong to the specification itself, so a part answering in either is a wiring
# mistake rather than a device.
reserved = i2c.is_reserved(i2c.RESERVED_FROM)
owner = "reserved by the specification" if reserved else "free for a device"
print(f"0x{i2c.RESERVED_FROM:02X} is {owner}")

# And a datasheet quotes SPI's clock polarity and phase as one mode number.
clock = spi.clock_for(3)
idle = "high" if clock.cpol else "low"
edge = "trailing" if clock.cpha else "leading"
print(f"SPI mode 3 idles {idle} and samples on the {edge} edge")

// Most relay boards energize when their input is pulled low, and a float switch
// wired to ground closes the same way. Saying "active low" once, here, is what
// keeps the inversion out of every line below it.
var pump = Switch.ActiveLow(new PinScript());
var floatSwitch = Contact.ActiveLow(new PinScript(PinLevel.High, PinLevel.Low));
PinLevel runsOn = Pin.LevelFor(pump.Polarity, true);
Console.WriteLine($"a pump on an active-low relay runs when its line is {runsOn}");

// The pump runs while the tank fills. The scripted line answers open and then
// closed, so this is the real loop with nothing plugged in; on a board the same two
// lines take a pin from the board's GPIO library instead.
pump.Set(true);
bool whileFilling = floatSwitch.IsAsserted();
bool onceFilled = floatSwitch.IsAsserted();
static string Full(bool closed) => closed ? "full" : "not full";
Console.WriteLine($"the float reads {Full(whileFilling)}, then {Full(onceFilled)}");

// The moment the float closes is that line going low, which is a falling edge. A
// watch armed for the rising one would sleep through the tank filling.
bool closing = Pin.Triggers(PinEdge.Falling, PinLevel.High, PinLevel.Low);
string edge = closing ? "a falling edge" : "not a falling edge";
Console.WriteLine($"the float closing is {edge} on that line");

// Full, so the pump stops. Releasing the switch hands the line back, and the levels
// it was driven to are the whole conversation the board saw.
pump.Set(false);
IReadOnlyList<PinLevel> driven = pump.Release().Driven;
(PinLevel ran, PinLevel stopped) = (driven[0], driven[1]);
Console.WriteLine($"running drove the line {ran} and stopping drove it {stopped}");

// A part on a shared bus answers to an address, and the byte on the wire is not
// the address the datasheet prints: it shifts up one and the low bit says read or
// write.
byte toWrite = I2c.AddressFrame(0x76)[0];
byte toRead = I2c.AddressFrame(0x76, read: true)[0];
Console.WriteLine(
    $"a part at 0x76 is written to as 0x{toWrite:X2} and read from as 0x{toRead:X2}");

// Two ranges belong to the specification itself, so a part answering in either is
// a wiring mistake rather than a device.
bool reserved = I2c.IsReserved(I2c.ReservedFrom);
string owner = reserved ? "reserved by the specification" : "free for a device";
Console.WriteLine($"0x{I2c.ReservedFrom:X2} is {owner}");

// And a datasheet quotes SPI's clock polarity and phase as one mode number.
SpiClock clock = Spi.ClockFor(3);
string idle = clock.Cpol ? "high" : "low";
string sampling = clock.Cpha ? "trailing" : "leading";
Console.WriteLine($"SPI mode 3 idles {idle} and samples on the {sampling} edge");

/// The same pump and float on a Raspberry Pi: the relay board's input on GPIO17 and the
/// float switch between GPIO27 and ground. Only the two lines change.
fn on_a_board(chip: &str) -> std::result::Result<(), Box<dyn Error>> {
    use std::time::{Duration, Instant};

    use pamoja_gpio::linux;
    use pamoja_gpio::pin::Level;
    use pamoja_gpio::switch::{Contact, Switch};

    // The relay energizes on a low input, so its line is taken high and the pump stays off
    // until it is asked to run. The float closes to ground against a pull-up.
    let mut pump = Switch::active_low(linux::output(chip, 17, Level::High)?);
    let mut float = Contact::active_low(linux::input(chip, 27)?);

    // Run the pump until the float closes, and stop it whatever happens: a pump left
    // running on a failed float is the fault this whole program exists to prevent.
    pump.set(true)?;
    let deadline = Instant::now() + Duration::from_secs(600);
    let filled = (|| -> std::result::Result<(), Box<dyn Error>> {
        while !float.is_asserted()? {
            if Instant::now() >= deadline {
                return Err(
                    "the tank did not fill in ten minutes; check the float and the supply".into(),
                );
            }
            std::thread::sleep(Duration::from_millis(100));
        }
        Ok(())
    })();
    pump.set(false)?;
    filled?;
    println!("the tank is full and the pump is off");
    Ok(())
}

// The same pump and float on a Raspberry Pi: the relay board's input on GPIO17 and the
// float switch between GPIO27 and ground. Only the two lines change.
async function onABoard(chip: string): Promise<void> {
  // The relay energizes on a low input, so its line is taken high and the pump stays off
  // until it is asked to run. The float closes to ground against a pull-up.
  const relay = GpioLine.openOutput(chip, 17, PinLevel.High)
  const floatLine = GpioLine.openInput(chip, 27)
  const pump = Switch.activeLow(relay)
  const float = Contact.activeLow(floatLine)

  // Run the pump until the float closes, and stop it whatever happens: a pump left running
  // on a failed float is the fault this whole program exists to prevent.
  const deadline = Date.now() + 10 * 60_000
  pump.set(true)
  try {
    while (!float.isAsserted()) {
      if (Date.now() >= deadline) {
        throw new Error('the tank did not fill in ten minutes; check the float and the supply')
      }
      await new Promise((resolve) => setTimeout(resolve, 100))
    }
  } finally {
    pump.set(false)
    relay.close()
    floatLine.close()
  }
  console.log('the tank is full and the pump is off')
}

def on_a_board(chip: str) -> None:
    """The same pump and float on a Raspberry Pi: the relay board's input on GPIO17 and
    the float switch between GPIO27 and ground. Only the two lines change."""
    # The relay energizes on a low input, so its line is taken high and the pump stays
    # off until it is asked to run. The float closes to ground against a pull-up.
    with (
        GpioLine.open_output(chip, 17, Level.HIGH) as relay,
        GpioLine.open_input(chip, 27) as float_line,
    ):
        pump = Switch.active_low(relay)
        float_switch = Contact.active_low(float_line)

        # Run the pump until the float closes, and stop it whatever happens: a pump left
        # running on a failed float is the fault this whole program exists to prevent.
        deadline = time.monotonic() + 10 * 60
        pump.set(True)
        try:
            while not float_switch.is_asserted():
                if time.monotonic() >= deadline:
                    raise TimeoutError(
                        "the tank did not fill in ten minutes; check the float and the supply"
                    )
                time.sleep(0.1)
        finally:
            pump.set(False)
    print("the tank is full and the pump is off")

/// <summary>
/// The same pump and float on a Raspberry Pi: the relay board's input on GPIO17 and the
/// float switch between GPIO27 and ground. Only the two lines change.
/// </summary>
/// <param name="chip">The GPIO chip's device file.</param>
public static void OnABoard(string chip)
{
    // The relay energizes on a low input, so its line is taken high and the pump stays
    // off until it is asked to run. The float closes to ground against a pull-up.
    using GpioLine relay = GpioLine.OpenOutput(chip, 17, PinLevel.High);
    using GpioLine floatLine = GpioLine.OpenInput(chip, 27);
    var pump = Switch.ActiveLow(relay);
    var floatSwitch = Contact.ActiveLow(floatLine);

    // Run the pump until the float closes, and stop it whatever happens: a pump left
    // running on a failed float is the fault this whole program exists to prevent.
    DateTime deadline = DateTime.UtcNow.AddMinutes(10);
    pump.Set(true);
    try
    {
        while (!floatSwitch.IsAsserted())
        {
            if (DateTime.UtcNow >= deadline)
            {
                throw new TimeoutException(
                    "the tank did not fill in ten minutes; check the float and the supply");
            }

            Thread.Sleep(100);
        }
    }
    finally
    {
        pump.Set(false);
    }

    Console.WriteLine("the tank is full and the pump is off");
}