From 17eb4f391222a7189f7214fec98950ee1491c039 Mon Sep 17 00:00:00 2001 From: Empire Date: Thu, 9 May 2024 00:09:03 +0200 Subject: [PATCH] initial code --- rust/Cargo.toml | 63 +++++++++++-- rust/sdkconfig.defaults | 10 +- rust/src/main.rs | 203 ++++++++++++++++++++++++++++------------ 3 files changed, 205 insertions(+), 71 deletions(-) diff --git a/rust/Cargo.toml b/rust/Cargo.toml index 8380099..96d37c2 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -1,17 +1,41 @@ [package] -name = "rust" +name = "plant-ctrl2" version = "0.1.0" -authors = ["Empire "] +authors = ["Empire Phoenix"] edition = "2021" resolver = "2" rust-version = "1.71" -[profile.release] +[profile.dev] +# Explicitly disable LTO which the Xtensa codegen backend has issues +lto = false +strip = false +debug = true +overflow-checks = true +panic = "abort" +incremental = true opt-level = "s" -[profile.dev] -debug = true # Symbols are nice and they don't increase the size on Flash -opt-level = "z" +[profile.dev.build-override] +opt-level = 1 +incremental = true + +[package.metadata.cargo_runner] +# The string `$TARGET_FILE` will be replaced with the path from cargo. +command = [ + "cargo", + "espflash", + "save-image", + "--partition-table", + "partitions.csv", + "--chip", + "esp32c6", + "image.bin" +] + + +[package.metadata.espflash] +partition_table = "partitions.csv" [features] default = ["std", "embassy", "esp-idf-svc/native"] @@ -25,11 +49,36 @@ embassy = ["esp-idf-svc/embassy-sync", "esp-idf-svc/critical-section", "esp-idf- [dependencies] log = { version = "0.4", default-features = false } -esp-idf-svc = { version = "0.48", default-features = false } +serde = { version = "1.0.192", features = ["derive"] } +average = { version = "0.14.1" , features = ["std"] } +#esp32 = "0.28.0" +bit_field = "0.10.2" +ds18b20 = "0.1.1" embedded-svc = { version = "0.27.0", features = ["experimental"] } esp-idf-hal = "0.43.0" esp-idf-sys = { version = "0.34.0", features = ["binstart", "native"] } +esp-idf-svc = { version = "0.48.0", default-features = false } esp_idf_build = "0.1.3" +chrono = { version = "0.4.23", default-features = false , features = ["iana-time-zone" , "alloc"] } +chrono-tz = {version="0.8.0", default-features = false , features = [ "filter-by-regex" ]} +embedded-hal = "1.0.0" +one-wire-bus = "0.1.1" +anyhow = { version = "1.0.75", features = ["std", "backtrace"] } +schemars = "0.8.16" +heapless = { version = "0.8", features = ["serde"] } +serde_json = "1.0.108" +strum = { version = "0.26.1", features = ["derive"] } +once_cell = "1.19.0" +measurements = "0.11.0" +bq34z100 = "0.2.1" + +[patch.crates-io] +#esp-idf-hal = { git = "https://github.com/esp-rs/esp-idf-hal.git" } +esp-idf-hal = { git = "https://github.com/empirephoenix/esp-idf-hal.git" } +#esp-idf-sys = { git = "https://github.com/empirephoenix/esp-idf-sys.git" } +#esp-idf-sys = { git = "https://github.com/esp-rs/esp-idf-sys.git" } +#esp-idf-svc = { git = "https://github.com/esp-rs/esp-idf-svc.git" } [build-dependencies] embuild = "0.31.3" +vergen = { version = "8.2.6", features = ["build", "git", "gitcl"] } diff --git a/rust/sdkconfig.defaults b/rust/sdkconfig.defaults index 9ea5d73..6ae7e19 100644 --- a/rust/sdkconfig.defaults +++ b/rust/sdkconfig.defaults @@ -1,10 +1,10 @@ # Rust often needs a bit of an extra main task stack size compared to C (the default is 3K) -CONFIG_ESP_MAIN_TASK_STACK_SIZE=8000 +CONFIG_ESP_MAIN_TASK_STACK_SIZE=25000 # Use this to set FreeRTOS kernel tick frequency to 1000 Hz (100 Hz by default). # This allows to use 1 ms granuality for thread sleeps (10 ms by default). -#CONFIG_FREERTOS_HZ=1000 +CONFIG_FREERTOS_HZ=1000 -# Workaround for https://github.com/espressif/esp-idf/issues/7631 -#CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=n -#CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=n +CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y +CONFIG_I2C_ENABLE_DEBUG_LOG=y +DEBUG_LEVEL=5 \ No newline at end of file diff --git a/rust/src/main.rs b/rust/src/main.rs index d3f9d7f..0211cd0 100644 --- a/rust/src/main.rs +++ b/rust/src/main.rs @@ -1,19 +1,31 @@ -use esp_idf_hal::gpio::{AnyInputPin, Gpio10, Gpio6, Gpio5, InputOutput, Level, PinDriver, Pull}; -use esp_idf_svc::hal::{peripheral::Peripheral, peripherals::Peripherals}; -use esp_idf_sys::{esp, gpio_hold_dis, gpio_hold_en, vTaskDelay, EspError}; -use esp_idf_hal::delay::Delay; -use std::time::Duration; -use esp_idf_svc::eventloop::EspSystemEventLoop; -use esp_idf_svc::ipv4::IpInfo; -use esp_idf_svc::mqtt::client::QoS::AtLeastOnce; -use esp_idf_svc::mqtt::client::QoS::ExactlyOnce; -use esp_idf_svc::mqtt::client::{EspMqttClient, LwtConfiguration, MqttClientConfiguration}; -use esp_idf_svc::nvs::EspDefaultNvsPartition; -use esp_idf_svc::wifi::config::{ScanConfig, ScanType}; -use esp_idf_svc::wifi::EspWifi; -use esp_idf_hal::adc::{attenuation, AdcChannelDriver, AdcDriver}; +use std::sync::Mutex; -fn main() { +use chrono::{DateTime, Datelike, Timelike}; +use chrono_tz::Europe::Berlin; + +use esp_idf_hal::delay::Delay; +use esp_idf_sys:: + esp_restart +; +use log::error; +use once_cell::sync::Lazy; +use plant_hal::{CreatePlantHal, PlantCtrlBoard, PlantCtrlBoardInteraction, PlantHal}; +use serde::{Deserialize, Serialize}; + +pub mod plant_hal; + +#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)] +enum OnlineMode { + Offline, + Wifi, + SnTp, + Online, +} + +pub static BOARD_ACCESS: Lazy> = Lazy::new(|| PlantHal::create().unwrap()); + + +fn safe_main() -> anyhow::Result<()> { // It is necessary to call this function once. Otherwise some patches to the runtime // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71 esp_idf_svc::sys::link_patches(); @@ -21,54 +33,127 @@ fn main() { // Bind the log crate to the ESP Logging facilities esp_idf_svc::log::EspLogger::initialize_default(); - log::info!("Hello, world!"); - - let mut peripherals = Peripherals::take().unwrap(); - let mut in1 = PinDriver::input_output(peripherals.pins.gpio7).unwrap(); - let mut in2 = PinDriver::input_output(peripherals.pins.gpio6).unwrap(); - - let sys_loop = EspSystemEventLoop::take().unwrap(); - let nvs = EspDefaultNvsPartition::take().unwrap(); - let mut wifi_driver = EspWifi::new(peripherals.modem, sys_loop, Some(nvs)).unwrap(); - wifi_driver.start().unwrap(); - wifi_driver.start_scan( - &ScanConfig { - scan_type: ScanType::Passive(Duration::from_secs(1)), - show_hidden: false, - ..Default::default() - }, - true, - ).unwrap(); - let sr = wifi_driver.get_scan_result().unwrap(); - for r in sr.iter() { - println!("Found wifi {}", r.ssid); + if esp_idf_sys::CONFIG_MAIN_TASK_STACK_SIZE < 25000 { + error!( + "stack too small: {} bail!", + esp_idf_sys::CONFIG_MAIN_TASK_STACK_SIZE + ); + return Ok(()); } - let adc_config = esp_idf_hal::adc::config::Config { - resolution: esp_idf_hal::adc::config::Resolution::Resolution12Bit, - calibration: true, + log::info!("Startup Rust"); + + println!("Board hal init"); + let mut board: std::sync::MutexGuard<'_, PlantCtrlBoard<'_>> = BOARD_ACCESS.lock().unwrap(); + + let time = board.time(); + let mut cur = match time { + Ok(cur) => cur, + Err(err) => { + log::error!("time error {}", err); + DateTime::from_timestamp_millis(0).unwrap() + } }; - let mut tank_driver = AdcDriver::new(peripherals.adc2, &adc_config).unwrap(); - let mut tank_channel: AdcChannelDriver<'_, { attenuation::DB_11 }, Gpio5> = - AdcChannelDriver::new(peripherals.pins.gpio5).unwrap(); + //check if we know the time current > 2020 + if cur.year() < 2020 { + //assume TZ safe times ;) + cur = *cur.with_hour(15).get_or_insert(cur); + + } + + println!("cur is {}", cur); + + + let mut online_mode: OnlineMode; + + println!("attempting to connect wifi"); + let mut ssid: heapless::String<32> = heapless::String::new(); + let mut password: heapless::String<64> = heapless::String::new(); + + ssid.push_str("C3MA").unwrap(); + password.push_str("penis").unwrap(); + + let ip_address: Option; + match board.wifi(ssid, Option::Some(password), 10000) { + Ok(ip_info) => { + ip_address = Some(ip_info.ip.to_string()); + online_mode = OnlineMode::Wifi; + } + Err(_) => { + panic!("wifi down"); + } + } + + if online_mode == OnlineMode::Wifi { + match board.sntp(1000 * 5) { + Ok(new_time) => { + cur = new_time; + online_mode = OnlineMode::SnTp; + } + Err(err) => { + println!("Sntp error {}", err); + online_mode = OnlineMode::SnTp; + } + } + } + + println!("Running logic at utc {}", cur); + let europe_time = cur.with_timezone(&Berlin); + println!("Running logic at europe/berlin {}", europe_time); + + //do mqtt before config check, as mqtt might configure + if online_mode == OnlineMode::SnTp { + match board.mqtt() { + Ok(_) => { + println!("Mqtt connection ready"); + online_mode = OnlineMode::Online; + } + Err(err) => { + panic!("Could not connect mqtt due to {}", err); + } + } + } + + if online_mode == OnlineMode::Online { + match ip_address { + Some(add_some) => { + let _ = board.mqtt_publish("/firmware/address", add_some.as_bytes()); + } + None => { + let _ = board.mqtt_publish("/firmware/address", "N/A?".as_bytes()); + } + } + let _ = board.mqtt_publish( + "/firmware/last_online", + europe_time.to_rfc3339().as_bytes(), + ); + let _ = board.mqtt_publish("/state", "online".as_bytes()); + + } + drop(board); loop { - - let mut delay = Delay::new_default(); - - - in1.set_low().unwrap(); - in2.set_high().unwrap(); - for i in 0..50 { - delay.delay_ms(100); - let value_up = tank_driver.read(&mut tank_channel).unwrap(); - println!("up {}", value_up); - } - - let value_down = tank_driver.read(&mut tank_channel).unwrap(); - println!("down {}", value_down); - in1.set_low().unwrap(); - in2.set_low().unwrap(); - delay.delay_ms(5000); + //wait till earth ends + Delay::new(1000).delay_ms(1000); + let mut lock = BOARD_ACCESS.lock().unwrap(); + let position = lock.get_position(); + lock.mqtt_publish("/position", format!("{}", position).as_bytes()).unwrap(); } } + +fn main() { + let result = safe_main(); + match result { + Ok(_) => { + println!("Main app finished, restarting"); + unsafe { esp_restart() }; + } + Err(err) => { + panic!("Failed main {}", err); + } + } +} +//error codes +//error_reading_config_after_upgrade +//error_no_config_after_upgrade +//error_tank_sensor_fault