eepy-launcher: implement all serial commands eepytool: initial commit elf2epb: fix padding handling

.idea/epd_firmware.iml

···
       <sourceFolder url="file://$MODULE_DIR$/eepy-sys/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/eepy/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/eepy-launcher/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/eepytool/src" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/fw16_epd_bsp/target" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
       <excludeFolder url="file://$MODULE_DIR$/fw16-epd-bsp/target" />

Cargo.toml

···
     "eepy-example-app",
     "elf2epb",
     "pervasive-spi",
-    "tp370pgh01", "eepy-launcher",
+    "tp370pgh01",
+    "eepy-launcher",
+    "eepytool",
 ]
 
 [workspace.dependencies]
···
 once_cell = { version = "1.20", default-features = false, features = ["critical-section"] }
 postcard = "1.1"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
+elf = "0.7"
+clap = { version = "4.5", features = ["derive"] }
+serialport = "4.7"
+tar = "0.4"
+zstd = "0.13"

eepy-gui/src/element/button.rs

···
 use embedded_graphics::primitives::{CornerRadii, PrimitiveStyle, Rectangle, RoundedRectangle};
 use embedded_graphics::text::{Alignment, Baseline, Text, TextStyle, TextStyleBuilder};
 use embedded_graphics::text::renderer::TextRenderer;
-use eepy_sys::input::{Event, TouchEventType};
+use eepy_sys::input_common::{Event, TouchEventType};
 use crate::draw_target::EpdDrawTarget;
 use crate::element::{Gui, DEFAULT_PRIMITIVE_STYLE, DEFAULT_TEXT_STYLE};
 

eepy-gui/src/element/mod.rs

···
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::prelude::*;
 use embedded_graphics::primitives::{PrimitiveStyle, PrimitiveStyleBuilder, Rectangle};
-use eepy_sys::input::Event;
+use eepy_sys::input_common::Event;
 use tp370pgh01::{DIM_X, DIM_Y};
 use crate::draw_target::EpdDrawTarget;
 

eepy-gui/src/element/slider.rs

···
 use embedded_graphics::geometry::Point;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::primitives::{Circle, Line, PrimitiveStyle, Rectangle};
-use eepy_sys::input::{Event, TouchEventType};
+use eepy_sys::input_common::{Event, TouchEventType};
 use crate::draw_target::EpdDrawTarget;
 use crate::element::{Gui, DEFAULT_PRIMITIVE_STYLE};
 

eepy-launcher/Cargo.toml

···
 usbd-serial.workspace = true
 portable-atomic.workspace = true
 heapless.workspace = true
+postcard.workspace = true
 panic-halt = "1.0"

eepy-launcher/src/main.rs

···
 use eepy_gui::element::slider::Slider;
 use eepy_sys::exec::exec;
 use eepy_sys::image::RefreshBlockMode;
-use eepy_sys::input::{has_event, next_event, set_touch_enabled, Event, TouchEventType};
+use eepy_sys::input::{has_event, next_event, set_touch_enabled};
+use eepy_sys::input_common::{Event, TouchEventType};
 use eepy_sys::header::{ProgramSlotHeader, Programs};
-use eepy_sys::misc::{get_serial};
+use eepy_sys::misc::get_serial;
 use eepy_sys::usb;
 use eepy_sys::usb::UsbBus;
 use usb_device::prelude::*;
 use usbd_serial::SerialPort;
-use crate::serial::NEEDS_REFRESH_PROGRAMS;
+use crate::serial::{HOST_APP, NEEDS_REFRESH, NEEDS_REFRESH_PROGRAMS};
 
 #[link_section = ".header"]
 #[used]
