Struct NetworkSimulator

Source

pub struct NetworkSimulator { /* private fields */ }

Implementations§

Source §

impl NetworkSimulator

NetworkSimulator is designed to simulate the network which consist of 1+ ethers. Each ether is instance of EtherSimulator

Source

pub fn new(ms_per_tick: u64) -> Self

Examples found in repository ?

examples/embedded_nano_mesh.rs (line 12)

10fn main() {
11    /* Create simulator, ether, and devices registered in that ether. */
12    let mut simulator = NetworkSimulator::new(1);
13
14    simulator.create_ether("1");
15    simulator.create_ether("2");
16
17    let mut driver_1 = WirelessModemFake::new("1");
18    let mut driver_2 = WirelessModemFake::new("2");
19    let mut driver_3 = WirelessModemFake::new("3");
20
21    {
22        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
23        ether_1.register_driver(driver_1.clone());
24        ether_1.register_driver(driver_2.clone());
25    }
26    {
27        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
28        ether_2.register_driver(driver_2.clone());
29        ether_2.register_driver(driver_3.clone());
30    }
31
32    /* Create tested nodes. */
33    let mut mesh_node_1 = Node::new(NodeConfig {
34        device_address: ExactAddressType::try_from(1).expect("1 equals to 0"),
35        listen_period: NODE_1_LISTEN_PERIOD,
36    });
37
38    let mut mesh_node_2 = Node::new(NodeConfig {
39        device_address: ExactAddressType::try_from(2).expect("2 equals to 0"),
40        listen_period: NODE_2_LISTEN_PERIOD,
41    });
42
43    let mut mesh_node_3 = Node::new(NodeConfig {
44        device_address: ExactAddressType::try_from(3).expect("3 equals to 0"),
45        listen_period: NODE_3_LISTEN_PERIOD,
46    });
47
48    /* Do testing scenario */
49    let _ = mesh_node_1.send_to_exact(
50        NodeString::try_from("Message from node 1")
51            .expect("Fail to pack message")
52            .into_bytes(),
53        ExactAddressType::try_from(3).expect("3 is 0"),
54        2.into(),
55        false,
56    );
57
58    simulator.start_simulation_thread();
59
60    let start_time = Instant::now();
61    loop {
62        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;
63
64        let _ = mesh_node_1.update(&mut driver_1, current_time);
65        let _ = mesh_node_2.update(&mut driver_2, current_time);
66        let _ = mesh_node_3.update(&mut driver_3, current_time);
67
68        if current_time >= 200 {
69            panic!("Simulation timeout");
70        }
71
72        if let Some(_packet) = mesh_node_3.receive() {
73            break;
74        }
75    }
76
77    simulator.stop_simulation_thread();
78
79    println!("Simulation done");
80}

Source

pub fn create_ether(&self, name: &str)

Examples found in repository ?

examples/embedded_nano_mesh.rs (line 14)

10fn main() {
11    /* Create simulator, ether, and devices registered in that ether. */
12    let mut simulator = NetworkSimulator::new(1);
13
14    simulator.create_ether("1");
15    simulator.create_ether("2");
16
17    let mut driver_1 = WirelessModemFake::new("1");
18    let mut driver_2 = WirelessModemFake::new("2");
19    let mut driver_3 = WirelessModemFake::new("3");
20
21    {
22        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
23        ether_1.register_driver(driver_1.clone());
24        ether_1.register_driver(driver_2.clone());
25    }
26    {
27        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
28        ether_2.register_driver(driver_2.clone());
29        ether_2.register_driver(driver_3.clone());
30    }
31
32    /* Create tested nodes. */
33    let mut mesh_node_1 = Node::new(NodeConfig {
34        device_address: ExactAddressType::try_from(1).expect("1 equals to 0"),
35        listen_period: NODE_1_LISTEN_PERIOD,
36    });
37
38    let mut mesh_node_2 = Node::new(NodeConfig {
39        device_address: ExactAddressType::try_from(2).expect("2 equals to 0"),
40        listen_period: NODE_2_LISTEN_PERIOD,
41    });
42
43    let mut mesh_node_3 = Node::new(NodeConfig {
44        device_address: ExactAddressType::try_from(3).expect("3 equals to 0"),
45        listen_period: NODE_3_LISTEN_PERIOD,
46    });
47
48    /* Do testing scenario */
49    let _ = mesh_node_1.send_to_exact(
50        NodeString::try_from("Message from node 1")
51            .expect("Fail to pack message")
52            .into_bytes(),
53        ExactAddressType::try_from(3).expect("3 is 0"),
54        2.into(),
55        false,
56    );
57
58    simulator.start_simulation_thread();
59
60    let start_time = Instant::now();
61    loop {
62        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;
63
64        let _ = mesh_node_1.update(&mut driver_1, current_time);
65        let _ = mesh_node_2.update(&mut driver_2, current_time);
66        let _ = mesh_node_3.update(&mut driver_3, current_time);
67
68        if current_time >= 200 {
69            panic!("Simulation timeout");
70        }
71
72        if let Some(_packet) = mesh_node_3.receive() {
73            break;
74        }
75    }
76
77    simulator.stop_simulation_thread();
78
79    println!("Simulation done");
80}

