Actuator drivers#

use pamoja_actuators::pca9685::{self, mode1, register, Pca9685, Pwm, INTERNAL_OSC_HZ};
use pamoja_actuators::stepper::{steps_for_degrees, Drive, FourWire, StepDir};
use pamoja_actuators::DriverError;
use pamoja_hal::bus::I2cBus;
use pamoja_hal::digital::PinState;
use pamoja_hal::i2c::I2c;
use pamoja_hal::script::{DelayLog, PinScript};
use pamoja_hal::sim::I2cPart;

// Where the rig's parts connect: the PCA9685 answers at 0x40 with its six address pins
// low, the tilt servo is on its channel 0, and the status LED on channel 15.
let address = pca9685::DEFAULT_I2C_ADDRESS;
const TILT: u8 = 0;
const STATUS: u8 = 15;
let glow = Pwm::duty(pca9685::COUNTS / 16);

// The rig with nothing plugged in: a PCA9685 that powers up and keeps its datasheet's
// rules the way the part does. On a Raspberry Pi the bus is I2cBus::open("/dev/i2c-1")
// and nothing after this statement changes.
let bus = I2cBus::simulated([pca9685::sim::part(address)]);

// A hobby servo wants a pulse every 20 ms, 50 Hz. The driver works the prescale out from
// that and writes it with the oscillator asleep, since only then does the part take it,
// then wakes the oscillator and waits the 500 us it needs to settle.
let mut controller = Pca9685::new(bus.clone(), address, bus.delay()).with_frequency(50);
controller.init()?;
println!(
    "controller   prescale {} for {:.1} Hz, awake after {} us",
    controller.prescale(),
    controller.frequency(),
    bus.waited_micros()
);

// A servo turns to the width of the pulse it is sent, and this one points the camera a
// little below level at 1300 us. The LED glows at a sixteenth of full brightness while
// the rig waits. Reading the channels back shows what the part now holds.
controller.set_channel(TILT, Pwm::servo(1_300, 50))?;
controller.set_channel(STATUS, glow)?;
let tilt = controller.channel(TILT)?;
let status = controller.channel(STATUS)?;
println!(
    "tilt         1300 us pulse, low at count {} of {}",
    tilt.off(),
    pca9685::COUNTS
);
println!(
    "status       glowing, high for {} of {} counts",
    status.off(),
    pca9685::COUNTS
);

// The slider: a 1.8-degree motor, 200 steps a turn, behind an A4988 with MS1 to MS3
// high, which splits each step into sixteen. A 20-tooth GT2 pulley pulls 40 mm of belt
// a turn, so 5 mm between frames is an eighth of a turn.
const SLIDER_STEPS_PER_TURN: u32 = 200 * 16;
const BELT_MM_PER_TURN: f32 = 40.0;
let slide = steps_for_degrees(360.0 * 5.0 / BELT_MM_PER_TURN, SLIDER_STEPS_PER_TURN);
let mut slider = StepDir::new(PinScript::new([]), PinScript::new([]), DelayLog::new())
    .with_step_interval(500);

// The pan head: a 28BYJ-48 through a ULN2003, half-stepped, 4096 half-steps a turn
// through its gearbox. With a camera on it, it steps every 4 ms, half the 500 Hz its
// pack is rated to start at with no load.
const PAN_STEPS_PER_TURN: u32 = 4096;
let pan_step = steps_for_degrees(2.0, PAN_STEPS_PER_TURN);
let coils = (
    PinScript::new([]),
    PinScript::new([]),
    PinScript::new([]),
    PinScript::new([]),
);
let mut pan = FourWire::new(coils, DelayLog::new(), Drive::HalfStep).with_step_interval(4_000);

// Four frames. The LED lights for each exposure, and between frames the rig slides and
// pans while it glows. The stepper lines record every level, and the delays count every
// wait without sleeping through it.
for frame in 1..=4 {
    controller.set_channel(STATUS, Pwm::full_on())?;
    println!(
        "frame {frame}      slider {:.1} mm, pan {:.2} degrees",
        slider.position() as f32 * BELT_MM_PER_TURN / SLIDER_STEPS_PER_TURN as f32,
        pan.position() as f32 * 360.0 / PAN_STEPS_PER_TURN as f32
    );
    controller.set_channel(STATUS, glow)?;
    if frame < 4 {
        slider.steps(slide)?;
        pan.steps(pan_step)?;
    }
}

// A four-wire motor draws current for as long as its coils hold, so the pan head
// drops them once the shoot is over.
pan.idle()?;
let slid = slider.position();
let panned = pan.position();
let ((step_line, direction_line), slider_delay) = slider.release();
let ((a, b, c, d), pan_delay) = pan.release();
let pulses = step_line
    .driven()
    .iter()
    .filter(|level| **level == PinState::High)
    .count();
