LoRa radios#

use pamoja_lora::budget::{Decibels, LinkBudget};
use pamoja_lora::region::Region;
use pamoja_radios::duty::DutyCycle;
use pamoja_radios::radio::{RadioConfig, Reception};
use pamoja_radios::sim::Chip;
use pamoja_radios::sx126x::config::{PowerAmplifier, TxPower};
use pamoja_radios::sx126x::Board;

// An SX1262 node sends a ten-byte reading on 868.1 MHz at DR3, SF9 at 125 kHz, through a
// 2.15 dBi whip on half a decibel of pigtail. The plan caps the EIRP there, and the antenna
// and pigtail decide how hard the amplifier may drive under that cap.
let eu868 = Region::Eu868.plan();
let frequency = 868_100_000;
let link = eu868.link_settings(3).expect("DR3 is a LoRa data rate");
let whip = LinkBudget {
    transmit_antenna_gain_dbi: Decibels::from_hundredths(215),
    transmit_cable_loss_db: Decibels::from_tenths(5),
    ..LinkBudget::default()
};
let ceiling = eu868.max_eirp_dbm(frequency);
let power = TxPower::under_ceiling(
    PowerAmplifier::HighPower,
    &whip,
    Decibels::from_db(ceiling.into()),
);
println!(
    "power     {} dBm under a {ceiling} dBm EIRP ceiling",
    power.setting_dbm
);

// A simulated SX1262 stands in for the chip on the node's board, driven by the same code
// that drives a real one, and it reports what that code told it.
let chip = Chip::sx126x(Board::new(PowerAmplifier::HighPower));
let mut radio = chip.radio();
radio.init()?;
radio.configure(RadioConfig::new(frequency, link, power.setting_dbm))?;
let tuned = chip.tuning();
println!(
    "tuned     {:.1} MHz, SF{} at {} kHz, {} dBm",
    f64::from(tuned.frequency_hz) / 1e6,
    tuned.link.spreading_factor(),
    tuned.link.bandwidth_hz() / 1000,
    tuned.output_dbm
);

// The reading goes out, and the airtime comes back for the duty-cycle guard. The sub-band
// that holds 868.1 MHz allows 1% of the time, so the frame buys ninety-nine times as long
// in silence before the next.
let reading = b"level=0.42";
let airtime = radio.transmit(reading)?;
println!(
    "sent      {} bytes, {airtime} us on air",
    chip.sent()[0].payload.len()
);
let permille = eu868
    .duty_cycle_permille(frequency)
    .expect("868.1 MHz is in a sub-band");
let mut guard = DutyCycle::new(permille);
guard.transmitted(0, &link, reading.len());
println!(
    "silence   the next frame starts {} us after this one did",
    guard.wait_us(0)
);

// A gateway's answer arrives from the edge of range, 2.5 dB under the noise.
chip.hear(b"ack", Decibels::from_db(-109), Decibels::from_tenths(-25));
let mut buffer = [0u8; 255];
if let Reception::Frame { len, levels } = radio.receive(&mut buffer, 1_000_000)? {
    println!(
        "received  {} at {} dBm, SNR {} dB",
        String::from_utf8_lossy(&buffer[..len]),
        levels.rssi_dbm,
        levels.snr_db
    );
}

// With nothing on the air the reception times out, and a frame whose CRC fails is dropped
// rather than handed over.
let quiet = radio.receive(&mut buffer, 1_000_000)?;
chip.hear_corrupt(Decibels::from_db(-121), Decibels::from_db(-12));
let broken = radio.receive(&mut buffer, 1_000_000)?;
println!("then      {quiet:?}, then {broken:?}");

use pamoja_lora::budget::{Decibels, LinkBudget};
use pamoja_lora::region::Region;
use pamoja_radios::radio::{RadioConfig, Reception};
use pamoja_radios::sim::Chip;
use pamoja_radios::sx126x::config::{llcc68_supports, LoraModulation as Sx126xModulation};
use pamoja_radios::sx127x::config::{PaOutput, TxPower};
use pamoja_radios::sx127x::Board;