Source

pub fn get_ether(&self, name: &str) -> Option<EtherSimulator>

Examples found in repository ?

examples/embedded_nano_mesh.rs (line 22)

10fn main() {
11    /* Create simulator, ether, and devices registered in that ether. */
12    let mut simulator = NetworkSimulator::new(1);
13
14    simulator.create_ether("1");
15    simulator.create_ether("2");
16
17    let mut driver_1 = WirelessModemFake::new("1");
18    let mut driver_2 = WirelessModemFake::new("2");
19    let mut driver_3 = WirelessModemFake::new("3");
20
21    {
22        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
23        ether_1.register_driver(driver_1.clone());
24        ether_1.register_driver(driver_2.clone());
25    }
26    {
27        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
28        ether_2.register_driver(driver_2.clone());
29        ether_2.register_driver(driver_3.clone());
30    }
31
32    /* Create tested nodes. */
33    let mut mesh_node_1 = Node::new(NodeConfig {
34        device_address: ExactAddressType::try_from(1).expect("1 equals to 0"),
35        listen_period: NODE_1_LISTEN_PERIOD,
36    });
37
38    let mut mesh_node_2 = Node::new(NodeConfig {
39        device_address: ExactAddressType::try_from(2).expect("2 equals to 0"),
40        listen_period: NODE_2_LISTEN_PERIOD,
41    });
42
43    let mut mesh_node_3 = Node::new(NodeConfig {
44        device_address: ExactAddressType::try_from(3).expect("3 equals to 0"),
45        listen_period: NODE_3_LISTEN_PERIOD,
46    });
47
48    /* Do testing scenario */
49    let _ = mesh_node_1.send_to_exact(
50        NodeString::try_from("Message from node 1")
51            .expect("Fail to pack message")
52            .into_bytes(),
53        ExactAddressType::try_from(3).expect("3 is 0"),
54        2.into(),
55        false,
56    );
57
58    simulator.start_simulation_thread();
59
60    let start_time = Instant::now();
61    loop {
62        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;
63
64        let _ = mesh_node_1.update(&mut driver_1, current_time);
65        let _ = mesh_node_2.update(&mut driver_2, current_time);
66        let _ = mesh_node_3.update(&mut driver_3, current_time);
67
68        if current_time >= 200 {
69            panic!("Simulation timeout");
70        }
71
72        if let Some(_packet) = mesh_node_3.receive() {
73            break;
74        }
75    }
76
77    simulator.stop_simulation_thread();
78
79    println!("Simulation done");
80}

Source

pub fn start_simulation_thread(&mut self)

Examples found in repository ?

examples/embedded_nano_mesh.rs (line 58)