···
     draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
 
     loop {
-        while let Some(ev) = next_event() {
-            gui.tick(&mut draw_target, ev);
-        }
+        if !HOST_APP.load(Ordering::Relaxed) {
+            while let Some(ev) = next_event() {
+                gui.tick(&mut draw_target, ev);
+            }
 
-        if !has_event() {
-            // has_event() is a syscall. The SVCall exception is a WFE wakeup event, so we need two
-            // WFEs so we don't immediately wake up.
-            unsafe { asm!("wfe", "wfe") };
-        }
-
-        if NEEDS_REFRESH_PROGRAMS.swap(false, Ordering::Relaxed) {
-            gui.main_page.refresh_buttons();
-            if gui.current_page == Page::MainPage {
+            if NEEDS_REFRESH_PROGRAMS.swap(false, Ordering::Relaxed) {
+                gui.main_page.refresh_buttons();
+                if gui.current_page == Page::MainPage {
+                    gui.draw_init(&mut draw_target);
+                    draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+                }
+            } else if NEEDS_REFRESH.swap(false, Ordering::Relaxed) {
                 gui.draw_init(&mut draw_target);
                 draw_target.refresh(false, RefreshBlockMode::BlockAcknowledge);
+            } else if !has_event() {
+                // has_event() is a syscall. The SVCall exception is a WFE wakeup event, so we need two
+                // WFEs so we don't immediately wake up.
+                unsafe { asm!("wfe", "wfe") };
             }
         }
     }

eepy-launcher/src/serial.rs

···
 use core::sync::atomic::Ordering;
 use core::fmt::Write;
-use portable_atomic::AtomicBool;
+use portable_atomic::{AtomicBool, AtomicU8};
 use usb_device::device::UsbDevice;
 use usbd_serial::SerialPort;
 use eepy_serial::{Response, SerialCommand};
 use eepy_sys::flash::{erase_and_program, invalidate_cache};
 use eepy_sys::image::{refresh, write_image, RefreshBlockMode};
 use eepy_sys::IMAGE_BYTES;
-use eepy_sys::misc::{debug, trace};
+use eepy_sys::input::{next_event, set_touch_enabled};
+use eepy_sys::misc::{debug, info, trace};
 use eepy_sys::usb::UsbBus;
 use crate::{USB_DEVICE, USB_SERIAL};
 
···
     }
 }
 
+pub(crate) static NEEDS_REFRESH: AtomicBool = AtomicBool::new(false);
 pub(crate) static NEEDS_REFRESH_PROGRAMS: AtomicBool = AtomicBool::new(false);