// An RFM95W wires the SX1276's PA_BOOST amplifier to its antenna. The same whip and the
// same 16 dBm ceiling leave it the same 14 dBm.
let band = Region::Eu868.plan();
let channel = 868_100_000;
let dr3 = band.link_settings(3).expect("DR3 is a LoRa data rate");
let antenna = LinkBudget {
    transmit_antenna_gain_dbi: Decibels::from_hundredths(215),
    transmit_cable_loss_db: Decibels::from_tenths(5),
    ..LinkBudget::default()
};
let limit = Decibels::from_db(band.max_eirp_dbm(channel).into());
let rfm95w = TxPower::under_ceiling(PaOutput::PaBoost, &antenna, limit);

// The same driver calls tune it, through registers this time. Its synthesizer steps in
// 61 Hz, so the carrier lands on the step nearest the one asked for.
let chip = Chip::sx127x(Board::new(PaOutput::PaBoost));
let mut radio = chip.radio();
radio.init()?;
radio.configure(RadioConfig::new(channel, dr3, rfm95w.output_dbm))?;
let tuned = chip.tuning();
println!(
    "rfm95w    {} dBm on PA_BOOST, carrier {} Hz, {} Hz from {channel}",
    tuned.output_dbm,
    tuned.frequency_hz,
    channel.abs_diff(tuned.frequency_hz)
);

// The SX1276 gives a packet's strength in whole decibels, and works out the strength of
// the signal itself from the SNR when it arrived under the noise.
chip.hear(b"ack", Decibels::from_db(-109), Decibels::from_tenths(-25));
let mut buffer = [0u8; 255];
if let Reception::Frame { levels, .. } = radio.receive(&mut buffer, 1_000_000)? {
    println!(
        "received  RSSI {} dBm, SNR {} dB, signal {} dBm",
        levels.rssi_dbm, levels.snr_db, levels.signal_rssi_dbm
    );
}

// An LLCC68 in the RFM95W's place could carry DR3, but not DR2, which is SF10 at 125 kHz.
let carries = |data_rate: u8| {
    let fits = band
        .link_settings(data_rate)
        .and_then(|link| Sx126xModulation::from_link(&link))
        .is_some_and(|modulation| {
            llcc68_supports(modulation.spreading_factor, modulation.bandwidth)
        });
    if fits {
        "carries"
    } else {
        "cannot carry"
    }
};
println!("llcc68    {} DR3 and {} DR2", carries(3), carries(2));

use pamoja_lora::budget::{Decibels, LinkBudget};
use pamoja_lora::region::Region;
use pamoja_radios::linux::{self, Wiring};
use pamoja_radios::radio::RadioConfig;
use pamoja_radios::sx127x::config::{PaOutput, TxPower};
use pamoja_radios::sx127x::Board;

// An RFM95W on a Raspberry Pi: the header's first chip select, with the module's reset pin
// on GPIO25. The SX1276 family has no BUSY line, so the wiring names none.
let wiring = Wiring::new("/dev/spidev0.0", "/dev/gpiochip0", 25);
println!(
    "radio     an RFM95W on {}, reset on GPIO{}",
    wiring.spi.display(),
    wiring.reset_line
);

// The channel and the power the same whip leaves under the same ceiling, now as the number
// the radio is set to rather than the registers it goes into.
let band = Region::Eu868.plan();
let channel = 868_100_000;
let dr3 = band.link_settings(3).expect("DR3 is a LoRa data rate");
let antenna = LinkBudget {
    transmit_antenna_gain_dbi: Decibels::from_hundredths(215),
    transmit_cable_loss_db: Decibels::from_tenths(5),
    ..LinkBudget::default()
};
let ceiling = Decibels::from_db(i32::from(band.max_eirp_dbm(channel)));
let rfm95w = TxPower::under_ceiling(PaOutput::PaBoost, &antenna, ceiling);
println!(
    "plan      {channel} Hz at DR3, {} dBm on PA_BOOST",
    rfm95w.output_dbm
);

// Opening resets the chip and reads its version back, so a wiring mistake is caught here
// rather than on the first frame. With no radio wired, this is the line that prints.
match linux::open_sx127x(&wiring, Board::new(PaOutput::PaBoost)) {
    Ok(mut radio) => {
        radio
            .configure(RadioConfig::new(channel, dr3, rfm95w.output_dbm))
            .expect("the chip takes the settings");
        let airtime_us = radio.transmit(b"21.5").expect("the frame goes out");
        println!("sent      a reading in {airtime_us} us on air");
    }
    Err(_) => println!("absent    no radio answered, so nothing went out"),
}

