auto reconnect

esp32/src/bin/scan.rs

@@ -46,7 +46,7 @@ async fn main(_spawner: Spawner) -> ! {
 
     loop {
         println!("Scan");
-        let scan_config = ScanConfig::default().with_max(10);
+        let scan_config = ScanConfig::default().with_max(20);
         let result = controller.scan_async(&scan_config).await.unwrap();
         for ap in result {
             println!("{:?}", ap);

esp32/src/input.rs

@@ -3,7 +3,7 @@ use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channe
 use embassy_time::{Duration, Timer};
 use esp_hal::gpio::Input;
 use esp_hal::i2c::master::{Config, I2c};
-use esp_hal::peripherals::{GPIO4, GPIO5, I2C0};
+use esp_hal::peripherals::{GPIO21, GPIO22, I2C0};
 use esp_hal::time::Rate;
 use esp_println::println;
 
@@ -15,17 +15,20 @@ pub static ANGLE: Mutex<CriticalSectionRawMutex, u16> = Mutex::new(0);
 
 pub struct RotationConfig {
     pub i2c0: I2C0<'static>,
-    pub scl: GPIO5<'static>,
-    pub sda: GPIO4<'static>,
+    pub scl: GPIO22<'static>,
+    pub sda: GPIO21<'static>,
 }
 
 #[embassy_executor::task]
 pub async fn rotation_read_task(config: RotationConfig) {
-    let i2c = I2c::new(config.i2c0, Config::default().with_frequency(Rate::from_khz(400)))
-        .unwrap()
-        .with_sda(config.sda)
-        .with_scl(config.scl)
-        .into_async();
+    let i2c = I2c::new(
+        config.i2c0,
+        Config::default().with_frequency(Rate::from_khz(400)),
+    )
+    .unwrap()
+    .with_sda(config.sda)
+    .with_scl(config.scl)
+    .into_async();
     let mut as5600 = As5600::new(i2c);
 
     loop {
@@ -43,14 +46,7 @@ pub async fn rotation_read_task(config: RotationConfig) {
             let mut value = wheel.value;
             let mut accumulated = wheel.accumulated;
             let precision = crate::WHEEL_PRECISION;
-            apply_wheel_delta(
-                &mut value,
-                min,
-                max,
-                &mut accumulated,
-                diff,
-                precision,
-            );
+            apply_wheel_delta(&mut value, min, max, &mut accumulated, diff, precision);
             wheel.value = value;
             wheel.accumulated = accumulated;
         }

esp32/src/main.rs

@@ -1,17 +1,23 @@
 #![no_std]
 #![no_main]
 
+extern crate alloc;
+
 use core::str::FromStr;
 
 use embassy_executor::Spawner;
+use embassy_futures::select::{Either, select};
 use embassy_net::tcp::{TcpReader, TcpWriter};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::mutex::Mutex;
 use embassy_sync::signal::Signal;
+use embassy_time::Timer;
 use embedded_io::Write;
 use esp_backtrace as _;
 use esp_hal::{
     gpio::{Input, InputConfig as GpioInputConfig, Pin, Pull},
+    interrupt::software::SoftwareInterruptControl,
+    timer::timg::TimerGroup,
 };
 use esp_println::println;
 use owned_str::OwnedStr;
@@ -25,18 +31,29 @@ mod screen;
 
 pub use input::ANGLE;
 
+use crate::screen::overwrite_lcd;
+
 const WIFI_NETWORK: &str = "flamme";
 const WIFI_PASSWORD: &str = "12345678";
 const TARGET_IP: &str = "84.238.32.253";
 const TARGET_PORT: u16 = 7070;
 const WHEEL_PRECISION: i32 = 32;
 const WHEEL_INVERTED: bool = false;
+const DEVICE_ID: &str = "esp32-1";
 
 enum QuestionType {
     Choice,
     Numeric { min: i32, max: i32 },
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum TcpDisconnect {
+    ReadError,
+    ReadEof,
+    WriteError,
+    Cancelled,
+}
+
 struct QuestionData {
     text: OwnedStr<256>,
     q_type: QuestionType,
@@ -61,18 +78,44 @@ static WHEEL_VALUE: Mutex<CriticalSectionRawMutex, WheelData> = Mutex::new(Wheel
     accumulated: 0,
 });
 
+pub async fn reset_state() {
+    *QUESTION.lock().await = None;
+    *WHEEL_VALUE.lock().await = WheelData {
+        value: 0,
+        min: 0,
+        max: 0,
+        accumulated: 0,
+    };
+}
+
 #[panic_handler]
-fn panic(_: &core::panic::PanicInfo) -> ! {
+fn panic(info: &core::panic::PanicInfo) -> ! {
+    println!("PANIC! {:?}", info);
     loop {}
 }
 
-pub async fn tcp_read_loop(mut read: TcpReader<'_>) {
+pub async fn tcp_read_loop(
+    mut read: TcpReader<'_>,
+    cancel: &Signal<CriticalSectionRawMutex, ()>,
+) -> Result<(), TcpDisconnect> {
     let mut buf = [0u8; 1024];
     let mut generation = 1;
 
-    while let Ok(len) = read.read(&mut buf).await {
+    loop {
+        let read_fut = read.read(&mut buf);
+        let cancel_fut = cancel.wait();
+        let len = match select(read_fut, cancel_fut).await {
+            Either::First(Ok(len)) => len,
+            Either::First(Err(_)) => {
+                cancel.signal(());
+                return Err(TcpDisconnect::ReadError);
+            }
+            Either::Second(()) => return Err(TcpDisconnect::Cancelled),
+        };
+
         if len == 0 {
-            break;
+            cancel.signal(());
+            return Err(TcpDisconnect::ReadEof);
         }
         let Ok(str) = core::str::from_utf8(&buf[..len]) else {
             continue;
@@ -86,6 +129,10 @@ pub async fn tcp_read_loop(mut read: TcpReader<'_>) {
             accumulated: 0,
         };
         for line in str.lines() {
+            if line == "##" {
+                overwrite_lcd("Waiting", DEVICE_ID).await;
+                break;
+            }
             if line == "$$" {
                 counter = 1;
                 continue;
@@ -109,7 +156,10 @@ pub async fn tcp_read_loop(mut read: TcpReader<'_>) {
                     if key == "rangeMin" || key == "rangeMax" {
                         match q_type {
                             QuestionType::Choice => {}
-                            QuestionType::Numeric { ref mut min, ref mut max } => {
+                            QuestionType::Numeric {
+                                ref mut min,
+                                ref mut max,
+                            } => {
                                 if key == "rangeMin" {
                                     *min = value.parse().unwrap();
                                     future_wheel.min = *min;
@@ -152,15 +202,30 @@ pub async fn tcp_read_loop(mut read: TcpReader<'_>) {
     }
 }
 
-pub async fn tcp_write_loop(mut write: TcpWriter<'_>) {
+pub async fn tcp_write_loop(
+    mut write: TcpWriter<'_>,
+    cancel: &Signal<CriticalSectionRawMutex, ()>,
+) -> Result<(), TcpDisconnect> {
+    if write.write(DEVICE_ID.as_bytes()).await.is_err() {
+        cancel.signal(());
+        return Err(TcpDisconnect::WriteError);
+    }
     let mut buffer = buffer::WriteBuffer::<256>::new();
     loop {
-        let data = input::INPUT.receive().await;
+        let input_fut = input::INPUT.receive();
+        let cancel_fut = cancel.wait();
+        let data = match select(input_fut, cancel_fut).await {
+            Either::First(data) => data,
+            Either::Second(()) => return Err(TcpDisconnect::Cancelled),
+        };
         println!("button={}", data);
         let angle = *ANGLE.lock().await;
         core::writeln!(buffer, "button={} angle={}", data, angle).ok();
         println!("write: {}", &buffer);
-        write.write(&buffer).await.ok();
+        if write.write(&buffer).await.is_err() {
+            cancel.signal(());
+            return Err(TcpDisconnect::WriteError);
+        }
         buffer.clear();
     }
 }
@@ -221,42 +286,98 @@ pub async fn main_loop() {
     }
 }
 
+esp_bootloader_esp_idf::esp_app_desc!();
+
 #[esp_rtos::main]
 async fn main(spawner: Spawner) -> ! {
-    let p = esp_hal::init(esp_hal::Config::default().with_cpu_clock(esp_hal::clock::CpuClock::max()));
+    let p =
+        esp_hal::init(esp_hal::Config::default().with_cpu_clock(esp_hal::clock::CpuClock::max()));
+
+    println!("Booting");
+    let timg0 = TimerGroup::new(p.TIMG0);
+    let sw_int = SoftwareInterruptControl::new(p.SW_INTERRUPT);
+    esp_rtos::start(timg0.timer0, sw_int.software_interrupt0);
 
     esp_alloc::heap_allocator!(size: 64 * 1024);
 
     let lcd = screen::LcdPins {
-        rs: p.GPIO10,
-        e: p.GPIO11,
-        d4: p.GPIO12,
-        d5: p.GPIO13,
-        d6: p.GPIO14,
-        d7: p.GPIO15,
+        rs: p.GPIO4,
+        e: p.GPIO16,
+        d4: p.GPIO17,
+        d5: p.GPIO18,
+        d6: p.GPIO19,
+        d7: p.GPIO23,
     };
 
     spawner.spawn(screen::lcd_display_task(screen::LcdConfig { pins: lcd }).expect("spawn lcd"));
-    spawner.spawn(input::rotation_read_task(input::RotationConfig {
-        i2c0: p.I2C0,
-        scl: p.GPIO5,
-        sda: p.GPIO4,
-    }).expect("spawn rotation"));
+    spawner.spawn(
+        input::rotation_read_task(input::RotationConfig {
+            i2c0: p.I2C0,
+            scl: p.GPIO22,
+            sda: p.GPIO21,
+        })
+        .expect("spawn rotation"),
+    );
 
-    spawner.spawn(input::button_task(Input::new(p.GPIO18.degrade(), GpioInputConfig::default().with_pull(Pull::Up)), 1).expect("spawn btn1"));
-    spawner.spawn(input::button_task(Input::new(p.GPIO19.degrade(), GpioInputConfig::default().with_pull(Pull::Up)), 2).expect("spawn btn2"));
-    spawner.spawn(input::button_task(Input::new(p.GPIO20.degrade(), GpioInputConfig::default().with_pull(Pull::Up)), 3).expect("spawn btn3"));
-    spawner.spawn(input::button_task(Input::new(p.GPIO21.degrade(), GpioInputConfig::default().with_pull(Pull::Up)), 4).expect("spawn btn4"));
+    spawner.spawn(
+        input::button_task(
+            Input::new(
+                p.GPIO26.degrade(),
+                GpioInputConfig::default().with_pull(Pull::Up),
+            ),
+            1,
+        )
+        .expect("spawn btn1"),
+    );
+    spawner.spawn(
+        input::button_task(
+            Input::new(
+                p.GPIO25.degrade(),
+                GpioInputConfig::default().with_pull(Pull::Up),
+            ),
+            2,
+        )
+        .expect("spawn btn2"),
+    );
+    spawner.spawn(
+        input::button_task(
+            Input::new(
+                p.GPIO33.degrade(),
+                GpioInputConfig::default().with_pull(Pull::Up),
+            ),
+            3,
+        )
+        .expect("spawn btn3"),
+    );
+    spawner.spawn(
+        input::button_task(
+            Input::new(
+                p.GPIO32.degrade(),
+                GpioInputConfig::default().with_pull(Pull::Up),
+            ),
+            4,
+        )
+        .expect("spawn btn4"),
+    );
 
-    spawner.spawn(net::network_setup_task(spawner, net::NetworkConfig {
-        wifi: p.WIFI,
-        wifi_network: WIFI_NETWORK,
-        wifi_password: WIFI_PASSWORD,
-        target_ip: TARGET_IP,
-        target_port: TARGET_PORT,
-    }).expect("spawn net"));
+    spawner.spawn(
+        net::network_setup_task(
+            spawner,
+            net::NetworkConfig {
+                wifi: p.WIFI,
+                wifi_network: WIFI_NETWORK,
+                wifi_password: WIFI_PASSWORD,
+                target_ip: TARGET_IP,
+                target_port: TARGET_PORT,
+            },
+        )
+        .expect("spawn net"),
+    );
+
+    println!("Init done");
 
     loop {
-        embassy_time::Timer::after_millis(1000).await;
+        Timer::after_millis(1000).await;
+        // println!("Looping");
     }
 }

esp32/src/net.rs

@@ -1,16 +1,21 @@
 use core::net::SocketAddrV4;
 use core::str::FromStr;
 
+use alloc::format;
 use embassy_futures::join::join;
 use embassy_net::tcp::TcpSocket;
-use embassy_time::Duration;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::signal::Signal;
+use embassy_time::{Duration, Timer};
 use esp_hal::peripherals::WIFI;
 use esp_hal::rng::Rng;
 use esp_println::println;
-use esp_radio::wifi::{scan::ScanConfig, Config, ControllerConfig};
 use esp_radio::wifi::sta::StationConfig;
+use esp_radio::wifi::{Config, ControllerConfig, scan::ScanConfig};
 
-use crate::{buffer::wait_for_config, tcp_read_loop, tcp_write_loop};
+use crate::screen::overwrite_lcd;
+use crate::{TcpDisconnect, buffer::wait_for_config, tcp_read_loop, tcp_write_loop};
+use crate::{WIFI_NETWORK, WIFI_PASSWORD};
 
 pub struct NetworkConfig<'a> {
     pub wifi: WIFI<'a>,
@@ -21,12 +26,17 @@ pub struct NetworkConfig<'a> {
 }
 
 #[embassy_executor::task]
-async fn net_task(mut runner: embassy_net::Runner<'static, esp_radio::wifi::Interface<'static>>) -> ! {
+async fn net_task(
+    mut runner: embassy_net::Runner<'static, esp_radio::wifi::Interface<'static>>,
+) -> ! {
     runner.run().await
 }
 
 #[embassy_executor::task]
-pub async fn network_setup_task(spawner: embassy_executor::Spawner, config: NetworkConfig<'static>) {
+pub async fn network_setup_task(
+    spawner: embassy_executor::Spawner,
+    config: NetworkConfig<'static>,
+) {
     let wifi_config = Config::Station(
         StationConfig::default()
             .with_ssid(config.wifi_network)
@@ -41,6 +51,10 @@ pub async fn network_setup_task(spawner: embassy_executor::Spawner, config: Netw
     .unwrap();
     println!("Wifi configured and started!");
 
+    controller
+        .set_power_saving(esp_radio::wifi::PowerSaveMode::None)
+        .unwrap();
+
     let wifi_interface = interfaces.station;
     let net_config = embassy_net::Config::dhcpv4(Default::default());
     let rng = Rng::new();
@@ -54,28 +68,92 @@ pub async fn network_setup_task(spawner: embassy_executor::Spawner, config: Netw
     );
     spawner.spawn(net_task(runner).expect("spawn net task"));
 
-    println!("Scan");
-    let scan_config = ScanConfig::default().with_max(10);
-    let result = controller.scan_async(&scan_config).await.unwrap();
-    for ap in result {
-        println!("{:?}", ap);
+    loop {
+        loop {
+            overwrite_lcd("Connecting", "").await;
+            println!("Scan");
+            let scan_config = ScanConfig::default().with_max(10);
+            let result = controller.scan_async(&scan_config).await.unwrap();
+            for ap in result {
+                println!(
+                    "- {} (CH {} Strength {})",
+                    ap.ssid.as_str(),
+                    ap.channel,
+                    ap.signal_strength
+                );
+            }
+
+            println!("Scan ended");
+
+            if let Err(e) = controller.set_config(&Config::Station(
+                StationConfig::default()
+                    // .with_auth_method(esp_radio::wifi::AuthenticationMethod::Wpa2Wpa3Personal)
+                    .with_ssid(WIFI_NETWORK)
+                    .with_password(WIFI_PASSWORD.into()),
+            )) {
+                println!("Connection error: {:?}", e);
+                overwrite_lcd("Connection error", &format!("{}", e)).await;
+                Timer::after_millis(1000).await;
+                continue;
+            }
+
+            if let Err(e) = controller.connect_async().await {
+                println!("Connect error: {:?}", e);
+                overwrite_lcd("Connection error", &format!("{}", e)).await;
+                Timer::after_millis(1000).await;
+                continue;
+            }
+
+            println!("Configured");
+
+            stack.wait_config_up().await;
+
+            break;
+        }
+
+        println!("Waiting for DHCP");
+
+        let cfg = wait_for_config(stack).await;
+        let local_addr = cfg.address.address();
+        println!("IP address: {:?}", local_addr);
+
+        loop {
+            let host_addr = embassy_net::Ipv4Address::from_str(config.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, config.target_port))
+                .await
+            {
+                println!("tcp connect error: {:?}", e);
+                overwrite_lcd("TCP error", &format!("{}", e)).await;
+                Timer::after_millis(1000).await;
+                continue;
+            }
+            overwrite_lcd("Connected", "").await;
+
+            let cancel = Signal::<CriticalSectionRawMutex, ()>::new();
+            let (read, write) = socket.split();
+            let (read_result, write_result) =
+                join(tcp_read_loop(read, &cancel), tcp_write_loop(write, &cancel)).await;
+            let disconnect = read_result.err().or(write_result.err());
+
+            if let Some(reason) = disconnect {
+                println!("tcp disconnected: {:?}", reason);
+            } else {
+                println!("tcp loops ended");
+            }
+
+            if !stack.is_config_up() {
+                println!("wifi down, reconnecting wifi");
+                break;
+            }
+
+            overwrite_lcd("Connection close", "").await;
+            Timer::after_millis(500).await;
+        }
     }
-
-    stack.wait_config_up().await;
-    let cfg = wait_for_config(stack).await;
-    let local_addr = cfg.address.address();
-    println!("IP address: {:?}", local_addr);
-
-    let host_addr = embassy_net::Ipv4Address::from_str(config.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, config.target_port)).await {
-        println!("tcp connect error: {:?}", e);
-    }
-
-    let (read, write) = socket.split();
-    join(tcp_read_loop(read), tcp_write_loop(write)).await;
 }

esp32/src/screen.rs

@@ -1,19 +1,16 @@
-use core::convert::Infallible;
-
 use ag_lcd::LcdDisplay;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex, signal::Signal};
 use embassy_time::{Delay, Timer};
 use esp_hal::gpio::{Level, Output, OutputConfig};
-use esp_hal::peripherals::{GPIO10, GPIO11, GPIO12, GPIO13, GPIO14, GPIO15};
-use ufmt::uWrite;
+use esp_hal::peripherals::{GPIO4, GPIO16, GPIO17, GPIO18, GPIO19, GPIO23};
 
 pub struct LcdPins {
-    pub rs: GPIO10<'static>,
-    pub e: GPIO11<'static>,
-    pub d4: GPIO12<'static>,
-    pub d5: GPIO13<'static>,
-    pub d6: GPIO14<'static>,
-    pub d7: GPIO15<'static>,
+    pub rs: GPIO4<'static>,
+    pub e: GPIO16<'static>,
+    pub d4: GPIO17<'static>,
+    pub d5: GPIO18<'static>,
+    pub d6: GPIO19<'static>,
+    pub d7: GPIO23<'static>,
 }
 
 pub struct LcdConfig {
@@ -26,13 +23,16 @@ pub async fn overwrite_lcd(line1: &str, line2: &str) {
     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());
+    let len1 = line1.len().min(buffer.line1.len());
+    let len2 = line2.len().min(buffer.line2.len());
+    buffer.line1[..len1].copy_from_slice(line1[..len1].as_bytes());
+    buffer.line2[..len2].copy_from_slice(line2[..len2].as_bytes());
     LCD_UPDATE.signal(());
 }
 
 pub fn stack_resources() -> &'static mut embassy_net::StackResources<5> {
-    static RESOURCES: static_cell::StaticCell<embassy_net::StackResources<5>> = static_cell::StaticCell::new();
+    static RESOURCES: static_cell::StaticCell<embassy_net::StackResources<5>> =
+        static_cell::StaticCell::new();
     RESOURCES.init(embassy_net::StackResources::new())
 }
 
@@ -53,7 +53,10 @@ impl ScreenBuffer {
 }
 
 pub static SCREEN_BUFFER: Mutex<CriticalSectionRawMutex, ScreenBuffer> = Mutex::new(ScreenBuffer {
-    line1: [0; 16], line1_ptr: 0, line2: [0; 16], line2_ptr: 0,
+    line1: [0; 16],
+    line1_ptr: 0,
+    line2: [0; 16],
+    line2_ptr: 0,
 });
 static LCD_UPDATE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
 
@@ -76,14 +79,20 @@ pub async fn lcd_display_task(config: LcdConfig) {
     .with_cursor(ag_lcd::Cursor::On)
     .with_lines(ag_lcd::Lines::TwoLines)
     .build();
+    lcd.set_blink(ag_lcd::Blink::Off);
+    lcd.set_cursor(ag_lcd::Cursor::Off);
 
     loop {
         LCD_UPDATE.wait().await;
         let buffer = SCREEN_BUFFER.lock().await;
         lcd.clear();
-        for byte in &buffer.line1 { lcd.write(*byte); }
+        for byte in &buffer.line1 {
+            lcd.write(*byte);
+        }
         lcd.set_position(0, 1);
-        for byte in &buffer.line2 { lcd.write(*byte); }
+        for byte in &buffer.line2 {
+            lcd.write(*byte);
+        }
         Timer::after_millis(20).await;
     }
 }