rhetenor/creaturedex
1
0
Fork 0
Code Issues 22 Pull Requests Packages Projects 1 Releases Wiki Activity

Implemented tertiary LCD display

Browse Source
This commit is contained in:
lukas
2026-08-22 18:25:48 +02:00
parent b44ae59c8b
commit 07c5210d7b
7 changed files with 251 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bin/main.rs
+26 -6
View File
@@ -11,14 +11,19 @@ use alloc::boxed::Box;
use creaturedex::card::decoder::split_nfc_hex;
use creaturedex::card::model::Card;
use creaturedex::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd};
use creaturedex::display::tertiary_lcd::{init_tertiary_lcd, write_wrapped};
use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
use creaturedex::navigation::inputs::Inputs;
use creaturedex::navigation::navigation::{self, CARD_DATA};
use creaturedex::network::wifi::setup_wifi;
use embassy_executor::Spawner;
use embedded_hal_bus::i2c::AtomicDevice;
use embedded_hal_bus::util::AtomicCell;
use esp_hal::Blocking;
use esp_hal::clock::CpuClock;
use esp_hal::gpio::{Input, InputConfig, Pull};
use esp_hal::timer::timg::TimerGroup;
use esp_hal::i2c::master::{Config as I2cConfig, I2c};
use log::error;
#[panic_handler]
@@ -63,14 +68,29 @@ async fn main(spawner: Spawner) {
peripherals.GPIO12, // shared dc
)));
setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
let config = I2cConfig::default().with_frequency(esp_hal::time::Rate::from_khz(20));
let i2c = match I2c::new(peripherals.I2C0, config) {
Ok(bus) => bus.with_sda(peripherals.GPIO17).with_scl(peripherals.GPIO18),
Err(e) => {
log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
panic!("Shared I2C bus initialization failed");
}
};
let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
let mut nfc_driver =
NfcPn532Driver::new(peripherals.I2C0, peripherals.GPIO17, peripherals.GPIO18);
let mut lcd = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
if let Err(_) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
log::error!("Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses");
}
// setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
if nfc_driver.configure_sam().await.is_ok() {
log::info!("NFC SAM configuration successful");
log::info!("NFC SAM configuration successful on the shared I2C bus");
} else {
log::error!("NFC SAM configuration failed");
log::error!("NFC SAM configuration failed on the shared I2C bus");
}
let button_config = InputConfig::default().with_pull(Pull::Up);
@@ -90,7 +110,7 @@ async fn main(spawner: Spawner) {
#[embassy_executor::task]
async fn nfc_driver_task(mut nfc_driver: NfcPn532Driver<'static>) {
async fn nfc_driver_task(mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>) {
loop {
while CARD_DATA.lock().await.is_none() {
match nfc_driver.read_card_data().await {
src/display/tertiary_lcd.rs
+88 -1
View File
@@ -1 +1,88 @@
// Tertiary LCD module
use embedded_hal::i2c::I2c;
use esp_hal::delay::Delay;
use i2c_character_display::{CharacterDisplayPCF8574T, LcdDisplayType};
use log::error;
pub type TertiaryLcd<I2C> = CharacterDisplayPCF8574T<I2C, Delay>;
pub fn init_tertiary_lcd<I2C>(i2c: I2C) -> TertiaryLcd<I2C>
where
I2C: I2c,
{
let mut lcd = CharacterDisplayPCF8574T::new(i2c, LcdDisplayType::Lcd16x2, Delay::new());
match lcd.init() {
Ok(()) => {
log::info!("I2C tertiary LCD initialized on PCF8574T at address 0x27");
lcd
}
Err(_) => {
error!("I2C tertiary LCD init failed on PCF8574T at address 0x27; check bus wiring, power, and device address");
panic!("tertiary LCD initialization failed");
}
}
}
pub fn write_line<I2C>(
lcd: &mut TertiaryLcd<I2C>,
line: u8,
text: &str,
) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
where
I2C: I2c,
{
if let Err(e) = lcd.set_cursor(0, line) {
error!("I2C LCD cursor move failed on line {line}; bus or device may be unavailable");
return Err(e);
}
if let Err(e) = lcd.print(text) {
error!("I2C LCD print failed on line {line}; payload length={} and device may be busy or disconnected", text.len());
return Err(e);
}
Ok(())
}
pub fn write_wrapped<I2C>(
lcd: &mut TertiaryLcd<I2C>,
text: &str,
) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
where
I2C: I2c,
{
const DISPLAY_WIDTH: usize = 16;
const DISPLAY_ROWS: usize = 2;
if let Err(e) = lcd.clear() {
error!("I2C LCD clear failed before wrapped write; check the shared bus and display response");
return Err(e);
}
let mut offset = 0;
for row in 0..DISPLAY_ROWS {
let remaining = &text[offset..];
if remaining.is_empty() {
return Ok(());
}
let chunk = if remaining.len() > DISPLAY_WIDTH {
&remaining[..DISPLAY_WIDTH]
} else {
remaining
};
if let Err(e) = lcd.set_cursor(0, row as u8) {
error!("I2C LCD cursor move failed while writing wrapped row {row}; bus may be busy or device unresponsive");
return Err(e);
}
if let Err(e) = lcd.print(chunk) {
error!("I2C LCD wrapped write failed on row {row}; chunk length={} and text may exceed display width", chunk.len());
return Err(e);
}
offset += chunk.len();
if offset >= text.len() {
return Ok(());
}
}
Ok(())
}
src/drivers/nfc_pn532.rs
+23 -27
View File
@@ -1,9 +1,7 @@
use alloc::vec::Vec;
use core::convert::Infallible;
use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
use esp_hal::i2c::master::{Config as I2cConfig, I2c};
use esp_hal::peripherals::I2C0;
use esp_hal::time::{Duration, Instant, Rate};
use embedded_hal::i2c::I2c;
use esp_hal::time::{Duration, Instant};
use log::{error, info};
use pn532::i2c::I2CInterface;
use pn532::requests::SAMMode;
@@ -55,25 +53,21 @@ impl pn532::CountDown for TimerWrapper {
}
}
pub type Pn532Device<'a> = Pn532<I2CInterface<I2c<'a, esp_hal::Blocking>>, (), 32>;
pub type Pn532Device<I2C> = Pn532<I2CInterface<I2C>, (), 32>;
/// PN532 NFC reader driver.
pub struct NfcPn532Driver<'a> {
pn532: Pn532Device<'a>,
pub struct NfcPn532Driver<I2C>
where
I2C: I2c,
{
pn532: Pn532Device<I2C>,
}
impl<'a> NfcPn532Driver<'a> {
pub fn new<SDA, SCL>(i2c0: I2C0<'static>, sda: SDA, scl: SCL) -> Self
where
SDA: PeripheralInput<'static> + PeripheralOutput<'static>,
SCL: PeripheralInput<'static> + PeripheralOutput<'static>,
{
let config = I2cConfig::default().with_frequency(Rate::from_khz(20));
let i2c = I2c::new(i2c0, config)
.expect("Failed to init I2C")
.with_sda(sda)
.with_scl(scl);
impl<I2C> NfcPn532Driver<I2C>
where
I2C: I2c,
{
pub fn new(i2c: I2C) -> Self {
let pn532 = Pn532::new_async(I2CInterface { i2c });
Self { pn532 }
}
@@ -83,10 +77,10 @@ impl<'a> NfcPn532Driver<'a> {
&Request::sam_configuration(SAMMode::Normal, false),
0,
).await {
error!("Could not initialize PN532: {e:?}");
error!("PN532 SAM configuration failed over I2C: {e:?}");
Err(())
} else {
info!("Successfully init'ed PN532");
info!("PN532 SAM configuration successful on shared I2C bus");
Ok(())
}
}
@@ -94,11 +88,11 @@ impl<'a> NfcPn532Driver<'a> {
pub async fn poll_target(&mut self) -> Result<(), ()> {
match self.pn532.process_async(&Request::INLIST_ONE_ISO_A_TARGET, 23).await {
Ok(uid) => {
info!("uid = {uid:?}");
info!("PN532 detected NFC target UID: {uid:?}");
Ok(())
}
Err(e) => {
info!("No NFC card found: {e:?}");
info!("No NFC card found on shared I2C bus: {e:?}");
Err(())
}
}
@@ -117,12 +111,14 @@ impl<'a> NfcPn532Driver<'a> {
}
pub async fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
self.poll_target().await?;
if let Err(e) = self.poll_target().await {
error!("PN532 I2C target poll failed before reading card data: {e:?}");
return Err(e);
}
let mut data: Vec<u8> = Vec::with_capacity(858);
for i in 0x0B..=230 {
let mut parse_result = Err(());
while parse_result.is_err() {
let Ok(result) = self.pn532.process_async(&Request::ntag_read(i), 17).await else {
@@ -139,11 +135,11 @@ impl<'a> NfcPn532Driver<'a> {
data.extend(bytes);
}
info!("Full data: {data:02x?}");
info!("PN532 full card payload read over I2C: {:02x?}", data);
Ok(data)
}
pub fn device_mut(&mut self) -> &mut Pn532Device<'a> {
pub fn device_mut(&mut self) -> &mut Pn532Device<I2C> {
&mut self.pn532
}
}
src/navigation/navigation.rs
+3 -3
View File
@@ -62,15 +62,15 @@ pub async fn run(mut inputs: Inputs, display: &'static mut PrimaryLcdDisplay<'st
Either::First(selection_buttons) => match selection_buttons {
Either6::First(_) => Action::Up,
Either6::Second(_) => Action::Down,
Either6::Third(_) => Action::Back,
Either6::Fourth(_) => Action::Ok,
Either6::Third(_) => Action::Left,
Either6::Fourth(_) => Action::Right,
Either6::Fifth(_) => Action::Ok,
Either6::Sixth(_) => Action::Back,
},
Either::Second(_) => Action::Timer,
};
log::info!("Action: {:?}", action);
log::info!("Action: {:?}", action);
let new_state = if action == Action::Back {
if state.screens.len() > 1 {