+pub(crate) static HOST_APP: AtomicBool = AtomicBool::new(false);
+
+static PROG_SLOT: AtomicU8 = AtomicU8::new(0);
 
 pub(crate) extern "C" fn usb_handler() {
     trace("USB handler");
···
     let buf = unsafe { &mut BUF };
 
     if dev.poll(&mut [serial]) {
+        let mut s = heapless::String::<100>::new();
+        write!(s, "{state:?}").unwrap();
+        debug(&s);
+
         match state {
             SerialState::ReadyForCommand => {
                 let mut cmd_buf = [0u8];
···
                         return;
                     }
 
-                    match SerialCommand::try_from(cmd_buf[0]) {
-                        Ok(SerialCommand::RefreshNormal) => *state = SerialState::ReceivingImage { fast_refresh: false, index: 0 },
-                        Ok(SerialCommand::RefreshFast) => *state = SerialState::ReceivingImage { fast_refresh: true, index: 0 },
-                        Ok(SerialCommand::UploadProgram) => *state = SerialState::FlashingProgram { index: 0, page: 0, num_pages: None, remainder: None },
-                        Ok(_) => write_all(serial, &[Response::UnknownCommand as u8]),
-                        Err(_) => write_all(serial, &[Response::UnknownCommand as u8]),
+                    if HOST_APP.load(Ordering::Relaxed) {
+                        match SerialCommand::try_from(cmd_buf[0]) {
+                            Ok(SerialCommand::RefreshNormal) => *state = SerialState::ReceivingImage { fast_refresh: false, index: 0 },
+                            Ok(SerialCommand::RefreshFast) => *state = SerialState::ReceivingImage { fast_refresh: true, index: 0 },
+                            Ok(SerialCommand::ExitHostApp) => {
+                                set_touch_enabled(true);
+                                HOST_APP.store(false, Ordering::Relaxed);
+                                NEEDS_REFRESH.store(true, Ordering::Relaxed);
+                                write_all(serial, &[Response::Ack as u8]);
+                            },
+                            Ok(SerialCommand::NextEvent) => {
+                                write_all(serial, &[Response::Ack as u8]);
+                                write_all(serial, &postcard::to_vec::<_, 32>(&next_event()).unwrap());
+                            },
+                            Ok(SerialCommand::EnableTouch) => {
+                                set_touch_enabled(true);
+                                write_all(serial, &[Response::Ack as u8]);
+                            },
+                            Ok(SerialCommand::DisableTouch) => {
+                                set_touch_enabled(false);
+                                write_all(serial, &[Response::Ack as u8]);
+                            },
+                            Ok(SerialCommand::EnterHostApp | SerialCommand::GetProgramSlot | SerialCommand::UploadProgram) => {
+                                write_all(serial, &[Response::IncorrectMode as u8]);
+                            }
+                            Err(_) => write_all(serial, &[Response::UnknownCommand as u8]),
+                        }
+                    } else {
+                        match SerialCommand::try_from(cmd_buf[0]) {
+                            Ok(SerialCommand::GetProgramSlot) => {
+                                write_all(serial, &[Response::Ack as u8, 1]);
+                                PROG_SLOT.store(1, Ordering::Relaxed);
+                            },
+                            Ok(SerialCommand::UploadProgram) => {
+                                if PROG_SLOT.load(Ordering::Relaxed) == 0 {
+                                    write_all(serial, &[Response::NoProgramSlot as u8]);
+                                } else {
+                                    *state = SerialState::FlashingProgram { index: 0, page: 0, num_pages: None, remainder: None };
+                                    write_all(serial, &[Response::Ack as u8]);
+                                }
+                            },
+                            Ok(SerialCommand::EnterHostApp) => {
+                                HOST_APP.store(true, Ordering::Relaxed);
+                                write_image(&[0u8; IMAGE_BYTES]);
+                                refresh(false, RefreshBlockMode::NonBlocking);
+                                set_touch_enabled(false);
+                                write_all(serial, &[Response::Ack as u8]);
+                            },
+                            Ok(
+                                SerialCommand::RefreshNormal
+                                | SerialCommand::RefreshFast
+                                | SerialCommand::ExitHostApp
+                                | SerialCommand::NextEvent
+                                | SerialCommand::DisableTouch
+                                | SerialCommand::EnableTouch
+                            ) => write_all(serial, &[Response::IncorrectMode as u8]),
+                            Err(_) => write_all(serial, &[Response::UnknownCommand as u8]),
+                        }
                     }
                 }
             }
···
                             // Actually write the flash page
                             // TODO: get next slot instead of always using slot 1
                             // TODO: wear levelling
+                            debug("writing page");
                             unsafe { write_flash(&buf[4096..8192], 1, *page) };
 
                             *page += 1;
                             // If this is the last page, also flash the first page which we didn't
                             // do at the start
                             if *page == num_pages {
+                                debug("finalising");
                                 unsafe { write_flash(&buf[0..4096], 1, 0) };
 
+                                debug("invalidating XIP cache");
                                 // Invalidate the XIP cache, in case something from the flash area
                                 // we just wrote is in there
-                                unsafe { invalidate_cache() }
+                                unsafe { invalidate_cache() };
+                                debug("invalidated XIP cache");
 
                                 NEEDS_REFRESH_PROGRAMS.store(true, Ordering::Relaxed);
-                                debug("Finished writing program");
+                                info("Finished writing program");
 
                                 *state = SerialState::ReadyForCommand;
                             }

eepy-serial/Cargo.toml

···
 version = "0.1.0"
 edition = "2021"
 
-[dependencies]
+[dependencies]
+eepy-sys = { path = "../eepy-sys" }

eepy-serial/src/lib.rs

···
 #![no_std]
 
+pub use eepy_sys::input_common::Event;
+
+use core::fmt::{Display, Formatter};
+
 #[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum SerialCommand {
     /// Refresh the screen. Must be followed by exactly 12480 bytes of image data.
     RefreshNormal = 0,
···
     /// only available when not in Host App mode.
     GetProgramSlot = 7,
     /// Upload a program. The program will be stored in the slot returned by the previous
-    /// GetProgramSlot call. The host program should
+    /// GetProgramSlot call. The program uploaded must be linked correctly for the
+    /// slot. Only available when not in Host App mode.
     UploadProgram = 8,
 }
 
···
 }
 
 #[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum Response {
     UnknownCommand = 0x00,
     IncorrectMode = 0x01,