import { LoraRegion, linkBudget, planFor } from '@pamoja/lora'
import { DutyCycle, SimulatedLoraChip, sx126x } from '@pamoja/radios'

async function onTheBench() {
  // An SX1262 node sends a ten-byte reading on 868.1 MHz at DR3, SF9 at 125 kHz, through a
  // 2.15 dBi whip on half a decibel of pigtail. The plan caps the EIRP there, and the
  // antenna and pigtail decide how hard the amplifier may drive under that cap.
  const eu868 = planFor(LoraRegion.Eu868)
  const frequency = 868_100_000
  const link = eu868.linkSettings(3)!
  const whip = linkBudget({ transmitAntennaGainDbi: 2.15, transmitCableLossDb: 0.5 })
  const ceiling = eu868.maxEirpDbm(frequency)
  const power = sx126x.txPowerUnderCeiling(sx126x.Amplifier.HighPower, whip, ceiling)
  console.log(`power     ${power.settingDbm} dBm under a ${ceiling} dBm EIRP ceiling`)

  // A simulated SX1262 stands in for the chip on the node's board, driven by the same code
  // that drives a real one, and it reports what that code told it.
  const chip = SimulatedLoraChip.sx126x({ amplifier: sx126x.Amplifier.HighPower })
  const radio = chip.radio()
  await radio.configure({ frequencyHz: frequency, link, outputDbm: power.settingDbm })
  const tuned = chip.tuning()
  console.log(
    `tuned     ${(tuned.frequencyHz / 1e6).toFixed(1)} MHz, SF${tuned.link.spreadingFactor} ` +
      `at ${tuned.link.bandwidthHz / 1000} kHz, ${tuned.outputDbm} dBm`,
  )

  // The reading goes out, and the airtime comes back for the duty-cycle guard. The sub-band
  // that holds 868.1 MHz allows 1% of the time, so the frame buys ninety-nine times as long
  // in silence before the next.
  const reading = Buffer.from('level=0.42')
  const airtime = await radio.transmit(reading)
  console.log(`sent      ${chip.sent()[0].payload.length} bytes, ${airtime} us on air`)
  const guard = new DutyCycle(eu868.dutyCyclePermille(frequency)!)
  guard.transmitted(0, link, reading.length)
  console.log(`silence   the next frame starts ${guard.waitUs(0)} us after this one did`)

  // A gateway's answer arrives from the edge of range, 2.5 dB under the noise.
  chip.hear(Buffer.from('ack'), -109, -2.5)
  const heard = await radio.receive(1_000_000)
  if (heard.outcome === 'Frame') {
    console.log(
      `received  ${heard.payload!.toString()} at ${heard.rssiDbm!.toFixed(2)} dBm, ` +
        `SNR ${heard.snrDb!.toFixed(2)} dB`,
    )
  }

  // With nothing on the air the reception times out, and a frame whose CRC fails is dropped
  // rather than handed over.
  const quiet = (await radio.receive(1_000_000)).outcome
  chip.hearCorrupt(-121, -12)
  const broken = (await radio.receive(1_000_000)).outcome
  console.log(`then      ${quiet}, then ${broken}`)
  radio.close()
  return { power, tuned, airtime, link, reading, guard, chip, quiet, broken }
}

import { sx127x } from '@pamoja/radios'

