dan/itpdp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

esp32 folder

Browse source
This commit is contained in:
Daniel Bulant 2026-05-11 17:01:04 +02:00
parent 922f2415a4
commit 126c98e5af
No known key found for this signature in database
23 changed files with 3375 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
esp32/.cargo/config.toml Normal file
View file

@ -0,0 +1,9 @@
[target.xtensa-esp32-none-elf]
runner = "espflash flash --monitor"
[build]
target = "xtensa-esp32-none-elf"
[env]
DEFMT_LOG = "debug"

1
esp32/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
target

2116
esp32/Cargo.lock generated Normal file
View file

File diff suppressed because it is too large Load diff

52
esp32/Cargo.toml Normal file
View file

@ -0,0 +1,52 @@
[package]
name = "pico"
version = "0.1.0"
edition = "2024"
[dependencies]
embedded-hal-compat = "0.13.0"
embassy-usb-logger = "0.5.1"
ufmt = "0.2.0"
log = "0.4"
ag-lcd={ version = "0.3", features = ["ufmt"]}
as5600 = "0.8.0"
embassy-futures = "0.1.2"
embedded-io-async = "0.7.0"
embedded-io = "0.7.1"
owned_str = "0.1.2"
embassy-sync = "0.8.0"
arrayvec = { version = "0.7.6", default-features = false }
embassy-net = { version = "0.9.1",features = ["defmt", "icmp", "tcp", "udp", "raw", "dhcpv4", "medium-ethernet", "dns", "proto-ipv4", "proto-ipv6", "multicast"]}
embassy-executor = { version = "0.10.0", features = [
"platform-cortex-m",
"executor-thread",
"executor-interrupt",
"defmt",
] }
embassy-rp = { version = "0.10.0", features = [
"defmt",
"unstable-pac",
"time-driver",
"critical-section-impl",
"rp2040",
] }
embassy-time = { version = "0.5.1", features = [
"defmt",
"defmt-timestamp-uptime",
] }
cortex-m = { version = "0.7.7", features = ["inline-asm"] }
cortex-m-rt = "0.7.5"
critical-section = "1.2.0"
static_cell = "2.1.1"
portable-atomic = { version = "1.13.1", features = ["critical-section"] }
defmt = "1.0.1"
defmt-rtt = "1.1.0"
panic-probe = { version = "1.0.0", features = ["print-defmt"] }
cyw43 = { version = "0.7.0", features = ["defmt", "firmware-logs"] }
cyw43-pio = { version = "0.10.0", features = ["defmt"] }

36
esp32/build.rs Normal file
View file

@ -0,0 +1,36 @@
//! This build script copies the `memory.x` file from the crate root into
//! a directory where the linker can always find it at build time.
//! For many projects this is optional, as the linker always searches the
//! project root directory -- wherever `Cargo.toml` is. However, if you
//! are using a workspace or have a more complicated build setup, this
//! build script becomes required. Additionally, by requesting that
//! Cargo re-run the build script whenever `memory.x` is changed,
//! updating `memory.x` ensures a rebuild of the application with the
//! new memory settings.
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::PathBuf;
fn main() {
// Put `memory.x` in our output directory and ensure it's
// on the linker search path.
let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
File::create(out.join("memory.x"))
.unwrap()
.write_all(include_bytes!("memory.x"))
.unwrap();
println!("cargo:rustc-link-search={}", out.display());
// By default, Cargo will re-run a build script whenever
// any file in the project changes. By specifying `memory.x`
// here, we ensure the build script is only re-run when
// `memory.x` is changed.
println!("cargo:rerun-if-changed=memory.x");
println!("cargo:rustc-link-arg-bins=--nmagic");
println!("cargo:rustc-link-arg-bins=-Tlink.x");
println!("cargo:rustc-link-arg-bins=-Tlink-rp.x");
println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
}

26
esp32/elf2uf2.nix Normal file
View file

@ -0,0 +1,26 @@
{ lib, stdenv, rustPlatform, fetchFromGitHub, pkg-config, libudev-zero }:
rustPlatform.buildRustPackage rec {
pname = "elf2uf2-rs";
version = "2038e9a199101ee8a16d046a87136be2a607001d";
src = fetchFromGitHub {
owner = "JoNil";
repo = pname;
rev = "${version}";
# sha256 = "sha256-CHuTpnAnD4I5PY47sceSxfjGdPZznXWfARE4YBfYoIg=";
# sha256 = "sha256-tvjncEmVHFurhRtWN6m8JT0XIgrti4QTnZ2XioBtqxo=";
sha256 = "sha256-CHuTpnAnD4I5PY47sceSxfjGdPZznXWfARE4YBfYoIg=";
};
nativeBuildInputs = [
pkg-config
];
buildInputs = [
libudev-zero
];
# cargoHash = "sha256-OefAKK5rvh4HSHd26Pac4BSbcNO3ntqBReYepulV8Dk=";
cargoHash = "sha256-tvjncEmVHFurhRtWN6m8JT0XIgrti4QTnZ2XioBtqxo=";
}

39
esp32/esp32_quiz/esp32_quiz.ino
View file

