Simulators#

use pamoja_core::{Actuator, Sensor, Transport};
use pamoja_kit::Twist;
use pamoja_loopback::{LoopbackBroker, LoopbackTransport};
use pamoja_sim::{DegradedLink, RecordingActuator, Replay, SimRobot, SimSensor};

// The clear distance ahead, in meters, replayed from an earlier survey of the row,
// so every run sees the same row.
let mut ahead = Replay::new(vec![4.0, 3.0, 1.5, 0.5]);
// The drive keeps the commands it is given instead of turning a motor.
let mut drive = RecordingActuator::new();
let told = drive.log();
// The rover's pose comes from integrating each command over half a second.
let dt = 0.5;
let mut rover = SimRobot::new(dt);
// The soil probe reads around 31 percent, drying half a point a reading, with a
// wobble drawn from a seed, so the same seed gives the same readings every run.
let mut soil = SimSensor::new(31.0)
    .with_drift(-0.5)
    .with_noise(0.3)
    .with_seed(7);
// The radio loses every third report on its way to the base.
let mut radio = DegradedLink::new(LoopbackTransport::new(LoopbackBroker::new())).drop_every(3);
radio.connect().await?;

let mut moisture = Vec::new();
let mut delivered = 0;
loop {
    // A replay that has handed back every reading reports that it is closed.
    let clear = match ahead.read().await {
        Ok(clear) => clear,
        Err(error) => {
            println!(
                "ahead     ran out after {} readings: {error}",
                moisture.len()
            );
            break;
        }
    };
    let (speed, turn) = if clear > 1.0 { (1.0, 0.0) } else { (0.0, 1.0) };
    drive.apply(speed).await?;
    rover.apply(Twist::planar(speed, turn)).await?;
    let wet = soil.read().await?;
    let elapsed = moisture.len() as f32 * dt;
    moisture.push(wet);
    let report = format!("{wet:.1}");
    if radio
        .send_text("vineyard/row-4/soil", &report)
        .await
        .is_ok()
    {
        delivered += 1;
    }
    println!("{elapsed:.1} s     {clear:.1} m clear: drive {speed:.1}, turn {turn:.1}, soil {report}");
}

// The drive kept every command, which is how a test says what the loop decided
// rather than only what it ended up doing.
let commands: Vec<String> = told.commands().iter().map(|c| format!("{c:.1}")).collect();
println!("drive     recorded {}", commands.join(", "));

// Three half-second commands at 1 m/s reach 1.5 m along x. The last turns on the
// spot at 1 rad/s for half a second, which moves the rover nowhere.
let pose = rover.pose();
println!(
    "rover     ended at x {:.1} m, y {:.1} m, heading {:.1} rad",
    pose.x, pose.y, pose.theta
);

// A second probe with the same seed reads exactly the same values.
let mut twin = SimSensor::new(31.0)
    .with_drift(-0.5)
    .with_noise(0.3)
    .with_seed(7);
let mut again = Vec::new();
for _ in 0..moisture.len() {
    again.push(twin.read().await?);
}
let verdict = if again == moisture {
    "the same"
} else {
    "different"
};
println!(
    "soil      a probe with the same seed read {verdict} {} values",
    again.len()
);
println!(
    "radio     delivered {delivered} of {} soil reports and lost the third",
    moisture.len()
);

import { Transport } from '@pamoja/core'
import { LoopbackBroker } from '@pamoja/loopback'
import { RecordingActuator, Replay, SimulatedRobot, SimulatedSensor } from '@pamoja/sim'