async function anRfm95w() {
  // An RFM95W wires the SX1276's PA_BOOST amplifier to its antenna. The same whip and the
  // same 16 dBm ceiling leave it the same 14 dBm.
  const band = planFor(LoraRegion.Eu868)
  const channel = 868_100_000
  const dr3 = band.linkSettings(3)!
  const antenna = linkBudget({ transmitAntennaGainDbi: 2.15, transmitCableLossDb: 0.5 })
  const rfm95w = sx127x.txPowerUnderCeiling(
    sx127x.PaOutput.PaBoost,
    antenna,
    band.maxEirpDbm(channel),
  )

  // The same driver calls tune it, through registers this time. Its synthesizer steps in
  // 61 Hz, so the carrier lands on the step nearest the one asked for.
  const chip = SimulatedLoraChip.sx127x({ output: sx127x.PaOutput.PaBoost })
  const radio = chip.radio()
  await radio.configure({ frequencyHz: channel, link: dr3, outputDbm: rfm95w.outputDbm })
  const tuned = chip.tuning()
  const off = Math.abs(channel - tuned.frequencyHz)
  console.log(
    `rfm95w    ${tuned.outputDbm} dBm on PA_BOOST, carrier ${tuned.frequencyHz} Hz, ` +
      `${off} Hz from ${channel}`,
  )

  // The SX1276 gives a packet's strength in whole decibels, and works out the strength of
  // the signal itself from the SNR when it arrived under the noise.
  chip.hear(Buffer.from('ack'), -109, -2.5)
  const heard = await radio.receive(1_000_000)
  if (heard.outcome === 'Frame') {
    console.log(
      `received  RSSI ${heard.rssiDbm!.toFixed(2)} dBm, SNR ${heard.snrDb!.toFixed(2)} dB, ` +
        `signal ${heard.signalRssiDbm!.toFixed(2)} dBm`,
    )
  }
  radio.close()

  // An LLCC68 in the RFM95W's place could carry DR3, but not DR2, which is SF10 at 125 kHz.
  const carries = (dataRate: number): string =>
    sx126x.llcc68Supports(band.linkSettings(dataRate)!) ? 'carries' : 'cannot carry'
  console.log(`llcc68    ${carries(3)} DR3 and ${carries(2)} DR2`)
  return { rfm95w, tuned, channel, carries }
}

import { LoraRadio } from '@pamoja/radios'

async function onALinuxBoard(): Promise<void> {
  // An RFM95W on a Raspberry Pi: the header's first chip select, with the module's reset pin
  // on GPIO25. The SX1276 family has no BUSY line, so the wiring names none.
  const wiring = { spi: '/dev/spidev0.0', gpioChip: '/dev/gpiochip0', resetLine: 25 }
  console.log(`radio     an RFM95W on ${wiring.spi}, reset on GPIO${wiring.resetLine}`)

  // The channel and the power the same whip leaves under the same ceiling, now as the number
  // the radio is set to rather than the registers it goes into.
  const band = planFor(LoraRegion.Eu868)
  const channel = 868_100_000
  const dr3 = band.linkSettings(3)!
  const antenna = linkBudget({ transmitAntennaGainDbi: 2.15, transmitCableLossDb: 0.5 })
  const ceiling = band.maxEirpDbm(channel)
  const rfm95w = sx127x.txPowerUnderCeiling(sx127x.PaOutput.PaBoost, antenna, ceiling)
  console.log(`plan      ${channel} Hz at DR3, ${rfm95w.outputDbm} dBm on PA_BOOST`)

  // Opening resets the chip and reads its version back, so a wiring mistake is caught here
  // rather than on the first frame. With no radio wired, this is the line that prints.
  let radio
  try {
    radio = LoraRadio.openSx127x(wiring, { output: sx127x.PaOutput.PaBoost })
  } catch {
    console.log('absent    no radio answered, so nothing went out')
    return
  }
  try {
    await radio.configure({ frequencyHz: channel, link: dr3, outputDbm: rfm95w.outputDbm })
    const airtimeUs = await radio.transmit(Buffer.from('21.5'))
    console.log(`sent      a reading in ${airtimeUs} us on air`)
  } finally {
    radio.close()
  }
}

from pamoja.lora import LinkBudget, plan_for
from pamoja.radios import DutyCycle, SimulatedLoraChip, sx126x

# An SX1262 node sends a ten-byte reading on 868.1 MHz at DR3, SF9 at 125 kHz, through a
# 2.15 dBi whip on half a decibel of pigtail. The plan caps the EIRP there, and the antenna
# and pigtail decide how hard the amplifier may drive under that cap.
eu868 = plan_for("EU868")
frequency = 868_100_000
link = eu868.link_settings(3)
whip = LinkBudget(transmit_antenna_gain_dbi=2.15, transmit_cable_loss_db=0.5)
ceiling = eu868.max_eirp_dbm(frequency)
power = sx126x.tx_power_under_ceiling(sx126x.Amplifier.HIGH_POWER, whip, ceiling)
print(f"power     {power.setting_dbm} dBm under a {ceiling} dBm EIRP ceiling")