@ -1,39 +0,0 @@
#include <WiFi.h>
#include <LiquidCrystal.h>
// LCD pins: RS, EN, D4, D5, D6, D7
LiquidCrystal lcd(18, 19, 13, 14, 15, 26);
const int LED_PIN = 2; // built-in LED on most ESP32 devkits
void setup() {
Serial.begin(115200);
// WiFi chip init (not connected yet)
WiFi.mode(WIFI_STA);
WiFi.disconnect();
Serial.println("WiFi initialized");
// Let LCD power up before init (ESP32 boots faster than LCD expects)
delay(500);
lcd.begin(16, 2);
lcd.clear();
pinMode(LED_PIN, OUTPUT);
}
void loop() {
Serial.println("led on!");
digitalWrite(LED_PIN, HIGH);
delay(1000);
lcd.clear();
lcd.print("Test message!");
Serial.println("led off!");
digitalWrite(LED_PIN, LOW);
delay(1000);
lcd.clear();
lcd.print("Test message2!");
}

BIN
esp32/firmware/43439A0.bin Normal file
View file

Binary file not shown.

BIN
esp32/firmware/43439A0_clm.bin Normal file
View file

Binary file not shown.

BIN
esp32/firmware/nvram_rp2040.bin Normal file
View file

Binary file not shown.

130
esp32/flake.lock Normal file
View file

