Sensor drivers#

use pamoja_hal::bus::I2cBus;
use pamoja_hal::sim::Part;
use pamoja_sensors::ds18b20::{self, linux::Thermometer, Resolution, Scratchpad};
use pamoja_sensors::ina226::AddressPin;
use pamoja_sensors::{ads1115, bmp280, hdc1080, ina219, ina226, opt3001, scd4x, sht3x, tmp117};

// The address plan. Every part answers at the address its pins choose, and two parts on
// one address garble each other, so a bench of nine is planned around the two that
// cannot move: the HDC1080 and the SCD41 have one address each.
let air = sht3x::I2C_ADDRESS_A;
let pressure = bmp280::I2C_ADDRESS_SECONDARY;
let light = opt3001::I2C_ADDRESS_SCL;
let soil = ads1115::address::SDA;
let enclosure = tmp117::address::ADD0_VPLUS;
let panel = ina219::address(AddressPin::Ground, AddressPin::Supply);
let battery = ina226::address(AddressPin::Supply, AddressPin::Supply);

// The bench with nothing plugged in: each part answers the way its datasheet says, with
// the reading it is given here, a warm and humid afternoon. A bus holds parts of three
// kinds, and a `Part` is any of them. On a Raspberry Pi the bus is
// `I2cBus::open("/dev/i2c-1")` and nothing after this statement changes.
let bus = I2cBus::simulated::<Part>([
    sht3x::sim::reporting(air, 24.1, 62.0).into(),
    bmp280::sim::reporting(pressure, 24.1, 1003.2).into(),
    scd4x::sim::reporting(1_180, 24.1, 62.0).into(),
    opt3001::sim::reporting(light, 4_200.0).into(),
    ads1115::sim::reporting(soil, ads1115::Pga::Fsr4_096, 2.35).into(),
    tmp117::sim::reporting(enclosure, 31.25).into(),
    hdc1080::sim::reporting(31.25, 38.0).into(),
    ina219::sim::reporting(panel, 100, 3_200_000, 18_400, 1_250_000).into(),
    ina226::sim::reporting(battery, 2, 20_000_000, 12_800_000, -350_000).into(),
]);

// One driver per part. Each holds its own share of the bus and a delay that sleeps only
// when a real part is on the other end, and each runs its datasheet's whole conversation
// on the first measurement: reset, identify, configure, convert, read.
let air_now = sht3x::Sht3x::new(bus.clone(), air, bus.delay()).measure()?;
println!(
    "air          {:.2} C, {:.2} %",
    air_now.temperature_celsius(),
    air_now.relative_humidity()
);

let weather = bmp280::Bmp280::i2c(bus.clone(), pressure, bus.delay()).measure()?;
println!("pressure     {:.1} hPa", weather.hectopascals());

let co2 = scd4x::Scd4x::new(bus.clone(), bus.delay()).measure()?;
println!("co2          {} ppm", co2.co2_ppm);

let sun = opt3001::Opt3001::new(bus.clone(), light, bus.delay()).measure()?;
println!("light        {:.0} lux", sun.lux());

// A capacitive probe's voltage falls as the soil wets and nears 3 V in dry soil, past
// the ADS1115's default range of 2.048 V, so the driver is given the 4.096 V range.
let probe = ads1115::Ads1115::new(bus.clone(), soil, bus.delay())
    .with_input(ads1115::Mux::Ain0Gnd)
    .with_gain(ads1115::Pga::Fsr4_096)
    .sample()?;
println!("soil         {:.3} V", probe.volts());

let case = tmp117::Tmp117::new(bus.clone(), enclosure, bus.delay()).measure()?;
let case_air = hdc1080::Hdc1080::new(bus.clone(), bus.delay()).measure()?;
println!(
    "enclosure    {:.2} C, {:.1} %",
    case.celsius(),
    case_air.relative_humidity()
);

// Two current monitors, each calibrated for its own shunt. The fans and the pump draw
// more than the panel gives, so the battery makes up the rest and its current reads
// negative: current through a shunt is signed by its direction.
let charge = ina219::Ina219::new(bus.clone(), panel, bus.delay())
    .with_shunt(100, 3_200_000)
    .measure()?;
