Struct EtherSimulator 

pub struct EtherSimulator { /* private fields */ }

Implementations

impl EtherSimulator

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

pub fn get_name(&self) -> &str

Gets the name of the ether

use proto_lab::EtherSimulator;
let mut ether = EtherSimulator::new("my_ether");
assert_eq!(ether.get_name(), "my_ether");

pub fn register_driver(&mut self, driver: WirelessModemFake)

Registers a new device (driver / modem)

use proto_lab::EtherSimulator;
use proto_lab::WirelessModemFake;
use proto_lab::IODriverSimulator;

let mut ether = EtherSimulator::new("my_ether");
ether.register_driver(WirelessModemFake::new("my_modem"));
assert_eq!(ether.get_driver("my_modem").unwrap().get_name(), "my_modem");

Examples found in repository

examples/embedded_nano_mesh.rs (line 20)

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

    simulator.create_ether("1");

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

    {
        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());
    }

    /* Create tested nodes. */
    let mut mesh_node_1 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(1).expect("1 equals to 0"),
        listen_period: NODE_1_LISTEN_PERIOD,
    });

    let mut mesh_node_2 = Node::new(NodeConfig {
        device_address: ExactAddressType::try_from(2).expect("2 equals to 0"),
        listen_period: NODE_2_LISTEN_PERIOD,
    });

    /* Do testing scenario */
    let _ = mesh_node_1.send_to_exact(
        NodeString::try_from("Message from node 1")
            .expect("Fail to pack message")
            .into_bytes(),
        ExactAddressType::try_from(2).expect("2 is 0"),
        2.into(),
        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);

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

        if let Some(_packet) = mesh_node_2.receive() {
            break;
        }
    }

    simulator.stop_simulation_thread();

    println!("Simulation done");
}

pub fn unregister_driver(&mut self, name: &str)

Unregisters a device

use proto_lab::EtherSimulator;
use proto_lab::WirelessModemFake;
use proto_lab::IODriverSimulator;

let mut ether = EtherSimulator::new("my_ether");
ether.register_driver(WirelessModemFake::new("my_modem"));
ether.unregister_driver("my_modem");
assert!(ether.get_driver("my_modem").is_none());

pub fn get_driver(&self, name: &str) -> Option<WirelessModemFake>

Gets a registered device

use proto_lab::EtherSimulator;
use proto_lab::WirelessModemFake;
use proto_lab::IODriverSimulator;

let mut ether = EtherSimulator::new("my_ether");
assert!(ether.get_driver("my_modem").is_none());
ether.register_driver(WirelessModemFake::new("my_modem"));
assert_eq!(ether.get_driver("my_modem").unwrap().get_name(), "my_modem");

pub fn start_tick(&self)

Prepares all the registered devices for starting of simulation during tick.

pub fn end_tick(&self)

Prepares all the registered devices for ending of simulation during tick.

pub fn simulate(&mut self)

This operation shall be called only during tick is active.

pub fn clone(&self) -> EtherSimulator

Clones itself. Also makes all internal data shared to be able to use from multiple threads.

use proto_lab::EtherSimulator;
use proto_lab::WirelessModemFake;
use proto_lab::IODriverSimulator;

let mut ether = EtherSimulator::new("my_ether");
let ether_clone = ether.clone();

assert_eq!(ether.get_name(), ether_clone.get_name());