@ -0,0 +1,130 @@
{
"nodes": {
"esp-rs": {
"inputs": {
"flake-parts": "flake-parts",
"nixpkgs": "nixpkgs"
},
"locked": {
"lastModified": 1772358514,
"narHash": "sha256-EV0KKHtOmqFyAX4HakujCYwnX7ef+Hr8AKf73cd9n7s=",
"owner": "leighleighleigh",
"repo": "esp-rs-nix",
"rev": "8baa40f096e7f52a10e8438b0bd55ef5dc280164",
"type": "github"
},
"original": {
"owner": "leighleighleigh",
"repo": "esp-rs-nix",
"type": "github"
}
},
"flake-parts": {
"inputs": {
"nixpkgs-lib": "nixpkgs-lib"
},
"locked": {
"lastModified": 1759362264,
"narHash": "sha256-wfG0S7pltlYyZTM+qqlhJ7GMw2fTF4mLKCIVhLii/4M=",
"owner": "hercules-ci",
"repo": "flake-parts",
"rev": "758cf7296bee11f1706a574c77d072b8a7baa881",
"type": "github"
},
"original": {
"owner": "hercules-ci",
"repo": "flake-parts",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1760038930,
"narHash": "sha256-Oncbh0UmHjSlxO7ErQDM3KM0A5/Znfofj2BSzlHLeVw=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "0b4defa2584313f3b781240b29d61f6f9f7e0df3",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs-lib": {
"locked": {
"lastModified": 1754788789,
"narHash": "sha256-x2rJ+Ovzq0sCMpgfgGaaqgBSwY+LST+WbZ6TytnT9Rk=",
"owner": "nix-community",
"repo": "nixpkgs.lib",
"rev": "a73b9c743612e4244d865a2fdee11865283c04e6",
"type": "github"
},
"original": {
"owner": "nix-community",
"repo": "nixpkgs.lib",
"type": "github"
}
},
"nixpkgs_2": {
"locked": {
"lastModified": 1777383249,
"narHash": "sha256-b6T90GXUr21iIu6Aw+KGy5uSiB/cVT/UecId1YSESys=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "61a7520db583d9b41be602b4c1e1b1b1b1faa1f4",
"type": "github"
},
"original": {
"owner": "NixOS",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_3": {
"locked": {
"lastModified": 1744536153,
"narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"esp-rs": "esp-rs",
"nixpkgs": "nixpkgs_2",
"rust-overlay": "rust-overlay"
}
},
"rust-overlay": {
"inputs": {
"nixpkgs": "nixpkgs_3"
},
"locked": {
"lastModified": 1777346187,
"narHash": "sha256-oVxyGjpiIsrXhWTJVUOs38fZQkLjd0nZGOY9K7Kfot8=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "146e7bf7569b8288f24d41d806b9f584f7cfd5b5",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

49
esp32/flake.nix Normal file
View file

@ -0,0 +1,49 @@
{
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs";
rust-overlay.url = "github:oxalica/rust-overlay";
esp-rs.url = "github:leighleighleigh/esp-rs-nix";
};
outputs =
{
self,
rust-overlay,
nixpkgs,
esp-rs,
}:
let
overlays = [ (import rust-overlay) ];
pkgs = import nixpkgs {
system = "x86_64-linux";
inherit overlays;
};
in
{
packages.x86_64-linux.elf2uf2-rs = pkgs.callPackage ./elf2uf2.nix { };
devShell.x86_64-linux = pkgs.mkShell {
buildInputs = with pkgs; [
espflash
esptool
esp-rs.packages.${system}.default
cargo-espmonitor
# (pkgs.rust-bin.selectLatestNightlyWith (
# toolchain:
# toolchain.default.override {
# targets = [
# "thumbv6m-none-eabi"
# "xtensa-esp32-none-eabi"
# ];
# extensions = [ "rust-src" ];
# }
# ))
pkgs.rust-analyzer
pkgs.flip-link
pkgs.probe-rs-tools
self.packages.x86_64-linux.elf2uf2-rs
pkgs.rustfmt
# pkgs.picotool
];
};
};
}

17
esp32/memory.x Normal file
View file

@ -0,0 +1,17 @@
MEMORY {
BOOT2 : ORIGIN = 0x10000000, LENGTH = 0x100
FLASH : ORIGIN = 0x10000100, LENGTH = 2048K - 0x100
/* Pick one of the two options for RAM layout */
/* OPTION A: Use all RAM banks as one big block */
/* Reasonable, unless you are doing something */
/* really particular with DMA or other concurrent */
/* access that would benefit from striping */
RAM : ORIGIN = 0x20000000, LENGTH = 264K
/* OPTION B: Keep the unstriped sections separate */
/* RAM: ORIGIN = 0x20000000, LENGTH = 256K */
/* SCRATCH_A: ORIGIN = 0x20040000, LENGTH = 4K */
/* SCRATCH_B: ORIGIN = 0x20041000, LENGTH = 4K */
}

36
esp32/src/bin/logger.rs Normal file
View file

@ -0,0 +1,36 @@
//! This example shows how to use USB (Universal Serial Bus) in the RP2040 chip.
//!
//! This creates the possibility to send log::info/warn/error/debug! to USB serial port.
#![no_std]
#![no_main]
use embassy_executor::Spawner;
use embassy_rp::bind_interrupts;
use embassy_rp::peripherals::USB;
use embassy_rp::usb::{Driver, InterruptHandler};
use embassy_time::Timer;
use {defmt_rtt as _, panic_probe as _};
bind_interrupts!(struct Irqs {
USBCTRL_IRQ => InterruptHandler<USB>;
});
#[embassy_executor::task]
async fn logger_task(driver: Driver<'static, USB>) {
embassy_usb_logger::run!(1024, log::LevelFilter::Info, driver);
}
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let p = embassy_rp::init(Default::default());
let driver = Driver::new(p.USB, Irqs);
spawner.spawn(logger_task(driver).unwrap());
let mut counter = 0;
loop {
counter += 1;
log::info!("Tick {}", counter);
Timer::after_secs(1).await;
}
}

101
esp32/src/bin/scan.rs Normal file
View file

@ -0,0 +1,101 @@
//! This example uses the RP Pico W board Wifi chip (cyw43).
//! Scans Wifi for ssid names.
#![no_std]
#![no_main]
#![allow(async_fn_in_trait)]
use core::str;
use cyw43::aligned_bytes;
use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
use defmt::*;
use embassy_executor::Spawner;
use embassy_rp::gpio::{Level, Output};
use embassy_rp::peripherals::{DMA_CH0, PIO0, USB};
use embassy_rp::pio::{InterruptHandler, Pio};
use embassy_rp::{bind_interrupts, dma, usb};
use embassy_time::Timer;
use static_cell::StaticCell;
use {defmt_rtt as _, panic_probe as _};
bind_interrupts!(struct Irqs {
PIO0_IRQ_0 => InterruptHandler<PIO0>;
USBCTRL_IRQ => usb::InterruptHandler<USB>;
DMA_IRQ_0 => dma::InterruptHandler<DMA_CH0>;
});
#[embassy_executor::task]
async fn cyw43_task(
runner: cyw43::Runner<'static, cyw43::SpiBus<Output<'static>, PioSpi<'static, PIO0, 0>>>,
) -> ! {
runner.run().await
}
#[embassy_executor::task]
async fn logger_task(usb: embassy_rp::Peri<'static, embassy_rp::peripherals::USB>) {
let driver = embassy_rp::usb::Driver::new(usb, Irqs);
embassy_usb_logger::run!(1024, log::LevelFilter::Info, driver);
}
#[embassy_executor::task]
async fn periodic_log() {
loop {
info!("periodic log");
Timer::after_millis(1000).await;
}
}
#[embassy_executor::main]
async fn main(spawner: Spawner) {
let p = embassy_rp::init(Default::default());
spawner.spawn(unwrap!(logger_task(p.USB)));
spawner.spawn(unwrap!(periodic_log()));
info!("Hello World!");
let fw = aligned_bytes!("../../firmware/43439A0.bin");
let clm = aligned_bytes!("../../firmware/43439A0_clm.bin");
let nvram = aligned_bytes!("../../firmware/nvram_rp2040.bin");
// To make flashing faster for development, you may want to flash the firmwares independently
// at hardcoded addresses, instead of baking them into the program with `include_bytes!`:
// probe-rs download 43439A0.bin --binary-format bin --chip RP2040 --base-address 0x10100000
// probe-rs download 43439A0_clm.bin --binary-format bin --chip RP2040 --base-address 0x10140000
//let fw = unsafe { core::slice::from_raw_parts(0x10100000 as *const u8, 230321) };
//let clm = unsafe { core::slice::from_raw_parts(0x10140000 as *const u8, 4752) };
let pwr = Output::new(p.PIN_23, Level::Low);
let cs = Output::new(p.PIN_25, Level::High);
let mut pio = Pio::new(p.PIO0, Irqs);
let spi = PioSpi::new(
&mut pio.common,
pio.sm0,
DEFAULT_CLOCK_DIVIDER,
pio.irq0,
cs,
p.PIN_24,
p.PIN_29,
dma::Channel::new(p.DMA_CH0, Irqs),
);
static STATE: StaticCell<cyw43::State> = StaticCell::new();
let state = STATE.init(cyw43::State::new());
let (_net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw, nvram).await;
spawner.spawn(unwrap!(cyw43_task(runner)));
control.init(clm).await;
control
.set_power_management(cyw43::PowerManagementMode::PowerSave)
.await;
loop {
info!("scan loop");
let mut scanner = control.scan(Default::default()).await;
while let Some(bss) = scanner.next().await {
if let Ok(ssid_str) = str::from_utf8(&bss.ssid) {
info!("scanned {} == {:x}", ssid_str, bss.bssid);
}
}
Timer::after_millis(1000).await;
}
}

63
esp32/src/buffer.rs Normal file
View file

@ -0,0 +1,63 @@
use core::{convert::Infallible, fmt::Display, ops::Deref};
use arrayvec::ArrayVec;
use embassy_futures::yield_now;
use embassy_net::Stack;
pub struct WriteBuffer<const CAP: usize>(ArrayVec<u8, CAP>);
impl<const CAP: usize> Display for WriteBuffer<CAP> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(str::from_utf8(self).map_err(|_| core::fmt::Error)?)
}
}
impl<const CAP: usize> Deref for WriteBuffer<CAP> {
type Target = [u8];
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<const CAP: usize> WriteBuffer<CAP> {
pub fn new() -> Self {
Self(ArrayVec::new())
}
pub fn clear(&mut self) {
self.0.clear();
}
}
impl<const CAP: usize> embedded_io::ErrorType for WriteBuffer<CAP> {
type Error = Infallible;
}
impl<const CAP: usize> embedded_io::Write for WriteBuffer<CAP> {
#[inline]
fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
let _ = self.0.try_extend_from_slice(buf); //silently fails!
Ok(buf.len())
}
#[inline]
fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
self.write(buf)?;
Ok(())
}
#[inline]
fn flush(&mut self) -> Result<(), Self::Error> {
Ok(())
}
}
pub async fn wait_for_config(stack: Stack<'static>) -> embassy_net::StaticConfigV4 {
loop {
if let Some(config) = stack.config_v4() {
return config.clone();
}
yield_now().await;
}
}

90
esp32/src/input.rs Normal file
View file

@ -0,0 +1,90 @@
use as5600::As5600;
use embassy_executor::Spawner;
use embassy_rp::{
Peri,
gpio::{AnyPin, Input},
i2c::{Config, I2c},
peripherals::{I2C0, PIN_4, PIN_5},
};
use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, mutex::Mutex};
use embassy_time::{Duration, Timer};
use ufmt::uwrite;
use crate::{Irqs, WHEEL_VALUE, screen::SCREEN_BUFFER, unwrap};
/// Button input notification channel
pub static INPUT: Channel<CriticalSectionRawMutex, u8, 64> = Channel::new();
#[embassy_executor::task(pool_size = 4)]
/// Polls a single pin for falling edge (assumes buttons are pulled up and shorted when pressed)
/// Sends [INPUT] with given id
pub async fn button_poll_task(mut button: Input<'static>, id: u8) {
loop {
button.wait_for_falling_edge().await;
INPUT.send(id).await;
// uwrite!(SCREEN_BUFFER.lock().await.line1(), "btn {}", id);
Timer::after(Duration::from_millis(50)).await;
}
}
pub static ANGLE: Mutex<CriticalSectionRawMutex, u16> = Mutex::new(0);
#[embassy_executor::task]
pub async fn rotation_read_task(
i2c: Peri<'static, I2C0>,
scl: Peri<'static, PIN_5>,
sda: Peri<'static, PIN_4>,
) {
let i2c = I2c::new_async(i2c, scl, sda, Irqs, Config::default());
let mut as5600 = As5600::new(i2c);
loop {
Timer::after(Duration::from_millis(50)).await;
let angle = as5600.angle().unwrap_or(0);
let mut locked = ANGLE.lock().await;
let old = *locked as i32;
*locked = angle;
drop(locked);
let left_diff = old - angle as i32;
let right_diff = angle as i32 - old;
let diff = if left_diff.abs() < right_diff.abs() {
-left_diff
} else {
right_diff
};
let mut wheel = WHEEL_VALUE.lock().await;
if wheel.max != wheel.min {
let wheel_range = wheel.max - wheel.min;
wheel.value += diff * wheel_range / 4096;
if wheel.value < wheel.min {
wheel.value = wheel.min;
} else if wheel.value > wheel.max {
wheel.value = wheel.max;
}
}
drop(wheel);
}
}
pub struct InputConfig {
pub i2c0: Peri<'static, I2C0>,
pub scl: Peri<'static, PIN_5>,
pub sda: Peri<'static, PIN_4>,
pub button_pins: [(Peri<'static, AnyPin>, u8); 4],
}
pub fn setup(spawner: Spawner, config: InputConfig) {
spawner.spawn(unwrap!(rotation_read_task(
config.i2c0,
config.scl,
config.sda,
)));
for (pin, id) in config.button_pins {
spawner.spawn(unwrap!(button_poll_task(
Input::new(pin, embassy_rp::gpio::Pull::Up),
id,
)));
}
}

312
esp32/src/main.rs Normal file
View file

@ -0,0 +1,312 @@
#![no_std]
#![no_main]
use core::str::FromStr;
use embassy_net::tcp::{TcpReader, TcpWriter};
use embassy_rp::multicore::{Stack, spawn_core1};
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::mutex::Mutex;
use embassy_sync::signal::Signal;
use embedded_io::Write;
use log::info;
use owned_str::OwnedStr;
use ufmt::uwrite;
use crate::buffer::WriteBuffer;
use crate::input::{ANGLE, INPUT, InputConfig};
use crate::net::network_setup_task;
use crate::owned_str_writer::{OwnedStrWriter, center_str};
use crate::screen::{lcd_display_task, overwrite_lcd};
use ag_lcd::{Blink, Cursor, Display, LcdDisplay};
use defmt::*;
use embassy_executor::{Executor, Spawner};
use embassy_rp::gpio::{Level, Output};
use embassy_rp::i2c::{self};
use embassy_rp::peripherals::{DMA_CH0, I2C0, PIO0};
use embassy_rp::pio::InterruptHandler;
use embassy_rp::{bind_interrupts, dma};
use embassy_rp::{peripherals::USB, usb};
use embassy_time::{Delay, Timer};
use static_cell::StaticCell;
use {defmt_rtt as _, panic_probe as _};
mod buffer;
mod input;
mod net;
mod owned_str_writer;
mod screen;
const WIFI_NETWORK: &str = "flamme";
const WIFI_PASSWORD: &str = "12345678";
const TARGET_IP: &str = "84.238.32.253";
const TARGET_PORT: u16 = 7070;
bind_interrupts!(struct Irqs {
PIO0_IRQ_0 => InterruptHandler<PIO0>;
DMA_IRQ_0 => dma::InterruptHandler<DMA_CH0>;
USBCTRL_IRQ => usb::InterruptHandler<USB>;
I2C0_IRQ => i2c::InterruptHandler<I2C0>;
});
#[embassy_executor::task]
async fn logger_task(usb: embassy_rp::Peri<'static, embassy_rp::peripherals::USB>) {
let driver = embassy_rp::usb::Driver::new(usb, Irqs);
embassy_usb_logger::run!(1024, log::LevelFilter::Info, driver);
}
enum QuestionType {
Choice,
Numeric { min: i32, max: i32 },
}
struct QuestionData {
text: OwnedStr<256>,
q_type: QuestionType,
points: i32,
generation: usize,
}
#[derive(Clone, Copy)]
struct WheelData {
value: i32,
min: i32,
max: i32,
}
static QUESTION: Mutex<CriticalSectionRawMutex, Option<QuestionData>> = Mutex::new(None);
static QUESTION_UPDATE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
static WHEEL_VALUE: Mutex<CriticalSectionRawMutex, WheelData> = Mutex::new(WheelData {
value: 0,
min: 0,
max: 0,
});
pub async fn tcp_read_loop(mut read: TcpReader<'_>) {
let mut buf = [0u8; 1024];
let mut generation = 1;
while let Ok(len) = read.read(&mut buf).await {
if len == 0 {
break;
}
let Ok(str) = str::from_utf8(&buf[..len]) else {
continue;
};
let mut counter = 0;
let mut question_data = None;
let mut future_wheel = WheelData {
value: 0,
min: 0,
max: 0,
};
for line in str.lines() {
if line == "$$" {
counter = 1;
continue;
}
if counter == 1 {
let mut q_type = QuestionType::Choice;
let mut points = -1;
for pairs in line.split(" ") {
let (key, value) = pairs.split_once("=").unwrap();
if key == "type" {
q_type = if value == "choice" {
QuestionType::Choice
} else {
QuestionType::Numeric { min: -1, max: -1 }
};
}
if key == "points" {
points = value.parse().unwrap();
}
if key == "rangeMin" || key == "rangeMax" {
match q_type {
QuestionType::Choice => {}
QuestionType::Numeric {
ref mut min,
ref mut max,
} => {
if key == "rangeMin" {
*min = value.parse().unwrap();
future_wheel.min = *min;
} else {
*max = value.parse().unwrap();
future_wheel.max = *max;
}
}
}
}
}
match q_type {
QuestionType::Numeric { min, max } => {
let diff = max - min;
future_wheel.value = min + diff / 2;
}
_ => {}
}
question_data = Some(QuestionData {
text: OwnedStr::new(),
q_type,
points,
generation,
});
counter = 2;
continue;
}
if counter == 2 {
question_data.as_mut().unwrap().text = OwnedStr::from_str(line).unwrap();
generation += 1;
counter = 0;
}
}
if let Some(question_data) = question_data {
*QUESTION.lock().await = Some(question_data);
*WHEEL_VALUE.lock().await = future_wheel;
QUESTION_UPDATE.signal(());
}
}
}
pub async fn tcp_write_loop(mut write: TcpWriter<'_>) {
let mut buffer = WriteBuffer::<256>::new();
loop {
let data = INPUT.receive().await;
info!("button={}", data);
let angle = *ANGLE.lock().await;
core::writeln!(buffer, "button={} angle={}", data, angle).ok();
info!("write: {}", &buffer);
write.write(&buffer).await.ok();
buffer.clear();
}
}
const ARROW_RIGHT: char = char::from_u32(0b0111_1110).unwrap();
const ARROW_LEFT: char = char::from_u32(0b0111_1111).unwrap();
const DOT: char = char::from_u32(0b1010_0101).unwrap();
#[embassy_executor::task]
pub async fn main_loop() {
let mut last_gen = 0;
let mut title_offset = 0;
info!("Main loop started");
loop {
Timer::after_millis(50).await;
let wheel = *WHEEL_VALUE.lock().await;
let question = QUESTION.lock().await;
let Some(question) = question.as_ref() else {
continue;
};
title_offset += 1;
if question.generation != last_gen {
last_gen = question.generation;
title_offset = 0;
}
let title_line = if question.text.len() > 16 {
title_offset %= question.text.len() - 16;
&question.text[title_offset..title_offset + 16]
} else {
&question.text
};
let number_str: OwnedStr<16> = match question.q_type {
QuestionType::Choice => {
let mut writer = OwnedStrWriter::new();
writer.push(DOT).unwrap();
writer.push(' ').unwrap();
uwrite!(writer, "{}", question.points).unwrap();
writer.into()
}
QuestionType::Numeric { min, max } => {
let mut writer = OwnedStrWriter::new();
if wheel.value > min {
writer.push(ARROW_LEFT).unwrap();
writer.push(' ').unwrap();
}
uwrite!(writer, "{}", wheel.value).unwrap();
if wheel.value < max {
writer.push(ARROW_RIGHT).unwrap();
writer.push(' ').unwrap();
}
writer.into()
}
};
let second_line = center_str::<16>(&number_str, 16).unwrap();
info!("lcd: {} {}", title_line, second_line);
overwrite_lcd(title_line, &second_line).await;
}
}
static mut CORE1_STACK: Stack<4096> = Stack::new();
// static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
// #[cortex_m_rt::entry]
#[embassy_executor::main]
async fn main(spawner: Spawner) -> () {
let p = embassy_rp::init(Default::default());
let lcd: LcdDisplay<_, _> = LcdDisplay::new(
Output::new(p.PIN_10, Level::Low),
Output::new(p.PIN_11, Level::Low),
Delay,
)
.with_half_bus(
Output::new(p.PIN_12, Level::Low),
Output::new(p.PIN_13, Level::Low),
Output::new(p.PIN_14, Level::Low),
Output::new(p.PIN_15, Level::Low),
)
.with_autoscroll(ag_lcd::AutoScroll::Off)
.with_display(Display::On)
.with_blink(Blink::On)
.with_cursor(Cursor::On)
.with_lines(ag_lcd::Lines::TwoLines);
spawn_core1(
p.CORE1,
unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
move || {
let executor1 = EXECUTOR1.init(Executor::new());
executor1.run(|spawner| {
let mut lcd = lcd.build();
lcd.set_blink(Blink::Off);
lcd.set_cursor(Cursor::Off);
spawner.spawn(unwrap!(lcd_display_task(lcd)));
});
},
);
// let executor0 = EXECUTOR0.init(Executor::new());
// executor0.run(|spawner| {
spawner.spawn(unwrap!(logger_task(p.USB)));
spawner.spawn(unwrap!(network_setup_task(
p.PIN_23, p.PIN_25, p.PIO0, p.PIN_24, p.PIN_29, p.DMA_CH0, spawner
)));
// let mut lcd = lcd.build();
// lcd.set_blink(Blink::Off);
// lcd.set_cursor(Cursor::Off);
// spawner.spawn(unwrap!(lcd_display_task(lcd)));
crate::input::setup(
spawner,
InputConfig {
i2c0: p.I2C0,
scl: p.PIN_5,
sda: p.PIN_4,
button_pins: [
(p.PIN_18.into(), 1),
(p.PIN_19.into(), 2),
(p.PIN_20.into(), 3),
(p.PIN_21.into(), 4),
],
},
);
// });
}

183
esp32/src/net.rs Normal file
View file

@ -0,0 +1,183 @@
use core::net::SocketAddrV4;
use core::str::FromStr;
use embassy_futures::join::join;
use embassy_net::tcp::TcpSocket;
use crate::buffer::wait_for_config;
use crate::screen::SCREEN_BUFFER;
use crate::{
Irqs, TARGET_IP, TARGET_PORT, WIFI_NETWORK, WIFI_PASSWORD, main_loop, tcp_read_loop,
tcp_write_loop,
};
use cyw43::{JoinOptions, ScanOptions, aligned_bytes};
use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
use defmt::*;
use embassy_executor::Spawner;
use embassy_net::StackResources;
use embassy_rp::clocks::RoscRng;
use embassy_rp::gpio::{Level, Output};
use embassy_rp::peripherals::{DMA_CH0, PIN_23, PIN_24, PIN_25, PIN_29, PIO0};
use embassy_rp::pio::Pio;
use embassy_rp::{Peri, dma};
use embassy_time::{Duration, Timer};
use static_cell::StaticCell;
use ufmt::uwrite;
#[embassy_executor::task]
async fn cyw43_task(
runner: cyw43::Runner<'static, cyw43::SpiBus<Output<'static>, PioSpi<'static, PIO0, 0>>>,
) -> ! {
runner.run().await
}
#[embassy_executor::task]
async fn net_task(mut runner: embassy_net::Runner<'static, cyw43::NetDriver<'static>>) -> ! {
runner.run().await
}
#[embassy_executor::task]
pub async fn network_setup_task(
pin23: Peri<'static, PIN_23>,
pin25: Peri<'static, PIN_25>,
pio: Peri<'static, PIO0>,
pin24: Peri<'static, PIN_24>,
pin29: Peri<'static, PIN_29>,
dma: Peri<'static, DMA_CH0>,
spawner: Spawner,
) {
let fw = aligned_bytes!("../firmware/43439A0.bin");
let clm = aligned_bytes!("../firmware/43439A0_clm.bin");
let nvram = aligned_bytes!("../firmware/nvram_rp2040.bin");
let mut rng = RoscRng;
// To make flashing faster for development, you may want to flash the firmwares independently
// at hardcoded addresses, instead of baking them into the program with `include_bytes!`:
// probe-rs download ../../cyw43-firmware/43439A0.bin --binary-format bin --chip RP2040 --base-address 0x10100000
// probe-rs download ../../cyw43-firmware/43439A0_clm.bin --binary-format bin --chip RP2040 --base-address 0x10140000
//let fw = unsafe { core::slice::from_raw_parts(0x10100000 as *const u8, 230321) };
//let clm = unsafe { core::slice::from_raw_parts(0x10140000 as *const u8, 4752) };
let pwr = Output::new(pin23, Level::Low);
let cs = Output::new(pin25, Level::High);
let mut pio = Pio::new(pio, Irqs);
let spi = PioSpi::new(
&mut pio.common,
pio.sm0,
DEFAULT_CLOCK_DIVIDER,
pio.irq0,
cs,
pin24,
pin29,
dma::Channel::new(dma, Irqs),
);
static STATE: StaticCell<cyw43::State> = StaticCell::new();
let state = STATE.init(cyw43::State::new());
let (net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw, nvram).await;
spawner.spawn(unwrap!(cyw43_task(runner)));
control.init(clm).await;
control
.set_power_management(cyw43::PowerManagementMode::Performance)
.await;
static RESOURCES: StaticCell<StackResources<5>> = StaticCell::new();
let (stack, runner) = embassy_net::new(
net_device,
embassy_net::Config::dhcpv4(Default::default()),
RESOURCES.init(StackResources::new()),
rng.next_u64(),
);
spawner.spawn(unwrap!(net_task(runner)));
Timer::after_millis(1000).await;
uwrite!(SCREEN_BUFFER.lock().await.line1(), "con - scan");
info!("scan started");
let mut opts = ScanOptions::default();
opts.scan_type = cyw43::ScanType::Active;
let mut scanner = control.scan(opts).await;
while let Some(bss) = scanner.next().await {
let mut buf = SCREEN_BUFFER.lock().await;
if let Ok(ssid_str) = str::from_utf8(&bss.ssid) {
info!("scanned {} == {:x}", ssid_str, bss.bssid);
uwrite!(buf.line1(), "{}", ssid_str);
// uwrite!(buf.line2(), "{:x}", bss.bssid);
} else {
info!("scanned {:x}", bss.bssid);
uwrite!(buf.line1(), "not-utf8");
// uwrite!(buf.line2(), "{:x}", bss.bssid);
}
drop(buf);
Timer::after_millis(500).await;
}
info!("scan completed");
uwrite!(SCREEN_BUFFER.lock().await.line1(), "scan end.");
Timer::after_millis(500).await;
drop(scanner);
while let Err(err) = control
.join(WIFI_NETWORK, JoinOptions::new(WIFI_PASSWORD.as_bytes()))
.await
{
let mut buf = SCREEN_BUFFER.lock().await;
buf.clear();
match err {
cyw43::JoinError::AuthenticationFailure => {
uwrite!(buf.line1(), "join failure");
uwrite!(buf.line2(), "bad password");
info!("authentication failure");
}
cyw43::JoinError::JoinFailure(e) => {
uwrite!(buf.line1(), "join failure");
uwrite!(buf.line2(), "code {}", e);
info!("join failure: {}", e);
}
cyw43::JoinError::NetworkNotFound => {
uwrite!(buf.line1(), "join failure");
uwrite!(buf.line2(), "wifi not found");
info!("network not found");
}
};
Timer::after_millis(200).await;
}
let mut buf = SCREEN_BUFFER.lock().await;
buf.clear();
uwrite!(buf.line1(), "link.");
drop(buf);
stack.wait_link_up().await;
uwrite!(SCREEN_BUFFER.lock().await.line1(), "dhcp.");
stack.wait_config_up().await;
let cfg = wait_for_config(stack).await;
let local_addr = cfg.address.address();
info!("IP address: {:?}", local_addr);
let host_addr = embassy_net::Ipv4Address::from_str(TARGET_IP).unwrap();
let mut rx_buffer = [0; 4096];
let mut tx_buffer = [0; 4096];
let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
socket.set_timeout(Some(Duration::from_secs(10)));
socket.set_keep_alive(Some(Duration::from_secs(1)));
if let Err(e) = socket
.connect(SocketAddrV4::new(host_addr, TARGET_PORT))
.await
{
uwrite!(SCREEN_BUFFER.lock().await.line1(), "tcperr");
error!("tcp connect error: {}", e);
} else {
uwrite!(SCREEN_BUFFER.lock().await.line1(), "tcpok");
}
let (read, write) = socket.split();
spawner.spawn(unwrap!(main_loop()));
join(tcp_read_loop(read), tcp_write_loop(write)).await;
}

50
esp32/src/owned_str_writer.rs Normal file
View file

@ -0,0 +1,50 @@
use owned_str::{Error, OwnedStr};
use ufmt::uWrite;
pub struct OwnedStrWriter<const CAP: usize>(OwnedStr<CAP>);
impl<const CAP: usize> OwnedStrWriter<CAP> {
pub fn new() -> Self {
Self(OwnedStr::new())
}
pub fn push(&mut self, c: char) -> Result<(), Error> {
self.0.try_push(c).map(|_| ())
}
}
impl<const CAP: usize> From<OwnedStr<CAP>> for OwnedStrWriter<CAP> {
fn from(owned_str: OwnedStr<CAP>) -> Self {
Self(owned_str)
}
}
impl<const CAP: usize> From<OwnedStrWriter<CAP>> for OwnedStr<CAP> {
fn from(writer: OwnedStrWriter<CAP>) -> Self {
writer.0
}
}
impl<const CAP: usize> uWrite for OwnedStrWriter<CAP> {
type Error = owned_str::Error;
fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
self.0.try_push_str(s).map(|_| ())
}
fn write_char(&mut self, c: char) -> Result<(), Self::Error> {
self.0.try_push(c).map(|_| ())
}
}
pub fn center_str<const CAP: usize>(
str: &str,
width: usize,
) -> Result<OwnedStr<CAP>, owned_str::Error> {
let mut res = OwnedStr::new();
let len = str.len();
let padding = (width.saturating_sub(len) + 1) / 2;
for _ in 0..padding {
res.try_push(' ')?;
}
res.try_push_str(str)?;
Ok(res)
}

103
esp32/src/screen.rs Normal file
View file

@ -0,0 +1,103 @@
use core::convert::Infallible;
use ag_lcd::LcdDisplay;
use embassy_rp::gpio::Output;
use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex, signal::Signal};
use embassy_time::{Delay, Timer};
use ufmt::uWrite;
pub struct ScreenBuffer {
line1: [u8; 16],
line2: [u8; 16],
line1_ptr: u8,
line2_ptr: u8,
}
impl ScreenBuffer {
pub fn clear(&mut self) {
self.line1.fill(0);
self.line2.fill(0);
self.line1_ptr = 0;
self.line2_ptr = 0;
}
pub fn line1(&mut self) -> ScreenBufferWriter<'_> {
ScreenBufferWriter { buf: self, line: 0 }
}
pub fn line2(&mut self) -> ScreenBufferWriter<'_> {
ScreenBufferWriter { buf: self, line: 1 }
}
}
pub struct ScreenBufferWriter<'a> {
buf: &'a mut ScreenBuffer,
line: u8,
}
impl<'a> uWrite for ScreenBufferWriter<'a> {
type Error = Infallible;
fn write_char(&mut self, c: char) -> Result<(), Self::Error> {
if self.line == 0 {
let ptr = self.buf.line1_ptr as usize;
self.buf.line1[ptr] = c as u8;
self.buf.line1_ptr = (self.buf.line1_ptr + 1) % 16;
} else {
let ptr = self.buf.line2_ptr as usize;
self.buf.line2[ptr] = c as u8;
self.buf.line2_ptr = (self.buf.line2_ptr + 1) % 16;
}
Ok(())
}
fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
for c in s.chars() {
self.write_char(c)?;
}
Ok(())
}
}
impl Drop for ScreenBufferWriter<'_> {
fn drop(&mut self) {
LCD_UPDATE.signal(());
}
}
pub static SCREEN_BUFFER: Mutex<CriticalSectionRawMutex, ScreenBuffer> = Mutex::new(ScreenBuffer {
line1: [0; 16],
line1_ptr: 0,
line2: [0; 16],
line2_ptr: 0,
});
static LCD_UPDATE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
#[embassy_executor::task]
pub async fn lcd_display_task(mut lcd: LcdDisplay<Output<'static>, Delay>) {
loop {
LCD_UPDATE.wait().await;
let buffer = SCREEN_BUFFER.lock().await;
lcd.clear();
for byte in &buffer.line1 {
lcd.write(*byte);
}
lcd.set_position(0, 1);
for byte in &buffer.line2 {
lcd.write(*byte);
}
Timer::after_millis(20).await;
}
}
pub async fn overwrite_lcd(line1: &str, line2: &str) {
let mut buffer = SCREEN_BUFFER.lock().await;
buffer.line1_ptr = 0;
buffer.line2_ptr = 0;
buffer.line1.fill(0);
buffer.line2.fill(0);
buffer.line1[..line1.len()].copy_from_slice(line1.as_bytes());
buffer.line2[..line2.len()].copy_from_slice(line2.as_bytes());
LCD_UPDATE.signal(());
}