println!(
    "panel        {:.2} V, {:.2} A, {:.2} W",
    f64::from(charge.bus_millivolts()) / 1e3,
    f64::from(charge.current_microamps()) / 1e6,
    f64::from(charge.power_microwatts()) / 1e6
);
let drain = ina226::Ina226::new(bus.clone(), battery, bus.delay())
    .with_shunt(2, 20_000_000)
    .measure()?;
println!(
    "battery      {:.2} V, {:.2} A, {:.2} W",
    drain.bus_volts(),
    drain.current_amps(),
    drain.power_watts()
);

// Every driver waited as its datasheet asks, the OPT3001's 800 ms integration and the
// SCD41's command times most of all. The simulated bus counted the waits and slept none.
println!(
    "waited       {:.2} s across {} transfers",
    bus.waited_micros() as f64 / 1e6,
    bus.transfers()
);

// The same probe read at the default range. Past 2.048 V the converter pins at its top
// code, and the sample says so rather than passing the edge of the range off as a reading.
bus.attach(ads1115::sim::reporting(soil, ads1115::Pga::Fsr2_048, 2.35))?;
let pinned = ads1115::Ads1115::new(bus.clone(), soil, bus.delay())
    .with_input(ads1115::Mux::Ain0Gnd)
    .sample()?;
println!(
    "default gain {:.3} V, clipped: {}",
    pinned.volts(),
    pinned.clipped()
);

// A driver aimed at the wrong address meets whatever answers there. The TMP117 reads its
// device id before anything else, so pointed at the soil probe's converter it refuses
// rather than reporting that part's registers as a temperature.
match tmp117::Tmp117::new(bus.clone(), soil, bus.delay()).init() {
    Ok(()) => println!("wrong part   accepted, which should never happen"),
    Err(error) => println!("wrong part   {error}"),
}

// A DS18B20 on a lead into a pot, read the way a Linux board reads one: the kernel's
// 1-Wire driver serves each probe as a file under /sys/bus/w1/devices. The program writes
// that file itself, with the text the kernel prints, so it runs anywhere.
let devices = std::env::temp_dir().join(format!("pamoja-bench-{}", std::process::id()));
let directory = devices.join(format!("{:02x}-000005e2fdc3", ds18b20::FAMILY_CODE));
std::fs::create_dir_all(&directory)?;
let scratchpad = Scratchpad::new(
    ds18b20::temperature_from_celsius(19.5, Resolution::Bits12),
    Resolution::Bits12,
    30,
    5,
);
std::fs::write(
    directory.join(ds18b20::linux::W1_SLAVE),
    ds18b20::w1_slave_text(&scratchpad),
)?;
let mut found = Vec::new();
for thermometer in Thermometer::discover_in(&devices)? {
    let reading = thermometer.read_scratchpad()?;
    println!(
        "soil probe   {:.4} C, alarms at {} and {} C",
        reading.temperature_celsius(),
        reading.alarm_low(),
        reading.alarm_high()
    );
    found.push(reading);
}
std::fs::remove_dir_all(&devices)?;

import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { I2cBus } from '@pamoja/hal'
import {
  Ads1115,
  Bmp280,
  Ds18b20Thermometer,
  Hdc1080,
  Ina219,
  Ina226,
  Opt3001,
  Scd4x,
  Sht3x,
  Tmp117,
  ads1115,
  bmp280,
  ds18b20,
  hdc1080,
  ina219,
  ina226,
  opt3001,
  scd4x,
  sht3x,
  tmp117,
} from '@pamoja/sensors'

// The address plan. Every part answers at the address its pins choose, and two parts on one
// address garble each other, so a bench of nine is planned around the two that cannot move:
// the HDC1080 and the SCD41 have one address each.
const air = sht3x.addressA
const pressure = bmp280.addressSecondary
const light = opt3001.addressScl
const soil = ads1115.addressSda
const enclosure = tmp117.address.add0Vplus
const panel = ina219.address(ina219.pin.ground, ina219.pin.supply)
const battery = ina226.address(ina226.pin.supply, ina226.pin.supply)

