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

sethp · sethp · commit a7f342d93145 · 2023-04-16T09:26:03.000-07:00
diff --git a/Cargo.toml b/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]
 
diff --git a/README.md b/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.
diff --git a/examples/escape_seq.rs b/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);
 
diff --git a/src/ansi.rs b/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),
             },
         )
diff --git a/src/bin/vgaterm.rs b/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;
         }
 
diff --git a/src/channel.rs b/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> {
diff --git a/src/display.rs b/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)
-
                 }
             }
         }
diff --git a/src/keyboard.rs b/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,
 };
diff --git a/src/terminal.rs b/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);
                     }
                 }
             },
diff --git a/src/uart.rs b/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())
+        }
     });
 }
 

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,6 @@ fn main() -> ! {`
`87`	`87`	`riscv::interrupt::enable();`
`88`	`88`	`}`
`89`	`89`
`90`		`-`
`91`	`90`	`let r = ansi::parse_esc_str("abcd\u{1B}[XYZ\u{1B}[");`
`92`	`91`	`println!("{:?}", r);`
`93`	`92`
Original file line number	Diff line number	Diff line change
`@@ -214,7 +214,7 @@ fn cursor_to_line_col(input: &str) -> OpResult {`
`214`	`214`	`(`
`215`	`215`	`rest,`
`216`	`216`	`Op::MoveCursorAbs {`
`217`		`- x: b.saturating_sub(1) - 1,`
	`217`	`+ x: b.saturating_sub(1),`
`218`	`218`	`y: a.saturating_sub(1),`
`219`	`219`	`},`
`220`	`220`	`)`
Original file line number	Diff line number	Diff line change
`@@ -105,14 +105,8 @@ impl Cursor {`
`105`	`105`	`text.write_char(self.pos.row(), self.pos.col(), c);`
`106`	`106`	`}`
`107`	`107`
`108`		`- fn reset_highlight_timer(&mut self, text: &mut TextDisplay) {`
`109`		`- self.set_highlight(text);`
`110`		`- self.time_to_next_blink = SystemTimer::now().wrapping_add(self.blink_length);`
`111`		`- }`
`112`		`-`
`113`	`108`	`fn update(&mut self, text: &mut TextDisplay) {`
`114`	`109`	`let now = SystemTimer::now();`
`115`		`- // println!("now {}, upcoming time {}", now, self.time_to_next_blink);`
`116`	`110`	`if now >= self.time_to_next_blink {`
`117`	`111`	`self.time_to_next_blink = now.wrapping_add(self.blink_length);`
`118`	`112`	`self.swap_highlight(text);`
`@@ -262,23 +256,18 @@ impl TextField {`
`262`	`256`	`}`
`263`	`257`	`EraseLine(erase) => match erase {`
`264`	`258`	`EraseMode::All => {`
`265`		`- self.cursor.reset_highlight_timer(&mut self.text);`
`266`	`259`	`for c in 0..display::COLUMNS {`
`267`	`260`	`self.text.write(self.cursor.pos.row(), c, ' ');`
`268`	`261`	`}`
`269`	`262`	`}`
`270`	`263`	`EraseMode::FromCursor => {`
`271`		`- self.cursor.reset_highlight_timer(&mut self.text);`
`272`	`264`	`for c in self.cursor.pos.col()..display::COLUMNS {`
`273`	`265`	`self.text.write(self.cursor.pos.row(), c, ' ');`
`274`		`- self.cursor.update(&mut self.text);`
`275`	`266`	`}`
`276`	`267`	`}`
`277`	`268`	`EraseMode::ToCursor => {`
`278`		`- self.cursor.reset_highlight_timer(&mut self.text);`
`279`	`269`	`for c in 0..self.cursor.pos.col() {`
`280`	`270`	`self.text.write(self.cursor.pos.row(), c, ' ');`
`281`		`- self.cursor.update(&mut self.text);`
`282`	`271`	`}`
`283`	`272`	`}`
`284`	`273`	`},`