headless!

src/main.rs

@@ -3,13 +3,17 @@
 
 mod webee;
 
-use webee::{Webee};
+use core::fmt::Debug;
+use webee::Webee;
 
 
-use arduino_hal::{delay_ms, Peripherals};
+use arduino_hal::Peripherals;
+use arduino_hal::port::PinOps;
 use arduino_hal::prelude::*;
-use ufmt::{uDisplay};
+use arduino_hal::usart::UsartOps;
+use ufmt::uDisplay;
 use panic_halt as _;
+use crate::webee::SendCmd::{Baudrate, Channel, MAC, PanId, Role, TransmitPower};
 
 
 #[arduino_hal::entry]
@@ -20,51 +24,28 @@ fn main() -> ! {
     let webee_rx = pins.d2.forget_imode();
     let mut serial = arduino_hal::default_serial!(dp, pins, 57600);
 
-    let mut test = Webee::new(
+    let mut webee = Webee::new(
         dp.USART1,
         pins.d19.forget_imode(),
         pins.d18.into_output(),
     );
 
-    let ready = webee_rx.is_high();
-    ufmt::uwriteln!(&mut serial, "Webee initialized: {}", ready).void_unwrap();
-    delay_ms(1000);
-    if (!ready) {
-        ufmt::uwriteln!(&mut serial, "Webee initialized: {}", webee_rx.is_high()).void_unwrap();
-    }
+    ufmt::uwriteln!(&mut serial, "Webee initialized.").void_unwrap();
 
-    let func = |byte : u8| {
-        ufmt::uwriteln!(&mut serial, "R {}", byte);
-    };
+    // --------------------------------
 
-    test.send_void(&[0x5a, 0xaa, 0xb1]);
-    ufmt::uwrite!(&mut serial, "Role: ");
-    let role = test.recv();
-    for i in 0..role.len() {
-        let byte = *role.get(i).unwrap();
-        ufmt::uwrite!(&mut serial, "{} ", byte);
+    for mut cmd in [Role, PanId, Channel, Baudrate, TransmitPower, MAC] {
+        let command_string = cmd.to_str();
+        let response = webee.send_cmd(cmd);
+
+        ufmt::uwrite!(&mut serial, "{}:", command_string).void_unwrap();
+        for i in 0..response.len() {
+            ufmt::uwrite!(&mut serial, " {:02X}", *response.get(i).unwrap());
         }
         ufmt::uwriteln!(&mut serial, "");
+    }
 
-    let data = test.recv();
-    ufmt::uwrite!(&mut serial, "{}", data.len());
-
-    // for byte in role.items() {
-    //     ufmt::uwrite!(&mut serial, "{:02X}", byte);
-    // }
-
-    // for byte in [0x5a, 0xaa, 0xb1].iter() {
-    //     webee.write_byte(*byte);
-    //     ufmt::uwriteln!(&mut serial, "Wrote byte: {:X}", *byte).void_unwrap();
-    // }
-    //
-    // ufmt::uwrite!(&mut serial, "Role:").void_unwrap();
-    // let mut result: u8 = webee.read_byte();
-    //
-    // while result != 0xFF {
-    //     ufmt::uwrite!(&mut serial, " {:02X}", result).void_unwrap();
-    //     result = webee.read_byte();
-    // }
+    // --------------------------------
 
     loop {
         let b = nb::block!(serial.read()).void_unwrap();
@@ -73,38 +54,3 @@ fn main() -> ! {
     }
 }
 
-// fn readBytesUntil()
-
-// struct Webee<USART, RX, TX> {
-//     serial: Usart<USART, RX, TX>,
-// }
-//
-// impl<USART, RX, TX> Webee<USART, RX, TX> {
-//     pub fn new(usart: USART, rx: RX, tx: TX) -> Self {
-//         Webee {
-//             serial: crate::Usart::new(usart, rx, tx, Baudrate::new(38400)),
-//         }
-//     }
-// }
-
-
-// struct Webee<'a> {
-//     serial: &'a usart
-// }
-//
-// impl Webee {
-//     fn new(serial: usart) -> Self {
-//         Self {
-//             serial
-//         }
-//     }
-//
-//     fn send_cmd(&mut self, cmd: u8) -> ! {
-//         let frame: [u8; 3] = [0x55, 0xAA, cmd];
-//         self.serial.write(&frame)
-//     }
-//
-//     fn recv(&mut self) -> ! {
-//         self.serial.read()
-//     }
-// }

src/webee.rs

@@ -1,10 +1,11 @@
+use arduino_hal::delay_ms;
 use arduino_hal::hal::Atmega;
 use arduino_hal::port::{Pin, PinOps};
 use arduino_hal::port::mode::{Input, Output};
 use arduino_hal::usart::{Usart, UsartOps};
 use arduino_hal::prelude::*;
 
-use heapless::Vec;
+use heapless::{String, Vec};
 
 // mod simple_vector;
 // pub use simple_vector::SimpleVec;
@@ -15,9 +16,35 @@ pub struct Webee<USART: UsartOps<Atmega, RX, TX>, RX, TX>
     pub webee: Usart<USART, RX, TX>,
 }
 
-enum SendCmd {}
+#[repr(u8)]
+pub enum SendCmd {
+    Role = 0xB1,
+    PanId = 0xB2,
+    Channel = 0xB3,
+    Baudrate = 0xB4,
+    TransmitPower = 0xB5,
+    LocalMulticastNumber = 0xB6,
+    TargetShortAddress = 0xB7,
+    TargetMulticastNumber = 0xB8,
+    AllDataTransmission = 0xB9,
+    MAC = 0xBA,
+    LocalShortAddress = 0xBB,
+    ZigbeeNetworkKey = 0xBC
+}
 
-const STOP: u8 = 0xFF;
+impl SendCmd where {
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            SendCmd::Role => "Role",
+            SendCmd::PanId => "PAN ID",
+            SendCmd::Channel => "Channel",
+            SendCmd::Baudrate => "Baudrate",
+            SendCmd::TransmitPower => "Transmit Power",
+            SendCmd::MAC => "MAC",
+            _ => "not_implemented"
+        }
+    }
+}
 
 impl<USART, RX, TX>
     Webee<