async function main() {
  // The bench with nothing plugged in: each part answers the way its datasheet says, with the
  // reading it is given here, a warm and humid afternoon. On a Raspberry Pi the bus is
  // I2cBus.open('/dev/i2c-1') and nothing after this statement changes.
  const bus = I2cBus.simulated([
    sht3x.sim.reporting(air, 24.1, 62.0),
    bmp280.sim.reporting(pressure, 24.1, 1003.2),
    scd4x.sim.reporting(1_180, 24.1, 62.0),
    opt3001.sim.reporting(light, 4_200),
    ads1115.sim.reporting(soil, ads1115.pga.fsr4_096, 2.35),
    tmp117.sim.reporting(enclosure, 31.25),
    hdc1080.sim.reporting(31.25, 38.0),
    ina219.sim.reporting(panel, 100, 3_200_000, 18_400, 1_250_000),
    ina226.sim.reporting(battery, 2, 20_000_000, 12_800_000, -350_000),
  ])

  // One driver per part. Each holds its own share of the bus, runs its datasheet's whole
  // conversation on the first measurement, and resolves once the part has answered.
  const airNow = await new Sht3x(bus, air).measure()
  console.log(`air          ${airNow.celsius.toFixed(2)} C, ${airNow.relativeHumidity.toFixed(2)} %`)

  const weather = await new Bmp280(bus, pressure).measure()
  console.log(`pressure     ${weather.hectopascals.toFixed(1)} hPa`)

  const co2 = await new Scd4x(bus).measure()
  console.log(`co2          ${co2.co2Ppm} ppm`)

  const sun = await new Opt3001(bus, light).measure()
  console.log(`light        ${sun.lux.toFixed(0)} lux`)

  // A capacitive probe's voltage falls as the soil wets and nears 3 V in dry soil, past the
  // ADS1115's default range of 2.048 V, so the driver is given the 4.096 V range.
  const probe = await new Ads1115(bus, soil, {
    mux: ads1115.mux.ain0Gnd,
    pga: ads1115.pga.fsr4_096,
  }).sample()
  console.log(`soil         ${probe.volts.toFixed(3)} V`)

  const box = await new Tmp117(bus, enclosure).measure()
  const boxAir = await new Hdc1080(bus).measure()
  console.log(`enclosure    ${box.celsius.toFixed(2)} C, ${boxAir.relativeHumidity.toFixed(1)} %`)

  // Two current monitors, each calibrated for its own shunt. The fans and the pump draw more
  // than the panel gives, so the battery makes up the rest and its current reads negative:
  // current through a shunt is signed by its direction.
  const charge = await new Ina219(bus, panel, {
    shuntMilliohms: 100,
    maxMicroamps: 3_200_000,
  }).measure()
  console.log(
    `panel        ${(charge.busMillivolts / 1e3).toFixed(2)} V, ` +
      `${(charge.currentMicroamps / 1e6).toFixed(2)} A, ` +
      `${(charge.powerMicrowatts / 1e6).toFixed(2)} W`,
  )
  const drain = await new Ina226(bus, battery, {
    shuntMilliohms: 2,
    maxMicroamps: 20_000_000,
  }).measure()
  console.log(
    `battery      ${drain.busVolts.toFixed(2)} V, ${drain.currentAmps.toFixed(2)} A, ` +
      `${drain.powerWatts.toFixed(2)} W`,
  )

  // Every driver waited as its datasheet asks, the OPT3001's 800 ms integration and the
  // SCD41's command times most of all. The simulated bus counted the waits and slept none.
  console.log(`waited       ${(bus.waitedMicros / 1e6).toFixed(2)} s across ${bus.transfers} transfers`)

  // The same probe read at the default range. Past 2.048 V the converter pins at its top code,
  // and the sample says so rather than passing the edge of the range off as a reading.
  bus.attach(ads1115.sim.reporting(soil, ads1115.pga.fsr2_048, 2.35))
  const pinned = await new Ads1115(bus, soil, { mux: ads1115.mux.ain0Gnd }).sample()
  console.log(`default gain ${pinned.volts.toFixed(3)} V, clipped: ${pinned.clipped}`)

  // A driver aimed at the wrong address meets whatever answers there. The TMP117 reads its
  // device id before anything else, so pointed at the soil probe's converter it refuses
  // rather than reporting that part's registers as a temperature.
  try {
    await new Tmp117(bus, soil).init()
    console.log('wrong part   accepted, which should never happen')
  } catch (error) {
    console.log(`wrong part   ${(error as Error).message}`)
  }

  // A DS18B20 on a lead into a pot, read the way a Linux board reads one: the kernel's 1-Wire
  // driver serves each probe as a file under /sys/bus/w1/devices. The program writes that
  // file itself, with the text the kernel prints, so it runs anywhere.
  const devices = join(tmpdir(), `pamoja-bench-${process.pid}`)
  const directory = join(devices, `${ds18b20.familyCode.toString(16)}-000005e2fdc3`)
  mkdirSync(directory, { recursive: true })
  const scratchpad = ds18b20.buildScratchpad(19.5, 12, 30, 5)
  writeFileSync(join(directory, 'w1_slave'), ds18b20.w1SlaveText(scratchpad))
  const found = []
  for (const thermometer of Ds18b20Thermometer.discover(devices)) {
    const reading = await thermometer.read()
    console.log(
      `soil probe   ${reading.celsius.toFixed(4)} C, ` +
        `alarms at ${reading.alarmLow} and ${reading.alarmHigh} C`,
    )
    found.push(reading)
  }
  rmSync(devices, { recursive: true })

  return { airNow, weather, co2, sun, probe, box, boxAir, charge, drain, pinned, found }
}

