RINGBUFFER FTW!

Cargo.lock

@@ -25,6 +25,21 @@ dependencies = [
  "avr-hal-generic",
 ]
 
+[[package]]
+name = "atomic-polyfill"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ff7eb3f316534d83a8a2c3d1674ace8a5a71198eba31e2e2b597833f699b28"
+dependencies = [
+ "critical-section",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
 [[package]]
 name = "avr-device"
 version = "0.5.1"
@@ -71,6 +86,7 @@ dependencies = [
  "arduino-hal",
  "avr-device",
  "embedded-hal",
+ "heapless",
  "nb 0.1.3",
  "panic-halt",
  "ufmt",
@@ -82,6 +98,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fe8f5a8a398345e52358e18ff07cc17a568fbca5c6f73873d3a62056309603"
 
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -94,6 +116,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "critical-section"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7059fff8937831a9ae6f0fe4d658ffabf58f2ca96aa9dec1c889f936f705f216"
+
 [[package]]
 name = "embedded-hal"
 version = "0.2.7"
@@ -110,6 +138,38 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "723dce4e9f25b6e6c5f35628e144794e5b459216ed7da97b7c4b66cdb3fa82ca"
 
+[[package]]
+name = "hash32"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "heapless"
+version = "0.7.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db04bc24a18b9ea980628ecf00e6c0264f3c1426dac36c00cb49b6fbad8b0743"
+dependencies = [
+ "atomic-polyfill",
+ "hash32",
+ "rustc_version",
+ "spin",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
 [[package]]
 name = "nb"
 version = "0.1.3"
@@ -161,12 +221,48 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
 
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "semver"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad977052201c6de01a8ef2aa3378c4bd23217a056337d1d6da40468d267a4fb0"
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
 [[package]]
 name = "syn"
 version = "1.0.109"

Cargo.toml

@@ -17,6 +17,7 @@ ufmt = "0.1.0"
 nb = "0.1.2"
 embedded-hal = "0.2.3"
 avr-device = "0.5.1"
+heapless = "0.7.16"
 
 [dependencies.arduino-hal]
 git = "https://github.com/rahix/avr-hal"

src/main.rs

@@ -1,123 +1,138 @@
 #![no_std]
 #![no_main]
+#![feature(abi_avr_interrupt)]
 
-mod webee;
-use webee::{Webee, Vector};
 
+use arduino_hal::hal::Atmega;
+use arduino_hal::hal::port::{PE0, PE1, PD2, PD3};
+use arduino_hal::port::Pin;
+use arduino_hal::port::mode::{Input, Output};
 use arduino_hal::Peripherals;
 use arduino_hal::prelude::*;
+use arduino_hal::usart::{UsartOps, Usart};
+use avr_device::atmega2560::{USART0, USART1};
 use panic_halt as _;
 
+use embedded_hal::serial::Read;
+
+mod webee;
+
+use webee::Webee;
+use crate::webee::SendCmd::{Baudrate, Channel, MAC, PanId, Role, TransmitPower, ZigbeeNetworkKey};
+use webee::BufferErr;
+
+static mut WEBEE: Option<Webee<USART1, Pin<Input, PD2>, Pin<Output, PD3>>> = None;
+static mut BUFFER_STATUS: Result<(), BufferErr> = Ok(());
+
+
+#[avr_device::interrupt(atmega2560)]
+unsafe fn USART1_RX() {
+    let mut webee = WEBEE.as_mut().unwrap();
+    if let Ok(b) = webee.webee.read() {
+        if let Err(x) = webee.READ_BUFFER.write(b) {
+            BUFFER_STATUS = Err(x);
+        }
+    }
+}
 
 #[arduino_hal::entry]
 fn main() -> ! {
     let dp = Peripherals::take().unwrap();
     let pins = arduino_hal::pins!(dp);
-    let status = pins.d13.into_output();
+    let mut err_led = pins.d13.into_output();
-    let mut serial = arduino_hal::default_serial!(dp, pins, 57600);
+    let mut console = arduino_hal::default_serial!(dp, pins, 57600);
-    let rx = pins.d2;
+    unsafe {
+        avr_device::interrupt::enable();
+    }
 
-    let mut test = Webee::new(
+    // let mut webee = Webee::new(
+    unsafe {
+        WEBEE = Some(Webee::new(
             dp.USART1,
-        pins.d19,
+            pins.d19.forget_imode(),
-        pins.d18.into_output()
+            pins.d18.into_output(),
-    );
+        ));
+    }
 
-    // let mut webee = Usart::new(
+    ufmt::uwriteln!(&mut console, "Webee initialized.").void_unwrap();
-    //     dp.USART1,
-    //     pins.d19,
-    //     pins.d18.into_output(),
-    //     38400.into_baudrate(),
-    // );
 
-    // ufmt::uwriteln!(&mut serial, "Hello, World!").void_unwrap();
+    // --------------------------------
-    // ufmt::uwriteln!(&mut serial, "RX ready: {}", rx.is_high()).void_unwrap();
-    // delay_ms(1000);
-    // ufmt::uwriteln!(&mut serial, "RX ready: {}", rx.is_high()).void_unwrap();
 
-    // let webee = Webee::new(dp.USART1, pins.d19, pins.d18);
+    // let cmd = ZigbeeNetworkKey;
-
+    // let command_string = cmd.to_str();
-
+    // let response;
-    // let mut test = webee.write(0xFF);
+    // unsafe {
-    // while let Err(_) = test {
+    //     response = WEBEE.as_mut().unwrap().send_cmd(cmd);
-    //     test = webee.write(0xFF);
-    //     ufmt::uwriteln!(&mut serial, "initializing..").void_unwrap();
-    //     delay_ms(500);
-    // }
-    ufmt::uwriteln!(&mut serial, "Webee initialized!").void_unwrap();
-    // delay_ms(1000);
-
-    // let mut init = true;
-    // while init {
-    //     match webee.write(0) {
-    //         Ok(_) => {
-    //             webee.flush();
-    //             ufmt::uwriteln!(&mut serial, "Webee initialized!").void_unwrap();
-    //             init = false;
-    //         }
-    //         Err(_) => {
-    //             ufmt::uwriteln!(&mut serial, "initializing..").void_unwrap();
-    //             delay_ms(500);
-    //         }
-    //     }
-    // }
-
-    // ufmt::uwriteln!(&mut serial, "RX ready: {}", rx.is_high()).void_unwrap();
-    let role : Vector<u8> = test.send(vector!([0x5a, 0xaa, 0xb1]));
-    ufmt::uwriteln!(&mut serial, "Role: {}", role);
-
-    // 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();
+    // ufmt::uwrite!(&mut serial, "[{}] {}:", response.len(), command_string).void_unwrap();
-    // let mut result: u8 = webee.read_byte();
+    // for i in 0..response.len() {
-    //
+    //     // for i in 0..10 {
-    // while result != 0xFF {
+    //     ufmt::uwrite!(&mut serial, " {:02X}", *response.get(i).unwrap()).void_unwrap();
-    //     ufmt::uwrite!(&mut serial, " {:02X}", result).void_unwrap();
-    //     result = webee.read_byte();
     // }
+    // ufmt::uwriteln!(&mut serial, "").void_unwrap();
+
+    // for cmd in [Role, Baudrate, PanId, Channel, TransmitPower, MAC, ZigbeeNetworkKey] {
+    //     let command_string = cmd.to_str();
+    //     let response;
+    //     unsafe {
+    //         response = WEBEE.as_mut().unwrap().send_cmd(cmd);
+    //     }
+    //
+    //     ufmt::uwrite!(&mut serial, "[{}] {}:", response.len(), command_string).void_unwrap();
+    //     for i in 0..response.len() {
+    //         // for i in 0..10 {
+    //         ufmt::uwrite!(&mut serial, " {:02X}", *response.get(i).unwrap()).void_unwrap();
+    //     }
+    //     ufmt::uwriteln!(&mut serial, "").void_unwrap();
+    // }
+
+    // --------------------------------
+
+    let webee;
+    unsafe {
+        webee = WEBEE.as_mut().unwrap();
+    }
+
+    unsafe {
+        WEBEE.as_mut().unwrap().void_send_cmd(ZigbeeNetworkKey);
+    }
+
+    ufmt::uwriteln!(&mut console, "Starting Loop!").void_unwrap();
 
     loop {
-        let b = nb::block!(serial.read()).void_unwrap();
+        // Errors
+        if let Err(err) = unsafe { BUFFER_STATUS } {
+            err_led.toggle();
+            match err {
+                BufferErr::Full => {
+                    arduino_hal::delay_ms(100);
+                }
+                BufferErr::Empty => {
+                    arduino_hal::delay_ms(1000);
+                }
+                BufferErr::NotEnoughSpace => {
+                    arduino_hal::delay_ms(5000);
+                }
+            }
+            continue;
+        }
 
-        ufmt::uwriteln!(&mut serial, "Got {:X}!", b).void_unwrap();
+        // Read a byte from the serial connection and put response in buffer.
+        if unsafe { webee.READ_BUFFER.has_data() } {
+            let b = match unsafe { webee.READ_BUFFER.read() } {
+                Ok(b) => b,
+                Err(x) => {
+                    unsafe {
+                        BUFFER_STATUS = Err(x);
+                    }
+                    continue;
+                }
+            };
+            unsafe {
+                ufmt::uwriteln!(&mut console, "Got {:02X}!\r", b).void_unwrap();
+            }
+        }
     }
 }
 
-// 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,45 +1,127 @@
-use arduino_hal::Usart;
+mod ring_buffer;
-use arduino_hal::usart::UsartOps;
+
+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 embedded_hal::serial::{Read};
 
-mod vector;
+use heapless::Vec;
+pub use crate::webee::ring_buffer::{RingBuffer, BufferErr};
 
-pub use vector::Vector;
 
-pub struct Webee<USART, RX, TX> where
+pub struct Webee<USART: UsartOps<Atmega, RX, TX>, RX, TX>
-    USART: UsartOps<H, RX, TX>
 {
-    webee: Usart<USART, RX, TX>,
+    pub webee: Usart<USART, RX, TX>,
+    pub READ_BUFFER: RingBuffer
 }
 
-enum SEND_CMD {}
+#[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,
+}
 
-impl<USART, RX, TX> Webee<USART, RX, TX> {
+impl SendCmd where {
-    const STOP: u8 = 0xFF;
+    pub fn to_str(&self) -> &'static str {
-
+        match self {
-    pub fn new(device: USART, rx: RX, tx: TX) -> Self {
+            SendCmd::Role => "Role",
-        Self {
+            SendCmd::PanId => "PAN ID",
-            webee: Usart::new(device, rx, tx, 38400.into_baudrate())
+            SendCmd::Channel => "Channel",
+            SendCmd::Baudrate => "Baudrate",
+            SendCmd::TransmitPower => "Transmit Power",
+            SendCmd::MAC => "MAC",
+            SendCmd::ZigbeeNetworkKey => "Zigbee Network Key",
+            _ => "not_implemented"
         }
     }
-
+}
-    pub fn send(&mut self, data: Vector<u8>) -> Vector<u8> {
+
-        for byte in data {
+impl<USART, RX, TX>
-            self.webee.write_byte(byte);
+Webee<
-        }
+    USART,
-
+    Pin<Input, RX>,
-        return self.recv();
+    Pin<Output, TX>
-    }
+>
-
+    where
-    fn recv(&mut self) -> Vector<u8> {
+        USART: UsartOps<Atmega, Pin<Input, RX>, Pin<Output, TX>>,
-        const buffer: Vector<u8> = Vector::new(0, &[]);
+        RX: PinOps,
-        let byte: u8 = self.webee.read_byte();
+        TX: PinOps
-
+{
-        while byte != self.STOP {
+    pub fn new(device: USART, rx: Pin<Input, RX>, tx: Pin<Output, TX>) -> Self {
-            buffer.push(byte);
+        let mut interface = Usart::new(device, rx, tx, 38400.into_baudrate());
-        }
+        interface.listen(arduino_hal::hal::usart::Event::RxComplete);
-
+
-        return buffer;
+        let instance = Self {
-    }
+            webee: interface,
+            READ_BUFFER: RingBuffer::new()
+        };
+
+        delay_ms(1000);
+        instance
+    }
+
+    pub fn send(&mut self, data: &[u8]) -> Vec<u8, 128> {
+        for byte in data.iter() {
+            self.webee.write_byte(*byte);
+        }
+
+        self.recv()
+    }
+
+    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 void_send_cmd(&mut self, cmd: SendCmd) {
+        let frame = [0x5A, 0xAA, cmd as u8];
+        self.void_send(frame.as_slice())
+    }
+
+    pub fn query_parameter(&mut self) {}
+
+    pub fn recv(&mut self) -> Vec<u8, 128> {
+        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);
+
+        // for i in 0..5 {
+        //     buffer.push(self.webee.read_byte()).unwrap();
+        // }
+
+        while let Ok(byte) = self.webee.read() {
+            buffer.push(byte).unwrap();
+            delay_ms(10);
+        }
+
+        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();
+    // }
 }

src/webee/ring_buffer.rs

@@ -0,0 +1,68 @@
+
+use arduino_hal::prelude::*;
+
+use embedded_hal::serial::Read;
+use ufmt::uWrite;
+
+const BUFFER_SIZE: usize = 128;
+pub struct RingBuffer {
+    data: [u8; BUFFER_SIZE],
+    start: u16,
+    end: u16,
+}
+
+#[derive(Copy, Clone)]
+pub enum BufferErr {
+    Full,
+    Empty,
+    NotEnoughSpace,
+}
+
+impl RingBuffer {
+    pub const fn new() -> Self {
+        RingBuffer {
+            start: 0,
+            end: 0,
+            data: [0; BUFFER_SIZE],
+        }
+    }
+    const fn size_remaining(&self) -> u16 {
+        if self.has_data() {
+            (self.start + BUFFER_SIZE as u16 - self.end) % BUFFER_SIZE as u16
+        } else {
+            BUFFER_SIZE as u16
+        }
+    }
+    pub const fn has_data(&self) -> bool {
+        self.start != self.end
+    }
+    pub fn write(&mut self, data: u8) -> Result<(), BufferErr> {
+        let next = (self.end + 1) % BUFFER_SIZE as u16;
+        if next == self.start {
+            return Err(BufferErr::Full);
+        }
+        self.data[next as usize] = data;
+        self.end = next;
+        Ok(())
+    }
+    pub fn read(&mut self) -> Result<u8, BufferErr> {
+        if !self.has_data() {
+            return Err(BufferErr::Empty);
+        }
+        self.start = (self.start + 1) % BUFFER_SIZE as u16;
+        Ok(self.data[self.start as usize])
+    }
+}
+
+impl uWrite for RingBuffer {
+    type Error = BufferErr;
+    fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
+        if (self.size_remaining() as usize) < s.len() {
+            return Err(BufferErr::NotEnoughSpace);
+        }
+        for b in s.bytes() {
+            self.write(b)?;
+        }
+        Ok(())
+    }
+}

src/webee/simple_vector.rs

@@ -0,0 +1,80 @@
+#[derive(Copy, Clone, Debug)]
+pub struct SimpleVec {
+    items: [VecItem; 128],
+}
+
+
+#[derive(Copy, Clone, Debug)]
+pub struct VecItem {
+    value: u8,
+    indexed: bool,
+}
+
+
+impl VecItem {
+    fn new() -> Self {
+        Self {
+            value: 0,
+            indexed: false,
+        }
+    }
+}
+
+impl SimpleVec {
+    pub fn new() -> Self {
+        Self { items: [VecItem { value: 0, indexed: false }; 128] }
+    }
+
+    pub fn len(&self) -> usize {
+        let mut len = 0;
+        for i in &self.items {
+            if i.indexed { len = len + 1 };
+        };
+
+        len
+    }
+
+    pub fn full(&self) -> bool {
+        self.items.len() == self.len()
+    }
+
+
+    pub fn push(&mut self, value: u8) {
+        let vec_item = VecItem {
+            value,
+            indexed: true,
+        };
+
+        let mut items = self.items;
+        {
+            let (_left, right) = items.split_at_mut(self.len());
+            right[0] = vec_item;
+        }
+
+        self.items = items;
+    }
+
+    pub fn pop(&mut self) {
+        let index = if self.len() > 0 { self.len() - 1 } else { 0 };
+
+        let mut items = self.items;
+        {
+            let (left, _right) = items.split_at_mut(self.len());
+            left[index] = VecItem::new();
+        }
+
+        self.items = items;
+    }
+
+    pub fn items(&self) -> [u8; 128] {
+        self.items.map(|i| i.value)
+    }
+
+    pub fn from_slice(slice: &[u8]) -> Self {
+        let mut simple_array = Self::new();
+        for i in slice {
+            simple_array.push(*i);
+        };
+        simple_array
+    }
+}

src/webee/vector.rs

@@ -1,19 +1,50 @@
-pub struct Vector<'a, T> {
+use avr_device::atmega2560::TC0;
-    size: u16,
+use ufmt::{Formatter, uDisplay, uWrite};
-    array: &'a [T]
+
+pub struct SimpleVector<T> {
+    size: usize,
+    array: [T]
 }
 
-impl<'a, T> Vector<'a, T> {
+impl<T> SimpleVector<T> {
-    pub fn new(size: u16, array: &[T]) -> Self {
+    pub fn new(size: usize, array: [T]) -> Self {
         Self {
             size, array
         }
     }
+
+    pub fn push(&mut self, byte: T) {
+        let array : &[T];
+
+        if self.size > 0 {
+            array = &mut self.array[0..self.size];
+            array[self.size] = byte;
+        } else {
+            array = &mut [byte];
+        }
+
+        self.array = array;
+        self.size = self.size + 1;
+    }
+}
+
+impl<'a, T> Iterator for SimpleVector<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        todo!()
+    }
+}
+
+impl<'a, T> uDisplay for SimpleVector<'a, T> {
+    fn fmt<W>(&self, _: &mut Formatter<'_, W>) -> Result<(), W::Error> where W: uWrite + ?Sized {
+        todo!()
+    }
 }
 
 #[macro_export]
 macro_rules! vector {
     ($array:expr) => {
-        Vector::new($array.len(), $array);
+        Vector::new(&mut $array.len(), $array)
     };
 }