# A simulated SX1262 stands in for the chip on the node's board, driven by the same code that
# drives a real one, and it reports what that code told it.
chip = SimulatedLoraChip.sx126x(sx126x.Amplifier.HIGH_POWER)
bench = chip.radio()
bench.configure(frequency, link, power.setting_dbm)
tuned = chip.tuning()
print(
    f"tuned     {tuned.frequency_hz / 1e6:.1f} MHz, SF{tuned.link.spreading_factor} "
    f"at {tuned.link.bandwidth_hz // 1000} kHz, {tuned.output_dbm} dBm"
)

# The reading goes out, and the airtime comes back for the duty-cycle guard. The sub-band that
# holds 868.1 MHz allows 1% of the time, so the frame buys ninety-nine times as long in silence
# before the next.
reading = b"level=0.42"
airtime = bench.transmit(reading)
print(f"sent      {len(chip.sent()[0].payload)} bytes, {airtime} us on air")
guard = DutyCycle(eu868.duty_cycle_permille(frequency))
guard.transmitted(0, link, len(reading))
print(f"silence   the next frame starts {guard.wait_us(0)} us after this one did")

# A gateway's answer arrives from the edge of range, 2.5 dB under the noise.
chip.hear(b"ack", -109, -2.5)
heard = bench.receive(1_000_000)
if heard.outcome == "Frame":
    print(
        f"received  {heard.payload.decode()} at {heard.rssi_dbm:.2f} dBm, "
        f"SNR {heard.snr_db:.2f} dB"
    )

# With nothing on the air the reception times out, and a frame whose CRC fails is dropped
# rather than handed over.
quiet = bench.receive(1_000_000).outcome
chip.hear_corrupt(-121, -12)
broken = bench.receive(1_000_000).outcome
print(f"then      {quiet}, then {broken}")
bench.close()

from pamoja.lora import LinkBudget, plan_for
from pamoja.radios import SimulatedLoraChip, sx126x, sx127x

# An RFM95W wires the SX1276's PA_BOOST amplifier to its antenna. The same whip and the same
# 16 dBm ceiling leave it the same 14 dBm.
band = plan_for("EU868")
channel = 868_100_000
dr3 = band.link_settings(3)
antenna = LinkBudget(transmit_antenna_gain_dbi=2.15, transmit_cable_loss_db=0.5)
rfm95w = sx127x.tx_power_under_ceiling(
    sx127x.PaOutput.PA_BOOST, antenna, band.max_eirp_dbm(channel)
)

# The same driver calls tune it, through registers this time. Its synthesizer steps in 61 Hz,
# so the carrier lands on the step nearest the one asked for.
module = SimulatedLoraChip.sx127x(sx127x.PaOutput.PA_BOOST)
radio = module.radio()
radio.configure(channel, dr3, rfm95w.output_dbm)
carrier = module.tuning()
print(
    f"rfm95w    {carrier.output_dbm} dBm on PA_BOOST, carrier {carrier.frequency_hz} Hz, "
    f"{abs(channel - carrier.frequency_hz)} Hz from {channel}"
)

# The SX1276 gives a packet's strength in whole decibels, and works out the strength of the
# signal itself from the SNR when it arrived under the noise.
module.hear(b"ack", -109, -2.5)
packet = radio.receive(1_000_000)
if packet.outcome == "Frame":
    print(
        f"received  RSSI {packet.rssi_dbm:.2f} dBm, SNR {packet.snr_db:.2f} dB, "
        f"signal {packet.signal_rssi_dbm:.2f} dBm"
    )
radio.close()


def carries(data_rate: int) -> str:
    """Whether an LLCC68 in the RFM95W's place could carry a data rate: DR3, but not DR2,
    which is SF10 at 125 kHz."""
    return "carries" if sx126x.llcc68_supports(band.link_settings(data_rate)) else "cannot carry"


print(f"llcc68    {carries(3)} DR3 and {carries(2)} DR2")

from pamoja.core import PamojaError
from pamoja.radios import LoraRadio