···
     Ack = 0xff,
 }
 
+impl From<Response> for Result<(), SerialError> {
+    fn from(value: Response) -> Self {
+        match value {
+            Response::UnknownCommand => Err(SerialError::UnknownCommand),
+            Response::IncorrectMode => Err(SerialError::IncorrectMode),
+            Response::ProgramSlotsFull => Err(SerialError::ProgramSlotsFull),
+            Response::NoProgramSlot => Err(SerialError::NoProgramSlot),
+            Response::Ack => Ok(()),
+        }
+    }
+}
+
+impl Display for Response {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Response::UnknownCommand => write!(f, "Invalid command"),
+            Response::IncorrectMode => write!(f, "Incorrect mode"),
+            Response::ProgramSlotsFull => write!(f, "No program slot is available"),
+            Response::NoProgramSlot => write!(f, "Call GetProgramSlot before UploadProgram"),
+            Response::Ack => write!(f, "Success"),
+        }
+    }
+}
+
 impl TryFrom<u8> for Response {
     type Error = ();
 
···
             _ => Err(()),
         }
     }
-}
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum SerialError {
+    UnknownCommand,
+    IncorrectMode,
+    ProgramSlotsFull,
+    NoProgramSlot,
+}
+
+impl Display for SerialError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self {
+            SerialError::UnknownCommand => write!(f, "Invalid command"),
+            SerialError::IncorrectMode => write!(f, "Incorrect mode"),
+            SerialError::ProgramSlotsFull => write!(f, "No program slot is available"),
+            SerialError::NoProgramSlot => write!(f, "Call GetProgramSlot before UploadProgram"),
+        }
+    }
+}
+
+impl core::error::Error for SerialError {}

eepy-sys/src/input.rs

···
-use core::fmt::{Display, Formatter};
 use core::mem::MaybeUninit;
 use crate::{syscall, SafeOption};
+use crate::input_common::Event;
 use crate::syscall::SyscallNumber;
 
 #[repr(usize)]
···
             x if x == InputSyscall::HasEvent as usize => Ok(InputSyscall::HasEvent),
             _ => Err(()),
         }
-    }
-}
-
-#[repr(C)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
-pub enum Event {
-    Touch(TouchEvent),
-    RefreshFinished,
-}
-
-#[repr(u8)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
-pub enum TouchEventType {
-    Down,
-    Up,
-    Move,
-}
-
-#[repr(C)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct TouchEvent {
-    pub ev_type: TouchEventType,
-    pub x: u16,
-    pub y: u16,
-}
-
-impl TouchEvent {
-    pub const fn new() -> Self {
-        Self {
-            ev_type: TouchEventType::Down,
-            x: u16::MAX,
-            y: u16::MAX,
-        }
-    }
-
-    #[cfg(feature = "embedded-graphics")]
-    pub fn eg_point(&self) -> embedded_graphics::prelude::Point {
-        embedded_graphics::prelude::Point::new(self.x as i32, self.y as i32)
-    }
-}
-
-impl Display for TouchEvent {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        let ty = match self.ev_type {
-            TouchEventType::Down => "Down",
-            TouchEventType::Up => "Up",
-            TouchEventType::Move => "Move",
-        };
-        write!(f, "{ty} @ ({}, {})", self.x, self.y)
     }
 }
 