async function main() {
  // The clear distance ahead, in meters, replayed from an earlier survey of the row, so
  // every run sees the same row.
  const ahead = new Replay([4, 3, 1.5, 0.5])
  // The drive keeps the commands it is given instead of turning a motor.
  const drive = new RecordingActuator()
  // The rover's pose comes from integrating each command over half a second.
  const dt = 0.5
  const rover = new SimulatedRobot(dt)
  // The soil probe reads around 31 percent, drying half a point a reading, with a wobble
  // drawn from a seed, so the same seed gives the same readings every run.
  const soil = new SimulatedSensor(31, -0.5, 0.3, 7)
  // The radio loses every third report on its way to the base.
  const radio = Transport.degraded(new LoopbackBroker().rung(), { dropEvery: 3 })
  await radio.connect()

  const moisture: number[] = []
  let delivered = 0
  for (;;) {
    // A replay that has handed back every reading reports that it is closed.
    let clear: number
    try {
      clear = await ahead.read()
    } catch (error) {
      console.log(`ahead     ran out after ${moisture.length} readings: ${(error as Error).message}`)
      break
    }
    const [speed, turn] = clear > 1 ? [1, 0] : [0, 1]
    await drive.apply(speed)
    await rover.apply({ vx: speed, vy: 0, omega: turn })
    const wet = await soil.read()
    const elapsed = moisture.length * dt
    moisture.push(wet)
    const report = wet.toFixed(1)
    const sent = await radio.send('vineyard/row-4/soil', report).then(
      () => true,
      () => false,
    )
    if (sent) delivered += 1
    console.log(
      `${elapsed.toFixed(1)} s     ${clear.toFixed(1)} m clear:` +
        ` drive ${speed.toFixed(1)}, turn ${turn.toFixed(1)}, soil ${report}`,
    )
  }

  // The drive kept every command, which is how a test says what the loop decided rather
  // than only what it ended up doing.
  const commands = await drive.commands()
  console.log(`drive     recorded ${commands.map((command) => command.toFixed(1)).join(', ')}`)

  // Three half-second commands at 1 m/s reach 1.5 m along x. The last turns on the spot
  // at 1 rad/s for half a second, which moves the rover nowhere.
  const pose = await rover.pose()
  console.log(
    `rover     ended at x ${pose.x.toFixed(1)} m, y ${pose.y.toFixed(1)} m,` +
      ` heading ${pose.theta.toFixed(1)} rad`,
  )

  // A second probe with the same seed reads exactly the same values.
  const twin = new SimulatedSensor(31, -0.5, 0.3, 7)
  const again: number[] = []
  for (let read = 0; read < moisture.length; read += 1) {
    again.push(await twin.read())
  }
  const same = again.every((value, index) => value === moisture[index])
  console.log(`soil      a probe with the same seed read ${same ? 'the same' : 'different'} ${again.length} values`)
  console.log(`radio     delivered ${delivered} of ${moisture.length} soil reports and lost the third`)

  return { commands, pose, same, delivered }
}

main()

import asyncio

from pamoja.core import PamojaError, Transport
from pamoja.loopback import LoopbackBroker
from pamoja.sim import RecordingActuator, Replay, SimulatedRobot, SimulatedSensor


async def main() -> None:
    # The clear distance ahead, in meters, replayed from an earlier survey of the row,
    # so every run sees the same row.
    ahead = Replay([4.0, 3.0, 1.5, 0.5])
    # The drive keeps the commands it is given instead of turning a motor.
    drive = RecordingActuator()
    # The rover's pose comes from integrating each command over half a second.
    dt = 0.5
    rover = SimulatedRobot(dt)
    # The soil probe reads around 31 percent, drying half a point a reading, with a
    # wobble drawn from a seed, so the same seed gives the same readings every run.
    soil = SimulatedSensor(31.0, drift_per_read=-0.5, noise=0.3, seed=7)
    # The radio loses every third report on its way to the base.
    radio = Transport.degraded(LoopbackBroker().rung(), drop_every=3)
    await radio.connect()

    moisture = []
    delivered = 0
    while True:
        # A replay that has handed back every reading reports that it is closed.
        try:
            clear = await ahead.read()
        except PamojaError as error:
            print(f"ahead     ran out after {len(moisture)} readings: {error}")
            break
        speed, turn = (1.0, 0.0) if clear > 1.0 else (0.0, 1.0)
        await drive.apply(speed)
        await rover.apply(vx=speed, omega=turn)
        wet = await soil.read()
        elapsed = len(moisture) * dt
        moisture.append(wet)
        report = f"{wet:.1f}"
        try:
            await radio.send("vineyard/row-4/soil", report)
            delivered += 1
        except PamojaError:
            pass
        print(
            f"{elapsed:.1f} s     {clear:.1f} m clear:"
            f" drive {speed:.1f}, turn {turn:.1f}, soil {report}"
        )

    # The drive kept every command, which is how a test says what the loop decided
    # rather than only what it ended up doing.
    commands = await drive.commands()
    print(f"drive     recorded {', '.join(f'{command:.1f}' for command in commands)}")

    # Three half-second commands at 1 m/s reach 1.5 m along x. The last turns on the
    # spot at 1 rad/s for half a second, which moves the rover nowhere.
    pose = await rover.pose()
    print(f"rover     ended at x {pose.x:.1f} m, y {pose.y:.1f} m, heading {pose.theta:.1f} rad")

    # A second probe with the same seed reads exactly the same values.
    twin = SimulatedSensor(31.0, drift_per_read=-0.5, noise=0.3, seed=7)
    again = [await twin.read() for _ in moisture]
    verdict = "the same" if again == moisture else "different"
    print(f"soil      a probe with the same seed read {verdict} {len(again)} values")
    print(f"radio     delivered {delivered} of {len(moisture)} soil reports and lost the third")

    return commands, pose, again == moisture, delivered