println!(
    "slider       {pulses} pulses on STEP, DIR {:?}",
    direction_line.level()
);
println!(
    "pan head     {panned} half-steps, coils {:?} {:?} {:?} {:?}",
    a.level(),
    b.level(),
    c.level(),
    d.level()
);
println!(
    "moving       slider {} ms, pan head {} ms",
    slider_delay.total_millis(),
    pan_delay.total_millis()
);

// The part takes a new prescale only while its oscillator sleeps. Written while it
// runs, as a driver that skipped the sleep would write it, the value is dropped and the
// servos stay at 50 Hz.
let mut raw = bus.clone();
let fast = pca9685::prescale_for_frequency(1_000, INTERNAL_OSC_HZ);
raw.write(address, &[register::PRE_SCALE, fast])?;
let held: I2cPart = bus.part(address).ok_or("the controller left the bus")?;
println!(
    "prescale     written while awake, still {}",
    held.register(register::PRE_SCALE)
);

// A channel the part does not have is refused before anything reaches the bus.
match controller.set_channel(16, Pwm::full_on()) {
    Err(DriverError::Command(reason)) => println!("channel 16   {reason}"),
    other => println!("channel 16   {other:?}, which should never happen"),
}

// The shoot is over: every channel off in one transfer through the ALL_LED registers,
// then the oscillator asleep. The part keeps its registers while it sleeps.
controller.set_all(Pwm::full_off())?;
controller.sleep()?;
let parked: I2cPart = bus.part(address).ok_or("the controller left the bus")?;
let all_off = controller.channel(TILT)? == Pwm::full_off()
    && controller.channel(STATUS)? == Pwm::full_off();
let asleep = parked.register(register::MODE1) & mode1::SLEEP != 0;
println!(
    "parked       every channel {}, oscillator {}",
    if all_off { "off" } else { "still on" },
    if asleep { "asleep" } else { "running" }
);

import {
  FourWire,
  Pca9685,
  StepDir,
  StepDrive,
  pca9685,
  pwm,
  stepsForDegrees,
} from '@pamoja/actuators'
import { PinLevel, PinScript } from '@pamoja/gpio'
import { DelayLog, I2cBus, I2cPart } from '@pamoja/hal'

// Where the rig's parts connect: the PCA9685 answers at 0x40 with its six address pins low, the
// tilt servo is on its channel 0, and the status LED on channel 15.
const address = pca9685.defaultAddress
const TILT = 0
const STATUS = 15
const glow = pwm.duty(pca9685.counts / 16)