eepy-sys/src/input_common.rs

···
+use core::fmt::{Display, Formatter};
+
+#[repr(C)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+pub enum Event {
+    Touch(TouchEvent),
+    RefreshFinished,
+}
+
+#[repr(u8)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+pub enum TouchEventType {
+    Down,
+    Up,
+    Move,
+}
+
+#[repr(C)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct TouchEvent {
+    pub ev_type: TouchEventType,
+    pub x: u16,
+    pub y: u16,
+}
+
+impl TouchEvent {
+    pub const fn new() -> Self {
+        Self {
+            ev_type: TouchEventType::Down,
+            x: u16::MAX,
+            y: u16::MAX,
+        }
+    }
+
+    #[cfg(feature = "embedded-graphics")]
+    pub fn eg_point(&self) -> embedded_graphics::prelude::Point {
+        embedded_graphics::prelude::Point::new(self.x as i32, self.y as i32)
+    }
+}
+
+impl Display for TouchEvent {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        let ty = match self.ev_type {
+            TouchEventType::Down => "Down",
+            TouchEventType::Up => "Up",
+            TouchEventType::Move => "Move",
+        };
+        write!(f, "{ty} @ ({}, {})", self.x, self.y)
+    }
+}

eepy-sys/src/lib.rs

···
 #![no_std]
 
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod header;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod syscall;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod misc;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod image;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod input;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod usb;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod exec;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod critical_section;
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 pub mod flash;
+pub mod input_common;
+
 
 #[cfg(feature = "critical-section-impl")]
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 mod critical_section_impl;
 
 pub use tp370pgh01::IMAGE_BYTES;

eepy-sys/src/syscall.rs

···
 
 /// Perform a raw system call.
 #[macro_export]
+#[cfg(all(target_os = "none", target_arch = "arm"))]
 macro_rules! syscall {
     (
         $syscall_num:expr,
···
             syscall_num = const $syscall_num as u8,
         )
     }
+}
+
+#[macro_export]
+#[cfg(not(all(target_os = "none", target_arch = "arm")))]
+macro_rules! syscall {
+    ( $( $_foo:tt )* ) => { panic!("Cannot use eepyOS syscalls on non-eepyOS platforms") };
 }

eepy/src/main.rs

···
 use fw16_epd_bsp::hal::timer::{Alarm, Alarm0};
 use fw16_epd_bsp::pac::I2C0;
 use fw16_epd_bsp::pac::interrupt;
-use eepy_sys::input::{Event, TouchEvent, TouchEventType};
+use eepy_sys::input_common::{Event, TouchEvent, TouchEventType};
 use tp370pgh01::rp2040::{Rp2040PervasiveSpiDelays, IoPin};
 use tp370pgh01::{Tp370pgh01, IMAGE_BYTES};
 use crate::ringbuffer::RingBuffer;
···
 
     let mut timer = Timer::new(pac.TIMER, &mut pac.RESETS, &clocks);
     // make sure temperature sensor has read temperature
-    //timer.delay_ms(35);
+    timer.delay_ms(35);
     let mut alarm = timer.alarm_0().unwrap();
     alarm.enable_interrupt();
     critical_section::with(|cs| GLOBAL_ALARM0.borrow_ref_mut(cs).replace(alarm));
···
     pac::NVIC::pend(interrupt::TIMER_IRQ_0);
 
     usb::init_usb(pac.USBCTRL_REGS, pac.USBCTRL_DPRAM, clocks.usb_clock);