10fn main() {
11    /* Create simulator, ether, and devices registered in that ether. */
12    let mut simulator = NetworkSimulator::new(1);
13
14    simulator.create_ether("1");
15    simulator.create_ether("2");
16
17    let mut driver_1 = WirelessModemFake::new("1");
18    let mut driver_2 = WirelessModemFake::new("2");
19    let mut driver_3 = WirelessModemFake::new("3");
20
21    {
22        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
23        ether_1.register_driver(driver_1.clone());
24        ether_1.register_driver(driver_2.clone());
25    }
26    {
27        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
28        ether_2.register_driver(driver_2.clone());
29        ether_2.register_driver(driver_3.clone());
30    }
31
32    /* Create tested nodes. */
33    let mut mesh_node_1 = Node::new(NodeConfig {
34        device_address: ExactAddressType::try_from(1).expect("1 equals to 0"),
35        listen_period: NODE_1_LISTEN_PERIOD,
36    });
37
38    let mut mesh_node_2 = Node::new(NodeConfig {
39        device_address: ExactAddressType::try_from(2).expect("2 equals to 0"),
40        listen_period: NODE_2_LISTEN_PERIOD,
41    });
42
43    let mut mesh_node_3 = Node::new(NodeConfig {
44        device_address: ExactAddressType::try_from(3).expect("3 equals to 0"),
45        listen_period: NODE_3_LISTEN_PERIOD,
46    });
47
48    /* Do testing scenario */
49    let _ = mesh_node_1.send_to_exact(
50        NodeString::try_from("Message from node 1")
51            .expect("Fail to pack message")
52            .into_bytes(),
53        ExactAddressType::try_from(3).expect("3 is 0"),
54        2.into(),
55        false,
56    );
57
58    simulator.start_simulation_thread();
59
60    let start_time = Instant::now();
61    loop {
62        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;
63
64        let _ = mesh_node_1.update(&mut driver_1, current_time);
65        let _ = mesh_node_2.update(&mut driver_2, current_time);
66        let _ = mesh_node_3.update(&mut driver_3, current_time);
67
68        if current_time >= 200 {
69            panic!("Simulation timeout");
70        }
71
72        if let Some(_packet) = mesh_node_3.receive() {
73            break;
74        }
75    }
76
77    simulator.stop_simulation_thread();
78
79    println!("Simulation done");
80}

Source

pub fn stop_simulation_thread(&mut self)

Examples found in repository ?

examples/embedded_nano_mesh.rs (line 77)

10fn main() {
11    /* Create simulator, ether, and devices registered in that ether. */
12    let mut simulator = NetworkSimulator::new(1);
13
14    simulator.create_ether("1");
15    simulator.create_ether("2");
16
17    let mut driver_1 = WirelessModemFake::new("1");
18    let mut driver_2 = WirelessModemFake::new("2");
19    let mut driver_3 = WirelessModemFake::new("3");
20
21    {
22        let mut ether_1 = simulator.get_ether("1").expect("Failed to find ether 1");
23        ether_1.register_driver(driver_1.clone());
24        ether_1.register_driver(driver_2.clone());
25    }
26    {
27        let mut ether_2 = simulator.get_ether("2").expect("Failed to find ether 2");
28        ether_2.register_driver(driver_2.clone());
29        ether_2.register_driver(driver_3.clone());
30    }
31
32    /* Create tested nodes. */
33    let mut mesh_node_1 = Node::new(NodeConfig {
34        device_address: ExactAddressType::try_from(1).expect("1 equals to 0"),
35        listen_period: NODE_1_LISTEN_PERIOD,
36    });
37
38    let mut mesh_node_2 = Node::new(NodeConfig {
39        device_address: ExactAddressType::try_from(2).expect("2 equals to 0"),
40        listen_period: NODE_2_LISTEN_PERIOD,
41    });
42
43    let mut mesh_node_3 = Node::new(NodeConfig {
44        device_address: ExactAddressType::try_from(3).expect("3 equals to 0"),
45        listen_period: NODE_3_LISTEN_PERIOD,
46    });
47
48    /* Do testing scenario */
49    let _ = mesh_node_1.send_to_exact(
50        NodeString::try_from("Message from node 1")
51            .expect("Fail to pack message")
52            .into_bytes(),
53        ExactAddressType::try_from(3).expect("3 is 0"),
54        2.into(),
55        false,
56    );
57
58    simulator.start_simulation_thread();
59
60    let start_time = Instant::now();
61    loop {
62        let current_time = Instant::now().duration_since(start_time).as_millis() as ms;
63
64        let _ = mesh_node_1.update(&mut driver_1, current_time);
65        let _ = mesh_node_2.update(&mut driver_2, current_time);
66        let _ = mesh_node_3.update(&mut driver_3, current_time);
67
68        if current_time >= 200 {
69            panic!("Simulation timeout");
70        }
71
72        if let Some(_packet) = mesh_node_3.receive() {
73            break;
74        }
75    }
76
77    simulator.stop_simulation_thread();
78
79    println!("Simulation done");
80}