C3MA/PlantCtrl
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

go to stay alive

Browse Source
This commit is contained in:
Empire 2024-01-07 14:33:02 +01:00
parent 5724088780
commit a30dbe0759
12 changed files with 1205 additions and 763 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
rust/build.rs
View File

@ -3,16 +3,23 @@ use std::process::Command;
use vergen::EmitBuilder;
fn main() {
println!("cargo:rerun-if-changed=./src/src_webpack");
Command::new("rm").arg("./src/webserver/bundle.js").output().expect("failed to execute process");
let output = Command::new("npx").arg("webpack").current_dir("./src_webpack").output().expect("failed to execute process");
Command::new("rm")
.arg("./src/webserver/bundle.js")
.output()
.expect("failed to execute process");
let output = Command::new("npx")
.arg("webpack")
.current_dir("./src_webpack")
.output()
.expect("failed to execute process");
println!("status: {}", output.status);
println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
assert!(output.status.success());
embuild::espidf::sysenv::output();
let _ = EmitBuilder::builder().all_git().emit();
}
}

2
rust/partitions.csv
View File

@ -1,6 +1,6 @@
nvs, data, nvs, , 16k,
otadata, data, ota, , 8k,
phy_init, data, phy, , 4k,
ota_0, app, ota_0, , 1792K,
ota_0, app, ota_0, , 1792K,
ota_1, app, ota_1, , 1792K,
storage, data, spiffs, , 400K,
1 nvs data nvs 16k
2 otadata data ota 8k
3 phy_init data phy 4k
4 ota_0 app ota_0 1792K
5 ota_1 app ota_1 1792K
6 storage data spiffs 400K

3
rust/rust-toolchain.toml
View File

@ -1,2 +1,3 @@
[toolchain]
channel = "esp"
channel = "nightly"

2
rust/sdkconfig.defaults
View File

@ -1,5 +1,5 @@
# 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=20000
# 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).

98
rust/src/config.rs
View File

@ -1,54 +1,78 @@
use std::fmt;
use serde::{Serialize, Deserialize};
use serde::{Deserialize, Serialize};
use crate::PLANT_COUNT;
#[derive(Serialize, Deserialize)]
#[derive(Debug)]
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct Config {
tank_sensor_enabled: bool,
tank_full_ml: u32,
tank_warn_percent: u8,
pub mqtt_url: heapless::String<128>,
pub base_topic: heapless::String<64>,
pub max_consecutive_pump_count: u8,
night_lamp_hour_start: u8,
night_lamp_hour_end: u8,
night_lamp_only_when_dark: bool,
pub tank_allow_pumping_if_sensor_error: bool,
pub tank_sensor_enabled: bool,
pub tank_useable_ml: u32,
pub tank_warn_percent: u8,
pub tank_empty_mv: f32,
pub tank_full_mv: f32,
plants: [Plant;PLANT_COUNT]
pub night_lamp_hour_start: u8,
pub night_lamp_hour_end: u8,
pub night_lamp_only_when_dark: bool,
pub plants: [Plant; PLANT_COUNT],
}
impl Default for Config {
fn default() -> Self {
Self { tank_sensor_enabled: true,
tank_full_ml: 5000,
tank_warn_percent: 50,
night_lamp_hour_start: 21,
night_lamp_hour_end: 2,
night_lamp_only_when_dark: true,
plants: [Plant::default();PLANT_COUNT]
fn default() -> Self {
Self {
base_topic: "plant/one".into(),
mqtt_url: "mqtt://192.168.1.1:1883".into(),
tank_allow_pumping_if_sensor_error: true,
tank_sensor_enabled: true,
tank_warn_percent: 50,
night_lamp_hour_start: 21,
night_lamp_hour_end: 2,
night_lamp_only_when_dark: true,
plants: [Plant::default(); PLANT_COUNT],
max_consecutive_pump_count: 15,
tank_useable_ml: 5000,
tank_empty_mv: 0.1,
tank_full_mv: 3.3,
}
}
}
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
pub enum Mode {
OFF,
TargetMoisture,
TimerOnly,
}
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
pub struct Plant {
pub mode: Mode,
pub target_moisture: u8,
pub pump_time_s: u16,
pub pump_cooldown_min: u16,
pub pump_hour_start: u8,
pub pump_hour_end: u8,
}
impl Default for Plant {
fn default() -> Self {
Self {
target_moisture: 40,
pump_time_s: 60,
pump_cooldown_min: 60,
pump_hour_start: 8,
pump_hour_end: 20,
mode: Mode::OFF,
}
}
}
#[derive(Serialize, Deserialize, Copy, Clone)]
#[derive(Debug)]
pub struct Plant{
target_moisture: u8,
pump_time_s: u16,
pump_cooldown_min: u16,
pump_hour_start: u8,
pump_hour_end: u8
}
impl Default for Plant {
fn default() -> Self {
Self { target_moisture: 40, pump_time_s: 60, pump_cooldown_min: 60, pump_hour_start: 8, pump_hour_end: 20 }
}
}
#[derive(Serialize, Deserialize)]
#[derive(Debug)]
#[derive(Serialize, Deserialize, Debug)]
pub struct WifiConfig {
pub ssid: heapless::String<32>,
pub password: Option<heapless::String<64>>,
@ -58,4 +82,4 @@ impl fmt::Display for WifiConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, ****)", self.ssid)
}
}
}

2
rust/src/lib.rs
View File

@ -1,4 +1,4 @@
#![allow(dead_code)]
extern crate embedded_hal as hal;
pub mod sipo;
pub mod sipo;

362
rust/src/main.rs
View File