-
-    /*
-    let usb_bus = UsbBusAllocator::new(hal::usb::UsbBus::new(
-        pac.USBCTRL_REGS,
-        pac.USBCTRL_DPRAM,
-        clocks.usb_clock,
-        true,
-        &mut pac.RESETS,
-    ));
-
-    unsafe {
-        GLOBAL_USB_BUS = Some(usb_bus);
-    }
-
-    // Safety: These are only accessed within this interrupt handler, or in main() before the
-    // interrupt is enabled.
-    #[allow(static_mut_refs)]
-    let bus_ref = unsafe { GLOBAL_USB_BUS.as_ref().unwrap() };
-
-    let serial = SerialPort::new(bus_ref);
-    let usb_device = UsbDeviceBuilder::new(bus_ref, UsbVidPid(0x2e8a, 0x000a))
-        .strings(&[StringDescriptors::default()
-            .manufacturer("arthomnix")
-            .product("Touchscreen EPD Input Module for Framework 16 [eepyOS]")
-            .serial_number(get_serial())
-        ])
-        .unwrap()
-        .device_class(usbd_serial::USB_CLASS_CDC)
-        .build();
-
-    unsafe {
-        GLOBAL_USB_SERIAL = Some(serial);
-        GLOBAL_USB_DEVICE = Some(usb_device);
-    }
-
-    unsafe {
-        core.NVIC.set_priority(interrupt::USBCTRL_IRQ, 0b11000000);
-        pac::NVIC::unmask(interrupt::USBCTRL_IRQ);
-
-        // FIXME testing
-        core.NVIC.set_priority(interrupt::SW5_IRQ, 0b11000000);
-        pac::NVIC::unmask(interrupt::SW5_IRQ);
-    }
-     */
 
     unsafe {
         core.NVIC.set_priority(interrupt::USBCTRL_IRQ, 0b11000000);

eepy/src/syscall.rs

···
 
 mod input {
     use core::sync::atomic::Ordering;
-    use eepy_sys::input::{Event, InputSyscall};
+    use eepy_sys::input::InputSyscall;
+    use eepy_sys::input_common::Event;
     use eepy_sys::SafeOption;
     use crate::{EVENT_QUEUE, TOUCH_ENABLED};
     use super::StackFrame;
···
 }
 
 mod flash {
+    use core::arch::asm;
     use core::sync::atomic::Ordering;
     use eepy_sys::flash::FlashSyscall;
     use eepy_sys::header::{SLOT_SIZE, XIP_BASE};
···
             let xip = pac::Peripherals::steal().XIP_CTRL;
             xip.flush().write(|w| w.flush().set_bit());
             xip.flush().read();
+            asm!("dsb", "isb");
         };
     }
 }

eepy/src/usb.rs

···
 use core::fmt::{Debug, Formatter};
 use core::sync::atomic::Ordering;
 use critical_section::Mutex;
-use defmt::{debug, trace, warn};
+use defmt::{trace, warn};
 use portable_atomic::AtomicPtr;
 use eepy_sys::usb::{SafePollResult, SafeUsbError, UsbEpAllocArgs, UsbReadArgs, UsbSyscall, UsbWriteArgs};
 use fw16_epd_bsp::hal::clocks::UsbClock;

eepytool/Cargo.toml

···
+[package]
+name = "eepytool"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+eepy-serial = { path = "../eepy-serial" }
+postcard.workspace = true
+clap.workspace = true
+serialport.workspace = true
+tar.workspace = true
+zstd.workspace = true

eepytool/src/main.rs

