107 lines
3.5 KiB
Rust
107 lines
3.5 KiB
Rust
use esp_hal::uart::RxError;
|
|
#[no_std]
|
|
use esp_hal::uart::{self, Config, Uart};
|
|
use esp_hal::{Blocking, riscv::register::hpmcounter13h::read};
|
|
use rtt_target::{rprint, rprintln};
|
|
enum UART_STATEMACHINE {
|
|
WaitingP,
|
|
WaitingE,
|
|
Reading,
|
|
Terminator(u8),
|
|
}
|
|
pub struct Nextion<'a> {
|
|
interface: &'a mut Uart<'static, Blocking>,
|
|
state: UART_STATEMACHINE,
|
|
idx: usize,
|
|
}
|
|
impl<'a> Nextion<'a> {
|
|
pub fn new<'b>(uart: &'a mut Uart<'static, Blocking>) -> Self {
|
|
Nextion {
|
|
interface: uart,
|
|
state: UART_STATEMACHINE::WaitingP,
|
|
idx: 0,
|
|
}
|
|
}
|
|
pub fn send_command(&mut self, cmd: &[u8]) {
|
|
let _ = &self.interface.write(cmd);
|
|
let _ = &self.interface.write(b"\xff\xff\xff");
|
|
}
|
|
pub fn read_command(&mut self, buf: &mut [u8]) -> Result<usize, RxError> {
|
|
let size: usize = 0;
|
|
let mut tmp_buf: [u8; 20] = [0; 20];
|
|
let mut cmd_end_ctr = 0;
|
|
let mut i = 0;
|
|
let mut read_header = false;
|
|
loop {
|
|
if !self.interface.read_ready() {
|
|
continue;
|
|
}
|
|
let mut char: [u8; 1] = [0; 1];
|
|
|
|
self.interface.read(&mut char)?;
|
|
let byte = char[0];
|
|
match self.state {
|
|
UART_STATEMACHINE::WaitingP => {
|
|
if byte == b'P' {
|
|
self.state = UART_STATEMACHINE::WaitingE;
|
|
}
|
|
}
|
|
UART_STATEMACHINE::WaitingE => {
|
|
if byte == b'E' {
|
|
self.state = UART_STATEMACHINE::Reading;
|
|
self.idx = 0;
|
|
}
|
|
}
|
|
UART_STATEMACHINE::Reading => {
|
|
if byte == b'\xff' {
|
|
self.state = UART_STATEMACHINE::Terminator(1);
|
|
} else {
|
|
if self.idx < buf.len() {
|
|
buf[self.idx] = byte;
|
|
self.idx += 1;
|
|
} else {
|
|
self.reset();
|
|
return Err(RxError::FifoOverflowed);
|
|
}
|
|
}
|
|
}
|
|
UART_STATEMACHINE::Terminator(n) => {
|
|
if byte == b'\xff' {
|
|
if n >= 2 {
|
|
let idx = self.idx;
|
|
self.reset();
|
|
return Ok(idx);
|
|
} else {
|
|
self.state = UART_STATEMACHINE::Terminator(n + 1)
|
|
}
|
|
} else {
|
|
self.state = UART_STATEMACHINE::Reading;
|
|
|
|
let needed: usize = (n + 1).into(); // number of bytes to reinsert (FFs + current byte)
|
|
|
|
if self.idx + needed > buf.len() {
|
|
self.reset();
|
|
return Err(RxError::FifoOverflowed);
|
|
}
|
|
|
|
for _ in 0..n {
|
|
buf[self.idx] = 0xff;
|
|
self.idx += 1;
|
|
}
|
|
|
|
buf[self.idx] = byte;
|
|
self.idx += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn read_ready(&mut self) -> bool {
|
|
self.interface.read_ready()
|
|
}
|
|
fn reset(&mut self) {
|
|
self.state = UART_STATEMACHINE::WaitingP;
|
|
self.idx = 0;
|
|
}
|
|
}
|