main()

import os
import shutil
import tempfile
from pathlib import Path

from pamoja.core import PamojaError
from pamoja.hal import I2cBus
from pamoja.sensors import (
    Ads1115,
    Ads1115Mux,
    Ads1115Pga,
    Bmp280,
    Ds18b20Thermometer,
    Hdc1080,
    Ina219,
    Ina226,
    Opt3001,
    Scd4x,
    Sht3x,
    Tmp117,
    ads1115,
    bmp280,
    ds18b20,
    hdc1080,
    ina219,
    ina226,
    opt3001,
    scd4x,
    sht3x,
    tmp117,
)

# The address plan. Every part answers at the address its pins choose, and two parts on one
# address garble each other, so a bench of nine is planned around the two that cannot move:
# the HDC1080 and the SCD41 have one address each.
AIR = sht3x.ADDRESS_A
PRESSURE = bmp280.ADDRESS_SECONDARY
LIGHT = opt3001.ADDRESS_SCL
SOIL = ads1115.ADDRESS_SDA
ENCLOSURE = tmp117.ADDRESS_ADD0_VPLUS
PANEL = ina219.address(ina219.PIN_GROUND, ina219.PIN_SUPPLY)
BATTERY = ina226.address(ina226.PIN_SUPPLY, ina226.PIN_SUPPLY)

# The bench with nothing plugged in: each part answers the way its datasheet says, with the
# reading it is given here, a warm and humid afternoon. On a Raspberry Pi the bus is
# I2cBus.open("/dev/i2c-1") and nothing after this statement changes.
bus = I2cBus.simulated([
    sht3x.sim.reporting(AIR, 24.1, 62.0),
    bmp280.sim.reporting(PRESSURE, 24.1, 1003.2),
    scd4x.sim.reporting(1_180, 24.1, 62.0),
    opt3001.sim.reporting(LIGHT, 4_200.0),
    ads1115.sim.reporting(SOIL, Ads1115Pga.FSR_4_096, 2.35),
    tmp117.sim.reporting(ENCLOSURE, 31.25),
    hdc1080.sim.reporting(31.25, 38.0),
    ina219.sim.reporting(PANEL, 100, 3_200_000, 18_400, 1_250_000),
    ina226.sim.reporting(BATTERY, 2, 20_000_000, 12_800_000, -350_000),
])

# One driver per part. Each holds its own share of the bus, runs its datasheet's whole
# conversation on the first measurement, and releases the interpreter while the part answers.
air_now = Sht3x(bus, AIR).measure()
print(f"air          {air_now.celsius:.2f} C, {air_now.relative_humidity:.2f} %")

weather = Bmp280(bus, PRESSURE).measure()
print(f"pressure     {weather.hectopascals:.1f} hPa")

co2 = Scd4x(bus).measure()
print(f"co2          {co2.co2_ppm} ppm")

sun = Opt3001(bus, LIGHT).measure()
print(f"light        {sun.lux:.0f} lux")

# A capacitive probe's voltage falls as the soil wets and nears 3 V in dry soil, past the
# ADS1115's default range of 2.048 V, so the driver is given the 4.096 V range.
probe = Ads1115(bus, SOIL, mux=Ads1115Mux.AIN0_GND, pga=Ads1115Pga.FSR_4_096).sample()
print(f"soil         {probe.volts:.3f} V")