···
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use std::time::Duration;
+use clap::{Parser, Subcommand};
+use serialport::SerialPort;
+use tar::Archive;
+use eepy_serial::{Event, Response, SerialCommand, SerialError};
+
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+struct Args {
+    #[arg(short = 'p', long)]
+    serial_port: String,
+
+    #[command(subcommand)]
+    command: Subcommands,
+}
+
+#[derive(Subcommand, Debug)]
+enum Subcommands {
+    EnterHostApp,
+    ExitHostApp,
+
+    Refresh {
+        #[arg(long, action)]
+        fast: bool,
+        #[arg(short, long)]
+        image: PathBuf,
+    },
+
+    DisableTouch,
+    EnableTouch,
+    NextEvent,
+
+    UploadProgram {
+        package: PathBuf,
+    },
+}
+
+use Subcommands::*;
+
+fn write(serial: &mut Box<dyn SerialPort>, command: SerialCommand, data: &[u8]) -> Result<(), SerialError> {
+    serial.write_all(&[command as u8]).unwrap();
+    serial.write_all(data).unwrap();
+    let mut response_buf = [0u8];
+    serial.read_exact(&mut response_buf).unwrap();
+    Response::try_from(response_buf[0]).unwrap().into()
+}
+
+fn next_event(serial: &mut Box<dyn SerialPort>) -> Result<Option<Event>, SerialError> {
+    write(serial, SerialCommand::NextEvent, &[])?;
+    let mut event_buf = [0u8; 32];
+    serial.read(&mut event_buf).unwrap();
+    Ok(postcard::from_bytes(&event_buf).unwrap())
+}
+
+fn upload_program(serial: &mut Box<dyn SerialPort>, path: PathBuf) -> Result<(), SerialError> {
+    write(serial, SerialCommand::GetProgramSlot, &[])?;
+    let mut slot_n = [0u8];
+    serial.read_exact(&mut slot_n).unwrap();
+    let slot_n = slot_n[0];
+
+    let file = File::open(path).unwrap();
+    let zstd_reader = zstd::stream::read::Decoder::new(file).unwrap();
+    let mut tar = Archive::new(zstd_reader);
+    for file in tar.entries().unwrap() {
+        let mut file = file.unwrap();
+        if file.path().unwrap().to_str().unwrap().ends_with(&format!(".s{slot_n:02}.epb")) {
+            println!("Uploading {}", file.path().unwrap().to_str().unwrap());
+            let mut buf = vec![0u8; file.size() as usize];
+            file.read_exact(&mut buf).unwrap();
+            write(serial, SerialCommand::UploadProgram, &buf)?;
+            return Ok(());
+        }
+    }
+
+    panic!("App package did not contain binary for slot {slot_n}");
+}
+
+fn main() {
+    let args = Args::parse();
+
+    // Baud rate setting doesn't matter for pure USB serial so use 0
+    let mut port = serialport::new(&args.serial_port, 0)
+        .timeout(Duration::from_secs(60))
+        .open()
+        .expect(&format!("Failed to open serial port {}", args.serial_port));
+
+    match args.command {
+        EnterHostApp => write(&mut port, SerialCommand::EnterHostApp, &[]).unwrap(),
+        ExitHostApp => write(&mut port, SerialCommand::ExitHostApp, &[]).unwrap(),
+        Refresh { fast, image } => {
+            let data = std::fs::read(image).unwrap();
+            let cmd = if fast { SerialCommand::RefreshFast } else { SerialCommand::RefreshNormal };
+            write(&mut port, cmd, &data).unwrap();
+        },
+        DisableTouch => write(&mut port, SerialCommand::DisableTouch, &[]).unwrap(),
+        EnableTouch => write(&mut port, SerialCommand::EnableTouch, &[]).unwrap(),
+        NextEvent => println!("{:?}", next_event(&mut port).unwrap()),
+        UploadProgram { package } => upload_program(&mut port, package).unwrap(),
+    };
+}

elf2epb/Cargo.toml

···
 edition = "2021"
 
 [dependencies]
-elf = "0.7"
-clap = { version = "4.5", features = ["derive"] }
+elf.workspace = true
+clap.workspace = true
 crc32fast.workspace = true

elf2epb/src/main.rs

···
                 for _ in 0..diff {
                     bin.push(0);
                 }
+                *current_addr = phdr.p_paddr as u32;
             }
 
             let segment_data = elf.segment_data(&phdr).expect("Failed to parse ELF file");