display: Use write!() in display code.

Only 100-200 bytes more flash usage.

display/firmware/src/display.rs

+use core::fmt::Write;
+
 use embedded_hal::blocking::delay::DelayUs;
 use embedded_hal::digital::v2::OutputPin;
 use epd_waveshare::epd4in2::EPD4in2;
     }
 }
 
+struct WriteBuffer<T> {
+    buffer: T,
+    length: usize,
+}
+
+impl<T> Write for WriteBuffer<T>
+where
+    T: AsMut<[u8]>,
+{
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        let bytes = s.as_bytes();
+        if bytes.len() <= self.buffer.as_mut().len() - self.length {
+            self.buffer.as_mut()[self.length..bytes.len() + self.length].copy_from_slice(bytes);
+            self.length += bytes.len();
+            Ok(())
+        } else {
+            Err(core::fmt::Error)
+        }
+    }
+}
+
+impl<T> WriteBuffer<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn to_str<'a>(&'a self) -> &'a str {
+        unsafe {
+            // Safe, we did not use any non-UTF characters above.
+            core::str::from_utf8_unchecked(&self.buffer.as_ref()[0..self.length])
+        }
+    }
+}
+
 struct TempHumStrings {
-    temp: [u8; 9],
-    temp_length: usize,
-    hum: [u8; 6],
-    hum_length: usize,
+    temp: WriteBuffer<[u8; 12]>,
+    hum: WriteBuffer<[u8; 12]>,
 }
 
 impl TempHumStrings {
     fn new(data: TemperatureHumidity) -> TempHumStrings {
-        // TODO: Refactor the printing code.
-        let (temp, temp_length) = {
-            let mut x = data.temperature;
-            let mut length = 0;
-            let mut buffer = [0u8; 9];
-            let mut cursor = &mut buffer[..];
-            if x < 0 {
-                cursor[0] = '-' as u8;
-                x = -x;
-                cursor = &mut cursor[1..];
-                length += 1;
-            }
-            let orig_x = x;
-            x = i32::min(x, 9999);
-            if orig_x >= 1000 {
-                cursor[0] = '0' as u8 + (x / 1000) as u8;
-                cursor = &mut cursor[1..];
-                x %= 1000;
-                length += 1;
-            }
-            if orig_x >= 100 {
-                cursor[0] = '0' as u8 + (x / 100) as u8;
-                cursor = &mut cursor[1..];
-                x %= 100;
-                length += 1;
-            }
-            cursor[0] = '0' as u8 + (x / 10) as u8;
-            cursor[1] = ',' as u8;
-            cursor[2] = '0' as u8 + (x % 10) as u8;
-            cursor[3] = 0xc2;
-            cursor[4] = 0xb0;
-            cursor[5] = 'C' as u8;
-            length += 6;
-            (buffer, length)
-        };
-        let (hum, hum_length) = {
-            let mut x = data.humidity;
-            let mut length = 0;
-            let mut buffer = [0u8; 6];
-            let mut cursor = &mut buffer[..];
-            x = u32::min(x, 1000);
-            let orig_x = x;
-            if orig_x >= 1000 {
-                cursor[0] = '1' as u8;
-                cursor = &mut cursor[1..];
-                x %= 1000;
-                length += 1;
-            }
-            if orig_x >= 100 {
-                cursor[0] = '0' as u8 + (x / 100) as u8;
-                cursor = &mut cursor[1..];
-                x %= 100;
-                length += 1;
-            }
-            cursor[0] = '0' as u8 + (x / 10) as u8;
-            cursor[1] = ',' as u8;
-            cursor[2] = '0' as u8 + (x % 10) as u8;
-            cursor[3] = '%' as u8;
-            length += 4;
-            (buffer, length)
+        let mut strings = TempHumStrings {
+            temp: WriteBuffer {
+                buffer: [0u8; 12],
+                length: 0,
+            },
+            hum: WriteBuffer {
+                buffer: [0u8; 12],
+                length: 0,
+            },
         };
-        TempHumStrings {
-            temp,
-            temp_length,
-            hum,
-            hum_length,
-        }
+        write!(
+            strings.temp,
+            "{},{}°C",
+            data.temperature / 10,
+            (data.temperature % 10).abs()
+        )
+        .ok();
+        write!(
+            strings.hum,
+            "{},{}%",
+            data.humidity / 10,
+            data.humidity % 10
+        )
+        .ok();
+        strings
     }
 
     fn temperature<'a>(&'a self) -> &'a str {
-        unsafe {
-            // Safe, we did not use any non-UTF characters above.
-            core::str::from_utf8_unchecked(&self.temp[0..self.temp_length])
-        }
+        self.temp.to_str()
     }
 
     fn humidity<'a>(&'a self) -> &'a str {
-        unsafe {
-            // Safe, we did not use any non-UTF characters above.
-            core::str::from_utf8_unchecked(&self.hum[0..self.hum_length])
-        }
+        self.hum.to_str()
     }
 }
 
     }
 }
 
-struct PressureString {
-    buffer: [u8; 9],
-    length: usize,
-}
+struct PressureString(WriteBuffer<[u8; 12]>);
 
 impl PressureString {
     fn new(pressure: u32) -> PressureString {
-        let mut x = pressure;
-        let mut length = 0;
-        let mut buffer = [0u8; 9];
-        let mut cursor = &mut buffer[..];
-        // Round to one decimal place.
-        x = (x + 5) / 10;
-        x = u32::min(x, 99999);
-        if pressure >= 10000 {
-            cursor[0] = '0' as u8 + (x / 10000) as u8;
-            cursor = &mut cursor[1..];
-            x %= 10000;
-            length += 1;
-        }
-        if pressure >= 1000 {
-            cursor[0] = '0' as u8 + (x / 1000) as u8;
-            cursor = &mut cursor[1..];
-            x %= 1000;
-            length += 1;
-        }
-        if pressure >= 100 {
-            cursor[0] = '0' as u8 + (x / 100) as u8;
-            cursor = &mut cursor[1..];
-            x %= 100;
-            length += 1;
-        }
-        cursor[0] = '0' as u8 + (x / 10) as u8;
-        cursor[1] = ',' as u8;
-        cursor[2] = '0' as u8 + (x % 10) as u8;
-        cursor[3] = 'h' as u8;
-        cursor[4] = 'P' as u8;
-        cursor[5] = 'a' as u8;
-        length += 6;
-        PressureString { buffer, length }
+        let pressure = (pressure + 5) / 10;
+        let mut buffer = WriteBuffer {
+            buffer: [0u8; 12],
+            length: 0,
+        };
+        write!(buffer, "{},{}hPa", pressure / 10, pressure % 10).ok();
+        PressureString(buffer)
     }
 
     fn to_str<'a>(&'a self) -> &'a str {
-        unsafe {
-            // Safe, we did not use any non-UTF characters above.
-            core::str::from_utf8_unchecked(&self.buffer[0..self.length])
-        }
+        self.0.to_str()
     }
 }