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 network_simulator::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 network_simulator::EtherSimulator;
use network_simulator::WirelessModemFake;
use network_simulator::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 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");
}

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

Unregisters a device

use network_simulator::EtherSimulator;
use network_simulator::WirelessModemFake;
use network_simulator::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 network_simulator::EtherSimulator;
use network_simulator::WirelessModemFake;
use network_simulator::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(&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 network_simulator::EtherSimulator;
use network_simulator::WirelessModemFake;
use network_simulator::IODriverSimulator;

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

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