box = Tmp117(bus, ENCLOSURE).measure()
box_air = Hdc1080(bus).measure()
print(f"enclosure    {box.celsius:.2f} C, {box_air.relative_humidity:.1f} %")

# Two current monitors, each calibrated for its own shunt. The fans and the pump draw more than
# the panel gives, so the battery makes up the rest and its current reads negative: current
# through a shunt is signed by its direction.
charge = Ina219(bus, PANEL, shunt_milliohms=100, max_microamps=3_200_000).measure()
print(
    f"panel        {charge.bus_millivolts / 1e3:.2f} V, "
    f"{charge.current_microamps / 1e6:.2f} A, {charge.power_microwatts / 1e6:.2f} W"
)
drain = Ina226(bus, BATTERY, shunt_milliohms=2, max_microamps=20_000_000).measure()
print(
    f"battery      {drain.bus_volts:.2f} V, {drain.current_amps:.2f} A, "
    f"{drain.power_watts:.2f} W"
)

# Every driver waited as its datasheet asks, the OPT3001's 800 ms integration and the SCD41's
# command times most of all. The simulated bus counted the waits and slept none.
print(f"waited       {bus.waited_micros / 1e6:.2f} s across {bus.transfers} transfers")

# The same probe read at the default range. Past 2.048 V the converter pins at its top code,
# and the sample says so rather than passing the edge of the range off as a reading.
bus.attach(ads1115.sim.reporting(SOIL, Ads1115Pga.FSR_2_048, 2.35))
pinned = Ads1115(bus, SOIL, mux=Ads1115Mux.AIN0_GND).sample()
print(f"default gain {pinned.volts:.3f} V, clipped: {str(pinned.clipped).lower()}")

# A driver aimed at the wrong address meets whatever answers there. The TMP117 reads its
# device id before anything else, so pointed at the soil probe's converter it refuses rather
# than reporting that part's registers as a temperature.
try:
    Tmp117(bus, SOIL).init()
    print("wrong part   accepted, which should never happen")
except PamojaError as error:
    print(f"wrong part   {error}")

# A DS18B20 on a lead into a pot, read the way a Linux board reads one: the kernel's 1-Wire
# driver serves each probe as a file under /sys/bus/w1/devices. The program writes that file
# itself, with the text the kernel prints, so it runs anywhere.
devices = Path(tempfile.gettempdir()) / f"pamoja-bench-{os.getpid()}"
directory = devices / f"{ds18b20.FAMILY_CODE:02x}-000005e2fdc3"
directory.mkdir(parents=True, exist_ok=True)
scratchpad = ds18b20.build_scratchpad(19.5, 12, 30, 5)
(directory / "w1_slave").write_text(ds18b20.w1_slave_text(scratchpad), newline="")
found = []
for thermometer in Ds18b20Thermometer.discover(str(devices)):
    reading = thermometer.read()
    print(
        f"soil probe   {reading.celsius:.4f} C, "
        f"alarms at {reading.alarm_low} and {reading.alarm_high} C"
    )
    found.append(reading)
shutil.rmtree(devices)

// The address plan. Every part answers at the address its pins choose, and two parts on
// one address garble each other, so a bench of nine is planned around the two that
// cannot move: the HDC1080 and the SCD41 have one address each.
const byte Air = Sht3x.AddressA;
const byte Pressure = Bmp280.AddressSecondary;
const byte Light = Opt3001.AddressScl;
const byte Soil = Ads1115.AddressSda;
const byte Enclosure = Tmp117.AddressAdd0Vplus;
byte panel = Ina219.Address(Ina219.AddressPin.Ground, Ina219.AddressPin.Supply);
byte battery = Ina226.Address(Ina226.AddressPin.Supply, Ina226.AddressPin.Supply);