commands, pose, same, delivered = asyncio.run(main())

// The clear distance ahead, in meters, replayed from an earlier survey of the
// row, so every run sees the same row.
using var ahead = new Replay([4.0f, 3.0f, 1.5f, 0.5f]);
// The drive keeps the commands it is given instead of turning a motor.
using var drive = new RecordingActuator();
// The rover's pose comes from integrating each command over half a second.
const float Dt = 0.5f;
using var rover = new SimulatedRobot(Dt);
// The soil probe reads around 31 percent, drying half a point a reading, with a
// wobble drawn from a seed, so the same seed gives the same readings every run.
using var soil = new SimulatedSensor(31.0f, -0.5f, 0.3f, 7);
// The radio loses every third report on its way to the base.
using var station = new LoopbackBroker();
using Transport radio = Transport.Degraded(station.Rung(), dropEvery: 3);
await radio.ConnectAsync();

List<float> moisture = [];
int delivered = 0;
while (true)
{
    // A replay that has handed back every reading reports that it is closed.
    float clear;
    try
    {
        clear = await ahead.ReadAsync();
    }
    catch (PamojaException error)
    {
        Console.WriteLine($"ahead     ran out after {moisture.Count} readings: {error.Message}");
        break;
    }

    (float speed, float turn) = clear > 1.0f ? (1.0f, 0.0f) : (0.0f, 1.0f);
    await drive.ApplyAsync(speed);
    await rover.ApplyAsync(new Twist(speed, Omega: turn));
    float wet = await soil.ReadAsync();
    float elapsed = moisture.Count * Dt;
    moisture.Add(wet);
    string report = Tenths(wet);
    try
    {
        await radio.SendAsync("vineyard/row-4/soil", report);
        delivered++;
    }
    catch (PamojaException)
    {
    }

    Console.WriteLine(
        $"{Tenths(elapsed)} s     {Tenths(clear)} m clear:"
        + $" drive {Tenths(speed)}, turn {Tenths(turn)}, soil {report}");
}

// The drive kept every command, which is how a test says what the loop decided
// rather than only what it ended up doing.
Console.WriteLine($"drive     recorded {string.Join(", ", drive.Commands.Select(Tenths))}");

// Three half-second commands at 1 m/s reach 1.5 m along x. The last turns on
// the spot at 1 rad/s for half a second, which moves the rover nowhere.
Pose pose = rover.Pose;
Console.WriteLine(
    $"rover     ended at x {Tenths(pose.X)} m, y {Tenths(pose.Y)} m, heading {Tenths(pose.Theta)} rad");

// A second probe with the same seed reads exactly the same values.
using var twin = new SimulatedSensor(31.0f, -0.5f, 0.3f, 7);
List<float> again = [];
foreach (float _ in moisture)
{
    again.Add(await twin.ReadAsync());
}

string verdict = again.SequenceEqual(moisture) ? "the same" : "different";
Console.WriteLine($"soil      a probe with the same seed read {verdict} {again.Count} values");
Console.WriteLine($"radio     delivered {delivered} of {moisture.Count} soil reports and lost the third");