# An RFM95W on a Raspberry Pi: the header's first chip select, with the module's reset pin on
# GPIO25. The SX1276 family has no BUSY line, so the wiring names none.
spi, gpio_chip, reset_line = "/dev/spidev0.0", "/dev/gpiochip0", 25
print(f"radio     an RFM95W on {spi}, reset on GPIO{reset_line}")
print(f"plan      {channel} Hz at DR3, {rfm95w.output_dbm} dBm on PA_BOOST")

# Opening resets the chip and reads its version back, so a wiring mistake is caught here rather
# than on the first frame. With no radio wired, this is the line that prints.
try:
    radio = LoraRadio.open_sx127x(spi, gpio_chip, reset_line, sx127x.PaOutput.PA_BOOST)
except PamojaError:
    radio = None

if radio is None:
    print("absent    no radio answered, so nothing went out")
else:
    with radio:
        radio.configure(channel, dr3, rfm95w.output_dbm)
        airtime_us = radio.transmit(b"21.5")
        print(f"sent      a reading in {airtime_us} us on air")

// An SX1262 node sends a ten-byte reading on 868.1 MHz at DR3, SF9 at 125 kHz,
// through a 2.15 dBi whip on half a decibel of pigtail. The plan caps the EIRP
// there, and the antenna and pigtail decide how hard the amplifier may drive
// under that cap.
using LoraChannelPlan eu868 = LoraChannelPlan.ForRegion(LoraRegion.Eu868);
const uint Frequency = 868_100_000;
LoraLink link = eu868.LinkSettings(3)!;
var whip = new LoraLinkBudget { TransmitAntennaGainDbi = 2.15, TransmitCableLossDb = 0.5 };
sbyte ceiling = eu868.MaxEirpDbm(Frequency);
Sx126xTxPower power = Sx126x.TxPowerUnderCeiling(Sx126xAmplifier.HighPower, whip, ceiling);
Console.WriteLine($"power     {power.SettingDbm} dBm under a {ceiling} dBm EIRP ceiling");

// A simulated SX1262 stands in for the chip on the node's board, driven by the same
// code that drives a real one, and it reports what that code told it.
using SimulatedLoraChip chip = SimulatedLoraChip.Sx126x(new Sx126xBoard(Sx126xAmplifier.HighPower));
using LoraRadio bench = chip.Radio();
bench.Configure(new LoraRadioConfig(Frequency, link, power.SettingDbm));
LoraTuning tuned = chip.Tuning();
Console.WriteLine(Invariant(
    $"tuned     {tuned.FrequencyHz / 1e6:F1} MHz, SF{tuned.Link.SpreadingFactor} at {tuned.Link.BandwidthHz / 1000} kHz, {tuned.OutputDbm} dBm"));

// The reading goes out, and the airtime comes back for the duty-cycle guard. The
// sub-band that holds 868.1 MHz allows 1% of the time, so the frame buys ninety-nine
// times as long in silence before the next.
byte[] reading = "level=0.42"u8.ToArray();
ulong airtime = bench.Transmit(reading);
Console.WriteLine($"sent      {chip.Sent()[0].Payload.Length} bytes, {airtime} us on air");
using var guard = new RadioDutyCycle(eu868.DutyCyclePermille(Frequency)!.Value);
guard.Transmitted(0, link, reading.Length);
Console.WriteLine($"silence   the next frame starts {guard.WaitMicros(0)} us after this one did");

// A gateway's answer arrives from the edge of range, 2.5 dB under the noise.
chip.Hear("ack"u8, -109, -2.5);
LoraReception heard = bench.Receive(TimeSpan.FromSeconds(1));
if (heard.Outcome == LoraReceptionOutcome.Frame)
{
    Console.WriteLine(Invariant(
        $"received  {Encoding.UTF8.GetString(heard.Payload!)} at {heard.RssiDbm:F2} dBm, SNR {heard.SnrDb:F2} dB"));
}

// With nothing on the air the reception times out, and a frame whose CRC fails is
// dropped rather than handed over.
LoraReceptionOutcome quiet = bench.Receive(TimeSpan.FromSeconds(1)).Outcome;
chip.HearCorrupt(-121, -12);
LoraReceptionOutcome broken = bench.Receive(TimeSpan.FromSeconds(1)).Outcome;
Console.WriteLine($"then      {quiet}, then {broken}");

