adrian/avr-webee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: adrian:4d45ebba5beee0bf13172ecffea379c2e1f6f50b
Branches Tags
adrian:main
..
compare: adrian:main
Branches Tags
adrian:main

7 Commits
4d45ebba5b ... main

Author SHA1 Message Date
Adrian Marquis
b69710ad97 RINGBUFFER FTW! 2024-01-07 23:28:32 +01:00
Adrian Marquis
897ef263ca quicksave 2 2024-01-01 19:35:32 +01:00
Adrian Marquis
e64eafd869 quicksave 2023-10-25 12:13:17 +02:00
Adrian Marquis
84689485db define more commands & refactor 2023-10-16 18:42:52 +02:00
Adrian Marquis
233537f559 headless! 2023-10-14 21:03:54 +02:00
Adrian Marquis
8167fe55a0 headless? 2023-10-14 13:07:40 +02:00
Adrian Marquis
df53777a80 Fixed SimpleVector push 2023-09-28 21:51:38 +02:00
7 changed files with 389 additions and 172 deletions
Expand all files Collapse all files

96
Cargo.lock generated
View File

@@ -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"

1
Cargo.toml
View File

@@ -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"

208
src/main.rs
View File

@@ -1,126 +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::{port::{Pin, mode::AnyInput}};
use arduino_hal::hal::port::PD2;
use arduino_hal::port::mode::{Floating, Input};
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 serial = arduino_hal::default_serial!(dp, pins, 57600);
let mut err_led = pins.d13.into_output();
let mut console = arduino_hal::default_serial!(dp, pins, 57600);
unsafe {
avr_device::interrupt::enable();
}
let mut test = Webee::new(
// let mut webee = Webee::new(
unsafe {
WEBEE = Some(Webee::new(
dp.USART1,
pins.d19.forget_imode(),
pins.d18.into_output()
);
pins.d18.into_output(),
));
}
// let mut webee = Usart::new(
// dp.USART1,
// pins.d19,
// pins.d18.into_output(),
// 38400.into_baudrate(),
// );
ufmt::uwriteln!(&mut console, "Webee initialized.").void_unwrap();
// 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 mut test = webee.write(0xFF);
// while let Err(_) = test {
// 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 data: [u8; 3] = [0x5a, 0xaa, 0xb1];
let role : Vector<u8> = test.send(Vector::new(3, data.as_mut_slice()));
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();
// let cmd = ZigbeeNetworkKey;
// let command_string = cmd.to_str();
// let response;
// unsafe {
// response = WEBEE.as_mut().unwrap().send_cmd(cmd);
// }
//
// 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();
// 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();
// 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()
// }
// }

113
src/webee.rs
View File

@@ -1,26 +1,52 @@
use arduino_hal::clock::Clock;
mod ring_buffer;
use arduino_hal::delay_ms;
use arduino_hal::hal::Atmega;
use arduino_hal::port::{Pin, PinOps};
use arduino_hal::port::mode::{Input, Output, PullUp};
use arduino_hal::port::mode::{Input, Output};
use arduino_hal::usart::{Usart, UsartOps};
use arduino_hal::prelude::*;
use avr_device::atmega2560::usart0::ucsr0c::USBS0_A::STOP1;
use embedded_hal::serial::{Read};
mod vector;
pub use vector::Vector;
use heapless::Vec;
pub use crate::webee::ring_buffer::{RingBuffer, BufferErr};
pub struct Webee<USART: UsartOps<Atmega, RX, TX>, RX, TX>
{
webee: Usart<USART, RX, TX>,
pub webee: Usart<USART, RX, TX>,
pub READ_BUFFER: RingBuffer
}
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",
SendCmd::ZigbeeNetworkKey => "Zigbee Network Key",
_ => "not_implemented"
}
}
}
impl<USART, RX, TX>
Webee<
@@ -34,27 +60,68 @@ where
TX: PinOps
{
pub fn new(device: USART, rx: Pin<Input, RX>, tx: Pin<Output, TX>) -> Self {
Self {
webee: Usart::new(device, rx, tx, 38400.into_baudrate())
let mut interface = Usart::new(device, rx, tx, 38400.into_baudrate());
interface.listen(arduino_hal::hal::usart::Event::RxComplete);
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(&mut self, data: Vector<u8>) -> Vector<u8> {
for byte in data {
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)
}
return self.recv();
pub fn void_send_cmd(&mut self, cmd: SendCmd) {
let frame = [0x5A, 0xAA, cmd as u8];
self.void_send(frame.as_slice())
}
fn recv(&mut self) -> Vector<u8> {
let mut buffer: Vector<u8> = Vector::new(0, &mut []);
let byte: u8 = self.webee.read_byte();
pub fn query_parameter(&mut self) {}
while byte != STOP {
buffer.push(byte);
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);
}
return buffer;
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();
// }
}

68
src/webee/ring_buffer.rs Normal file
View File

@@ -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(())
}
}

41
src/webee/simpleVector.rs → src/webee/simple_vector.rs
View File

@@ -1,8 +1,6 @@
#[derive(Copy, Clone, Debug)]
pub struct SimpleVec {
items: [VecItem; 128]
items: [VecItem; 128],
}
@@ -23,27 +21,25 @@ impl VecItem {
}
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 index = if self.len() < 0 { self.len() + 1 } else { 0 };
let vec_item = VecItem {
value,
indexed: true,
@@ -51,21 +47,19 @@ impl SimpleVec {
let mut items = self.items;
{
let (left, right) = items.split_at_mut(self.len());
right[index] = vec_item;
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());
let (left, _right) = items.split_at_mut(self.len());
left[index] = VecItem::new();
}
@@ -76,32 +70,11 @@ impl SimpleVec {
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
}
}
fn main() {
let mut myarr = SimpleVec::new();
myarr.push(15);
println!("{:?}", myarr.items());
myarr.push(122);
println!("{:?}", myarr.items());
myarr.pop();
println!("{:?}", myarr.items());
let mut anotherarr = SimpleVec::from_slice(&[1,2,3]);
println!("{:?}", anotherarr);
}

12
src/webee/vector.rs
View File

@@ -1,13 +1,13 @@
use avr_device::atmega2560::TC0;
use ufmt::{Formatter, uDisplay, uWrite};
pub struct Vector<'a, T> {
pub struct SimpleVector<T> {
size: usize,
array: &'a mut [T]
array: [T]
}
impl<'a, T> Vector<'a, T> {
pub fn new(size: usize, array: &'a mut [T]) -> Self {
impl<T> SimpleVector<T> {
pub fn new(size: usize, array: [T]) -> Self {
Self {
size, array
}
@@ -28,7 +28,7 @@ impl<'a, T> Vector<'a, T> {
}
}
impl<'a, T> Iterator for Vector<'a, T> {
impl<'a, T> Iterator for SimpleVector<'a, T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
@@ -36,7 +36,7 @@ impl<'a, T> Iterator for Vector<'a, T> {
}
}
impl<'a, T> uDisplay for Vector<'a, T> {
impl<'a, T> uDisplay for SimpleVector<'a, T> {
fn fmt<W>(&self, _: &mut Formatter<'_, W>) -> Result<(), W::Error> where W: uWrite + ?Sized {
todo!()
}