async function main() {
  // The rig with nothing plugged in: a PCA9685 that powers up and keeps its datasheet's rules
  // the way the part does. On a Raspberry Pi the bus is I2cBus.open('/dev/i2c-1') and nothing
  // after this statement changes.
  const bus = I2cBus.simulated([pca9685.sim.part(address)])

  // A hobby servo wants a pulse every 20 ms, 50 Hz. The driver works the prescale out from that
  // and writes it with the oscillator asleep, since only then does the part take it, then wakes
  // the oscillator and waits the 500 us it needs to settle.
  const controller = new Pca9685(bus, address, { frequencyHz: 50 })
  await controller.init()
  console.log(
    `controller   prescale ${controller.prescale} for ${controller.frequency.toFixed(1)} Hz, ` +
      `awake after ${bus.waitedMicros} us`,
  )

  // A servo turns to the width of the pulse it is sent, and this one points the camera a little
  // below level at 1300 us. The LED glows at a sixteenth of full brightness while the rig waits.
  // Reading the channels back shows what the part now holds.
  await controller.setChannel(TILT, pwm.servo(1_300, 50))
  await controller.setChannel(STATUS, glow)
  const tilt = pwm.counts(await controller.channel(TILT))
  const status = pwm.counts(await controller.channel(STATUS))
  console.log(`tilt         1300 us pulse, low at count ${tilt.off} of ${pca9685.counts}`)
  console.log(`status       glowing, high for ${status.off} of ${pca9685.counts} counts`)

  // The slider: a 1.8-degree motor, 200 steps a turn, behind an A4988 with MS1 to MS3 high,
  // which splits each step into sixteen. A 20-tooth GT2 pulley pulls 40 mm of belt a turn, so
  // 5 mm between frames is an eighth of a turn.
  const sliderStepsPerTurn = 200 * 16
  const beltMmPerTurn = 40
  const slide = stepsForDegrees((360 * 5) / beltMmPerTurn, sliderStepsPerTurn)
  const sliderDelay = new DelayLog()
  const slider = new StepDir(new PinScript(), new PinScript(), {
    stepMicros: 500,
    delay: sliderDelay,
  })

  // The pan head: a 28BYJ-48 through a ULN2003, half-stepped, 4096 half-steps a turn through
  // its gearbox. With a camera on it, it steps every 4 ms, half the 500 Hz its pack is rated
  // to start at with no load.
  const panStepsPerTurn = 4096
  const panStep = stepsForDegrees(2, panStepsPerTurn)
  const coils = [new PinScript(), new PinScript(), new PinScript(), new PinScript()] as const
  const panDelay = new DelayLog()
  const pan = new FourWire(coils, StepDrive.HalfStep, { stepMicros: 4_000, delay: panDelay })

  // Four frames. The LED lights for each exposure, and between frames the rig slides and pans
  // while it glows. The stepper lines record every level, and the delays count every wait
  // without sleeping through it.
  for (let frame = 1; frame <= 4; frame += 1) {
    await controller.setChannel(STATUS, pwm.fullOn())
    const mm = (slider.position * beltMmPerTurn) / sliderStepsPerTurn
    const degrees = (pan.position * 360) / panStepsPerTurn
    console.log(`frame ${frame}      slider ${mm.toFixed(1)} mm, pan ${degrees.toFixed(2)} degrees`)
    await controller.setChannel(STATUS, glow)
    if (frame < 4) {
      await slider.steps(slide)
      await pan.steps(panStep)
    }
  }

  // A four-wire motor draws current for as long as its coils hold, so the pan head drops them
  // once the shoot is over.
  pan.idle()
  const [stepLine, directionLine] = slider.release()
  const [a, b, c, d] = pan.release()
  const pulses = stepLine.driven.filter((level) => level === PinLevel.High).length
  console.log(`slider       ${pulses} pulses on STEP, DIR ${directionLine.level}`)
  console.log(`pan head     ${pan.position} half-steps, coils ${a.level} ${b.level} ${c.level} ${d.level}`)
  console.log(`moving       slider ${sliderDelay.totalMillis} ms, pan head ${panDelay.totalMillis} ms`)

  // The part takes a new prescale only while its oscillator sleeps. Written while it runs, as a
  // driver that skipped the sleep would write it, the value is dropped and the servos stay at
  // 50 Hz.
  const fast = pca9685.prescaleForFrequency(1_000)
  bus.write(address, Buffer.from([pca9685.register.preScale, fast]))
  const held = bus.part(address)
  if (!(held instanceof I2cPart)) {
    throw new Error('the controller left the bus')
  }
  console.log(`prescale     written while awake, still ${held.register(pca9685.register.preScale)}`)

  // A channel the part does not have is refused before anything reaches the bus.
  try {
    await controller.setChannel(16, pwm.fullOn())
    console.log('channel 16   accepted, which should never happen')
  } catch (error) {
    console.log(`channel 16   ${(error as Error).message}`)
  }

  // The shoot is over: every channel off in one transfer through the ALL_LED registers, then the
  // oscillator asleep. The part keeps its registers while it sleeps.
  await controller.setAll(pwm.fullOff())
  await controller.sleep()
  const parked = bus.part(address) as I2cPart
  const allOff =
    (await controller.channel(TILT)).equals(pwm.fullOff()) &&
    (await controller.channel(STATUS)).equals(pwm.fullOff())
  const asleep = (parked.register(pca9685.register.mode1) & pca9685.mode1.sleep) !== 0
  console.log(
    `parked       every channel ${allOff ? 'off' : 'still on'}, ` +
      `oscillator ${asleep ? 'asleep' : 'running'}`,
  )

  return {
    bus,
    controller,
    tilt,
    status,
    slide,
    panStep,
    slider,
    pan,
    pulses,
    sliderDelay,
    panDelay,
    held,
    fast,
    parked,
    allOff,
    asleep,
  }
}

main()

from pamoja.actuators import Drive, FourWire, Pca9685, StepDir, pca9685, pwm, steps_for_degrees
from pamoja.gpio import Level, PinScript
from pamoja.hal import DelayLog, I2cBus

