Struct WirelessModemFake

pub struct WirelessModemFake { /* private fields */ }

Implementations

impl WirelessModemFake

pub fn new(name: &str) -> Self

Examples found in repository

examples/embedded_nano_mesh.rs (line 16)

fn main() {
    /* Create simulator, ether, and devices registered in that ether. */
    let mut simulator = NetworkSimulator::new(1);

    simulator.create_ether("1");
    simulator.create_ether("2");

    let mut driver_1 = WirelessModemFake::new("1");
    let mut driver_2 = WirelessModemFake::new("2");
    let mut driver_3 = WirelessModemFake::new("3");

    {
        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
        ether_1.register_driver(driver_1.clone());
        ether_1.register_driver(driver_2.clone());
    }
    {
        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
        ether_2.register_driver(driver_2.clone());
        ether_2.register_driver(driver_3.clone());
    }

    /* Create tested nodes. */
    let mut mesh_node_1 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(1).unwrap(),
        listen_period: NODE_LISTEN_PERIOD,
    });

    let mut mesh_node_2 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(2).unwrap(),
        listen_period: NODE_LISTEN_PERIOD,
    });

    let mut mesh_node_3 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(3).unwrap(),
        listen_period: NODE_LISTEN_PERIOD,
    });

    /* Do testing scenario */
    let _ = mesh_node_1.send_to_exact(
        NodeString::try_from(MESSAGE)
            .expect("Fail to pack message")
            .into_bytes(),
        ExactAddressType::try_from(3).expect("3 is 0"),
        2 as LifeTimeType,
        false,
    );

    simulator.start_simulation_thread();

    let start_time = Instant::now();

    loop {
        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;

        let _ = mesh_node_1.update(&mut driver_1, current_time);
        let _ = mesh_node_2.update(&mut driver_2, current_time);
        let _ = mesh_node_3.update(&mut driver_3, current_time);

        if current_time >= 200 {
            panic!("Simulation timeout");
        }

        if let Some(packet) = mesh_node_3.receive() {
            let got_message = NodeString::from_iter(packet.data.iter().map(|b| *b as char));
            if got_message.starts_with(MESSAGE) {
                break;
            }
        }
    }

    simulator.stop_simulation_thread();

    println!("Simulation done");
}

pub fn read(&self, buf: &mut [u8]) -> Result<usize, Infallible>

pub fn write(&self, buf: &[u8]) -> Result<usize, Infallible>

pub fn flush(&self) -> Result<(), Infallible>

pub fn clone(&self) -> Self

Examples found in repository

examples/embedded_nano_mesh.rs (line 22)

fn main() {
    /* Create simulator, ether, and devices registered in that ether. */
    let mut simulator = NetworkSimulator::new(1);

    simulator.create_ether("1");
    simulator.create_ether("2");

    let mut driver_1 = WirelessModemFake::new("1");
    let mut driver_2 = WirelessModemFake::new("2");
    let mut driver_3 = WirelessModemFake::new("3");

    {
        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
        ether_1.register_driver(driver_1.clone());
        ether_1.register_driver(driver_2.clone());
    }
    {
        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
        ether_2.register_driver(driver_2.clone());
        ether_2.register_driver(driver_3.clone());
    }

    /* Create tested nodes. */
    let mut mesh_node_1 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(1).unwrap(),
        listen_period: NODE_LISTEN_PERIOD,
    });

    let mut mesh_node_2 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(2).unwrap(),
        listen_period: NODE_LISTEN_PERIOD,
    });

    let mut mesh_node_3 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(3).unwrap(),
        listen_period: NODE_LISTEN_PERIOD,
    });

    /* Do testing scenario */
    let _ = mesh_node_1.send_to_exact(
        NodeString::try_from(MESSAGE)
            .expect("Fail to pack message")
            .into_bytes(),
        ExactAddressType::try_from(3).expect("3 is 0"),
        2 as LifeTimeType,
        false,
    );

    simulator.start_simulation_thread();

    let start_time = Instant::now();

    loop {
        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;

        let _ = mesh_node_1.update(&mut driver_1, current_time);
        let _ = mesh_node_2.update(&mut driver_2, current_time);
        let _ = mesh_node_3.update(&mut driver_3, current_time);

        if current_time >= 200 {
            panic!("Simulation timeout");
        }

        if let Some(packet) = mesh_node_3.receive() {
            let got_message = NodeString::from_iter(packet.data.iter().map(|b| *b as char));
            if got_message.starts_with(MESSAGE) {
                break;
            }
        }
    }

    simulator.stop_simulation_thread();

    println!("Simulation done");
}

Trait Implementations

impl ErrorType for WirelessModemFake

type Error = Infallible

Error type of all the IO operations on this type.

impl IODriverSimulator for WirelessModemFake

fn get_from_device_network_side(&self) -> Option<u8>

Simulates that the modem emits a byte towards the ether

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;

let device = WirelessModemFake::new("my_modem");
device.start_tick();
assert_eq!(device.get_from_device_network_side(), None);
device.end_tick();

device.put_to_rx_pin(1);

device.start_tick();
assert_eq!(device.get_from_device_network_side(), Some(1));
device.end_tick();

fn put_to_device_network_side(&self, byte: u8)

Simulates that the modem caught a byte from the ether

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;

let device = WirelessModemFake::new("my_modem");
assert_eq!(device.get_from_tx_pin(), None);
device.start_tick();
device.put_to_device_network_side(1);
device.end_tick();
assert_eq!(device.get_from_tx_pin(), Some(1));

fn get_from_tx_pin(&self) -> Option<u8>

Reads a byte on the TX pin

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;

let device = WirelessModemFake::new("my_modem");
assert_eq!(device.get_from_tx_pin(), None);
device.start_tick();
device.put_to_device_network_side(1);
device.end_tick();
assert_eq!(device.get_from_tx_pin(), Some(1));

fn put_to_rx_pin(&self, byte: u8)

Writes a byte on the RX pin

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;

let device = WirelessModemFake::new("my_modem");
device.put_to_rx_pin(1);
device.start_tick();
assert_eq!(device.get_from_device_network_side(), Some(1));
device.end_tick();

fn start_tick(&self)

Tick is needed only for simulating time during which ineraction with the ether is going. Other operations like put to pin or get from pin can be done not in tick.

fn end_tick(&self)

Tick is needed only for simulating time during which ineraction with the ether is going. Other operations like put to pin or get from pin can be done not in tick.

fn readable(&self) -> bool

Tells if the device has some bytes to be red from pin

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;
let mut device = WirelessModemFake::new("");
assert!(
!device.readable());
device.start_tick();
device.put_to_device_network_side(1);
device.end_tick();
assert!(device.readable());

fn writable(&self) -> bool

Tells if the device is ready to be written in

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;
assert!(WirelessModemFake::new("").writable());

fn get_name(&self) -> &str

Returns the name of the device

use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;
let device = WirelessModemFake::new("my_modem");
assert_eq!(device.get_name(), "my_modem");

impl Read for WirelessModemFake

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl ReadReady for WirelessModemFake

fn read_ready(&mut self) -> Result<bool, Self::Error>

Get whether the reader is ready for immediately reading.

impl Write for WirelessModemFake

fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.