// The bench with nothing plugged in: each part answers the way its datasheet says, with
// the reading it is given here, a warm and humid afternoon. The bus keeps a copy of each
// 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.
SimulatedPart[] parts =
[
    Sht3x.Sim.Reporting(Air, 24.1f, 62.0f),
    Bmp280.Sim.Reporting(Pressure, 24.1f, 1003.2f),
    Scd4x.Sim.Reporting(1_180, 24.1f, 62.0f),
    Opt3001.Sim.Reporting(Light, 4_200f),
    Ads1115.Sim.Reporting(Soil, Ads1115.Pga.Fsr4_096, 2.35f),
    Tmp117.Sim.Reporting(Enclosure, 31.25f),
    Hdc1080.Sim.Reporting(31.25f, 38.0f),
    Ina219.Sim.Reporting(panel, 100, 3_200_000, 18_400, 1_250_000),
    Ina226.Sim.Reporting(battery, 2, 20_000_000, 12_800_000, -350_000),
];
using I2cBus bus = I2cBus.Simulated(parts);
foreach (SimulatedPart part in parts)
{
    part.Dispose();
}

// One driver per part. Each holds its own share of the bus, and each runs its
// datasheet's whole conversation on the first measurement: reset, identify, configure,
// convert, read.
using var airSensor = new Sht3x(bus, Air);
var airNow = airSensor.Measure();
Console.WriteLine(Invariant($"air          {airNow.Celsius:F2} C, {airNow.RelativeHumidity:F2} %"));

using var barometer = new Bmp280(bus, Pressure);
Bmp280Reading weather = barometer.Measure();
Console.WriteLine(Invariant($"pressure     {weather.Hectopascals:F1} hPa"));

using var co2Sensor = new Scd4x(bus);
var co2 = co2Sensor.Measure();
Console.WriteLine($"co2          {co2.Co2Ppm} ppm");

using var lightSensor = new Opt3001(bus, Light);
Opt3001Reading sun = lightSensor.Measure();
Console.WriteLine(Invariant($"light        {sun.Lux:F0} lux"));

// A capacitive probe's voltage falls as the soil wets and nears 3 V in dry soil, past the
// ADS1115's default range of 2.048 V, so the driver is given the 4.096 V range.
using var converter = new Ads1115(bus, Soil, Ads1115.Mux.Ain0Gnd, Ads1115.Pga.Fsr4_096);
Ads1115Sample probe = converter.Sample();
Console.WriteLine(Invariant($"soil         {probe.Volts:F3} V"));

using var boxThermometer = new Tmp117(bus, Enclosure);
using var boxHygrometer = new Hdc1080(bus);
Tmp117Reading box = boxThermometer.Measure();
var boxAir = boxHygrometer.Measure();
Console.WriteLine(Invariant($"enclosure    {box.Celsius:F2} C, {boxAir.RelativeHumidity:F1} %"));

// Two current monitors, each calibrated for its own shunt. The fans and the pump draw
// more than the panel gives, so the battery makes up the rest and its current reads
// negative: current through a shunt is signed by its direction.
using var panelMonitor = new Ina219(bus, panel, shuntMilliohms: 100, maxMicroamps: 3_200_000);
Ina219Reading charge = panelMonitor.Measure();
Console.WriteLine(Invariant(
    $"panel        {charge.BusMillivolts / 1e3:F2} V, {charge.CurrentMicroamps / 1e6:F2} A, {charge.PowerMicrowatts / 1e6:F2} W"));
using var batteryMonitor = new Ina226(bus, battery, shuntMilliohms: 2, maxMicroamps: 20_000_000);
Ina226Reading drain = batteryMonitor.Measure();
Console.WriteLine(Invariant(
    $"battery      {drain.BusVolts:F2} V, {drain.CurrentAmps:F2} A, {drain.PowerWatts:F2} W"));

// Every driver waited as its datasheet asks, the OPT3001's 800 ms integration and the
// SCD41's command times most of all. The simulated bus counted the waits and slept none.
Console.WriteLine(Invariant($"waited       {bus.WaitedMicros / 1e6:F2} s across {bus.Transfers} transfers"));

// The same probe read at the default range. Past 2.048 V the converter pins at its top
// code, and the sample says so rather than passing the edge of the range off as a reading.
using (WordPart reprobed = Ads1115.Sim.Reporting(Soil, Ads1115.Pga.Fsr2_048, 2.35f))
{
    bus.Attach(reprobed);
}

using var defaultGain = new Ads1115(bus, Soil, Ads1115.Mux.Ain0Gnd);
Ads1115Sample pinned = defaultGain.Sample();
Console.WriteLine(Invariant(
    $"default gain {pinned.Volts:F3} V, clipped: {pinned.Clipped.ToString().ToLowerInvariant()}"));

