chore (examples): change the library for working with graphics, check the correct operation, change the toml

Author: mcuby

Cargo.toml

@@ -54,10 +54,11 @@ panic-semihosting = "0.5.3"
 cortex-m-semihosting = "0.3.3"
 arrayvec = { version = "0.5.1", default-features = false }
 panic-halt = "0.2.0"
-ssd1306 = "0.2.6"
-embedded-graphics = "0.4.9"
+ssd1306 = "0.3.1"
+embedded-graphics = "0.6.2"
 usb-device = "0.2.5"
 usbd-serial = "0.1.0"
+micromath = "1.0.0"
 
 [features]
 device-selected = []
@@ -116,6 +117,10 @@ required-features = ["rt", "stm32f411"]
 name = "stopwatch-with-ssd1306-and-interrupts"
 required-features = ["rt", "stm32f411"]
 
+[[example]]
+name = "analog-stopwatch-with-spi-ssd1306"
+required-features = ["rt", "stm32f429"]
+
 [[example]]
 name = "rng-display"
 required-features = ["rt", "stm32f407"]

examples/rng-display.rs

@@ -22,7 +22,7 @@ use panic_semihosting as _;
 
 use cortex_m_rt::ExceptionFrame;
 use cortex_m_rt::{entry, exception};
-use embedded_graphics::{fonts::Font6x8, prelude::*};
+use embedded_graphics::{fonts::Font6x8, fonts::Text, pixelcolor::BinaryColor, style::TextStyleBuilder, prelude::*};
 
 use ssd1306::{prelude::*, Builder as SSD1306Builder};
 
@@ -78,17 +78,22 @@ fn main() -> ! {
         let mut rand_source = dp.RNG.constrain(clocks);
         let mut format_buf = ArrayString::<[u8; 20]>::new();
         loop {
+            //display clear
+            disp.clear();
+        
             //this will continuously report an error if RNG_CLK < HCLK/16
             let rand_val = rand_source.next_u32();
 
             format_buf.clear();
             if fmt::write(&mut format_buf, format_args!("{}", rand_val)).is_ok() {
-                disp.draw(
-                    Font6x8::render_str(format_buf.as_str())
-                        .with_stroke(Some(1u8.into()))
-                        .translate(Coord::new(HINSET_PIX, VCENTER_PIX))
-                        .into_iter(),
-                );
+                   
+                let text_style = TextStyleBuilder::new(Font6x8)
+                    .text_color(BinaryColor::On)
+                    .build();
+            
+                Text::new(format_buf.as_str(), Point::new(HINSET_PIX, VCENTER_PIX))
+                    .into_styled(text_style)
+                    .draw(&mut disp).unwrap();                  
             }
             disp.flush().unwrap();
             //delay a little while between refreshes so the display is readable

examples/ssd1306-image.rs

@@ -19,7 +19,7 @@ extern crate stm32f4xx_hal as hal;
 
 use cortex_m_rt::ExceptionFrame;
 use cortex_m_rt::{entry, exception};
-use embedded_graphics::{image::Image1BPP, prelude::*};
+use embedded_graphics::{image::Image, image::ImageRaw, pixelcolor::BinaryColor, prelude::*};
 use ssd1306::{prelude::*, Builder as SSD1306Builder};
 
 use crate::hal::{i2c::I2c, prelude::*, stm32};
@@ -53,8 +53,9 @@ fn main() -> ! {
         disp.flush().unwrap();
 
         // Display the rustacean
-        let im = Image1BPP::new(include_bytes!("./ssd1306-image.data"), 128, 64);
-        disp.draw(im.into_iter());
+        let raw_image: ImageRaw<BinaryColor> = ImageRaw::new(include_bytes!("./ssd1306-image.data"), 128, 64);
+        let image: Image<_, BinaryColor> = Image::new(&raw_image, Point::zero());
+        image.draw(&mut disp).unwrap();
         disp.flush().unwrap();
 
         // Set up state for the loop

examples/stopwatch-with-ssd1306-and-interrupts.rs

@@ -37,10 +37,12 @@ use core::ops::DerefMut;
 use cortex_m::interrupt::{free, CriticalSection, Mutex};
 use cortex_m_rt::entry;
 use embedded_graphics::{
-    fonts::{Font12x16, Font6x12},
+    fonts::{Font12x16, Font6x12, Text},
     prelude::*,
+    pixelcolor::BinaryColor,  
+    style::TextStyleBuilder,
 };
-use ssd1306::{prelude::*, Builder as SSD1306Builder};
+use ssd1306::{mode::GraphicsMode, Builder as SSD1306Builder};
 
 // Set up global state. It's all mutexed up for concurrency safety.
 static ELAPSED_MS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0u32));
@@ -116,15 +118,22 @@ fn main() -> ! {
                 StopwatchState::Running => "",
                 StopwatchState::Stopped => "Stopped",
             };
-            let state_text = Font6x12::render_str(state_msg)
-                .with_stroke(Some(1u8.into()))
-                .translate(Coord::new(0, 0));
-            disp.draw(state_text.into_iter());
-
-            let elapsed_text = Font12x16::render_str(format_buf.as_str())
-                .with_stroke(Some(1u8.into()))
-                .translate(Coord::new(0, 14));
-            disp.draw(elapsed_text.into_iter());
+            
+            let text_style = TextStyleBuilder::new(Font6x12)
+                .text_color(BinaryColor::On)
+                .build();
+            
+            let text_style_format_buf = TextStyleBuilder::new(Font12x16)
+                .text_color(BinaryColor::On)
+                .build();
+        
+            Text::new(state_msg, Point::new(0, 0))
+            .into_styled(text_style)
+            .draw(&mut disp).unwrap();            
+            
+            Text::new(format_buf.as_str(), Point::new(0, 14))
+                .into_styled(text_style_format_buf)
+                .draw(&mut disp).unwrap();
 
             disp.flush().unwrap();
 

src/dwt.rs

@@ -72,21 +72,21 @@ impl Delay {
     /// Delay ticks
     /// NOTE DCB and DWT need to be set up for this to work, so it is private
     fn delay_ticks(mut start: u32, ticks: u64) {
-        if ticks < (u32::MAX / 2) as u64 {
+        if ticks < (core::u32::MAX / 2) as u64 {
             // Simple delay
             let ticks = ticks as u32;
             while (DWT::get_cycle_count().wrapping_sub(start)) < ticks {}
-        } else if ticks <= u32::MAX as u64 {
+        } else if ticks <= core::u32::MAX as u64 {
             // Try to avoid race conditions by limiting delay to u32::MAX / 2
             let mut ticks = ticks as u32;
-            ticks -= u32::MAX / 2;
-            while (DWT::get_cycle_count().wrapping_sub(start)) < u32::MAX / 2 {}
-            start -= u32::MAX / 2;
+            ticks -= core::u32::MAX / 2;
+            while (DWT::get_cycle_count().wrapping_sub(start)) < core::u32::MAX / 2 {}
+            start -= core::u32::MAX / 2;
             while (DWT::get_cycle_count().wrapping_sub(start)) < ticks {}
         } else {
             // Delay for ticks, then delay for rest * u32::MAX
             let mut rest = (ticks >> 32) as u32;
-            let ticks = (ticks & u32::MAX as u64) as u32;
+            let ticks = (ticks & core::u32::MAX as u64) as u32;
             loop {
                 while (DWT::get_cycle_count().wrapping_sub(start)) < ticks {}
                 if rest == 0 {