# Where the rig's parts connect: the PCA9685 answers at 0x40 with its six address pins low, the
# tilt servo is on its channel 0, and the status LED on channel 15.
ADDRESS = pca9685.DEFAULT_ADDRESS
TILT = 0
STATUS = 15
GLOW = pwm.duty(pca9685.COUNTS // 16)

# The rig with nothing plugged in: a PCA9685 that powers up and keeps its datasheet's rules the
# way the part does. On a Raspberry Pi the bus is I2cBus.open("/dev/i2c-1") and nothing after
# this statement changes.
bus = I2cBus.simulated([pca9685.sim.part(ADDRESS)])

# A hobby servo wants a pulse every 20 ms, 50 Hz. The driver works the prescale out from that and
# writes it with the oscillator asleep, since only then does the part take it, then wakes the
# oscillator and waits the 500 us it needs to settle.
controller = Pca9685(bus, ADDRESS, frequency_hz=50)
controller.init()
print(
    f"controller   prescale {controller.prescale} for {controller.frequency:.1f} Hz, "
    f"awake after {bus.waited_micros} us"
)

# A servo turns to the width of the pulse it is sent, and this one points the camera a little
# below level at 1300 us. The LED glows at a sixteenth of full brightness while the rig waits.
# Reading the channels back shows what the part now holds.
controller.set_channel(TILT, pwm.servo(1_300, 50))
controller.set_channel(STATUS, GLOW)
tilt = pwm.counts(controller.channel(TILT))
status = pwm.counts(controller.channel(STATUS))
print(f"tilt         1300 us pulse, low at count {tilt.off} of {pca9685.COUNTS}")
print(f"status       glowing, high for {status.off} of {pca9685.COUNTS} counts")

# The slider: a 1.8-degree motor, 200 steps a turn, behind an A4988 with MS1 to MS3 high, which
# splits each step into sixteen. A 20-tooth GT2 pulley pulls 40 mm of belt a turn, so 5 mm
# between frames is an eighth of a turn.
SLIDER_STEPS_PER_TURN = 200 * 16
BELT_MM_PER_TURN = 40.0
slide = steps_for_degrees(360.0 * 5.0 / BELT_MM_PER_TURN, SLIDER_STEPS_PER_TURN)
slider_delay = DelayLog()
slider = StepDir(PinScript(), PinScript(), step_micros=500, delay=slider_delay)

# The pan head: a 28BYJ-48 through a ULN2003, half-stepped, 4096 half-steps a turn through its
# gearbox. With a camera on it, it steps every 4 ms, half the 500 Hz its pack is rated to start
# at with no load.
PAN_STEPS_PER_TURN = 4096
pan_step = steps_for_degrees(2.0, PAN_STEPS_PER_TURN)
coils = (PinScript(), PinScript(), PinScript(), PinScript())
pan_delay = DelayLog()
pan = FourWire(coils, Drive.HALF_STEP, step_micros=4_000, delay=pan_delay)

# Four frames. The LED lights for each exposure, and between frames the rig slides and pans
# while it glows. The stepper lines record every level, and the delays count every wait without
# sleeping through it.
for frame in range(1, 5):
    controller.set_channel(STATUS, pwm.full_on())
    mm = slider.position * BELT_MM_PER_TURN / SLIDER_STEPS_PER_TURN
    degrees = pan.position * 360.0 / PAN_STEPS_PER_TURN
    print(f"frame {frame}      slider {mm:.1f} mm, pan {degrees:.2f} degrees")
    controller.set_channel(STATUS, GLOW)
    if frame < 4:
        slider.steps(slide)
        pan.steps(pan_step)

# A four-wire motor draws current for as long as its coils hold, so the pan head drops them once
# the shoot is over.
pan.idle()
step_line, direction_line = slider.release()
a, b, c, d = pan.release()
pulses = step_line.driven.count(Level.HIGH)
print(f"slider       {pulses} pulses on STEP, DIR {direction_line.level.value}")
levels = " ".join(line.level.value for line in (a, b, c, d))
print(f"pan head     {pan.position} half-steps, coils {levels}")
print(f"moving       slider {slider_delay.total_millis} ms, pan head {pan_delay.total_millis} ms")

# The part takes a new prescale only while its oscillator sleeps. Written while it runs, as a
# driver that skipped the sleep would write it, the value is dropped and the servos stay at
# 50 Hz.
fast = pca9685.prescale_for_frequency(1_000)
bus.write(ADDRESS, bytes([pca9685.REGISTER_PRE_SCALE, fast]))
held = bus.part(ADDRESS)
print(f"prescale     written while awake, still {held.register(pca9685.REGISTER_PRE_SCALE)}")

# A channel the part does not have is refused before anything reaches the bus.
try:
    controller.set_channel(16, pwm.full_on())
    print("channel 16   accepted, which should never happen")
except ValueError as error:
    print(f"channel 16   {error}")

# The shoot is over: every channel off in one transfer through the ALL_LED registers, then the
# oscillator asleep. The part keeps its registers while it sleeps.
controller.set_all(pwm.full_off())
controller.sleep()
parked = bus.part(ADDRESS)
all_off = all(controller.channel(channel) == pwm.full_off() for channel in (TILT, STATUS))
asleep = parked.register(pca9685.REGISTER_MODE1) & pca9685.MODE1_SLEEP != 0
print(
    f"parked       every channel {'off' if all_off else 'still on'}, "
    f"oscillator {'asleep' if asleep else 'running'}"
)

// Where the rig's parts connect: the PCA9685 answers at 0x40 with its six address pins
// low, the tilt servo is on its channel 0, and the status LED on channel 15.
const byte Address = Pca9685.DefaultAddress;
const byte Tilt = 0;
const byte Status = 15;
byte[] glow = Pwm.Duty(Pca9685.Counts / 16);

// The rig with nothing plugged in: a PCA9685 that powers up and keeps its datasheet's
// rules the way the part does. The bus keeps a copy of the part, so the program lets go
// of its own. On a Raspberry Pi the bus is I2cBus.Open("/dev/i2c-1") and nothing after
// this statement changes.
I2cBus bus;
using (I2cPart part = Pca9685.Sim.Part(Address))
{
    bus = I2cBus.Simulated(part);
}

using (bus)
{
    // A hobby servo wants a pulse every 20 ms, 50 Hz. The driver works the prescale out
    // from that and writes it with the oscillator asleep, since only then does the part
    // take it, then wakes the oscillator and waits the 500 us it needs to settle.
    using var controller = new Pca9685(bus, Address, frequencyHz: 50);
    controller.Init();
    Console.WriteLine(Invariant(
        $"controller   prescale {controller.Prescale} for {controller.Frequency:F1} Hz, awake after {bus.WaitedMicros} us"));

    // A servo turns to the width of the pulse it is sent, and this one points the camera
    // a little below level at 1300 us. The LED glows at a sixteenth of full brightness
    // while the rig waits. Reading the channels back shows what the part now holds.
    controller.SetChannel(Tilt, Pwm.Servo(1_300, 50));
    controller.SetChannel(Status, glow);
    var tilt = Pwm.Counts(controller.Channel(Tilt));
    var status = Pwm.Counts(controller.Channel(Status));
    Console.WriteLine($"tilt         1300 us pulse, low at count {tilt.Off} of {Pca9685.Counts}");
    Console.WriteLine($"status       glowing, high for {status.Off} of {Pca9685.Counts} counts");

    // The slider: a 1.8-degree motor, 200 steps a turn, behind an A4988 with MS1 to MS3
    // high, which splits each step into sixteen. A 20-tooth GT2 pulley pulls 40 mm of
    // belt a turn, so 5 mm between frames is an eighth of a turn.
    const uint SliderStepsPerTurn = 200 * 16;
    const float BeltMmPerTurn = 40.0f;
    int slide = Stepper.StepsForDegrees(360.0f * 5.0f / BeltMmPerTurn, SliderStepsPerTurn);
    var sliderDelay = new DelayLog();
    var slider = new StepDir<PinScript>(new PinScript(), new PinScript(), stepMicros: 500, delay: sliderDelay);

    // The pan head: a 28BYJ-48 through a ULN2003, half-stepped, 4096 half-steps a turn
    // through its gearbox. With a camera on it, it steps every 4 ms, half the 500 Hz its
    // pack is rated to start at with no load.
    const uint PanStepsPerTurn = 4096;
    int panStep = Stepper.StepsForDegrees(2.0f, PanStepsPerTurn);
    var coils = (new PinScript(), new PinScript(), new PinScript(), new PinScript());
    var panDelay = new DelayLog();
    using var pan = new FourWire<PinScript>(coils, StepDrive.HalfStep, stepMicros: 4_000, delay: panDelay);

    // Four frames. The LED lights for each exposure, and between frames the rig slides
    // and pans while it glows. The stepper lines record every level, and the delays count
    // every wait without sleeping through it.
    for (int frame = 1; frame <= 4; frame++)
    {
        controller.SetChannel(Status, Pwm.FullOn());
        float mm = slider.Position * BeltMmPerTurn / SliderStepsPerTurn;
        float degrees = pan.Position * 360.0f / PanStepsPerTurn;
        Console.WriteLine(Invariant($"frame {frame}      slider {mm:F1} mm, pan {degrees:F2} degrees"));
        controller.SetChannel(Status, glow);
        if (frame < 4)
        {
            slider.Steps(slide);
            pan.Steps(panStep);
        }
    }

    // A four-wire motor draws current for as long as its coils hold, so the pan head
    // drops them once the shoot is over.
    pan.Idle();
    var (stepLine, directionLine) = slider.Release();
    var (a, b, c, d) = pan.Release();
    int pulses = stepLine.Driven.Count(level => level == PinLevel.High);
    Console.WriteLine($"slider       {pulses} pulses on STEP, DIR {directionLine.Level}");
    Console.WriteLine($"pan head     {pan.Position} half-steps, coils {a.Level} {b.Level} {c.Level} {d.Level}");
    Console.WriteLine($"moving       slider {sliderDelay.TotalMillis} ms, pan head {panDelay.TotalMillis} ms");

    // The part takes a new prescale only while its oscillator sleeps. Written while it
    // runs, as a driver that skipped the sleep would write it, the value is dropped and
    // the servos stay at 50 Hz.
    byte fast = Pca9685.PrescaleForFrequency(1_000);
    bus.Write(Address, [Pca9685.Register.PreScale, fast]);
    byte stillHeld;
    using (I2cPart held = bus.Part<I2cPart>(Address)!)
    {
        stillHeld = held.Register(Pca9685.Register.PreScale);
    }

    Console.WriteLine($"prescale     written while awake, still {stillHeld}");

    // A channel the part does not have is refused before anything reaches the bus.
    try
    {
        controller.SetChannel(16, Pwm.FullOn());
        Console.WriteLine("channel 16   accepted, which should never happen");
    }
    catch (PamojaException error)
    {
        Console.WriteLine($"channel 16   {error.Message}");
    }

    // The shoot is over: every channel off in one transfer through the ALL_LED
    // registers, then the oscillator asleep. The part keeps its registers while it
    // sleeps.
    controller.SetAll(Pwm.FullOff());
    controller.Sleep();
    byte parkedMode;
    using (I2cPart parked = bus.Part<I2cPart>(Address)!)
    {
        parkedMode = parked.Register(Pca9685.Register.Mode1);
    }

    bool allOff = controller.Channel(Tilt).SequenceEqual(Pwm.FullOff())
        && controller.Channel(Status).SequenceEqual(Pwm.FullOff());
    bool asleep = (parkedMode & Pca9685.Mode1.Sleep) != 0;
    Console.WriteLine(
        $"parked       every channel {(allOff ? "off" : "still on")}, oscillator {(asleep ? "asleep" : "running")}");

use pamoja_actuators::pca9685::{self, Pca9685, Pwm};
use pamoja_actuators::stepper::{steps_for_degrees, Drive, FourWire};
use pamoja_hal::bus::I2cBus;
use pamoja_hal::digital::PinState;
use pamoja_hal::linux;

/// The GPIO chip the header's lines live on, numbered as the BCM numbers.
const CHIP: &str = "/dev/gpiochip0";

/// The lines the ULN2003 board's IN1 to IN4 are wired to, coils A to D.
const PAN_LINES: [u32; 4] = [5, 6, 13, 26];

/// The PCA9685 channels the tilt servo and the LED are plugged into.
const TILT: u8 = 0;
const STATUS: u8 = 15;

/// The shoot: twelve frames across a 90-degree pan, one every five seconds.
const FRAMES: u32 = 12;
const SWEEP_DEGREES: f32 = 90.0;
const INTERVAL: Duration = Duration::from_secs(5);

fn main() -> Result<(), Box<dyn Error>> {
    // The PCA9685 on the header's I2C bus, at 50 Hz for the servo. The first channel written
    // runs the datasheet's start-up: sleep, prescale, wake, 500 us, restart.
    let bus = I2cBus::open("/dev/i2c-1")?;
    let mut controller =
        Pca9685::new(bus.clone(), pca9685::DEFAULT_I2C_ADDRESS, bus.delay()).with_frequency(50);
    let glow = Pwm::duty(pca9685::COUNTS / 16);
    controller.set_channel(TILT, Pwm::servo(1_300, 50))?;
    controller.set_channel(STATUS, glow)?;

    // Each coil line is taken low, so the motor holds nothing until its first step. The
    // 28BYJ-48 turns 4096 half-steps a turn through its gearbox, and with a camera on it,
    // it steps every 4 ms.
    let open = |line| linux::output(CHIP, line, "pamoja-pan", PinState::Low);
    let coils = (
        open(PAN_LINES[0])?,
        open(PAN_LINES[1])?,
        open(PAN_LINES[2])?,
        open(PAN_LINES[3])?,
    );
    let mut pan = FourWire::new(coils, linux::delay(), Drive::HalfStep).with_step_interval(4_000);
    let per_frame = steps_for_degrees(SWEEP_DEGREES / (FRAMES - 1) as f32, 4096);

    // The LED lights while the head holds still for the camera, and glows while it moves.
    for frame in 1..=FRAMES {
        controller.set_channel(STATUS, Pwm::full_on())?;
        println!(
            "frame {frame:2}  pan {:6.2} degrees",
            pan.position() as f32 * 360.0 / 4096.0
        );
        thread::sleep(INTERVAL);
        controller.set_channel(STATUS, glow)?;
        if frame < FRAMES {
            pan.steps(per_frame)?;
        }
    }

    // Back to the start, then everything off: the coils dropped, every channel off in one
    // transfer, and the oscillator asleep.
    pan.steps(-pan.position())?;
    pan.idle()?;
    controller.set_all(Pwm::full_off())?;
    controller.sleep()?;
    println!("parked at {} half-steps", pan.position());
    Ok(())
}

cd examples/boards/raspberry-pi
cargo run --release --bin rig

import { setTimeout as sleep } from 'node:timers/promises'
import { FourWire, Pca9685, StepDrive, pca9685, pwm, stepsForDegrees } from '@pamoja/actuators'
import { GpioLine, PinLevel } from '@pamoja/gpio'
import { I2cBus } from '@pamoja/hal'

// The GPIO chip the header's lines live on, numbered as the BCM numbers.
const CHIP = '/dev/gpiochip0'

// The lines the ULN2003 board's IN1 to IN4 are wired to, coils A to D.
const PAN_LINES = [5, 6, 13, 26] as const

// The PCA9685 channels the tilt servo and the LED are plugged into.
const TILT = 0
const STATUS = 15

// The shoot: twelve frames across a 90-degree pan, one every five seconds.
const FRAMES = 12
const SWEEP_DEGREES = 90
const INTERVAL_MS = 5_000

async function main(): Promise<void> {
  // The PCA9685 on the header's I2C bus, at 50 Hz for the servo. The first channel written runs
  // the datasheet's start-up: sleep, prescale, wake, 500 us, restart.
  const bus = I2cBus.open('/dev/i2c-1')
  const controller = new Pca9685(bus, pca9685.defaultAddress, { frequencyHz: 50 })
  const glow = pwm.duty(pca9685.counts / 16)
  await controller.setChannel(TILT, pwm.servo(1_300, 50))
  await controller.setChannel(STATUS, glow)

  // Each coil line is taken low, so the motor holds nothing until its first step. The 28BYJ-48
  // turns 4096 half-steps a turn through its gearbox, and with a camera on it, it steps every
  // 4 ms.
  const open = (line: number) => GpioLine.openOutput(CHIP, line, PinLevel.Low)
  const coils = [open(PAN_LINES[0]), open(PAN_LINES[1]), open(PAN_LINES[2]), open(PAN_LINES[3])] as const
  const pan = new FourWire(coils, StepDrive.HalfStep, { stepMicros: 4_000 })
  const perFrame = stepsForDegrees(SWEEP_DEGREES / (FRAMES - 1), 4096)

  // The LED lights while the head holds still for the camera, and glows while it moves.
  for (let frame = 1; frame <= FRAMES; frame += 1) {
    await controller.setChannel(STATUS, pwm.fullOn())
    const degrees = (pan.position * 360) / 4096
    console.log(`frame ${String(frame).padStart(2)}  pan ${degrees.toFixed(2).padStart(6)} degrees`)
    await sleep(INTERVAL_MS)
    await controller.setChannel(STATUS, glow)
    if (frame < FRAMES) {
      await pan.steps(perFrame)
    }
  }

  // Back to the start, then everything off: the coils dropped, every channel off in one
  // transfer, and the oscillator asleep.
  await pan.steps(-pan.position)
  pan.idle()
  await controller.setAll(pwm.fullOff())
  await controller.sleep()
  console.log(`parked at ${pan.position} half-steps`)
}

main().catch((error: Error) => {
  console.error(error.message)
  process.exitCode = 1
})

npm --prefix bindings/node run boards
node bindings/node/build/boards/raspberry-pi/rig.js

import time

from pamoja.actuators import Drive, FourWire, Pca9685, pca9685, pwm, steps_for_degrees
from pamoja.gpio import GpioLine, Level
from pamoja.hal import I2cBus

# The GPIO chip the header's lines live on, numbered as the BCM numbers.
CHIP = "/dev/gpiochip0"

# The lines the ULN2003 board's IN1 to IN4 are wired to, coils A to D.
PAN_LINES = (5, 6, 13, 26)

# The PCA9685 channels the tilt servo and the LED are plugged into.
TILT = 0
STATUS = 15

# The shoot: twelve frames across a 90-degree pan, one every five seconds.
FRAMES = 12
SWEEP_DEGREES = 90.0
INTERVAL_SECONDS = 5


def main() -> None:
    # The PCA9685 on the header's I2C bus, at 50 Hz for the servo. The first channel written
    # runs the datasheet's start-up: sleep, prescale, wake, 500 us, restart.
    bus = I2cBus.open("/dev/i2c-1")
    controller = Pca9685(bus, pca9685.DEFAULT_ADDRESS, frequency_hz=50)
    glow = pwm.duty(pca9685.COUNTS // 16)
    controller.set_channel(TILT, pwm.servo(1_300, 50))
    controller.set_channel(STATUS, glow)

    # Each coil line is taken low, so the motor holds nothing until its first step. The
    # 28BYJ-48 turns 4096 half-steps a turn through its gearbox, and with a camera on it, it
    # steps every 4 ms.
    a, b, c, d = (GpioLine.open_output(CHIP, line, Level.LOW) for line in PAN_LINES)
    pan = FourWire((a, b, c, d), Drive.HALF_STEP, step_micros=4_000)
    per_frame = steps_for_degrees(SWEEP_DEGREES / (FRAMES - 1), 4096)

    # The LED lights while the head holds still for the camera, and glows while it moves.
    for frame in range(1, FRAMES + 1):
        controller.set_channel(STATUS, pwm.full_on())
        print(f"frame {frame:2}  pan {pan.position * 360.0 / 4096:6.2f} degrees")
        time.sleep(INTERVAL_SECONDS)
        controller.set_channel(STATUS, glow)
        if frame < FRAMES:
            pan.steps(per_frame)

    # Back to the start, then everything off: the coils dropped, every channel off in one
    # transfer, and the oscillator asleep.
    pan.steps(-pan.position)
    pan.idle()
    controller.set_all(pwm.full_off())
    controller.sleep()
    print(f"parked at {pan.position} half-steps")


if __name__ == "__main__":
    main()

python bindings/python/boards/raspberry_pi/rig.py

using System.Globalization;

using Pamoja.Actuators;
using Pamoja.Gpio;
using Pamoja.Hal;

namespace Boards.RaspberryPi;

/// <summary>
/// A pan and tilt head for a time-lapse: a tilt servo and a status LED on a PCA9685 board on the
/// header's I2C bus, and a 28BYJ-48 pan motor on four GPIO lines through a ULN2003 board. Wire the
/// PCA9685 board's SDA to GPIO2, SCL to GPIO3, VCC to 3V3, and GND to ground, with the servo on
/// channel 0, an LED on channel 15, and V+ from a 5 V supply whose ground is joined to the Pi's.
/// Wire the ULN2003 board's IN1 to IN4 to GPIO5, GPIO6, GPIO13, and GPIO26.
/// </summary>
public static class Rig
{
    // The GPIO chip the header's lines live on, numbered as the BCM numbers.
    private const string Chip = "/dev/gpiochip0";

    // The PCA9685 channels the tilt servo and the LED are plugged into.
    private const byte Tilt = 0;
    private const byte Status = 15;

    // The shoot: twelve frames across a 90-degree pan, one every five seconds.
    private const int Frames = 12;
    private const float SweepDegrees = 90.0f;

    // The lines the ULN2003 board's IN1 to IN4 are wired to, coils A to D.
    private static readonly uint[] PanLines = [5, 6, 13, 26];

    private static readonly TimeSpan Interval = TimeSpan.FromSeconds(5);

    /// <summary>Runs the shoot, then parks the head.</summary>
    public static void Run()
    {
        // The PCA9685 on the header's I2C bus, at 50 Hz for the servo. The first channel
        // written runs the datasheet's start-up: sleep, prescale, wake, 500 us, restart.
        using I2cBus bus = I2cBus.Open("/dev/i2c-1");
        using var controller = new Pca9685(bus, Pca9685.DefaultAddress, frequencyHz: 50);
        byte[] glow = Pwm.Duty(Pca9685.Counts / 16);
        controller.SetChannel(Tilt, Pwm.Servo(1_300, 50));
        controller.SetChannel(Status, glow);

        // Each coil line is taken low, so the motor holds nothing until its first step. The
        // 28BYJ-48 turns 4096 half-steps a turn through its gearbox, and with a camera on it,
        // it steps every 4 ms.
        using GpioLine a = GpioLine.OpenOutput(Chip, PanLines[0], PinLevel.Low);
        using GpioLine b = GpioLine.OpenOutput(Chip, PanLines[1], PinLevel.Low);
        using GpioLine c = GpioLine.OpenOutput(Chip, PanLines[2], PinLevel.Low);
        using GpioLine d = GpioLine.OpenOutput(Chip, PanLines[3], PinLevel.Low);
        using var pan = new FourWire<GpioLine>((a, b, c, d), StepDrive.HalfStep, stepMicros: 4_000);
        int perFrame = Stepper.StepsForDegrees(SweepDegrees / (Frames - 1), 4096);

        // The LED lights while the head holds still for the camera, and glows while it moves.
        for (int frame = 1; frame <= Frames; frame++)
        {
            controller.SetChannel(Status, Pwm.FullOn());
            Console.WriteLine(string.Create(
                CultureInfo.InvariantCulture,
                $"frame {frame,2}  pan {pan.Position * 360.0f / 4096,6:F2} degrees"));
            Thread.Sleep(Interval);
            controller.SetChannel(Status, glow);
            if (frame < Frames)
            {
                pan.Steps(perFrame);
            }
        }

        // Back to the start, then everything off: the coils dropped, every channel off in one
        // transfer, and the oscillator asleep.
        pan.Steps(-pan.Position);
        pan.Idle();
        controller.SetAll(Pwm.FullOff());
        controller.Sleep();
        Console.WriteLine($"parked at {pan.Position} half-steps");
    }
}

dotnet run --project bindings/dotnet/samples/Pamoja.Boards -- raspberry-pi/rig