w5500 0.6.0

W5500 IoT Controller implementation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#![cfg_attr(not(test), no_std)]
#![allow(unused)]
#![deny(rustdoc::broken_intra_doc_links)]
#![doc = include_str!("../README.md")]

pub mod bus;
mod cursor;
mod device;
mod host;
pub mod net;
pub mod raw_device;
pub mod register;
mod socket;
pub mod tcp;
pub mod udp;
mod uninitialized_device;

#[doc(inline)]
pub use self::{
    device::{Device, DeviceState},
    host::{Dhcp, Host, HostConfig, Manual},
    net::MacAddress,
    uninitialized_device::{InitializeError, UninitializedDevice},
};

// TODO add better docs to all public items, add unit tests.

/// Settings for wake on LAN.  Allows the W5500 to optionally emit an interrupt upon receiving a packet
#[repr(u8)]
#[derive(Copy, Clone, Debug, PartialOrd, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum OnWakeOnLan {
    InvokeInterrupt = 0b00100000,
    Ignore = 0b00000000,
}

/// Ping Block Mode
///
/// Settings for ping.  Allows the W5500 to respond to or ignore network ping requests
#[repr(u8)]
#[derive(Copy, Clone, Debug, PartialOrd, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum OnPingRequest {
    /// 0: Disable Ping block
    Respond = 0b00000000,
    /// 1 : Enable Ping block
    ///
    /// If the bit is ‘1’, it blocks the response to a ping request.
    Ignore = 0b00010000,
}

/// Use [ConnectionType::PPoE] when talking
/// to an ADSL modem. Otherwise use [ConnectionType::Ethernet]
#[repr(u8)]
#[derive(Copy, Clone, Debug, PartialOrd, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum ConnectionType {
    PPoE = 0b00001000,
    Ethernet = 0b00000000,
}

/// Force ARP
///
#[derive(Copy, Clone, Debug, PartialOrd, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[repr(u8)]
pub enum ArpResponses {
    /// 0 : Disable Force ARP mode
    Cache = 0b00000000,
    /// 1 : Enable Force ARP mode
    ///
    /// In Force ARP mode, It forces on sending ARP Request whenever data is
    /// sent.
    DropAfterUse = 0b00000010,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Mode {
    pub on_wake_on_lan: OnWakeOnLan,
    pub on_ping_request: OnPingRequest,
    pub connection_type: ConnectionType,
    pub arp_responses: ArpResponses,
}

impl Mode {
    pub fn to_register(self) -> [u8; 1] {
        [self.to_u8()]
    }

    pub fn to_u8(self) -> u8 {
        let mut register = 0;
        register |= self.on_wake_on_lan as u8;
        register |= self.on_ping_request as u8;
        register |= self.connection_type as u8;
        register |= self.arp_responses as u8;

        register
    }
}

impl Default for Mode {
    fn default() -> Self {
        Self {
            on_wake_on_lan: OnWakeOnLan::Ignore,
            on_ping_request: OnPingRequest::Respond,
            connection_type: ConnectionType::Ethernet,
            arp_responses: ArpResponses::DropAfterUse,
        }
    }
}

#[cfg(test)]
mod test {
    use crate::Mode;

    #[test]
    fn test_mode_register() {
        let ping_respond_and_force_arp = Mode {
            // Bit: 7 Reset (RST) should be 0
            // Bit: 6 reserved
            // Bit: 5 should be 0 - Disable WOL mode
            on_wake_on_lan: crate::OnWakeOnLan::Ignore,
            // Bit: 4 should be 0 - Disable Ping Block Mode
            on_ping_request: crate::OnPingRequest::Respond,
            // Bit: 3 should be 0 - PPoE disabled
            connection_type: crate::ConnectionType::Ethernet,
            // Bit: 2 reserved
            // Bit: 1 should be 0 - Disabled Force ARP
            arp_responses: crate::ArpResponses::Cache,
            // Bit: 0 reserved
        };
        assert_eq!(0b0000_0000, ping_respond_and_force_arp.to_u8());

        let all_enabled = Mode {
            // Bit: 7 Reset (RST) should be 0
            // Bit: 6 reserved
            // Bit: 5 should be 1 - Enable WOL mode
            on_wake_on_lan: crate::OnWakeOnLan::InvokeInterrupt,
            // Bit: 4 should be 0 - Disable Ping Block Mode
            on_ping_request: crate::OnPingRequest::Respond,
            // Bit: 3 should be 1 - PPoE enable
            connection_type: crate::ConnectionType::PPoE,
            // Bit: 2 reserved
            // Bit: 1 should be 1 - Enable Force ARP
            arp_responses: crate::ArpResponses::DropAfterUse,
            // Bit: 0 reserved
        };
        assert_eq!(0b0010_1010, all_enabled.to_u8());
    }
}