Print primes onto text display

lwcpu/src/lib.rs

@@ -157,12 +157,14 @@ impl TextDisplay {
     // const SCROLL_RIGHT : u8 = 0b10000000;
 
     #[inline]
-    pub fn init(&mut self, blink: bool) {
+    pub fn clear(&mut self, blink: bool) {
         unsafe {
             let control_ptr = TEXT_DISPLAY_POINTER.offset(3);
             write_volatile(control_ptr, Self::CLEAR);
             match blink {
                 true => {
+                    write_volatile(TEXT_DISPLAY_POINTER as *mut u16, self.pos);
+                    write_volatile(control_ptr, Self::SET_CURSOR);
                     write_volatile(control_ptr, Self::BLINK);
                 },
                 false => {
@@ -185,17 +187,16 @@ impl TextDisplay {
                     self.pos += 64; // increment row
                 }
                 self.pos &= !63u16; // set column to 0
-                return;
+            } else {
-            }
+                write_volatile(TEXT_DISPLAY_POINTER as *mut u16, self.pos);
-
+                write_volatile(TEXT_DISPLAY_POINTER.offset(2), ch);
-            write_volatile(TEXT_DISPLAY_POINTER as *mut u16, self.pos);
+                write_volatile(control_ptr, Self::SET_CHAR);
-            write_volatile(TEXT_DISPLAY_POINTER.offset(2), ch);
+                write_volatile(control_ptr, control);
-            write_volatile(control_ptr, Self::SET_CHAR);
-            write_volatile(control_ptr, control);
 
-            self.pos += 1;
+                self.pos += 1;
 
-            write_volatile(TEXT_DISPLAY_POINTER as *mut u16, self.pos);
+                write_volatile(TEXT_DISPLAY_POINTER as *mut u16, self.pos);
+            }
 
             write_volatile(control_ptr, Self::SET_CURSOR);
             write_volatile(control_ptr, control);
@@ -226,6 +227,13 @@ impl NumberDisplay {
             write_volatile(NUMBER_DISPLAY_POINTER, number);
         }
     }
+    #[inline]
+    pub fn increment() {
+        unsafe {
+            let value = read_volatile(NUMBER_DISPLAY_POINTER);
+            write_volatile(NUMBER_DISPLAY_POINTER, value + 1);
+        }
+    }
 }
 
 pub struct RNG {}

primes/src/main.rs

@@ -3,7 +3,7 @@
 
 use core::fmt::Write;
 use core::panic::PanicInfo;
-use lwcpu::{NumberDisplay, CharDisplay};
+use lwcpu::{NumberDisplay, CharDisplay, TextDisplay};
 use riscv_rt::entry;
 
 const SEGMENT_MAX: usize = 8;
@@ -33,10 +33,11 @@ fn simple_sieve(primes: &mut [usize; SEGMENT_SIZE], n: &mut usize) {
     *n = index;
 }
 
-fn segment_sieve(primes: &[usize], prime_multiple: &mut [usize]) {
+fn segment_sieve(primes: &[usize], prime_multiple: &mut [usize], char: &mut CharDisplay, text: &mut TextDisplay) {
     let mut low: usize = SEGMENT_SIZE;
     let mut high: usize = SEGMENT_SIZE*2;
     for _ in 1..SEGMENT_SIZE { // there are [SEGMENT_SIZE] number of segments
+        char.show();
         let mut segment = [true; SEGMENT_SIZE];
         for (i,p) in primes.iter().enumerate() {
             let mut multiple = prime_multiple[i];
@@ -46,10 +47,12 @@ fn segment_sieve(primes: &[usize], prime_multiple: &mut [usize]) {
             }
             prime_multiple[i] = multiple;
         }
+        char.hide();
 
         for (x,prime) in segment.iter().enumerate() {
             if *prime {
-                NumberDisplay::display_number((low+x) as u32);
+                NumberDisplay::increment();
+                writeln!(text, "{} is prime", low+x).ok();
             }
         }
 
@@ -61,29 +64,43 @@ fn segment_sieve(primes: &[usize], prime_multiple: &mut [usize]) {
 #[panic_handler]
 fn panic_handler(_info: &PanicInfo) -> ! {
     NumberDisplay::display_number(0xDEADC0DE);
-    let mut text = CharDisplay{};
+    let mut text = TextDisplay::default();
+    text.clear(false);
     let _ = write!(text, "Panic: {}", _info.message());
     loop {}
 }
 
 #[entry]
 fn main() -> ! {
+    NumberDisplay::display_number(0);
+    let mut char = CharDisplay{};
+    char.init();
+    char.hide();
+    char.write_str("SIEVING...").ok();
+
+    let mut text = TextDisplay::default();
+    text.clear(true);
+
     // There will be no more than [SEGMENT_SIZE] primes in the segment
     let mut primes_buffer = [0; SEGMENT_SIZE];
     let mut n = 0;
+
+    char.show();
     simple_sieve(&mut primes_buffer, &mut n);
+    char.hide();
 
     let primes = &primes_buffer[..n];
 
     let mut prime_multiple = [0; SEGMENT_SIZE];
     for (i,x) in primes.iter().enumerate() {
-        NumberDisplay::display_number(*x as u32);
+        NumberDisplay::increment();
+        writeln!(text, "{} is prime", *x).ok();
         let mut multiple = *x;
         while multiple < SEGMENT_SIZE {
             multiple += x;
         }
         prime_multiple[i] = multiple;
     }
-    segment_sieve(primes, &mut prime_multiple);
+    segment_sieve(primes, &mut prime_multiple, &mut char, &mut text);
     loop {}
 }