5
pico/.cargo/config.toml
View file

@ -2,11 +2,8 @@
# runner = "probe-rs run --chip RP2040"
runner = "sudo picotool load -u -v -x -t elf"
[target.xtensa-esp32-none-elf]
runner = "espflash flash --monitor"
[build]
target = "xtensa-esp32-none-elf"
target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0
[env]
DEFMT_LOG = "debug"

5
pico/flake.nix
View file

@ -2,7 +2,6 @@
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs";
rust-overlay.url = "github:oxalica/rust-overlay";
esp-rs.url = "github:leighleighleigh/esp-rs-nix";
};
outputs =
@ -10,7 +9,6 @@
self,
rust-overlay,
nixpkgs,
esp-rs,
}:
let
overlays = [ (import rust-overlay) ];
@ -23,14 +21,11 @@
packages.x86_64-linux.elf2uf2-rs = pkgs.callPackage ./elf2uf2.nix { };
devShell.x86_64-linux = pkgs.mkShell {
buildInputs = with pkgs; [
espflash
esptool
(pkgs.rust-bin.selectLatestNightlyWith (
toolchain:
toolchain.default.override {
targets = [
"thumbv6m-none-eabi"
"xtensa-esp32-none-eabi"
];
extensions = [ "rust-src" ];
}