@@ -31,47 +58,56 @@ where
     TX: PinOps
 {
     pub fn new(device: USART, rx: Pin<Input, RX>, tx: Pin<Output, TX>) -> Self {
-        Self {
+        let instance = Self {
             webee: Usart::new(device, rx, tx, 38400.into_baudrate())
-        }
+        };
+
+        delay_ms(1000);
+        instance
     }
 
     pub fn send(&mut self, data: &[u8]) -> Vec<u8, 128> {
-        for byte in data {
+        for byte in data.iter() {
             self.webee.write_byte(*byte);
         }
 
         return self.recv();
     }
 
-    pub fn send_void(&mut self, data: &[u8]) {
-        for byte in data {
+    pub fn void_send(&mut self, data: &[u8]) {
+        for byte in data.iter() {
             self.webee.write_byte(*byte);
         }
     }
 
+    pub fn send_cmd(&mut self, cmd: SendCmd) -> Vec<u8, 128>{
+        let frame = [0x5A, 0xAA, cmd as u8];
+        self.send(&frame)
+    }
+
+    pub fn query_parameter(&mut self) {
+
+    }
+
     pub fn recv(&mut self) -> Vec<u8, 128> {
-        let mut byte: u8 = self.webee.read_byte();
         let mut buffer = Vec::new();
+        // Read first byte in blocking mode to wait until data is available
+        buffer.push(self.webee.read_byte()).unwrap();
+        delay_ms(10);
 
-        while byte != STOP && !buffer.is_full() {
+        while let Ok(byte) = self.webee.read() {
             buffer.push(byte).unwrap();
-            byte = self.webee.read_byte();
         }
 
         return buffer;
     }
 
-    pub fn recv_debug(&mut self, callback: fn(u8)) -> Vec<u8, 128> {
-        let mut byte: u8 = self.webee.read_byte();
-        callback(byte);
-        let mut buffer = Vec::new();
-
-        while byte != STOP && !buffer.is_full() {
-            buffer.push(byte).unwrap();
-            byte = self.webee.read_byte();
-        }
-
-        return buffer;
-    }
+    // pub fn vec_to_string(vec: Vec<u8, 128>) -> &'static str {
+    //     let mut result = String::new();
+    //     for byte in vec.iter() {
+    //         result = format!("{}", byte);
+    //     }
+    //
+    //     return result.as_str();
+    // }
 }