// An RFM95W wires the SX1276's PA_BOOST amplifier to its antenna. The same whip and
// the same 16 dBm ceiling leave it the same 14 dBm.
using LoraChannelPlan band = LoraChannelPlan.ForRegion(LoraRegion.Eu868);
const uint Channel = 868_100_000;
LoraLink dr3 = band.LinkSettings(3)!;
var antenna = new LoraLinkBudget { TransmitAntennaGainDbi = 2.15, TransmitCableLossDb = 0.5 };
Sx127xTxPower rfm95w = Sx127x.TxPowerUnderCeiling(
    Sx127xPaOutput.PaBoost, antenna, band.MaxEirpDbm(Channel));

// The same driver calls tune it, through registers this time. Its synthesizer steps
// in 61 Hz, so the carrier lands on the step nearest the one asked for.
using SimulatedLoraChip module = SimulatedLoraChip.Sx127x(new Sx127xBoard(Sx127xPaOutput.PaBoost));
using LoraRadio radio = module.Radio();
radio.Configure(new LoraRadioConfig(Channel, dr3, rfm95w.OutputDbm));
LoraTuning carrier = module.Tuning();
uint off = carrier.FrequencyHz > Channel ? carrier.FrequencyHz - Channel : Channel - carrier.FrequencyHz;
Console.WriteLine(
    $"rfm95w    {carrier.OutputDbm} dBm on PA_BOOST, carrier {carrier.FrequencyHz} Hz, {off} Hz from {Channel}");

// The SX1276 gives a packet's strength in whole decibels, and works out the strength
// of the signal itself from the SNR when it arrived under the noise.
module.Hear("ack"u8, -109, -2.5);
LoraReception packet = radio.Receive(TimeSpan.FromSeconds(1));
if (packet.Outcome == LoraReceptionOutcome.Frame)
{
    Console.WriteLine(Invariant(
        $"received  RSSI {packet.RssiDbm:F2} dBm, SNR {packet.SnrDb:F2} dB, signal {packet.SignalRssiDbm:F2} dBm"));
}

// An LLCC68 in the RFM95W's place could carry DR3, but not DR2, which is SF10 at 125 kHz.
string Carries(byte dataRate) =>
    Sx126x.Llcc68Supports(band.LinkSettings(dataRate)!) ? "carries" : "cannot carry";
Console.WriteLine($"llcc68    {Carries(3)} DR3 and {Carries(2)} DR2");

// An RFM95W on a Raspberry Pi: the header's first chip select, with the module's
// reset pin on GPIO25. The SX1276 family has no BUSY line, so the wiring names none.
var wiring = new LoraRadioWiring("/dev/spidev0.0", "/dev/gpiochip0", 25);
Console.WriteLine($"radio     an RFM95W on {wiring.Spi}, reset on GPIO{wiring.ResetLine}");

// The channel and the power the same whip leaves under the same ceiling, now as the
// number the radio is set to rather than the registers it goes into.
using LoraChannelPlan band = LoraChannelPlan.ForRegion(LoraRegion.Eu868);
const uint Channel = 868_100_000;
LoraLink dr3 = band.LinkSettings(3)!;
var antenna = new LoraLinkBudget { TransmitAntennaGainDbi = 2.15, TransmitCableLossDb = 0.5 };
Sx127xTxPower rfm95w = Sx127x.TxPowerUnderCeiling(
    Sx127xPaOutput.PaBoost, antenna, band.MaxEirpDbm(Channel));
Console.WriteLine($"plan      {Channel} Hz at DR3, {rfm95w.OutputDbm} dBm on PA_BOOST");

// Opening resets the chip and reads its version back, so a wiring mistake is caught
// here rather than on the first frame. With no radio wired, this line prints.
LoraRadio? radio = null;
try
{
    radio = LoraRadio.OpenSx127x(wiring, new Sx127xBoard(Sx127xPaOutput.PaBoost));
}
catch (PlatformNotSupportedException)
{
}
catch (PamojaException)
{
}

if (radio is null)
{
    Console.WriteLine("absent    no radio answered, so nothing went out");
    return;
}

using (radio)
{
    radio.Configure(new LoraRadioConfig(Channel, dr3, rfm95w.OutputDbm));
    ulong airtimeUs = radio.Transmit("21.5"u8);
    Console.WriteLine($"sent      a reading in {airtimeUs} us on air");
}