// A driver aimed at the wrong address meets whatever answers there. The TMP117 reads its
// device id before anything else, so pointed at the soil probe's converter it refuses
// rather than reporting that part's registers as a temperature.
try
{
    using var misplaced = new Tmp117(bus, Soil);
    misplaced.Init();
    Console.WriteLine("wrong part   accepted, which should never happen");
}
catch (PamojaException error)
{
    Console.WriteLine($"wrong part   {error.Message}");
}

// A DS18B20 on a lead into a pot, read the way a Linux board reads one: the kernel's
// 1-Wire driver serves each probe as a file under /sys/bus/w1/devices. The program writes
// that file itself, with the text the kernel prints, so it runs anywhere.
string devices = Path.Combine(Path.GetTempPath(), $"pamoja-bench-{Environment.ProcessId}");
string directory = Path.Combine(devices, $"{Ds18b20.FamilyCode:x2}-000005e2fdc3");
Directory.CreateDirectory(directory);
byte[] scratchpad = Ds18b20.BuildScratchpad(19.5f, 12, 30, 5);
File.WriteAllText(Path.Combine(directory, "w1_slave"), Ds18b20.W1SlaveText(scratchpad));
var found = new List<Ds18b20Reading>();
foreach (Ds18b20Thermometer thermometer in Ds18b20Thermometer.Discover(devices))
{
    using (thermometer)
    {
        Ds18b20Reading reading = thermometer.Read();
        Console.WriteLine(Invariant(
            $"soil probe   {reading.Celsius:F4} C, alarms at {reading.AlarmLow} and {reading.AlarmHigh} C"));
        found.Add(reading);
    }
}

Directory.Delete(devices, recursive: true);

use pamoja_hal::bus::I2cBus;
use pamoja_sensors::ds18b20::linux::Thermometer;
use pamoja_sensors::sht3x::{Sht3x, I2C_ADDRESS_A};

fn main() -> Result<(), Box<dyn Error>> {
    // The air sensor, on the header's I2C bus: /dev/i2c-1 on every model.
    let bus = I2cBus::open("/dev/i2c-1")?;
    let mut air = Sht3x::new(bus.clone(), I2C_ADDRESS_A, bus.delay());

    // The kernel lists each DS18B20 it has found on GPIO4 as a directory named for its
    // serial. The list is taken once, so a probe plugged in later needs a restart.
    let probes = Thermometer::discover()?;
    if probes.is_empty() {
        return Err(
            "no DS18B20 under /sys/bus/w1/devices: check the pull-up and the overlay".into(),
        );
    }

    loop {
        let now = air.measure()?;
        println!(
            "air           {:.2} C, {:.1} %",
            now.temperature_celsius(),
            now.relative_humidity()
        );

        // Reading a probe makes the kernel run a conversion, 750 ms at 12 bits. A reading
        // corrupted on a long lead fails its checksum, and the logger says so and reads the
        // probe again next time rather than stopping.
        for probe in &probes {
            let serial = probe.serial().unwrap_or_default();
            match probe.read_scratchpad() {
                Ok(soil) => println!("{serial}  {:.2} C", soil.temperature_celsius()),
                Err(error) => println!("{serial}  {error}"),
            }
        }
        thread::sleep(Duration::from_secs(10));
    }
}

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

import { setTimeout as sleep } from 'node:timers/promises'
import { I2cBus } from '@pamoja/hal'
import { Ds18b20Thermometer, Sht3x, sht3x } from '@pamoja/sensors'

async function main(): Promise<void> {
  // The air sensor, on the header's I2C bus: /dev/i2c-1 on every model.
  const bus = I2cBus.open('/dev/i2c-1')
  const air = new Sht3x(bus, sht3x.addressA)

  // The kernel lists each DS18B20 it has found on GPIO4 as a directory named for its
  // serial. The list is taken once, so a probe plugged in later needs a restart.
  const probes = Ds18b20Thermometer.discover()
  if (probes.length === 0) {
    throw new Error('no DS18B20 under /sys/bus/w1/devices: check the pull-up and the overlay')
  }

  for (;;) {
    const now = await air.measure()
    console.log(`air           ${now.celsius.toFixed(2)} C, ${now.relativeHumidity.toFixed(1)} %`)

    // Reading a probe makes the kernel run a conversion, 750 ms at 12 bits. A reading
    // corrupted on a long lead fails its checksum, and the logger says so and reads the probe
    // again next time rather than stopping.
    for (const probe of probes) {
      try {
        const soil = await probe.read()
        console.log(`${probe.serial}  ${soil.celsius.toFixed(2)} C`)
      } catch (error) {
        console.log(`${probe.serial}  ${(error as Error).message}`)
      }
    }
    await sleep(10_000)
  }
}

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

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