@ -1,60 +1,97 @@
use std::{sync::{Arc, Mutex, atomic::AtomicBool}, env};
use std::{
env,
sync::{atomic::AtomicBool, Arc, Mutex},
};
use chrono::{Datelike, NaiveDateTime, Timelike};
use once_cell::sync::Lazy;
use anyhow::Result;
use chrono::{Datelike, Duration, NaiveDateTime, Timelike};
use chrono_tz::Europe::Berlin;
use esp_idf_hal::delay::Delay;
use esp_idf_sys::{esp_restart, vTaskDelay};
use esp_idf_sys::{esp_restart, uxTaskGetStackHighWaterMark, vTaskDelay};
use esp_ota::rollback_and_reboot;
use log::error;
use once_cell::sync::Lazy;
use plant_hal::{CreatePlantHal, PlantCtrlBoard, PlantCtrlBoardInteraction, PlantHal, PLANT_COUNT};
use serde::{Deserialize, Serialize};
use crate::{config::{Config, WifiConfig}, webserver::webserver::{httpd_initial, httpd}};
use crate::{
config::{Config, WifiConfig},
webserver::webserver::{httpd, httpd_initial},
};
mod config;
pub mod plant_hal;
const MOIST_SENSOR_MAX_FREQUENCY: u32 = 5200; // 60kHz (500Hz margin)
const MOIST_SENSOR_MIN_FREQUENCY: u32 = 500; // 0.5kHz (500Hz margin)
const FROM: (f32, f32) = (
MOIST_SENSOR_MIN_FREQUENCY as f32,
MOIST_SENSOR_MAX_FREQUENCY as f32,
);
const TO: (f32, f32) = (0_f32, 100_f32);
mod webserver {
pub mod webserver;
}
#[derive(PartialEq)]
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
enum OnlineMode {
Offline,
Wifi,
SnTp,
Mqtt,
MqttRoundtrip
}
enum WaitType{
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
enum WaitType {
InitialConfig,
FlashError,
NormalConfig
NormalConfig,
StayAlive,
}
fn wait_infinity(wait_type:WaitType, reboot_now:Arc<AtomicBool>) -> !{
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Default)]
struct PlantState {
a: u8,
b: u8,
p: u8,
after_p: u8,
dry: bool,
active: bool,
pump_error: bool,
not_effective: bool,
cooldown: bool,
no_water: bool,
}
fn wait_infinity(wait_type: WaitType, reboot_now: Arc<AtomicBool>) -> ! {
let delay = match wait_type {
WaitType::InitialConfig => 250_u32,
WaitType::FlashError => 100_u32,
WaitType::NormalConfig => 500_u32
WaitType::NormalConfig => 500_u32,
WaitType::StayAlive => 1000_u32,
};
let led_count = match wait_type {
WaitType::InitialConfig => 8,
WaitType::FlashError => 8,
WaitType::NormalConfig => 4
WaitType::NormalConfig => 4,
WaitType::StayAlive => 2,
};
BOARD_ACCESS.lock().unwrap().light(true).unwrap();
loop {
unsafe {
//do not trigger watchdog
for i in 0..8 {
BOARD_ACCESS.lock().unwrap().fault(i, i <led_count);
BOARD_ACCESS.lock().unwrap().fault(i, i < led_count);
}
BOARD_ACCESS.lock().unwrap().general_fault(true);
vTaskDelay(delay);
BOARD_ACCESS.lock().unwrap().general_fault(false);
for i in 0..8 {
BOARD_ACCESS.lock().unwrap().fault(i, false);
BOARD_ACCESS.lock().unwrap().fault(i, false);
}
vTaskDelay(delay);
if wait_type == WaitType::StayAlive
&& !STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed)
{}
if reboot_now.load(std::sync::atomic::Ordering::Relaxed) {
println!("Rebooting");
esp_restart();
@ -63,9 +100,12 @@ fn wait_infinity(wait_type:WaitType, reboot_now:Arc<AtomicBool>) -> !{
}
}
pub static BOARD_ACCESS: Lazy<Mutex<PlantCtrlBoard>> = Lazy::new(|| {
PlantHal::create().unwrap()
});
pub static BOARD_ACCESS: Lazy<Mutex<PlantCtrlBoard>> = Lazy::new(|| PlantHal::create().unwrap());
pub static STAY_ALIVE: Lazy<AtomicBool> = Lazy::new(|| AtomicBool::new(false));
fn map_range(from_range: (f32, f32), to_range: (f32, f32), s: f32) -> f32 {
to_range.0 + (s - from_range.0) * (to_range.1 - to_range.0) / (from_range.1 - from_range.0)
}
fn main() -> Result<()> {
// It is necessary to call this function once. Otherwise some patches to the runtime
@ -75,16 +115,45 @@ fn main() -> Result<()> {
// Bind the log crate to the ESP Logging facilities
esp_idf_svc::log::EspLogger::initialize_default();
if esp_idf_sys::CONFIG_MAIN_TASK_STACK_SIZE < 20000 {
error!(
"stack too small: {} bail!",
esp_idf_sys::CONFIG_MAIN_TASK_STACK_SIZE
);
return Ok(());
}
log::info!("Startup Rust");
let git_hash = env!("VERGEN_GIT_DESCRIBE");
println!("Version useing git has {}", git_hash);
let mut partition_state: embedded_svc::ota::SlotState = embedded_svc::ota::SlotState::Unknown;
// match esp_idf_svc::ota::EspOta::new() {
// Ok(ota) => {
// match ota.get_running_slot(){
// Ok(slot) => {
// partition_state = slot.state;
// println!(
// "Booting from {} with state {:?}",
// slot.label, partition_state
// );
// },
// Err(err) => {
// println!("Error getting running slot {}", err);
// },
// }
// },
// Err(err) => {
// println!("Error obtaining ota info {}", err);
// },
// }
println!("Board hal init");
let mut board = BOARD_ACCESS.lock().unwrap();
let mut board: std::sync::MutexGuard<'_, PlantCtrlBoard<'_>> = BOARD_ACCESS.lock().unwrap();
println!("Mounting filesystem");
board.mountFileSystem()?;
let free_space = board.fileSystemSize()?;
board.mount_file_system()?;
let free_space = board.file_system_size()?;
println!(
"Mounted, total space {} used {} free {}",
free_space.total_size, free_space.used_size, free_space.free_size
@ -111,8 +180,15 @@ fn main() -> Result<()> {
println!("cur is {}", cur);
if board.is_config_reset() {
board.general_fault(true);
println!("Reset config is pressed, waiting 5s");
Delay::new_default().delay_ms(5000);
for i in 0..25 {
board.general_fault(true);
Delay::new_default().delay_ms(50);
board.general_fault(false);
Delay::new_default().delay_ms(50);
}
if board.is_config_reset() {
println!("Reset config is still pressed, deleting configs and reboot");
match board.remove_configs() {
@ -126,17 +202,29 @@ fn main() -> Result<()> {
wait_infinity(WaitType::FlashError, Arc::new(AtomicBool::new(false)));
}
}
} else {
board.general_fault(false);
}
}
let mut online_mode = OnlineMode::Offline;
let wifi_conf = board.get_wifi();
let wifi: WifiConfig;
match wifi_conf{
match wifi_conf {
Ok(conf) => {
wifi = conf;
},
}
Err(err) => {
if board.is_wifi_config_file_existant() {
match partition_state {
embedded_svc::ota::SlotState::Invalid
| embedded_svc::ota::SlotState::Unverified => {
println!("Config seem to be unparsable after upgrade, reverting");
rollback_and_reboot()?;
}
_ => {}
}
}
println!("Missing wifi config, entering initial config mode {}", err);
board.wifi_ap().unwrap();
//config upload will trigger reboot!
@ -144,48 +232,9 @@ fn main() -> Result<()> {
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd_initial(reboot_now.clone());
wait_infinity(WaitType::InitialConfig, reboot_now.clone());
},
}
};
//check if we have a config file
// if not found or parsing error -> error very fast blink general fault
//if this happens after a firmeware upgrade (check image state), mark as invalid
//blink general fault error_reading_config_after_upgrade, reboot after
// open accesspoint with webserver for wlan mqtt setup
//blink general fault error_no_config_after_upgrade
//once config is set store it and reboot
//if proceed.tank_sensor_enabled() {
//}
//is tank sensor enabled in config?
//measure tank level (without wifi due to interference)
//TODO this should be a result// detect invalid measurement value
let tank_value = board.tank_sensor_mv();
match tank_value {
Ok(tank_raw) => {
println!("Tank sensor returned {}", tank_raw);
}
Err(_) => {
//if not possible value, blink general fault error_tank_sensor_fault
board.general_fault(true);
//set general fault persistent
//set tank sensor state to fault
}
}
//measure each plant moisture
let mut initial_measurements_a: [i32; PLANT_COUNT] = [0; PLANT_COUNT];
let mut initial_measurements_b: [i32; PLANT_COUNT] = [0; PLANT_COUNT];
let mut initial_measurements_p: [i32; PLANT_COUNT] = [0; PLANT_COUNT];
for plant in 0..PLANT_COUNT {
initial_measurements_a[plant] = board.measure_moisture_hz(plant, plant_hal::Sensor::A)?;
initial_measurements_b[plant] = board.measure_moisture_hz(plant, plant_hal::Sensor::B)?;
initial_measurements_p[plant] =
board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)?;
}
println!("attempting to connect wifi");
match board.wifi(&wifi.ssid, wifi.password.as_deref(), 10000) {
Ok(_) => {
@ -202,7 +251,7 @@ fn main() -> Result<()> {
Ok(new_time) => {
cur = new_time;
online_mode = OnlineMode::SnTp;
},
}
Err(err) => {
println!("sntp error: {}", err);
board.general_fault(true);
@ -213,11 +262,11 @@ fn main() -> Result<()> {
println!("Running logic at europe/berlin {}", europe_time);
}
let config:Config;
match (board.get_config()){
let config: Config;
match board.get_config() {
Ok(valid) => {
config = valid;
},
}
Err(err) => {
println!("Missing normal config, entering config mode {}", err);
//config upload will trigger reboot!
@ -225,49 +274,150 @@ fn main() -> Result<()> {
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd(reboot_now.clone());
wait_infinity(WaitType::NormalConfig, reboot_now.clone());
},
}
}
//do mqtt before config check, as mqtt might configure
if online_mode == OnlineMode::SnTp {
//mqtt here
match board.mqtt(&config) {
Ok(_) => {
println!("Mqtt connection ready");
}
Err(err) => {
println!("Could not connect mqtt due to {}", err);
}
}
}
if online_mode == OnlineMode::Mqtt {
//mqtt roundtrip here
match board.battery_state() {
Ok(_state) => {}
Err(err) => {
board.general_fault(true);
println!("Could not read battery state, assuming low power {}", err);
}
}
let mut enough_water = true;
if config.tank_sensor_enabled {
let tank_value = board.tank_sensor_mv();
match tank_value {
Ok(tank_raw) => {
//FIXME clear
let percent = map_range(
(config.tank_empty_mv, config.tank_full_mv),
(0_f32, 100_f32),
tank_raw.into(),
);
let left_ml = ((percent / 100_f32) * config.tank_useable_ml as f32) as u32;
println!(
"Tank sensor returned mv {} as {}% leaving {} ml useable",
tank_raw, percent as u8, left_ml
);
if config.tank_warn_percent > percent as u8 {
board.general_fault(true);
println!(
"Low water, current percent is {}, minimum warn level is {}",
percent as u8, config.tank_warn_percent
);
//FIXME warn here
}
if config.tank_warn_percent <= 0 {
enough_water = false;
}
}
Err(_) => {
board.general_fault(true);
if !config.tank_allow_pumping_if_sensor_error {
enough_water = false;
}
//set tank sensor state to fault
}
}
}
let plantstate = [PlantState {
..Default::default()
}; PLANT_COUNT];
for plant in 0..PLANT_COUNT {
let mut state = plantstate[plant];
//return mapf(mMoisture_raw.getMedian(), MOIST_SENSOR_MIN_FRQ, MOIST_SENSOR_MAX_FRQ, 0, 100);
state.a = map_range(
FROM,
TO,
board.measure_moisture_hz(plant, plant_hal::Sensor::A)? as f32,
) as u8;
state.b = map_range(
FROM,
TO,
board.measure_moisture_hz(plant, plant_hal::Sensor::B)? as f32,
) as u8;
state.p = map_range(
FROM,
TO,
board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)? as f32,
) as u8;
let plant_config = config.plants[plant];
//FIXME how to average analyze whatever?
if state.a < plant_config.target_moisture || state.b < plant_config.target_moisture {
state.dry = true;
if !enough_water {
state.no_water = true;
}
}
let duration = Duration::minutes((60 * plant_config.pump_cooldown_min).into());
if (board.last_pump_time(plant)? + duration) > cur {
state.cooldown = true;
}
if state.dry {
let consecutive_pump_count = board.consecutive_pump_count(plant) + 1;
board.store_consecutive_pump_count(plant, consecutive_pump_count);
if consecutive_pump_count > config.max_consecutive_pump_count.into() {
state.not_effective = true;
board.fault(plant, true);
}
} else {
board.store_consecutive_pump_count(plant, 0);
}
//TODO update mqtt state here!
}
if (STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed)) {
drop(board);
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd(reboot_now.clone());
wait_infinity(WaitType::StayAlive, reboot_now.clone());
}
'eachplant: for plant in 0..PLANT_COUNT {
let mut state = plantstate[plant];
if (state.dry && !state.cooldown) {
println!("Trying to pump with pump {} now", plant);
let plant_config = config.plants[plant];
board.any_pump(true)?;
board.store_last_pump_time(plant, cur);
board.pump(plant, true)?;
board.last_pump_time(plant)?;
state.active = true;
unsafe { vTaskDelay(plant_config.pump_time_s.into()) };
state.after_p = map_range(
FROM,
TO,
board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)? as f32,
) as u8;
if state.after_p < state.p + 5 {
state.pump_error = true;
board.fault(plant, true);
}
break 'eachplant;
}
}
//TODO configmode webserver logic here
/*
//if config battery mode
//read battery level
//if not possible set general fault persistent, but do continue
//else
//assume 12v and max capacity
//if tank sensor is enabled
//if tank sensor fault abort if config require is set
//check if water is > minimum allowed || fault
//if not, set all plants requiring water to persistent fault
//for each plant
//check if moisture is < target
//state += dry
//check if in cooldown
//state += cooldown
//check if consecutive pumps > limit
//state += notworking
//set plant fault persistent
//pump one cycle
// set last pump time to now
//during pump state += active
//after pump check if Pump moisture value is increased by config delta x
// state -= active
// state += cooldown
// if not set plant error persistent fault
// state += notworking
//set consecutive pumps+=1
//check if during light time
//lightstate += out of worktime
@ -287,7 +437,7 @@ fn main() -> Result<()> {
}
*/
//deepsleep here?
return Ok(());
Ok(())
}
//error codes

979
rust/src/plant_hal.rs
View File

File diff suppressed because it is too large Load Diff

58
rust/src/sipo.rs
View File

@ -10,21 +10,21 @@ trait ShiftRegisterInternal {
}
/// Output pin of the shift register
pub struct ShiftRegisterPin<'a>
{
pub struct ShiftRegisterPin<'a> {
shift_register: &'a dyn ShiftRegisterInternal,
index: usize,
}
impl<'a> ShiftRegisterPin<'a>
{
impl<'a> ShiftRegisterPin<'a> {
fn new(shift_register: &'a dyn ShiftRegisterInternal, index: usize) -> Self {
ShiftRegisterPin { shift_register, index }
ShiftRegisterPin {
shift_register,
index,
}
}
}
impl OutputPin for ShiftRegisterPin<'_>
{
impl OutputPin for ShiftRegisterPin<'_> {
type Error = ();
fn set_low(&mut self) -> Result<(), Self::Error> {
@ -42,9 +42,10 @@ macro_rules! ShiftRegisterBuilder {
($name: ident, $size: expr) => {
/// Serial-in parallel-out shift register
pub struct $name<Pin1, Pin2, Pin3>
where Pin1: OutputPin,
Pin2: OutputPin,
Pin3: OutputPin
where
Pin1: OutputPin,
Pin2: OutputPin,
Pin3: OutputPin,
{
clock: RefCell<Pin1>,
latch: RefCell<Pin2>,
@ -53,12 +54,13 @@ macro_rules! ShiftRegisterBuilder {
}
impl<Pin1, Pin2, Pin3> ShiftRegisterInternal for $name<Pin1, Pin2, Pin3>
where Pin1: OutputPin,
Pin2: OutputPin,
Pin3: OutputPin
where
Pin1: OutputPin,
Pin2: OutputPin,
Pin3: OutputPin,
{
/// Sets the value of the shift register output at `index` to value `command`
fn update(&self, index: usize, command: bool) -> Result<(), ()>{
fn update(&self, index: usize, command: bool) -> Result<(), ()> {
self.output_state.borrow_mut()[index] = command;
let output_state = self.output_state.borrow();
self.latch.borrow_mut().set_low().map_err(|_e| ())?;
@ -78,11 +80,11 @@ macro_rules! ShiftRegisterBuilder {
}
}
impl<Pin1, Pin2, Pin3> $name<Pin1, Pin2, Pin3>
where Pin1: OutputPin,
Pin2: OutputPin,
Pin3: OutputPin
where
Pin1: OutputPin,
Pin2: OutputPin,
Pin3: OutputPin,
{
/// Creates a new SIPO shift register from clock, latch, and data output pins
pub fn new(clock: Pin1, latch: Pin2, data: Pin3) -> Self {
@ -95,14 +97,12 @@ macro_rules! ShiftRegisterBuilder {
}
/// Get embedded-hal output pins to control the shift register outputs
pub fn decompose(&self) -> [ShiftRegisterPin; $size] {
pub fn decompose(&self) -> [ShiftRegisterPin; $size] {
// Create an uninitialized array of `MaybeUninit`. The `assume_init` is
// safe because the type we are claiming to have initialized here is a
// bunch of `MaybeUninit`s, which do not require initialization.
let mut pins: [MaybeUninit<ShiftRegisterPin>; $size] = unsafe {
MaybeUninit::uninit().assume_init()
};
let mut pins: [MaybeUninit<ShiftRegisterPin>; $size] =
unsafe { MaybeUninit::uninit().assume_init() };
// Dropping a `MaybeUninit` does nothing, so if there is a panic during this loop,
// we have a memory leak, but there is no memory safety issue.
@ -117,12 +117,16 @@ macro_rules! ShiftRegisterBuilder {
/// Consume the shift register and return the original clock, latch, and data output pins
pub fn release(self) -> (Pin1, Pin2, Pin3) {
let Self{clock, latch, data, output_state: _} = self;
let Self {
clock,
latch,
data,
output_state: _,
} = self;
(clock.into_inner(), latch.into_inner(), data.into_inner())
}
}
}
};
}
ShiftRegisterBuilder!(ShiftRegister8, 8);
@ -143,4 +147,4 @@ ShiftRegisterBuilder!(ShiftRegister120, 120);
ShiftRegisterBuilder!(ShiftRegister128, 128);
/// 8 output serial-in parallel-out shift register
pub type ShiftRegister<Pin1, Pin2, Pin3> = ShiftRegister8<Pin1, Pin2, Pin3>;
pub type ShiftRegister<Pin1, Pin2, Pin3> = ShiftRegister8<Pin1, Pin2, Pin3>;

38
rust/src/webserver/config.html
View File

@ -11,23 +11,45 @@
<h2>config</h2>
<button id="dummy">Create</button>
<div id="configform">
<h3>Mqtt:</h3>
<div>
<input type="text" id="mqtt_url">
MQTT Url
</div>
<div>
<input type="text" id="base_topic">
Base Topic
</div>
<h3>Tank:</h3>
<div>
<input type="checkbox" id="tank_sensor_enabled">
Enable Tank Sensor
</div>
<div>
<input type="number" min="2" max="500000" id="tank_full_ml">
<input type="checkbox" id="tank_allow_pumping_if_sensor_error">
Allow Pumping if Sensor Error
</div>
<div>
<input type="number" min="2" max="500000" id="tank_useable_ml">
Tank Size mL
</div>
<div>
<input type="number" min="1" max="500000" id="tank_warn_percent">
Tank Warn below mL
</div>
<div>
<input type="number" min="1" max="500000" id="tank_empty_mv">
Tank Empty Voltage (mv)
</div>
<div>
<input type="number" min="1" max="500000" id="tank_full_mv">
Tank Full Voltage (mv)
</div>
<h3>Light:</h3>
<div>
@ -44,9 +66,17 @@
</div>
<h3>Plants:</h3>
<div>
<input type="number" min="2" max="100" id="max_consecutive_pump_count">
Max consecutive pump count:
</div>
<div id="plants"></div>
</div>
<button id="submit">Submit</button>
<div id="submit_status"></div>
<br>
<textarea id="json" cols=50 rows=10></textarea>
<script src="bundle.js"></script>

317
rust/src/webserver/webserver.rs
View File

@ -1,192 +1,222 @@
//offer ota and config mode
use std::{sync::{Mutex, Arc, atomic::AtomicBool}, str::from_utf8};
use std::{
str::from_utf8,
sync::{atomic::AtomicBool, Arc},
};
use embedded_svc::http::{Method, Headers};
use esp_idf_svc::http::server::EspHttpServer;
use crate::BOARD_ACCESS;
use embedded_svc::http::Method;
use esp_idf_svc::http::server::{Configuration, EspHttpServer};
use esp_ota::OtaUpdate;
use heapless::String;
use serde::Serialize;
use crate::BOARD_ACCESS;
use crate::{plant_hal::{PlantCtrlBoard, PlantCtrlBoardInteraction, PLANT_COUNT}, config::{WifiConfig, Config, Plant}};
use crate::{
config::{Config, WifiConfig},
plant_hal::PlantCtrlBoardInteraction,
};
#[derive(Serialize)]
#[derive(Debug)]
#[derive(Serialize, Debug)]
struct SSIDList<'a> {
ssids: Vec<&'a String<32>>
ssids: Vec<&'a String<32>>,
}
pub fn httpd_initial(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
let mut server = shared();
server.fn_handler("/",Method::Get, move |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("initial_config.html"))?;
return Ok(())
}).unwrap();
server
.fn_handler("/", Method::Get, move |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("initial_config.html"))?;
Ok(())
})
.unwrap();
server.fn_handler("/wifiscan",Method::Post, move |request| {
let mut response = request.into_ok_response()?;
let mut board = BOARD_ACCESS.lock().unwrap();
match board.wifi_scan() {
Err(error) => {
response.write(format!("Error scanning wifi: {}", error).as_bytes())?;
},
Ok(scan_result) => {
let mut ssids: Vec<&String<32>> = Vec::new();
scan_result.iter().for_each(|s|
ssids.push(&s.ssid)
);
let ssid_json = serde_json::to_string( &SSIDList{ssids})?;
println!("Sending ssid list {}", &ssid_json);
response.write( &ssid_json.as_bytes())?;
},
}
return Ok(())
}).unwrap();
server
.fn_handler("/wifiscan", Method::Post, move |request| {
let mut response = request.into_ok_response()?;
let mut board = BOARD_ACCESS.lock().unwrap();
match board.wifi_scan() {
Err(error) => {
response.write(format!("Error scanning wifi: {}", error).as_bytes())?;
}
Ok(scan_result) => {
let mut ssids: Vec<&String<32>> = Vec::new();
scan_result.iter().for_each(|s| ssids.push(&s.ssid));
let ssid_json = serde_json::to_string(&SSIDList { ssids })?;
println!("Sending ssid list {}", &ssid_json);
response.write(ssid_json.as_bytes())?;
}
}
Ok(())
})
.unwrap();
server.fn_handler("/wifisave",Method::Post, move |mut request| {
server
.fn_handler("/wifisave", Method::Post, move |mut request| {
let mut buf = [0_u8; 2048];
let read = request.read(&mut buf);
if read.is_err() {
let error_text = read.unwrap_err().to_string();
println!("Could not parse wificonfig {}", error_text);
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
let actual_data = &buf[0..read.unwrap()];
println!("raw {:?}", actual_data);
println!("Raw data {}", from_utf8(actual_data).unwrap());
let wifi_config: Result<WifiConfig, serde_json::Error> =
serde_json::from_slice(actual_data);
if wifi_config.is_err() {
let error_text = wifi_config.unwrap_err().to_string();
println!("Could not parse wificonfig {}", error_text);
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
let mut board = BOARD_ACCESS.lock().unwrap();
board.set_wifi(&wifi_config.unwrap())?;
let mut response = request.into_status_response(202)?;
response.write("saved".as_bytes())?;
reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
Ok(())
})
.unwrap();
let mut buf = [0_u8;2048];
let read = request.read(&mut buf);
if read.is_err(){
let error_text = read.unwrap_err().to_string();
println!("Could not parse wificonfig {}", error_text);
request.into_status_response(500)?.write(error_text.as_bytes())?;
return Ok(());
}
let actual_data = &buf[0..read.unwrap()];
println!("raw {:?}", actual_data);
println!("Raw data {}", from_utf8(actual_data).unwrap());
let wifi_config: Result<WifiConfig, serde_json::Error> = serde_json::from_slice(actual_data);
if wifi_config.is_err(){
let error_text = wifi_config.unwrap_err().to_string();
println!("Could not parse wificonfig {}", error_text);
request.into_status_response(500)?.write(error_text.as_bytes())?;
return Ok(());
}
let mut board = BOARD_ACCESS.lock().unwrap();
board.set_wifi(&wifi_config.unwrap())?;
let mut response = request.into_status_response(202)?;
response.write("saved".as_bytes())?;
reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
return Ok(())
}).unwrap();
server
.fn_handler("/boardtest", Method::Post, move |_| {
let mut board = BOARD_ACCESS.lock().unwrap();
board.test()?;
Ok(())
})
.unwrap();
server.fn_handler("/boardtest",Method::Post, move |request| {
let mut board = BOARD_ACCESS.lock().unwrap();
board.test();
return Ok(())
}).unwrap();
return server
server
}
pub fn httpd(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
let mut server = shared();
server
.fn_handler("/",Method::Get, move |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("config.html"))?;
return Ok(())
}).unwrap();
.fn_handler("/", Method::Get, move |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("config.html"))?;
Ok(())
})
.unwrap();
server
.fn_handler("/get_config",Method::Get, move |request| {
let mut response = request.into_ok_response()?;
let mut board = BOARD_ACCESS.lock()?;
match board.get_config() {
Ok(config) => {
let config_json = serde_json::to_string(&config)?;
response.write(config_json.as_bytes())?;
},
Err(_) => {
let config_json = serde_json::to_string(&Config::default())?;
response.write(config_json.as_bytes())?;
},
}
return Ok(())
}).unwrap();
server.fn_handler("/set_config",Method::Post, move |mut request| {
let mut buf = [0_u8;2048];
let read = request.read(&mut buf);
if read.is_err(){
let error_text = read.unwrap_err().to_string();
println!("Could not parse wificonfig {}", error_text);
request.into_status_response(500)?.write(error_text.as_bytes())?;
return Ok(());
}
let actual_data = &buf[0..read.unwrap()];
println!("raw {:?}", actual_data);
println!("Raw data {}", from_utf8(actual_data).unwrap());
let config: Result<Config, serde_json::Error> = serde_json::from_slice(actual_data);
if config.is_err(){
let error_text = config.unwrap_err().to_string();
println!("Could not parse wificonfig {}", error_text);
request.into_status_response(500)?.write(error_text.as_bytes())?;
return Ok(());
}
let mut board = BOARD_ACCESS.lock().unwrap();
board.set_config(&config.unwrap())?;
let mut response = request.into_status_response(202)?;
response.write("saved".as_bytes())?;
reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
return Ok(())
}).unwrap();
return server;
.fn_handler("/get_config", Method::Get, move |request| {
let mut response = request.into_ok_response()?;
let mut board = BOARD_ACCESS.lock()?;
match board.get_config() {
Ok(config) => {
let config_json = serde_json::to_string(&config)?;
response.write(config_json.as_bytes())?;
}
Err(_) => {
let config_json = serde_json::to_string(&Config::default())?;
response.write(config_json.as_bytes())?;
}
}
Ok(())
})
.unwrap();
server
.fn_handler("/set_config", Method::Post, move |mut request| {
let mut buf = [0_u8; 3072];
let read = request.read(&mut buf);
if read.is_err() {
let error_text = read.unwrap_err().to_string();
println!("Could not parse config {}", error_text);
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
let actual_data = &buf[0..read.unwrap()];
println!("Raw data {}", from_utf8(actual_data).unwrap());
let config: Result<Config, serde_json::Error> = serde_json::from_slice(actual_data);
if config.is_err() {
let error_text = config.unwrap_err().to_string();
println!("Could not parse config {}", error_text);
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
let mut board = BOARD_ACCESS.lock().unwrap();
board.set_config(&config.unwrap())?;
let mut response = request.into_status_response(202)?;
response.write("saved".as_bytes())?;
reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
Ok(())
})
.unwrap();
server
}
pub fn shared() -> Box<EspHttpServer<'static>> {
let mut server: Box<EspHttpServer<'static>> = Box::new(EspHttpServer::new(&Default::default()).unwrap());
let server_config = Configuration {
stack_size: 8192,
..Default::default()
};
let mut server: Box<EspHttpServer<'static>> =
Box::new(EspHttpServer::new(&server_config).unwrap());
server
.fn_handler("/version",Method::Get, |request| {
.fn_handler("/version", Method::Get, |request| {
let mut response = request.into_ok_response()?;
response.write(env!("VERGEN_GIT_DESCRIBE").as_bytes())?;
return Ok(())
}).unwrap();
Ok(())
})
.unwrap();
server
.fn_handler("/bundle.js",Method::Get, |request| {
.fn_handler("/bundle.js", Method::Get, |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("bundle.js"))?;
return Ok(())
}).unwrap();
Ok(())
})
.unwrap();
server
.fn_handler("/favicon.ico",Method::Get, |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("favicon.ico"))?;
return Ok(())
}).unwrap();
.fn_handler("/favicon.ico", Method::Get, |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("favicon.ico"))?;
Ok(())
})
.unwrap();
server
.fn_handler("/ota", Method::Post, |mut request| {
.fn_handler("/ota", Method::Post, |mut request| {
let ota = OtaUpdate::begin();
if ota.is_err(){
if ota.is_err() {
let error_text = ota.unwrap_err().to_string();
request.into_status_response(500)?.write(error_text.as_bytes())?;
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
let mut ota = ota.unwrap();
println!("start ota");
//having a larger buffer is not really faster, requires more stack and prevents the progress bar from working ;)
const BUFFER_SIZE:usize = 512;
let mut buffer :[u8;BUFFER_SIZE] = [0;BUFFER_SIZE];
const BUFFER_SIZE: usize = 512;
let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
let mut total_read: usize = 0;
loop {
let read = request.read(&mut buffer).unwrap();
total_read += read;
println!("received {read} bytes ota {total_read}");
let to_write = & buffer[0 .. read];
let to_write = &buffer[0..read];
let write_result = ota.write(to_write);
if write_result.is_err(){
if write_result.is_err() {
let error_text = write_result.unwrap_err().to_string();
request.into_status_response(500)?.write(error_text.as_bytes())?;
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
println!("wrote {read} bytes ota {total_read}");
@ -199,16 +229,19 @@ pub fn shared() -> Box<EspHttpServer<'static>> {
println!("finalizing and changing boot partition to {partition:?}");
let finalizer = ota.finalize();
if finalizer.is_err(){
if finalizer.is_err() {
let error_text = finalizer.err().unwrap().to_string();
request.into_status_response(500)?.write(error_text.as_bytes())?;
request
.into_status_response(500)?
.write(error_text.as_bytes())?;
return Ok(());
}
let mut finalizer = finalizer.unwrap();
println!("changing boot partition");
finalizer.set_as_boot_partition().unwrap();
finalizer.restart();
}).unwrap();
return server;
})
.unwrap();
server
}

88
rust/src_webpack/src/form.ts
View File

@ -1,11 +1,19 @@
interface PlantConfig {
mqtt_url: string,
base_topic: string,
tank_sensor_enabled: boolean,
tank_full_ml: number,
tank_allow_pumping_if_sensor_error: boolean,
tank_useable_ml: number,
tank_warn_percent: number,
tank_empty_mv: number,
tank_full_mv: number,
night_lamp_hour_start: number,
night_lamp_hour_end: number,
night_lamp_only_when_dark: boolean,
max_consecutive_pump_count: number,
plants: {
mode: string,
target_moisture: number,
pump_time_s: number,
pump_cooldown_min: number,
@ -28,12 +36,26 @@ let fromWrapper = (() => {
}
}
let tank_full_ml = document.getElementById("tank_full_ml") as HTMLInputElement;
tank_full_ml.onchange = updateJson
let mqtt_url = document.getElementById("mqtt_url") as HTMLInputElement;
mqtt_url.onchange = updateJson
let base_topic = document.getElementById("base_topic") as HTMLInputElement;
base_topic.onchange = updateJson
let max_consecutive_pump_count = document.getElementById("max_consecutive_pump_count") as HTMLInputElement;
max_consecutive_pump_count.onchange = updateJson
let tank_useable_ml = document.getElementById("tank_useable_ml") as HTMLInputElement;
tank_useable_ml.onchange = updateJson
let tank_empty_mv = document.getElementById("tank_empty_mv") as HTMLInputElement;
tank_empty_mv.onchange = updateJson
let tank_full_mv = document.getElementById("tank_full_mv") as HTMLInputElement;
tank_full_mv.onchange = updateJson
let tank_warn_percent = document.getElementById("tank_warn_percent") as HTMLInputElement;
tank_warn_percent.onchange = updateJson
let tank_sensor_enabled = document.getElementById("tank_sensor_enabled") as HTMLInputElement;
tank_sensor_enabled.onchange = updateJson
let tank_allow_pumping_if_sensor_error = document.getElementById("tank_allow_pumping_if_sensor_error") as HTMLInputElement;
tank_allow_pumping_if_sensor_error.onchange = updateJson
let night_lamp_only_when_dark = document.getElementById("night_lamp_only_when_dark") as HTMLInputElement;
night_lamp_only_when_dark.onchange = updateJson
let night_lamp_time_start = document.getElementById("night_lamp_time_start") as HTMLSelectElement;
@ -53,6 +75,33 @@ let fromWrapper = (() => {
header.textContent = "Plant " + (i + 1);
plant.appendChild(header);
{
let holder = document.createElement("div");
plant.appendChild(holder);
let inputf = document.createElement("select");
inputf.id = "plant_" + i + "_mode";
inputf.onchange = updateJson;
holder.appendChild(inputf)
let optionOff = document.createElement("option");
optionOff.value = "OFF";
optionOff.innerText = "Off";
inputf.appendChild(optionOff);
let optionTargetMoisture = document.createElement("option");
optionTargetMoisture.value = "TargetMoisture";
optionTargetMoisture.innerText = "Target Moisture";
inputf.appendChild(optionTargetMoisture);
let optionTimerOnly = document.createElement("option");
optionTimerOnly.value = "TimerOnly";
optionTimerOnly.innerText = "Timer";
inputf.appendChild(optionTimerOnly);
let text = document.createElement("span");
holder.appendChild(text)
text.innerHTML += "Mode"
}
{
let holder = document.createElement("div");
plant.appendChild(holder);
@ -130,16 +179,25 @@ let fromWrapper = (() => {
function sync(current: PlantConfig) {
plantcount = current.plants.length
tank_full_ml.disabled = !current.tank_sensor_enabled;
mqtt_url.value = current.mqtt_url;
base_topic.value = current.base_topic;
max_consecutive_pump_count.value = current.max_consecutive_pump_count.toString();
tank_useable_ml.disabled = !current.tank_sensor_enabled;
tank_warn_percent.disabled = !current.tank_sensor_enabled;
tank_sensor_enabled.checked = current.tank_sensor_enabled;
tank_full_ml.value = current.tank_full_ml.toString();
tank_allow_pumping_if_sensor_error.checked = current.tank_allow_pumping_if_sensor_error;
tank_useable_ml.value = current.tank_useable_ml.toString();
tank_warn_percent.value = current.tank_warn_percent.toString();
tank_empty_mv.value = current.tank_empty_mv.toString();
tank_full_mv.value = current.tank_full_mv.toString();
night_lamp_time_start.value = current.night_lamp_hour_start.toString();
night_lamp_time_end.value = current.night_lamp_hour_end.toString();
for (let i = 0; i < current.plants.length; i++) {
let plant_mode = document.getElementById("plant_" + i + "_mode") as HTMLSelectElement;
plant_mode.value = current.plants[i].mode;
let plant_target_moisture = document.getElementById("plant_" + i + "_target_moisture") as HTMLInputElement;
plant_target_moisture.value = current.plants[i].target_moisture.toString();
let plant_pump_time_s = document.getElementById("plant_" + i + "_pump_time_s") as HTMLInputElement;
@ -155,9 +213,15 @@ let fromWrapper = (() => {
function updateJson() {
var current: PlantConfig = {
max_consecutive_pump_count: +max_consecutive_pump_count.value,
mqtt_url: mqtt_url.value,
base_topic: base_topic.value,
tank_allow_pumping_if_sensor_error: tank_allow_pumping_if_sensor_error.checked,
tank_sensor_enabled: tank_sensor_enabled.checked,
tank_full_ml: +tank_full_ml.value,
tank_useable_ml: +tank_useable_ml.value,
tank_warn_percent: +tank_warn_percent.value,
tank_empty_mv: +tank_empty_mv.value,
tank_full_mv: +tank_full_mv.value,
night_lamp_hour_start: +night_lamp_time_start.value,
night_lamp_hour_end: +night_lamp_time_end.value,
night_lamp_only_when_dark: night_lamp_only_when_dark.checked,
@ -166,6 +230,7 @@ let fromWrapper = (() => {
for (let i = 0; i < plantcount; i++) {
console.log("Adding plant " + i)
let plant_mode = document.getElementById("plant_" + i + "_mode") as HTMLSelectElement;
let plant_target_moisture = document.getElementById("plant_" + i + "_target_moisture") as HTMLInputElement;
let plant_pump_time_s = document.getElementById("plant_" + i + "_pump_time_s") as HTMLInputElement;
let plant_pump_cooldown_min = document.getElementById("plant_" + i + "_pump_cooldown_min") as HTMLInputElement;
@ -173,6 +238,7 @@ let fromWrapper = (() => {
let plant_pump_hour_end = document.getElementById("plant_" + i + "_pump_hour_end") as HTMLInputElement;
current.plants[i] = {
mode: plant_mode.value,
target_moisture: +plant_target_moisture.value,
pump_time_s: +plant_pump_time_s.value,
pump_cooldown_min: +plant_pump_cooldown_min.value,
@ -184,18 +250,24 @@ let fromWrapper = (() => {
sync(current);
console.log(current);
var pretty = JSON.stringify(current, undefined, 4);
var pretty = JSON.stringify(current, undefined, 1);
json.value = pretty;
}
let submitFormBtn = document.getElementById("submit") as HTMLButtonElement
let submit_status = document.getElementById("submit_status")
if (submitFormBtn) {
submitFormBtn.onclick = function (){
updateJson()
fetch("/set_config", {
method :"POST",
body: json.value
})
.then(response => response.text())
.then(text => submit_status.innerText = text)
};
}