chore: socket docs

Signed-off-by: Lachezar Lechev <elpiel93@gmail.com>

src/socket.rs

@@ -12,6 +12,7 @@ pub struct Socket {
 }
 
 impl Socket {
+    /// 8 sockets available on the w5500
     pub fn new(index: u8) -> Self {
         /*
          * Socket 0 is at address    0x01
@@ -75,6 +76,7 @@ impl Socket {
     ) -> Result<bool, SpiBus::Error> {
         let mut data = [0u8];
         bus.read_frame(self.register(), socketn::INTERRUPT, &mut data)?;
+
         Ok(data[0] & code as u8 != 0)
     }
 
@@ -179,9 +181,11 @@ impl Socket {
         Ok(())
     }
 
+    /// Get the received bytes size of the socket's RX buffer.
+    ///
+    /// Section 4.2 of datasheet, Sn_TX_FSR address docs indicate that read must be repeated until two sequential reads are stable
     pub fn get_receive_size<SpiBus: Bus>(&self, bus: &mut SpiBus) -> Result<u16, SpiBus::Error> {
         loop {
-            // Section 4.2 of datasheet, Sn_TX_FSR address docs indicate that read must be repeated until two sequential reads are stable
             let mut sample_0 = [0u8; 2];
             bus.read_frame(self.register(), socketn::RECEIVED_SIZE, &mut sample_0)?;
             let mut sample_1 = [0u8; 2];
@@ -192,9 +196,94 @@ impl Socket {
         }
     }
 
+    /// Get the free TX buffer size still available for this socket.
+    ///
+    /// It's cleared once we `SEND` the buffer over the socket.
     pub fn get_tx_free_size<SpiBus: Bus>(&self, bus: &mut SpiBus) -> Result<u16, SpiBus::Error> {
         let mut data = [0; 2];
         bus.read_frame(self.register(), socketn::TX_FREE_SIZE, &mut data)?;
         Ok(u16::from_be_bytes(data))
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::register::*;
+
+    use super::*;
+
+    #[test]
+    fn test_socket_registers() {
+        // Socket 0
+        {
+            let socket_0 = Socket::new(0);
+
+            assert_eq!(socket_0.register, SOCKET0);
+            assert_eq!(socket_0.tx_buffer, SOCKET0_BUFFER_TX);
+            assert_eq!(socket_0.rx_buffer, SOCKET0_BUFFER_RX);
+        }
+
+        // Socket 1
+        {
+            let socket_1 = Socket::new(1);
+
+            assert_eq!(socket_1.register, SOCKET1);
+            assert_eq!(socket_1.tx_buffer, SOCKET1_BUFFER_TX);
+            assert_eq!(socket_1.rx_buffer, SOCKET1_BUFFER_RX);
+        }
+
+        // Socket 2
+        {
+            let socket_2 = Socket::new(2);
+
+            assert_eq!(socket_2.register, SOCKET2);
+            assert_eq!(socket_2.tx_buffer, SOCKET2_BUFFER_TX);
+            assert_eq!(socket_2.rx_buffer, SOCKET2_BUFFER_RX);
+        }
+
+        // Socket 3
+        {
+            let socket_3 = Socket::new(3);
+
+            assert_eq!(socket_3.register, SOCKET3);
+            assert_eq!(socket_3.tx_buffer, SOCKET3_BUFFER_TX);
+            assert_eq!(socket_3.rx_buffer, SOCKET3_BUFFER_RX);
+        }
+
+        // Socket 4
+        {
+            let socket_4 = Socket::new(4);
+
+            assert_eq!(socket_4.register, SOCKET4);
+            assert_eq!(socket_4.tx_buffer, SOCKET4_BUFFER_TX);
+            assert_eq!(socket_4.rx_buffer, SOCKET4_BUFFER_RX);
+        }
+
+        // Socket 5
+        {
+            let socket_5 = Socket::new(5);
+
+            assert_eq!(socket_5.register, SOCKET5);
+            assert_eq!(socket_5.tx_buffer, SOCKET5_BUFFER_TX);
+            assert_eq!(socket_5.rx_buffer, SOCKET5_BUFFER_RX);
+        }
+
+        // Socket 6
+        {
+            let socket_6 = Socket::new(6);
+
+            assert_eq!(socket_6.register, SOCKET6);
+            assert_eq!(socket_6.tx_buffer, SOCKET6_BUFFER_TX);
+            assert_eq!(socket_6.rx_buffer, SOCKET6_BUFFER_RX);
+        }
+
+        // Socket 7
+        {
+            let socket_7 = Socket::new(7);
+
+            assert_eq!(socket_7.register, SOCKET7);
+            assert_eq!(socket_7.tx_buffer, SOCKET7_BUFFER_TX);
+            assert_eq!(socket_7.rx_buffer, SOCKET7_BUFFER_RX);
+        }
+    }
+}