import time

from pamoja.core import PamojaError
from pamoja.hal import I2cBus
from pamoja.sensors import Ds18b20Thermometer, Sht3x, sht3x


def main() -> None:
    # The air sensor, on the header's I2C bus: /dev/i2c-1 on every model.
    bus = I2cBus.open("/dev/i2c-1")
    air = Sht3x(bus, sht3x.ADDRESS_A)

    # The kernel lists each DS18B20 it has found on GPIO4 as a directory named for its
    # serial. The list is taken once, so a probe plugged in later needs a restart.
    probes = Ds18b20Thermometer.discover()
    if not probes:
        raise SystemExit(
            "no DS18B20 under /sys/bus/w1/devices: check the pull-up and the overlay"
        )

    while True:
        now = air.measure()
        print(f"air           {now.celsius:.2f} C, {now.relative_humidity:.1f} %")

        # Reading a probe makes the kernel run a conversion, 750 ms at 12 bits. A reading
        # corrupted on a long lead fails its checksum, and the logger says so and reads the
        # probe again next time rather than stopping.
        for probe in probes:
            try:
                soil = probe.read()
                print(f"{probe.serial}  {soil.celsius:.2f} C")
            except PamojaError as error:
                print(f"{probe.serial}  {error}")
        time.sleep(10)

python bindings/python/boards/raspberry_pi/probes.py

using System.Globalization;

using Pamoja;
using Pamoja.Hal;
using Pamoja.Sensors;

namespace Boards.RaspberryPi;

/// <summary>
/// A greenhouse logger on a Raspberry Pi: the air from an SHT31 on the header's I2C bus, and
/// every DS18B20 soil probe the kernel's 1-Wire driver has found, printed every ten seconds.
/// Wire the SHT31's SDA to GPIO2, its SCL to GPIO3, VIN to 3V3, and GND to ground, and turn the
/// I2C interface on. Wire each probe's red lead to 3V3, its black lead to ground, and its yellow
/// data lead to GPIO4, with one 4.7 kilohm resistor from GPIO4 to 3V3 for the whole bus; add
/// <c>dtoverlay=w1-gpio</c> to config.txt and reboot.
/// </summary>
public static class Probes
{
    /// <summary>Runs until the process is stopped.</summary>
    public static void Run()
    {
        // The air sensor, on the header's I2C bus: /dev/i2c-1 on every model.
        using I2cBus bus = I2cBus.Open("/dev/i2c-1");
        using var air = new Sht3x(bus, Sht3x.AddressA);

        // The kernel lists each DS18B20 it has found on GPIO4 as a directory named for its
        // serial. The list is taken once, so a probe plugged in later needs a restart.
        IReadOnlyList<Ds18b20Thermometer> probes = Ds18b20Thermometer.Discover();
        if (probes.Count == 0)
        {
            throw new PamojaException("no DS18B20 under /sys/bus/w1/devices: check the pull-up and the overlay");
        }

        while (true)
        {
            var now = air.Measure();
            Console.WriteLine(string.Create(
                CultureInfo.InvariantCulture,
                $"air           {now.Celsius:F2} C, {now.RelativeHumidity:F1} %"));

            // Reading a probe makes the kernel run a conversion, 750 ms at 12 bits. A reading
            // corrupted on a long lead fails its checksum, and the logger says so and reads the
            // probe again next time rather than stopping.
            foreach (Ds18b20Thermometer probe in probes)
            {
                try
                {
                    Ds18b20Reading soil = probe.Read();
                    Console.WriteLine(string.Create(CultureInfo.InvariantCulture, $"{probe.Serial}  {soil.Celsius:F2} C"));
                }
                catch (PamojaException error)
                {
                    Console.WriteLine($"{probe.Serial}  {error.Message}");
                }
            }

            Thread.Sleep(TimeSpan.FromSeconds(10));
        }
    }
}

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