Merge branch 'buffered-terminal' of https://github.com/rustbox/esp32c3-vgaterm into refactor/nom-it-up

Author: sethp

Cargo.toml

@@ -40,6 +40,12 @@ critical-section = "1.1.1"
 embedded-graphics = "0.7.1"
 embedded-hal = "0.2"
 esp-alloc = { version = "0.2.0", features = ["oom-handler"] }
+esp-backtrace = { version = "0.6.0", features = [
+  "esp32c3",
+  "panic-handler",
+  "exception-handler",
+  "print-jtag-serial",
+] }
 esp-println = { version = "0.4.0", default-features = false, features = [
   "esp32c3",
   "jtag_serial",
@@ -54,12 +60,6 @@ nb = "1.1"
 nom = { version = "7.1.3", default-features = false, features = ["alloc"] }
 riscv = "0.10.1"
 unroll = "0.1.5"
-esp-backtrace = { version = "0.6.0", features = [
-  "esp32c3",
-  "panic-handler",
-  "exception-handler",
-  "print-jtag-serial",
-] }
 
 [dev-dependencies]
 

README.md

@@ -30,7 +30,7 @@ At this point you are ready to build and upload
 
 2. Flash to the CPU
 
-`espflash flash /dev/ttyUSB0 target/riscv32imac-unknown-none-elf/debug/vgaterm --monitor --format direct-boot`
+`espflash flash target/riscv32imac-unknown-none-elf/debug/vgaterm --monitor --format direct-boot`
 
 Where `/dev/ttyUSB0` should be whatever serial port the esp32 is connected to. It's highly recommended that your user
 is added to the `dialout` group which will allow you to interact with `/dev/ttyUSB0` without using sudo.

examples/escape_seq.rs

@@ -87,7 +87,6 @@ fn main() -> ! {
         riscv::interrupt::enable();
     }
 
-
     let r = ansi::parse_esc_str("abcd\u{1B}[XYZ\u{1B}[");
     println!("{:?}", r);
 

src/ansi.rs

@@ -214,7 +214,7 @@ fn cursor_to_line_col(input: &str) -> OpResult {
         (
             rest,
             Op::MoveCursorAbs {
-                x: b.saturating_sub(1) - 1,
+                x: b.saturating_sub(1),
                 y: a.saturating_sub(1),
             },
         )

src/bin/vgaterm.rs

@@ -5,19 +5,19 @@
 extern crate alloc;
 
 use alloc::{collections::VecDeque, string::String, vec::Vec};
-use esp32c3_hal::{clock::{ClockControl, CpuClock}, peripherals::UART0};
+use esp32c3_hal::clock::{ClockControl, CpuClock};
 use esp32c3_hal::prelude::*;
 use esp32c3_hal::timer::TimerGroup;
 use esp32c3_hal::{gpio::IO, peripherals::Peripherals, Rtc};
+use esp_backtrace as _;
 use esp_println::println;
-use vgaterm::{Delay, usb_keyboard::US_ENGLISH, Work, interrupt::Priority};
 use vgaterm::perf::configure_counter_for_cpu_cycles;
 use vgaterm::{self, video};
-use esp_backtrace as _;
+use vgaterm::{interrupt::Priority, usb_keyboard::US_ENGLISH, Work};
 
-use core::{arch::asm, fmt::Write};
+use core::fmt::Write;
 
-core::arch::global_asm!(".global _heap_size; _heap_size = 0xC000");
+core::arch::global_asm!(".global _heap_size; _heap_size = 0xB000");
 
 #[global_allocator]
 static ALLOCATOR: esp_alloc::EspHeap = esp_alloc::EspHeap::empty();
@@ -79,15 +79,17 @@ fn main() -> ! {
     vgaterm::uart::interrupt_enable0(Priority::Priority6);
     vgaterm::gpio::interrupt_enable(Priority::max());
 
-    
     unsafe {
         riscv::interrupt::enable();
     }
 
     vgaterm::timer::start_repeat_timer0_callback(1_000_000, || unsafe {
         if NUM_BYTES > 0 {
-            println!("{} bytes",  NUM_BYTES );
-            println!("{} draw cycles per byte", vgaterm::CHARACTER_DRAW_CYCLES as f32 / NUM_BYTES as f32);
+            println!("{} bytes", NUM_BYTES);
+            println!(
+                "{} draw cycles per byte",
+                vgaterm::CHARACTER_DRAW_CYCLES as f32 / NUM_BYTES as f32
+            );
             NUM_BYTES = 0;
         }
         vgaterm::CHARACTER_DRAW_CYCLES = 0;
@@ -176,7 +178,9 @@ fn main() -> ! {
             while let Ok(r) = serial0.read() {
                 b.push(r);
             }
-            unsafe { NUM_BYTES += b.len(); }
+            unsafe {
+                NUM_BYTES += b.len();
+            }
             String::from_utf8(b).unwrap()
         };
 
@@ -188,23 +192,23 @@ fn main() -> ! {
                 match mode {
                     ConnectMode::ConnectHost => {
                         let _ = serial0.write_str(c);
-                    },
+                    }
                     ConnectMode::LocalEcho => {
                         terminal.type_str(c);
-                    },
-                    ConnectMode::None => { }
+                    }
+                    ConnectMode::None => {}
                 };
-               
-            },
-            Work::WouldBlock => {},
+            }
+            Work::WouldBlock => {}
             Work::WouldBlockUntil(_) => {}
         }
 
         // Draw the characters on the frame
         // Flush the Display to the BUFFER
-        // display.flush();
-        
-        if !keyvents.is_empty() || unsafe { (*UART0::PTR).status.read().rxfifo_cnt().bits() } > 0 {
+        display.flush();
+
+        if !keyvents.is_empty() {
+            println!("{:?}", keyvents);
             continue;
         }
 

src/channel.rs

@@ -1,6 +1,11 @@
 use core::cell::RefCell;
 
-use alloc::{collections::VecDeque, sync::Arc, vec::Vec, string::{ToString, String}};
+use alloc::{
+    collections::VecDeque,
+    string::{String, ToString},
+    sync::Arc,
+    vec::Vec,
+};
 use critical_section::Mutex;
 
 pub struct Sender<T> {

src/display.rs

@@ -8,10 +8,10 @@ use embedded_graphics::{
     mono_font::{MonoTextStyle, MonoTextStyleBuilder},
     pixelcolor::raw::RawU8,
     prelude::*,
+    primitives::Rectangle,
     text::Text,
-    Pixel, primitives::Rectangle,
+    Pixel,
 };
-use esp_println::print;
 
 use crate::{
     color::{self, Rgb3},
@@ -38,7 +38,7 @@ impl Display {
 
     /// Sets the pixel color the location in the video BUFFER
     /// to the given color
-    /// 
+    ///
     /// SAFETY: This directly sets the pixel to video memory which
     /// is unsafe, but should be okay since we're the only ones
     /// setting memory in the buffer and SPI takes exclusive control
@@ -53,7 +53,6 @@ impl Display {
             *unsafe { &mut video::BUFFER[pos] } = px;
         }
     }
-
 }
 
 impl Default for Display {
@@ -85,20 +84,20 @@ impl DrawTarget for Display {
                     && coord.y < video::HEIGHT as i32
                 {
                     let i = coord.y as usize * video::WIDTH + coord.x as usize;
-                    // let raw = RawU8::from(color);
-                    self.set_pixel(i, color.to_byte());
+                    let raw = RawU8::from(color);
+                    self.push(i, raw.into_inner());
                 }
             }
         });
-        // unsafe { crate::CHARACTER_DRAW_CYCLES += count };
+        unsafe { crate::CHARACTER_DRAW_CYCLES += count };
         Ok(())
     }
 
     #[inline(always)]
     fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
-        where
-            I: IntoIterator<Item = Self::Color>, {
-
+    where
+        I: IntoIterator<Item = Self::Color>,
+    {
         let mut count = 0;
         crate::measure(&mut count, || {
             let mut colors = colors.into_iter();
@@ -117,7 +116,6 @@ impl DrawTarget for Display {
         unsafe { crate::CHARACTER_DRAW_CYCLES += count };
         Ok(())
     }
-    
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -357,7 +355,7 @@ fn index(row: usize, col: usize) -> usize {
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum Drawn {
     Dirty,
-    Clean
+    Clean,
 }
 
 pub struct TextDisplay {
@@ -454,7 +452,6 @@ impl TextDisplay {
                 if self.buffer[i].1 == Drawn::Dirty {
                     self.buffer[i].1 = Drawn::Clean;
                     self.draw(row, col, target)
-
                 }
             }
         }

src/keyboard.rs

@@ -1,7 +1,7 @@
 use alloc::vec::Vec;
 use esp32c3_hal::{
     clock::Clocks,
-    gpio::{Gpio1, Unknown, Gpio0},
+    gpio::{Gpio0, Gpio1, Unknown},
     interrupt::Priority,
     peripherals::UART1,
 };

src/terminal.rs

@@ -105,14 +105,8 @@ impl Cursor {
         text.write_char(self.pos.row(), self.pos.col(), c);
     }
 
-    fn reset_highlight_timer(&mut self, text: &mut TextDisplay) {
-        self.set_highlight(text);
-        self.time_to_next_blink = SystemTimer::now().wrapping_add(self.blink_length);
-    }
-
     fn update(&mut self, text: &mut TextDisplay) {
         let now = SystemTimer::now();
-        // println!("now {}, upcoming time {}", now, self.time_to_next_blink);
         if now >= self.time_to_next_blink {
             self.time_to_next_blink = now.wrapping_add(self.blink_length);
             self.swap_highlight(text);
@@ -262,23 +256,18 @@ impl TextField {
             }
             EraseLine(erase) => match erase {
                 EraseMode::All => {
-                    self.cursor.reset_highlight_timer(&mut self.text);
                     for c in 0..display::COLUMNS {
                         self.text.write(self.cursor.pos.row(), c, ' ');
                     }
                 }
                 EraseMode::FromCursor => {
-                    self.cursor.reset_highlight_timer(&mut self.text);
                     for c in self.cursor.pos.col()..display::COLUMNS {
                         self.text.write(self.cursor.pos.row(), c, ' ');
-                        self.cursor.update(&mut self.text);
                     }
                 }
                 EraseMode::ToCursor => {
-                    self.cursor.reset_highlight_timer(&mut self.text);
                     for c in 0..self.cursor.pos.col() {
                         self.text.write(self.cursor.pos.row(), c, ' ');
-                        self.cursor.update(&mut self.text);
                     }
                 }
             },

src/uart.rs

@@ -60,17 +60,11 @@ pub fn configure1(
 }
 
 pub fn make_uart0<'a>(uart: UART0) -> Uart<'a, UART0> {
-    uart.flow_conf.write(|w| {
-        w.sw_flow_con_en().set_bit()
-    });
-    uart.swfc_conf0.write(|w| {
-        w.xoff_threshold().variant(64)
-        .xoff_char().variant(0x13)
-    });
-    uart.swfc_conf1.write(|w| {
-        w.xon_threshold().variant(64)
-        .xon_char().variant(0x11)
-    });
+    uart.flow_conf.write(|w| w.sw_flow_con_en().set_bit());
+    uart.swfc_conf0
+        .write(|w| w.xoff_threshold().variant(64).xoff_char().variant(0x13));
+    uart.swfc_conf1
+        .write(|w| w.xon_threshold().variant(64).xon_char().variant(0x11));
     let serial0: Uart<UART0> = Uart::new(uart);
 
     serial0
@@ -202,7 +196,11 @@ fn UART0() {
             }
         }
         // Reset the "fifo full" interrupt
-        unsafe { (*UART0::PTR).int_clr.write(|w| w.rxfifo_full_int_clr().set_bit()) }
+        unsafe {
+            (*UART0::PTR)
+                .int_clr
+                .write(|w| w.rxfifo_full_int_clr().set_bit())
+        }
     });
 }