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

move to central config, make TZ compile time const, confgureable later!

Browse Source
This commit is contained in:
Empire 2024-11-13 22:04:47 +01:00
parent 7957cf4003
commit bfcf5e150c
10 changed files with 591 additions and 838 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
rust/Cargo.toml
View File

@ -77,6 +77,7 @@ serde_json = "1.0.108"
#timezone
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" ]}
eeprom24x = "0.7.2"
[patch.crates-io]

38
rust/src/config.rs
View File

@ -1,4 +1,4 @@
use std::{fmt, str::FromStr};
use std::{array::from_fn, str::FromStr};
use serde::{Deserialize, Serialize};
@ -6,8 +6,13 @@ use crate::PLANT_COUNT;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct Config {
pub mqtt_url: heapless::String<128>,
pub base_topic: heapless::String<64>,
pub ap_ssid: heapless::String<32>,
pub ssid: Option<heapless::String<32>>,
pub password: Option<heapless::String<64>>,
pub mqtt_url: Option<heapless::String<128>>,
pub base_topic: Option<heapless::String<64>>,
pub max_consecutive_pump_count: u8,
pub tank_allow_pumping_if_sensor_error: bool,
@ -27,15 +32,20 @@ pub struct Config {
impl Default for Config {
fn default() -> Self {
Self {
base_topic: heapless::String::from_str("plant/one").unwrap(),
mqtt_url: heapless::String::from_str("mqtt://192.168.1.1:1883").unwrap(),
ap_ssid: heapless::String::from_str("Plantctrl").unwrap(),
ssid: None,
password: None,
base_topic: Some(heapless::String::from_str("plant/one").unwrap()),
mqtt_url: Some(heapless::String::from_str("mqtt://192.168.1.1:1883").unwrap()),
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],
plants: from_fn(|_i| Plant::default()),
max_consecutive_pump_count: 15,
tank_useable_ml: 5000,
tank_empty_percent: 0_u8,
@ -43,7 +53,7 @@ impl Default for Config {
}
}
}
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum Mode {
OFF,
TargetMoisture,
@ -51,7 +61,7 @@ pub enum Mode {
TimerAndDeadzone,
}
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct Plant {
pub mode: Mode,
pub target_moisture: u8,
@ -74,15 +84,3 @@ impl Default for Plant {
}
}
}
#[derive(Serialize, Deserialize, Debug)]
pub struct WifiConfig {
pub ssid: heapless::String<32>,
pub password: Option<heapless::String<64>>,
}
impl fmt::Display for WifiConfig {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, ****)", self.ssid)
}
}

336
rust/src/main.rs
View File

@ -18,18 +18,20 @@ use esp_idf_sys::{
};
use log::error;
use once_cell::sync::Lazy;
use plant_hal::{CreatePlantHal, PlantCtrlBoard, PlantCtrlBoardInteraction, PlantHal, PLANT_COUNT};
use plant_hal::{PlantCtrlBoard, PlantHal, PLANT_COUNT};
use serde::{Deserialize, Serialize};
use crate::{
config::{Config, WifiConfig},
config::Config,
espota::{mark_app_valid, rollback_and_reboot},
webserver::webserver::{httpd, httpd_initial},
webserver::webserver::httpd,
};
mod config;
pub mod espota;
pub mod plant_hal;
const TIME_ZONE: Tz = Berlin;
const MOIST_SENSOR_MAX_FREQUENCY: u32 = 50000; // 60kHz (500Hz margin)
const MOIST_SENSOR_MIN_FREQUENCY: u32 = 500; // 0.5kHz (500Hz margin)
@ -46,21 +48,10 @@ mod webserver {
pub mod webserver;
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum OnlineMode {
Offline,
Wifi,
SnTp,
Online,
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
enum WaitType {
InitialConfig,
FlashError,
NormalConfig,
StayAlive,
StayAliveBtn
MissingConfig,
Config,
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
@ -208,20 +199,32 @@ fn safe_main() -> anyhow::Result<()> {
free_space.total_size, free_space.used_size, free_space.free_size
);
let time = board.time();
let mut cur = match time {
Ok(cur) => cur,
let mut cur = match board.get_rtc_time() {
Ok(time) => time,
Err(err) => {
log::error!("time error {}", err);
DateTime::from_timestamp_millis(0).unwrap()
println!("rtc module error: {}", err);
board.general_fault(true);
let time = board.time();
match time {
Ok(cur) => cur,
Err(err) => {
log::error!("time error {}", err);
DateTime::from_timestamp_millis(0).unwrap()
}
}
}
};
//check if we know the time current > 2020
if cur.year() < 2020 {
println!("Running time estimation super fallback");
if board.is_day() {
//assume TZ safe times ;)
println!("Is day -> 15:00");
cur = *cur.with_hour(15).get_or_insert(cur);
} else {
println!("Is night -> 3:00");
cur = *cur.with_hour(3).get_or_insert(cur);
}
}
@ -229,9 +232,9 @@ fn safe_main() -> anyhow::Result<()> {
println!("cur is {}", cur);
let mut to_config = false;
if board.is_config_reset() {
if board.is_mode_override() {
board.general_fault(true);
println!("Reset config is pressed, waiting 5s");
println!("config mode override is pressed, waiting 5s");
for _i in 0..5 {
board.general_fault(true);
Delay::new_default().delay_ms(100);
@ -239,133 +242,88 @@ fn safe_main() -> anyhow::Result<()> {
Delay::new_default().delay_ms(100);
}
if board.is_config_reset() {
if board.is_mode_override() {
to_config = true;
println!("Reset config is still pressed, proceed to config mode");
for _i in 0..25 {
board.general_fault(true);
Delay::new_default().delay_ms(25);
board.general_fault(false);
Delay::new_default().delay_ms(25);
}
if board.is_config_reset() {
println!("Reset config is still pressed, proceed to delete configs");
match board.remove_configs() {
Ok(case) => {
println!("Succeeded in deleting config {}", case);
}
Err(err) => {
println!("Could not remove config files, system borked {}", err);
//terminate main app and freeze
wait_infinity(WaitType::FlashError, Arc::new(AtomicBool::new(false)));
}
}
} else {
}
} else {
board.general_fault(false);
}
}
let mut online_mode = OnlineMode::Offline;
let wifi_conf = board.get_wifi();
let wifi: WifiConfig;
match wifi_conf {
Ok(conf) => {
wifi = conf;
}
Err(err) => {
if board.is_wifi_config_file_existant() {
if ota_state == esp_ota_img_states_t_ESP_OTA_IMG_PENDING_VERIFY {
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!
drop(board);
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd_initial(reboot_now.clone());
wait_infinity(WaitType::InitialConfig, reboot_now.clone());
}
};
println!("attempting to connect wifi");
let mut ip_address: Option<String> = None;
match board.wifi(wifi.ssid, wifi.password, 10000) {
Ok(ip_info) => {
ip_address = Some(ip_info.ip.to_string());
online_mode = OnlineMode::Wifi;
}
Err(_) => {
println!("Offline mode");
board.general_fault(true);
}
}
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);
board.general_fault(true);
}
}
}
println!("Running logic at utc {}", cur);
let europe_time = cur.with_timezone(&Berlin);
println!("Running logic at europe/berlin {}", europe_time);
let config: Config;
match board.get_config() {
match board.get_config() {
Ok(valid) => {
config = valid;
}
Err(err) => {
println!("Missing normal config, entering config mode {}", err);
//config upload will trigger reboot!
let _ = board.wifi_ap();
drop(board);
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd(reboot_now.clone());
wait_infinity(WaitType::NormalConfig, reboot_now.clone());
wait_infinity(WaitType::MissingConfig, reboot_now.clone());
}
}
//do mqtt before config check, as mqtt might configure
if online_mode == OnlineMode::SnTp {
match board.mqtt(&config) {
Ok(_) => {
println!("Mqtt connection ready");
online_mode = OnlineMode::Online;
let mut wifi = false;
let mut mqtt = false;
let mut sntp = false;
println!("attempting to connect wifi");
let mut ip_address: Option<String> = None;
if config.ssid.is_some() {
match board.wifi(config.ssid.clone().unwrap(), config.password.clone(), 10000) {
Ok(ip_info) => {
ip_address = Some(ip_info.ip.to_string());
wifi = true;
match board.sntp(1000 * 5) {
Ok(new_time) => {
println!("Using time from sntp");
let _ = board.set_rtc_time(&new_time);
cur = new_time;
sntp = true;
}
Err(err) => {
println!("sntp error: {}", err);
board.general_fault(true);
}
}
match board.mqtt(&config) {
Ok(_) => {
println!("Mqtt connection ready");
mqtt = true;
}
Err(err) => {
println!("Could not connect mqtt due to {}", err);
}
}
}
Err(err) => {
println!("Could not connect mqtt due to {}", err);
Err(_) => {
println!("Offline mode");
board.general_fault(true);
}
}
} else {
println!("No wifi configured");
}
if online_mode == OnlineMode::Online {
match ip_address {
Some(add_some) => {
let _ = board.mqtt_publish(&config, "/firmware/address", add_some.as_bytes());
}
None => {
let _ = board.mqtt_publish(&config, "/firmware/address", "N/A?".as_bytes());
}
}
let timezone_time = cur.with_timezone(&TIME_ZONE);
println!(
"Running logic at utc {} and {} {}",
cur,
TIME_ZONE.name(),
timezone_time
);
if mqtt {
let ip_string = ip_address.unwrap_or("N/A".to_owned());
let _ = board.mqtt_publish(&config, "/firmware/address", ip_string.as_bytes());
let _ = board.mqtt_publish(&config, "/firmware/githash", git_hash.as_bytes());
let _ = board.mqtt_publish(&config, "/firmware/buildtime", build_timestamp.as_bytes());
let _ = board.mqtt_publish(
&config,
"/firmware/last_online",
europe_time.to_rfc3339().as_bytes(),
timezone_time.to_rfc3339().as_bytes(),
);
let _ = board.mqtt_publish(&config, "/firmware/ota_state", ota_state_string.as_bytes());
let _ = board.mqtt_publish(
@ -378,6 +336,18 @@ fn safe_main() -> anyhow::Result<()> {
publish_battery_state(&mut board, &config);
}
println!("startup state wifi {} sntp {} mqtt {}", wifi, sntp, mqtt);
if to_config {
//check if client or ap mode and init wifi
println!("executing config mode override");
//config upload will trigger reboot!
drop(board);
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd(reboot_now.clone());
wait_infinity(WaitType::Config, reboot_now.clone());
}
let tank_state = determine_tank_state(&mut board, &config);
let mut tank_state_mqtt = TankStateMQTT {
enough_water: tank_state.enough_water,
@ -413,30 +383,27 @@ fn safe_main() -> anyhow::Result<()> {
None => tank_state_mqtt.water_frozen = "tank sensor error".to_owned(),
}
if online_mode == OnlineMode::Online {
match serde_json::to_string(&tank_state_mqtt) {
Ok(state) => {
let _ = board.mqtt_publish(&config, "/water", state.as_bytes());
}
Err(err) => {
println!("Error publishing tankstate {}", err);
}
};
}
match serde_json::to_string(&tank_state_mqtt) {
Ok(state) => {
let _ = board.mqtt_publish(&config, "/water", state.as_bytes());
}
Err(err) => {
println!("Error publishing tankstate {}", err);
}
};
let mut plantstate: [PlantState; PLANT_COUNT] = core::array::from_fn(|_| PlantState {
..Default::default()
});
let plant_to_pump = determine_next_plant(
&mut plantstate,
europe_time,
timezone_time,
&tank_state,
water_frozen,
&config,
&mut board,
);
let stay_alive_mqtt = STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed);
let stay_alive = stay_alive_mqtt;
println!("Check stay alive, current state is {}", stay_alive);
@ -452,7 +419,7 @@ fn safe_main() -> anyhow::Result<()> {
board.fault(plant, true);
}
let plant_config = config.plants[plant];
let plant_config = &config.plants[plant];
println!(
"Trying to pump for {}s with pump {} now",
@ -477,16 +444,15 @@ fn safe_main() -> anyhow::Result<()> {
println!("Nothing to do");
}
}
if online_mode == OnlineMode::Online {
update_plant_state(&mut plantstate, &mut board, &config);
}
update_plant_state(&mut plantstate, &mut board, &config);
let mut light_state = LightState {
..Default::default()
};
let is_day = board.is_day();
light_state.is_day = is_day;
light_state.out_of_work_hour = !in_time_range(
&europe_time,
&timezone_time,
config.night_lamp_hour_start,
config.night_lamp_hour_end,
);
@ -524,43 +490,32 @@ fn safe_main() -> anyhow::Result<()> {
println!("Lightstate is {:?}", light_state);
if online_mode == OnlineMode::Online {
match serde_json::to_string(&light_state) {
Ok(state) => {
let _ = board.mqtt_publish(&config, "/light", state.as_bytes());
}
Err(err) => {
println!("Error publishing lightstate {}", err);
}
};
}
match serde_json::to_string(&light_state) {
Ok(state) => {
let _ = board.mqtt_publish(&config, "/light", state.as_bytes());
}
Err(err) => {
println!("Error publishing lightstate {}", err);
}
};
let deep_sleep_duration_minutes: u32 = if state_of_charge < 10 {
if online_mode == OnlineMode::Online {
let _ = board.mqtt_publish(&config, "/deepsleep", "low Volt 12h".as_bytes());
}
let _ = board.mqtt_publish(&config, "/deepsleep", "low Volt 12h".as_bytes());
12 * 60
} else if is_day {
if did_pump {
if online_mode == OnlineMode::Online {
let _ = board.mqtt_publish(&config, "/deepsleep", "after pump".as_bytes());
}
let _ = board.mqtt_publish(&config, "/deepsleep", "after pump".as_bytes());
0
} else {
if online_mode == OnlineMode::Online {
let _ = board.mqtt_publish(&config, "/deepsleep", "normal 20m".as_bytes());
}
let _ = board.mqtt_publish(&config, "/deepsleep", "normal 20m".as_bytes());
20
}
} else {
if online_mode == OnlineMode::Online {
let _ = board.mqtt_publish(&config, "/deepsleep", "night 1h".as_bytes());
}
let _ = board.mqtt_publish(&config, "/deepsleep", "night 1h".as_bytes());
60
};
if online_mode == OnlineMode::Online {
let _ = board.mqtt_publish(&config, "/state", "sleep".as_bytes());
}
let _ = board.mqtt_publish(&config, "/state", "sleep".as_bytes());
//determine next event
//is light out of work trigger soon?
@ -568,19 +523,12 @@ fn safe_main() -> anyhow::Result<()> {
//is deep sleep
mark_app_valid();
if to_config {
println!("Go to button triggerd stay alive");
drop(board);
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd(reboot_now.clone());
wait_infinity(WaitType::StayAliveBtn, reboot_now.clone());
}
if stay_alive {
println!("Go to stay alive move");
drop(board);
let reboot_now = Arc::new(AtomicBool::new(false));
let _webserver = httpd(reboot_now.clone());
wait_infinity(WaitType::StayAlive, reboot_now.clone());
wait_infinity(WaitType::Config, reboot_now.clone());
}
unsafe { esp_deep_sleep(1000 * 1000 * 60 * deep_sleep_duration_minutes as u64) };
@ -734,8 +682,8 @@ fn determine_state_target_moisture_for_plant(
Some(last_pump) => {
let next_pump = last_pump + duration;
if next_pump > cur {
let europe_time = next_pump.with_timezone(&Berlin);
state.next_pump = Some(europe_time);
let local_time = next_pump.with_timezone(&TIME_ZONE);
state.next_pump = Some(local_time);
state.cooldown = true;
}
}
@ -777,7 +725,7 @@ fn determine_state_timer_only_for_plant(
Some(last_pump) => {
let next_pump = last_pump + duration;
if next_pump > cur {
let europe_time = next_pump.with_timezone(&Berlin);
let europe_time = next_pump.with_timezone(&TIME_ZONE);
state.next_pump = Some(europe_time);
state.cooldown = true;
} else {
@ -815,7 +763,7 @@ fn determine_state_timer_and_deadzone_for_plant(
Some(last_pump) => {
let next_pump = last_pump + duration;
if next_pump > cur {
let europe_time = next_pump.with_timezone(&Berlin);
let europe_time = next_pump.with_timezone(&TIME_ZONE);
state.next_pump = Some(europe_time);
state.cooldown = true;
}
@ -905,7 +853,7 @@ fn update_plant_state(
) {
for plant in 0..PLANT_COUNT {
let state = &plantstate[plant];
let plant_config = config.plants[plant];
let plant_config = &config.plants[plant];
let mode = format!("{:?}", plant_config.mode);
@ -946,20 +894,17 @@ fn update_plant_state(
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::StayAlive => 1000_u32,
WaitType::StayAliveBtn => 25_u32
};
let led_count = match wait_type {
WaitType::InitialConfig => 8,
WaitType::FlashError => 8,
WaitType::NormalConfig => 4,
WaitType::StayAlive => 2,
WaitType::StayAliveBtn => 5
WaitType::MissingConfig => 500_u32,
WaitType::Config => 100_u32,
};
let mut led_count = 8;
loop {
if wait_type == WaitType::MissingConfig {
led_count = led_count + 1;
if led_count > 8 {
led_count = 1;
}
};
unsafe {
//do not trigger watchdog
for i in 0..8 {
@ -972,10 +917,13 @@ fn wait_infinity(wait_type: WaitType, reboot_now: Arc<AtomicBool>) -> ! {
BOARD_ACCESS.lock().unwrap().fault(i, false);
}
vTaskDelay(delay);
if wait_type == WaitType::StayAlive
&& !STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed)
{
reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
match wait_type {
WaitType::MissingConfig => {}
WaitType::Config => {
if !STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed) {
reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
}
}
}
if reboot_now.load(std::sync::atomic::Ordering::Relaxed) {
println!("Rebooting");
@ -1002,14 +950,14 @@ fn main() {
}
fn time_to_string_utc(value_option: Option<DateTime<Utc>>) -> String {
let converted = value_option.and_then(|utc| Some(utc.with_timezone(&Berlin)));
let converted = value_option.and_then(|utc| Some(utc.with_timezone(&TIME_ZONE)));
return time_to_string(converted);
}
fn time_to_string(value_option: Option<DateTime<Tz>>) -> String {
match value_option {
Some(value) => {
let europe_time = value.with_timezone(&Berlin);
let europe_time = value.with_timezone(&TIME_ZONE);
if europe_time.year() > 2023 {
return europe_time.to_rfc3339();
} else {

586
rust/src/plant_hal.rs
View File

@ -1,14 +1,15 @@
use bq34z100::{Bq34Z100Error, Bq34z100g1, Bq34z100g1Driver};
use chrono_tz::Europe::Berlin;
use ds323x::Ds323x;
use ds323x::{DateTimeAccess, Ds323x};
use eeprom24x::{Eeprom24x, SlaveAddr};
use embedded_hal_bus::i2c::MutexDevice;
use embedded_svc::wifi::{
AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration,
};
use esp_idf_hal::adc::{attenuation, Resolution};
use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
use esp_idf_hal::adc::oneshot::{AdcChannelDriver, AdcDriver};
use esp_idf_hal::adc::{attenuation, Resolution};
use esp_idf_hal::i2c::{APBTickType, I2cConfig, I2cDriver, I2cError};
use esp_idf_hal::units::FromValueType;
use esp_idf_svc::eventloop::EspSystemEventLoop;
@ -20,13 +21,13 @@ use esp_idf_svc::nvs::EspDefaultNvsPartition;
use esp_idf_svc::wifi::config::{ScanConfig, ScanType};
use esp_idf_svc::wifi::EspWifi;
use measurements::Temperature;
use once_cell::sync::Lazy;
use plant_ctrl2::sipo::ShiftRegister40;
use anyhow::anyhow;
use anyhow::{anyhow, Context};
use anyhow::{bail, Ok, Result};
use std::ffi::CString;
use std::fs::File;
use std::ops::Deref;
use std::path::Path;
use chrono::{DateTime, Utc};
@ -47,10 +48,10 @@ use esp_idf_hal::prelude::Peripherals;
use esp_idf_hal::reset::ResetReason;
use esp_idf_svc::sntp::{self, SyncStatus};
use esp_idf_svc::systime::EspSystemTime;
use esp_idf_sys::{esp, gpio_hold_dis, gpio_hold_en, vTaskDelay, EspError};
use esp_idf_sys::{gpio_hold_dis, gpio_hold_en, vTaskDelay, EspError};
use one_wire_bus::OneWire;
use crate::config::{self, Config, WifiConfig};
use crate::config::{self, Config};
use crate::{plant_hal, STAY_ALIVE};
//Only support for 8 right now!
@ -58,7 +59,6 @@ pub const PLANT_COUNT: usize = 8;
const REPEAT_MOIST_MEASURE: usize = 3;
const SPIFFS_PARTITION_NAME: &str = "storage";
const WIFI_CONFIG_FILE: &str = "/spiffs/wifi.cfg";
const CONFIG_FILE: &str = "/spiffs/config.cfg";
const TANK_MULTI_SAMPLE: usize = 11;
@ -122,10 +122,9 @@ pub struct FileSystemSizeInfo {
}
#[derive(strum::Display)]
pub enum ClearConfigType {
WifiConfig,
Config,
None,
pub enum StartMode {
AP,
Normal,
}
#[derive(Debug, PartialEq)]
@ -133,73 +132,6 @@ pub enum Sensor {
A,
B,
}
pub trait PlantCtrlBoardInteraction {
fn time(&mut self) -> Result<chrono::DateTime<Utc>>;
fn wifi(
&mut self,
ssid: heapless::String<32>,
password: Option<heapless::String<64>>,
max_wait: u32,
) -> Result<IpInfo>;
fn sntp(&mut self, max_wait: u32) -> Result<chrono::DateTime<Utc>>;
fn mount_file_system(&mut self) -> Result<()>;
fn file_system_size(&mut self) -> Result<FileSystemSizeInfo>;
fn state_charge_percent(&mut self) -> Result<u8>;
fn remaining_milli_ampere_hour(&mut self) -> Result<u16>;
fn max_milli_ampere_hour(&mut self) -> Result<u16>;
fn design_milli_ampere_hour(&mut self) -> Result<u16>;
fn voltage_milli_volt(&mut self) -> Result<u16>;
fn average_current_milli_ampere(&mut self) -> Result<i16>;
fn cycle_count(&mut self) -> Result<u16>;
fn state_health_percent(&mut self) -> Result<u8>;
fn general_fault(&mut self, enable: bool);
fn is_day(&self) -> bool;
fn water_temperature_c(&mut self) -> Result<f32>;
fn tank_sensor_percent(&mut self) -> Result<u16>;
fn set_low_voltage_in_cycle(&mut self);
fn clear_low_voltage_in_cycle(&mut self);
fn low_voltage_in_cycle(&mut self) -> bool;
fn any_pump(&mut self, enabled: bool) -> Result<()>;
//keep state during deepsleep
fn light(&mut self, enable: bool) -> Result<()>;
fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<i32>;
fn pump(&self, plant: usize, enable: bool) -> Result<()>;
fn last_pump_time(&self, plant: usize) -> Option<chrono::DateTime<Utc>>;
fn store_last_pump_time(&mut self, plant: usize, time: chrono::DateTime<Utc>);
fn store_consecutive_pump_count(&mut self, plant: usize, count: u32);
fn consecutive_pump_count(&mut self, plant: usize) -> u32;
//keep state during deepsleep
fn fault(&self, plant: usize, enable: bool);
//config
fn is_config_reset(&mut self) -> bool;
fn remove_configs(&mut self) -> Result<ClearConfigType>;
fn get_config(&mut self) -> Result<config::Config>;
fn set_config(&mut self, wifi: &Config) -> Result<()>;
fn get_wifi(&mut self) -> Result<config::WifiConfig>;
fn set_wifi(&mut self, wifi: &WifiConfig) -> Result<()>;
fn wifi_ap(&mut self) -> Result<()>;
fn wifi_scan(&mut self) -> Result<Vec<AccessPointInfo>>;
fn test(&mut self) -> Result<()>;
fn test_pump(&mut self, plant: usize) -> Result<()>;
fn is_wifi_config_file_existant(&mut self) -> bool;
fn mqtt(&mut self, config: &Config) -> Result<()>;
fn mqtt_publish(&mut self, config: &Config, subtopic: &str, message: &[u8]) -> Result<()>;
fn sensor_multiplexer(&mut self, n: u8) -> Result<()>;
fn flash_bq34_z100(&mut self, line: &str, dryrun: bool) -> Result<()>;
}
pub trait CreatePlantHal<'a> {
fn create() -> Result<Mutex<PlantCtrlBoard<'static>>>;
}
pub struct PlantHal {}
@ -222,16 +154,23 @@ pub struct PlantCtrlBoard<'a> {
pub wifi_driver: EspWifi<'a>,
one_wire_bus: OneWire<PinDriver<'a, Gpio18, esp_idf_hal::gpio::InputOutput>>,
mqtt_client: Option<EspMqttClient<'a>>,
battery_driver: Option<Bq34z100g1Driver<MutexDevice<'a, I2cDriver<'a>>, Delay>>,
rtc: Option<Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>>
battery_driver: Bq34z100g1Driver<MutexDevice<'a, I2cDriver<'a>>, Delay>,
rtc:
Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>,
eeprom: Eeprom24x<
MutexDevice<'a, I2cDriver<'a>>,
eeprom24x::page_size::B32,
eeprom24x::addr_size::TwoBytes,
eeprom24x::unique_serial::No,
>,
}
impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
fn is_day(&self) -> bool {
impl PlantCtrlBoard<'_> {
pub fn is_day(&self) -> bool {
self.solar_is_day.get_level().into()
}
fn water_temperature_c(&mut self) -> Result<f32> {
pub fn water_temperature_c(&mut self) -> Result<f32> {
let mut delay = Delay::new_default();
self.one_wire_bus
@ -261,7 +200,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(sensor_data.temperature / 10_f32)
}
fn tank_sensor_percent(&mut self) -> Result<u16> {
pub fn tank_sensor_percent(&mut self) -> Result<u16> {
let delay = Delay::new_default();
self.tank_power.set_high()?;
//let stabilize
@ -295,26 +234,26 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
return Ok(percent as u16);
}
fn set_low_voltage_in_cycle(&mut self) {
pub fn set_low_voltage_in_cycle(&mut self) {
unsafe {
LOW_VOLTAGE_DETECTED = true;
}
}
fn clear_low_voltage_in_cycle(&mut self) {
pub fn clear_low_voltage_in_cycle(&mut self) {
unsafe {
LOW_VOLTAGE_DETECTED = false;
}
}
fn light(&mut self, enable: bool) -> Result<()> {
pub fn light(&mut self, enable: bool) -> Result<()> {
unsafe { gpio_hold_dis(self.light.pin()) };
self.light.set_state(enable.into())?;
unsafe { gpio_hold_en(self.light.pin()) };
Ok(())
}
fn pump(&self, plant: usize, enable: bool) -> Result<()> {
pub fn pump(&self, plant: usize, enable: bool) -> Result<()> {
let index = match plant {
0 => PUMP1_BIT,
1 => PUMP2_BIT,
@ -331,30 +270,30 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(())
}
fn last_pump_time(&self, plant: usize) -> Option<chrono::DateTime<Utc>> {
pub fn last_pump_time(&self, plant: usize) -> Option<chrono::DateTime<Utc>> {
let ts = unsafe { LAST_WATERING_TIMESTAMP }[plant];
return Some(DateTime::from_timestamp_millis(ts)?);
}
fn store_last_pump_time(&mut self, plant: usize, time: chrono::DateTime<Utc>) {
pub fn store_last_pump_time(&mut self, plant: usize, time: chrono::DateTime<Utc>) {
unsafe {
LAST_WATERING_TIMESTAMP[plant] = time.timestamp_millis();
}
}
fn store_consecutive_pump_count(&mut self, plant: usize, count: u32) {
pub fn store_consecutive_pump_count(&mut self, plant: usize, count: u32) {
unsafe {
CONSECUTIVE_WATERING_PLANT[plant] = count;
}
}
fn consecutive_pump_count(&mut self, plant: usize) -> u32 {
pub fn consecutive_pump_count(&mut self, plant: usize) -> u32 {
unsafe {
return CONSECUTIVE_WATERING_PLANT[plant];
}
}
fn fault(&self, plant: usize, enable: bool) {
pub fn fault(&self, plant: usize, enable: bool) {
let index = match plant {
0 => FAULT_1,
1 => FAULT_2,
@ -371,20 +310,20 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
.unwrap()
}
fn low_voltage_in_cycle(&mut self) -> bool {
pub fn low_voltage_in_cycle(&mut self) -> bool {
unsafe {
return LOW_VOLTAGE_DETECTED;
}
}
fn any_pump(&mut self, enable: bool) -> Result<()> {
pub fn any_pump(&mut self, enable: bool) -> Result<()> {
{
self.main_pump.set_state(enable.into()).unwrap();
Ok(())
}
}
fn time(&mut self) -> Result<chrono::DateTime<Utc>> {
pub fn time(&mut self) -> Result<chrono::DateTime<Utc>> {
let time = EspSystemTime {}.now().as_millis();
let smaller_time = time as i64;
let local_time = DateTime::from_timestamp_millis(smaller_time)
@ -392,7 +331,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(local_time)
}
fn sntp(&mut self, max_wait_ms: u32) -> Result<chrono::DateTime<Utc>> {
pub fn sntp(&mut self, max_wait_ms: u32) -> Result<chrono::DateTime<Utc>> {
let sntp = sntp::EspSntp::new_default()?;
let mut counter = 0;
while sntp.get_sync_status() != SyncStatus::Completed {
@ -407,7 +346,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
self.time()
}
fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<i32> {
pub fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<i32> {
let sensor_channel = match sensor {
Sensor::A => match plant {
0 => SENSOR_A_1,
@ -473,13 +412,13 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(results[mid])
}
fn general_fault(&mut self, enable: bool) {
pub fn general_fault(&mut self, enable: bool) {
unsafe { gpio_hold_dis(self.general_fault.pin()) };
self.general_fault.set_state(enable.into()).unwrap();
unsafe { gpio_hold_en(self.general_fault.pin()) };
}
fn wifi_ap(&mut self) -> Result<()> {
pub fn wifi_ap(&mut self) -> Result<()> {
let apconfig = AccessPointConfiguration {
ssid: heapless::String::from_str("PlantCtrl").unwrap(),
auth_method: AuthMethod::None,
@ -493,7 +432,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(())
}
fn wifi(
pub fn wifi(
&mut self,
ssid: heapless::String<32>,
password: Option<heapless::String<64>>,
@ -556,7 +495,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(address)
}
fn mount_file_system(&mut self) -> Result<()> {
pub fn mount_file_system(&mut self) -> Result<()> {
let base_path = CString::new("/spiffs")?;
let storage = CString::new(SPIFFS_PARTITION_NAME)?;
let conf = esp_idf_sys::esp_vfs_spiffs_conf_t {
@ -572,7 +511,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
}
}
fn file_system_size(&mut self) -> Result<FileSystemSizeInfo> {
pub fn file_system_size(&mut self) -> Result<FileSystemSizeInfo> {
let storage = CString::new(SPIFFS_PARTITION_NAME)?;
let mut total_size = 0;
let mut used_size = 0;
@ -590,59 +529,56 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
})
}
fn is_config_reset(&mut self) -> bool {
pub fn is_mode_override(&mut self) -> bool {
self.boot_button.get_level() == Level::Low
}
fn remove_configs(&mut self) -> Result<ClearConfigType> {
pub fn factory_reset(&mut self) -> Result<()> {
println!("factory resetting");
let config = Path::new(CONFIG_FILE);
if config.exists() {
println!("Removing config");
std::fs::remove_file(config)?;
return Ok(ClearConfigType::Config);
}
let wifi_config = Path::new(WIFI_CONFIG_FILE);
if wifi_config.exists() {
println!("Removing wifi config");
std::fs::remove_file(wifi_config)?;
return Ok(ClearConfigType::WifiConfig);
}
Ok(ClearConfigType::None)
}
fn get_wifi(&mut self) -> Result<config::WifiConfig> {
let cfg = File::open(WIFI_CONFIG_FILE)?;
let config: WifiConfig = serde_json::from_reader(cfg)?;
Ok(config)
}
fn set_wifi(&mut self, wifi: &WifiConfig) -> Result<()> {
let mut cfg = File::create(WIFI_CONFIG_FILE)?;
serde_json::to_writer(&mut cfg, &wifi)?;
println!("Wrote wifi config {}", wifi);
//TODO clear eeprom
Ok(())
}
fn get_config(&mut self) -> Result<config::Config> {
let cfg = File::open(CONFIG_FILE)?;
let mut config: Config = serde_json::from_reader(cfg)?;
//remove duplicate end of topic
if config.base_topic.ends_with("/") {
config.base_topic.pop();
pub fn get_rtc_time(&mut self) -> Result<DateTime<Utc>> {
match self.rtc.datetime() {
OkStd(rtc_time) => {
return Ok(rtc_time.and_utc());
}
Err(err) => {
bail!("Error getting rtc time {:?}", err)
}
}
}
pub fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> Result<()> {
let naive_time = time.naive_utc();
match self.rtc.set_datetime(&naive_time) {
OkStd(_) => Ok(()),
Err(err) => {
bail!("Error getting rtc time {:?}", err)
}
}
}
pub fn get_config(&mut self) -> Result<config::Config> {
let cfg = File::open(CONFIG_FILE)?;
let config: Config = serde_json::from_reader(cfg)?;
Ok(config)
}
fn set_config(&mut self, config: &Config) -> Result<()> {
pub fn set_config(&mut self, config: &Config) -> Result<()> {
let mut cfg = File::create(CONFIG_FILE)?;
serde_json::to_writer(&mut cfg, &config)?;
println!("Wrote config config {:?}", config);
Ok(())
}
fn wifi_scan(&mut self) -> Result<Vec<AccessPointInfo>> {
pub fn wifi_scan(&mut self) -> Result<Vec<AccessPointInfo>> {
self.wifi_driver.start_scan(
&ScanConfig {
scan_type: ScanType::Passive(Duration::from_secs(5)),
@ -654,7 +590,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(self.wifi_driver.get_scan_result()?)
}
fn test_pump(&mut self, plant: usize) -> Result<()> {
pub fn test_pump(&mut self, plant: usize) -> Result<()> {
self.any_pump(true)?;
self.pump(plant, true)?;
unsafe { vTaskDelay(30000) };
@ -663,7 +599,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(())
}
fn test(&mut self) -> Result<()> {
pub fn test(&mut self) -> Result<()> {
self.general_fault(true);
unsafe { vTaskDelay(100) };
self.general_fault(false);
@ -698,13 +634,16 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
Ok(())
}
fn is_wifi_config_file_existant(&mut self) -> bool {
pub fn is_wifi_config_file_existant(&mut self) -> bool {
let config = Path::new(CONFIG_FILE);
config.exists()
}
fn mqtt(&mut self, config: &Config) -> Result<()> {
let last_will_topic = format!("{}/state", config.base_topic);
pub fn mqtt(&mut self, config: &Config) -> Result<()> {
let base_topic = config.base_topic.as_ref().context("missing base topic")?;
let mqtt_url = config.mqtt_url.as_ref().context("missing mqtt url")?;
let last_will_topic = format!("{}/state", base_topic);
let mqtt_client_config = MqttClientConfiguration {
lwt: Some(LwtConfiguration {
topic: &last_will_topic,
@ -722,9 +661,8 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
let mqtt_connected_event_ok = Arc::new(AtomicBool::new(false));
let round_trip_ok = Arc::new(AtomicBool::new(false));
let round_trip_topic = format!("{}/internal/roundtrip", config.base_topic);
let stay_alive_topic = format!("{}/stay_alive", config.base_topic);
println!("Round trip topic is {}", round_trip_topic);
let round_trip_topic = format!("{}/internal/roundtrip", base_topic);
let stay_alive_topic = format!("{}/stay_alive", base_topic);
println!("Stay alive topic is {}", stay_alive_topic);
let mqtt_connected_event_received_copy = mqtt_connected_event_received.clone();
@ -734,60 +672,55 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
let round_trip_ok_copy = round_trip_ok.clone();
println!(
"Connecting mqtt {} with id {}",
config.mqtt_url,
mqtt_url,
mqtt_client_config.client_id.unwrap_or("not set")
);
let mut client =
EspMqttClient::new_cb(&config.mqtt_url, &mqtt_client_config, move |event| {
let payload = event.payload();
match payload {
embedded_svc::mqtt::client::EventPayload::Received {
id: _,
topic,
data,
details: _,
} => {
let data = String::from_utf8_lossy(data);
if let Some(topic) = topic {
//todo use enums
if topic.eq(round_trip_topic_copy.as_str()) {
round_trip_ok_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
} else if topic.eq(stay_alive_topic_copy.as_str()) {
let value = data.eq_ignore_ascii_case("true")
|| data.eq_ignore_ascii_case("1");
println!("Received stay alive with value {}", value);
STAY_ALIVE.store(value, std::sync::atomic::Ordering::Relaxed);
} else {
println!("Unknown topic recieved {}", topic);
}
let mut client = EspMqttClient::new_cb(&mqtt_url, &mqtt_client_config, move |event| {
let payload = event.payload();
match payload {
embedded_svc::mqtt::client::EventPayload::Received {
id: _,
topic,
data,
details: _,
} => {
let data = String::from_utf8_lossy(data);
if let Some(topic) = topic {
//todo use enums
if topic.eq(round_trip_topic_copy.as_str()) {
round_trip_ok_copy.store(true, std::sync::atomic::Ordering::Relaxed);
} else if topic.eq(stay_alive_topic_copy.as_str()) {
let value =
data.eq_ignore_ascii_case("true") || data.eq_ignore_ascii_case("1");
println!("Received stay alive with value {}", value);
STAY_ALIVE.store(value, std::sync::atomic::Ordering::Relaxed);
} else {
println!("Unknown topic recieved {}", topic);
}
}
embedded_svc::mqtt::client::EventPayload::Connected(_) => {
mqtt_connected_event_received_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
mqtt_connected_event_ok_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
println!("Mqtt connected");
}
embedded_svc::mqtt::client::EventPayload::Disconnected => {
mqtt_connected_event_received_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
mqtt_connected_event_ok_copy
.store(false, std::sync::atomic::Ordering::Relaxed);
println!("Mqtt disconnected");
}
embedded_svc::mqtt::client::EventPayload::Error(esp_error) => {
println!("EspMqttError reported {:?}", esp_error);
mqtt_connected_event_received_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
mqtt_connected_event_ok_copy
.store(false, std::sync::atomic::Ordering::Relaxed);
println!("Mqtt error");
}
_ => {}
}
})?;
embedded_svc::mqtt::client::EventPayload::Connected(_) => {
mqtt_connected_event_received_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
mqtt_connected_event_ok_copy.store(true, std::sync::atomic::Ordering::Relaxed);
println!("Mqtt connected");
}
embedded_svc::mqtt::client::EventPayload::Disconnected => {
mqtt_connected_event_received_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
mqtt_connected_event_ok_copy.store(false, std::sync::atomic::Ordering::Relaxed);
println!("Mqtt disconnected");
}
embedded_svc::mqtt::client::EventPayload::Error(esp_error) => {
println!("EspMqttError reported {:?}", esp_error);
mqtt_connected_event_received_copy
.store(true, std::sync::atomic::Ordering::Relaxed);
mqtt_connected_event_ok_copy.store(false, std::sync::atomic::Ordering::Relaxed);
println!("Mqtt error");
}
_ => {}
}
})?;
let wait_for_connections_event = 0;
while wait_for_connections_event < 100 {
@ -836,7 +769,10 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
bail!("Mqtt did not fire connection callback in time");
}
fn mqtt_publish(&mut self, config: &Config, subtopic: &str, message: &[u8]) -> Result<()> {
pub fn mqtt_publish(&mut self, config: &Config, subtopic: &str, message: &[u8]) -> Result<()> {
if self.mqtt_client.is_none() {
return Ok(());
}
if !subtopic.starts_with("/") {
println!("Subtopic without / at start {}", subtopic);
bail!("Subtopic without / at start {}", subtopic);
@ -845,136 +781,112 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
println!("Subtopic exceeds 192 chars {}", subtopic);
bail!("Subtopic exceeds 192 chars {}", subtopic);
}
if self.mqtt_client.is_none() {
println!("Not connected to mqtt");
bail!("Not connected to mqtt");
}
match &mut self.mqtt_client {
Some(client) => {
let mut full_topic: heapless::String<256> = heapless::String::new();
if full_topic.push_str(&config.base_topic).is_err() {
println!("Some error assembling full_topic 1");
bail!("Some error assembling full_topic 1")
};
if full_topic.push_str(subtopic).is_err() {
println!("Some error assembling full_topic 2");
bail!("Some error assembling full_topic 2")
};
let publish = client.publish(
&full_topic,
embedded_svc::mqtt::client::QoS::ExactlyOnce,
true,
message,
let client = self.mqtt_client.as_mut().unwrap();
let mut full_topic: heapless::String<256> = heapless::String::new();
if full_topic
.push_str(&config.base_topic.as_ref().unwrap())
.is_err()
{
println!("Some error assembling full_topic 1");
bail!("Some error assembling full_topic 1")
};
if full_topic.push_str(subtopic).is_err() {
println!("Some error assembling full_topic 2");
bail!("Some error assembling full_topic 2")
};
let publish = client.publish(
&full_topic,
embedded_svc::mqtt::client::QoS::ExactlyOnce,
true,
message,
);
Delay::new(10).delay_ms(50);
match publish {
OkStd(message_id) => {
println!(
"Published mqtt topic {} with message {:#?} msgid is {:?}",
full_topic,
String::from_utf8_lossy(message),
message_id
);
Delay::new(10).delay_ms(50);
match publish {
OkStd(message_id) => {
println!(
"Published mqtt topic {} with message {:#?} msgid is {:?}",
full_topic,
String::from_utf8_lossy(message),
message_id
);
return Ok(());
}
Err(err) => {
println!(
"Error during mqtt send on topic {} with message {:#?} error is {:?}",
full_topic,
String::from_utf8_lossy(message),
err
);
return Err(err)?;
}
};
return Ok(());
}
None => {
bail!("No mqtt client");
Err(err) => {
println!(
"Error during mqtt send on topic {} with message {:#?} error is {:?}",
full_topic,
String::from_utf8_lossy(message),
err
);
return Err(err)?;
}
};
}
pub fn state_charge_percent(&mut self) -> Result<u8> {
match self.battery_driver.state_of_charge() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading SoC {:?}", err),
}
}
fn state_charge_percent(&mut self) -> Result<u8> {
match &mut self.battery_driver {
Some(driver) => match driver.state_of_charge() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading SoC {:?}", err),
},
None => bail!("Error reading SoC bq34z100 not found"),
pub fn remaining_milli_ampere_hour(&mut self) -> Result<u16> {
match self.battery_driver.remaining_capacity() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Remaining Capacity {:?}", err),
}
}
fn remaining_milli_ampere_hour(&mut self) -> Result<u16> {
match &mut self.battery_driver {
Some(driver) => match driver.remaining_capacity() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Remaining Capacity {:?}", err),
},
None => bail!("Error reading Remaining Capacity bq34z100 not found"),
pub fn max_milli_ampere_hour(&mut self) -> Result<u16> {
match self.battery_driver.full_charge_capacity() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Full Charge Capacity {:?}", err),
}
}
fn max_milli_ampere_hour(&mut self) -> Result<u16> {
match &mut self.battery_driver {
Some(driver) => match driver.full_charge_capacity() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Full Charge Capacity {:?}", err),
},
None => bail!("Error reading Full Charge Capacity bq34z100 not found"),
pub fn design_milli_ampere_hour(&mut self) -> Result<u16> {
match self.battery_driver.design_capacity() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Design Capacity {:?}", err),
}
}
fn design_milli_ampere_hour(&mut self) -> Result<u16> {
match &mut self.battery_driver {
Some(driver) => match driver.design_capacity() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Design Capacity {:?}", err),
},
None => bail!("Error reading Design Capacity bq34z100 not found"),
pub fn voltage_milli_volt(&mut self) -> Result<u16> {
match self.battery_driver.voltage() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading voltage {:?}", err),
}
}
fn voltage_milli_volt(&mut self) -> Result<u16> {
match &mut self.battery_driver {
Some(driver) => match driver.voltage() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading voltage {:?}", err),
},
None => bail!("Error reading voltage bq34z100 not found"),
pub fn average_current_milli_ampere(&mut self) -> Result<i16> {
match self.battery_driver.average_current() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Average Current {:?}", err),
}
}
fn average_current_milli_ampere(&mut self) -> Result<i16> {
match &mut self.battery_driver {
Some(driver) => match driver.average_current() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Average Current {:?}", err),
},
None => bail!("Error reading Average Current bq34z100 not found"),
pub fn cycle_count(&mut self) -> Result<u16> {
match self.battery_driver.cycle_count() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Cycle Count {:?}", err),
}
}
fn cycle_count(&mut self) -> Result<u16> {
match &mut self.battery_driver {
Some(driver) => match driver.cycle_count() {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading Cycle Count {:?}", err),
},
None => bail!("Error reading Cycle Count bq34z100 not found"),
pub fn state_health_percent(&mut self) -> Result<u8> {
match self.battery_driver.state_of_health() {
OkStd(r) => Ok(r as u8),
Err(err) => bail!("Error reading State of Health {:?}", err),
}
}
fn state_health_percent(&mut self) -> Result<u8> {
match &mut self.battery_driver {
Some(driver) => match driver.state_of_health() {
OkStd(r) => Ok(r as u8),
Err(err) => bail!("Error reading State of Health {:?}", err),
},
None => bail!("Error reading State of Health bq34z100 not found"),
pub fn flash_bq34_z100(&mut self, line: &str, dryrun: bool) -> Result<()> {
match self.battery_driver.write_flash_stream_i2c(line, dryrun) {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading SoC {:?}", err),
}
}
fn sensor_multiplexer(&mut self, n: u8) -> Result<()> {
pub fn sensor_multiplexer(&mut self, n: u8) -> Result<()> {
assert!(n < 16);
let is_bit_set = |b: u8| -> bool { n & (1 << b) != 0 };
@ -1004,20 +916,10 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
}
Ok(())
}
fn flash_bq34_z100(&mut self, line: &str, dryrun: bool) -> Result<()> {
match &mut self.battery_driver {
Some(driver) => match driver.write_flash_stream_i2c(line, dryrun) {
OkStd(r) => Ok(r),
Err(err) => bail!("Error reading SoC {:?}", err),
},
None => bail!("Error reading SoC bq34z100 not found"),
}
}
}
fn print_battery(
battery_driver: &mut Bq34z100g1Driver<MutexDevice<'_, I2cDriver<'_>>, Delay>,
battery_driver: &mut Bq34z100g1Driver<MutexDevice<I2cDriver<'_>>, Delay>,
) -> Result<(), Bq34Z100Error<I2cError>> {
println!("Try communicating with battery");
let fwversion = battery_driver.fw_version().unwrap_or_else(|e| {
@ -1074,37 +976,61 @@ fn print_battery(
return Result::Ok(());
}
impl CreatePlantHal<'_> for PlantHal {
fn create() -> Result<Mutex<PlantCtrlBoard<'static>>> {
let peripherals = Peripherals::take()?;
pub static I2C_DRIVER: Lazy<Mutex<I2cDriver<'static>>> = Lazy::new(|| PlantHal::create_i2c());
impl PlantHal {
fn create_i2c() -> Mutex<I2cDriver<'static>> {
let peripherals = unsafe { Peripherals::new() };
let i2c = peripherals.i2c0;
let config = I2cConfig::new()
.scl_enable_pullup(true)
.sda_enable_pullup(true)
.baudrate(400_u32.kHz().into())
.baudrate(100_u32.kHz().into())
.timeout(APBTickType::from(Duration::from_millis(100)));
let i2c = peripherals.i2c0;
let scl = peripherals.pins.gpio19.downgrade();
let sda = peripherals.pins.gpio20.downgrade();
let driver = I2cDriver::new(i2c, sda, scl, &config).unwrap();
let i2c_port = driver.port();
let mut timeout: i32 = 0;
esp!(unsafe { esp_idf_sys::i2c_get_timeout(i2c_port, &mut timeout) }).unwrap();
println!("init i2c timeout is {}", timeout);
Mutex::new(I2cDriver::new(i2c, sda, scl, &config).unwrap())
}
pub fn create() -> Result<Mutex<PlantCtrlBoard<'static>>> {
let peripherals = Peripherals::take()?;
let i2c_mutex = Arc::new(Mutex::new(driver));
let i2c_battery_device = MutexDevice::new(&i2c_mutex);
let mut battery_driver: Bq34z100g1Driver<MutexDevice<I2cDriver>, Delay> = Bq34z100g1Driver {
i2c: i2c_battery_device,
println!("Init battery driver");
let mut battery_driver = Bq34z100g1Driver {
i2c: MutexDevice::new(&I2C_DRIVER),
delay: Delay::new(0),
flash_block_data: [0; 32],
};
let i2c_rtc_device = MutexDevice::new(&i2c_mutex);
let rtc = Ds323x::new_ds3231(i2c_rtc_device);
println!("Init rtc driver");
let mut rtc = Ds323x::new_ds3231(MutexDevice::new(&I2C_DRIVER));
println!("Init rtc eeprom driver");
let mut eeprom = {
Eeprom24x::new_24x32(
MutexDevice::new(&I2C_DRIVER),
SlaveAddr::Alternative(true, true, true),
)
};
let rtc_time = rtc.datetime();
match rtc_time {
OkStd(tt) => {
println!("Rtc Module reports time at UTC {}", tt);
}
Err(err) => {
println!("Rtc Module could not be read {:?}", err);
}
}
match eeprom.read_byte(0) {
OkStd(byte) => {
println!("Read first byte with status {}", byte);
}
Err(err) => {
println!("Eeprom could not read first byte {:?}", err);
}
}
let mut clock = PinDriver::input_output(peripherals.pins.gpio15.downgrade())?;
clock.set_pull(Pull::Floating).unwrap();
@ -1165,14 +1091,9 @@ impl CreatePlantHal<'_> for PlantHal {
LOW_VOLTAGE_DETECTED
);
for i in 0..PLANT_COUNT {
let smaller_time = LAST_WATERING_TIMESTAMP[i];
let utc_time = DateTime::from_timestamp_millis(smaller_time)
.ok_or(anyhow!("could not convert timestamp"))?;
let europe_time = utc_time.with_timezone(&Berlin);
println!(
"LAST_WATERING_TIMESTAMP[{}] = {} as europe {}",
i, LAST_WATERING_TIMESTAMP[i], europe_time
"LAST_WATERING_TIMESTAMP[{}] = UTC {}",
i, LAST_WATERING_TIMESTAMP[i]
);
}
for i in 0..PLANT_COUNT {
@ -1275,8 +1196,9 @@ impl CreatePlantHal<'_> for PlantHal {
signal_counter: counter_unit1,
wifi_driver,
mqtt_client: None,
battery_driver: Some(battery_driver),
rtc: Some(rtc)
battery_driver: battery_driver,
rtc: rtc,
eeprom: eeprom,
});
let _ = rv.lock().is_ok_and(|mut board| {

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

@ -17,15 +17,21 @@
<p id="loaded_n_total"></p>
</form>
<h2>Battery Firmeware (bq34z100 may be R2)</h2>
<form id="upload_form" method="post">
<input type="file" name="battery_flash_file" id="battery_flash_file"><br>
<progress id="battery_flash_progressBar" value="0" max="100" style="width:300px;"></progress>
<input type="button" name="battery_flash_button" id="battery_flash_button"><br>
<h3 id="battery_flash_status"></h3>
<p id="battery_flash_loaded_n_total"></p>
<div style="height: 100px; display: block; overflow-y: auto;" id = "battery_flash_message"></div>
</form>
<div>
<h2>WIFI</h2>
<input type="button" id="scan" value="Scan">
<br>
<label for="ap_ssid">AP SSID:</label>
<input type="text" id="ap_ssid" list="ssidlist">
<label for="ssid">SSID:</label>
<input type="text" id="ssid" list="ssidlist">
<datalist id="ssidlist">
<option value="Not scanned yet">
</datalist>
<label for="ssid">Password:</label>
<input type="text" id="password">
</div>
<h2>config</h2>
@ -84,6 +90,16 @@
Light only when dark
</div>
<h2>Battery Firmeware (bq34z100 may be R2)</h2>
<form id="upload_form" method="post">
<input type="file" name="battery_flash_file" id="battery_flash_file"><br>
<progress id="battery_flash_progressBar" value="0" max="100" style="width:300px;"></progress>
<input type="button" name="battery_flash_button" id="battery_flash_button"><br>
<h3 id="battery_flash_status"></h3>
<p id="battery_flash_loaded_n_total"></p>
<div style="height: 100px; display: block; overflow-y: auto;" id = "battery_flash_message"></div>
</form>
<h3>Plants:</h3>

47
rust/src/webserver/initial_config.html
View File

@ -1,47 +0,0 @@
<html>
<body>
<input type="button" id="test" value="Test">
<h2>Current Firmware</h2>
<div>
<div id="firmware_buildtime">Buildtime loading</div>
<div id="firmware_githash">Build githash loading</div>
</div>
<div>
<h2>firmeware OTA v3</h2>
<form id="upload_form" method="post">
<input type="file" name="file1" id="file1"><br>
<progress id="progressBar" value="0" max="100" style="width:300px;"></progress>
<h3 id="status"></h3>
<h3 id="answer"></h3>
<p id="loaded_n_total"></p>
</form>
</div>
<h2>Battery Firmeware (bq34z100 may be R2)</h2>
<form id="upload_form" method="post">
<input type="file" name="battery_flash_file" id="battery_flash_file"><br>
<progress id="battery_flash_progressBar" value="0" max="100" style="width:300px;"></progress>
<input type="button" name="battery_flash_button" id="battery_flash_button"><br>
<h3 id="battery_flash_status"></h3>
<p id="battery_flash_loaded_n_total"></p>
<div style="height: 100px; display: block; overflow-y: auto;" id = "battery_flash_message"></div>
</form>
<div>
<h2>WIFI</h2>
<input type="button" id="scan" value="Scan">
<br>
<label for="ssid">SSID:</label>
<input type="text" id="ssid" list="ssidlist">
<datalist id="ssidlist">
<option value="Not scanned yet">
</datalist>
<label for="ssid">Password:</label>
<input type="text" id="password">
<input type="button" id="save" value="Save & Restart">
<div id="wifistatus"></div>
<br>
</div>
<script src="bundle.js"></script>
</body>
</html>

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

@ -15,10 +15,7 @@ use esp_idf_svc::http::server::{Configuration, EspHttpServer};
use heapless::String;
use serde::{Deserialize, Serialize};
use crate::{
config::{Config, WifiConfig},
plant_hal::PlantCtrlBoardInteraction,
};
use crate::config::Config;
#[derive(Serialize, Debug)]
struct SSIDList<'a> {
@ -36,138 +33,9 @@ pub struct TestPump {
pump: usize,
}
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"))?;
anyhow::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())?;
}
}
anyhow::Ok(())
})
.unwrap();
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 anyhow::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 anyhow::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);
anyhow::Ok(())
})
.unwrap();
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"))?;
anyhow::Ok(())
})
.unwrap();
server
.fn_handler("/get_config", Method::Get, move |request| {
let mut response = request.into_ok_response()?;
let mut board = BOARD_ACCESS.lock().unwrap();
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())?;
}
}
anyhow::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 anyhow::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 server_config = Configuration {
stack_size: 8192,
stack_size: 32768,
..Default::default()
};
let mut server: Box<EspHttpServer<'static>> =
@ -293,6 +161,7 @@ pub fn shared() -> Box<EspHttpServer<'static>> {
.unwrap();
server
.fn_handler("/flashbattery", Method::Post, move |mut request| {
let mut board = BOARD_ACCESS.lock().unwrap();
let mut buffer: [u8; 128] = [0; 128];
let mut line_buffer: VecDeque<u8> = VecDeque::new();
@ -302,6 +171,7 @@ pub fn shared() -> Box<EspHttpServer<'static>> {
let mut toggle = true;
let delay = Delay::new(1);
todo!("Write to storage before attempting to flash!");
loop {
delay.delay_us(2);
let read = request.read(&mut buffer).unwrap();
@ -325,7 +195,6 @@ pub fn shared() -> Box<EspHttpServer<'static>> {
line_buffer.write_all(to_write).unwrap();
board.general_fault(toggle);
toggle = !toggle;
loop {
let has_line = line_buffer.contains(&b'\n');
if !has_line {
@ -357,5 +226,82 @@ pub fn shared() -> Box<EspHttpServer<'static>> {
anyhow::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())?;
}
}
anyhow::Ok(())
})
.unwrap();
server
.fn_handler("/", Method::Get, move |request| {
let mut response = request.into_ok_response()?;
response.write(include_bytes!("config.html"))?;
anyhow::Ok(())
})
.unwrap();
server
.fn_handler("/get_config", Method::Get, move |request| {
let mut response = request.into_ok_response()?;
let mut board = BOARD_ACCESS.lock().unwrap();
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())?;
}
}
anyhow::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 anyhow::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
}

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

@ -1,4 +1,7 @@
interface PlantConfig {
ap_ssid: string,
ssid: string,
password: string,
mqtt_url: string,
base_topic: string,
tank_sensor_enabled: boolean,
@ -24,12 +27,53 @@ interface PlantConfig {
}[]
}
interface SSIDList {
ssids : [string]
}
interface TestPump{
pump: number
}
let plants = document.getElementById("plants") as HTMLInputElement;
let scanWifiBtn = document.getElementById("scan") as HTMLButtonElement;
if(scanWifiBtn){
scanWifiBtn.onclick = scanWifi;
}
export function scanWifi(){
var scanButton = (document.getElementById("scan") as HTMLButtonElement);
scanButton.disabled = true;
var ajax = new XMLHttpRequest();
ajax.responseType = 'json';
ajax.onreadystatechange = () => {
if (ajax.readyState === 4) {
callback(ajax.response);
}
};
ajax.onerror = (evt) => {
console.log(evt)
scanButton.disabled = false;
alert("Failed to start see console")
}
ajax.open("POST", "/wifiscan");
ajax.send();
}
function callback(data:SSIDList){
var ssidlist = document.getElementById("ssidlist")
ssidlist.innerHTML = ''
for (var ssid of data.ssids) {
var wi = document.createElement("option");
wi.value = ssid;
ssidlist.appendChild(wi);
}
}
let fromWrapper = (() => {
let plantcount = 0;
@ -42,7 +86,12 @@ let fromWrapper = (() => {
}
}
var ap_ssid = (document.getElementById("ap_ssid") as HTMLInputElement);
ap_ssid.onchange = updateJson
var ssid = (document.getElementById("ssid") as HTMLInputElement);
ssid.onchange = updateJson
var password = (document.getElementById("password") as HTMLInputElement);
password.onchange = updateJson
let mqtt_url = document.getElementById("mqtt_url") as HTMLInputElement;
mqtt_url.onchange = updateJson
let base_topic = document.getElementById("base_topic") as HTMLInputElement;
@ -235,6 +284,11 @@ let fromWrapper = (() => {
function sync(current: PlantConfig) {
plantcount = current.plants.length
ap_ssid.value = current.ap_ssid;
ssid.value = current.ssid;
password.value = current.password;
mqtt_url.value = current.mqtt_url;
base_topic.value = current.base_topic;
max_consecutive_pump_count.value = current.max_consecutive_pump_count.toString();
@ -274,6 +328,9 @@ let fromWrapper = (() => {
function updateJson() {
var current: PlantConfig = {
ap_ssid: ap_ssid.value,
ssid: ssid.value,
password: password.value,
max_consecutive_pump_count: +max_consecutive_pump_count.value,
mqtt_url: mqtt_url.value,
base_topic: base_topic.value,
@ -339,7 +396,12 @@ let fromWrapper = (() => {
fetch("/get_config")
.then(response => response.json())
.then(json => { createForm(json as PlantConfig); }
.then(loaded => {
var currentConfig = loaded as PlantConfig;
createForm(currentConfig);
var pretty = JSON.stringify(currentConfig, undefined, 1);
json.value = pretty;
}
)
})
if (plants) {

93
rust/src_webpack/src/wifi.ts
View File

@ -1,93 +0,0 @@
interface WifiConfig {
ssid: string;
password: string;
}
interface SSIDList {
ssids : [string]
}
export function saveWifi(){
var saveButton = (document.getElementById("save") as HTMLButtonElement);
saveButton.disabled = true;
var ssid = (document.getElementById("ssid") as HTMLInputElement).value
var password = (document.getElementById("password") as HTMLInputElement).value
var wifistatus = document.getElementById("wifistatus")
var wificonfig:WifiConfig = {ssid, password}
var pretty = JSON.stringify(wificonfig, undefined, 4);
console.log("Sending config " + pretty)
var ajax = new XMLHttpRequest();
ajax.onreadystatechange = () => {
wifistatus.innerText = ajax.responseText
};
ajax.onerror = (evt) => {
console.log(evt)
wifistatus.innerText = ajax.responseText
saveButton.disabled = false;
alert("Failed to save config see console")
}
ajax.open("POST", "/wifisave");
ajax.send(pretty);
}
export function scanWifi(){
var scanButton = (document.getElementById("scan") as HTMLButtonElement);
scanButton.disabled = true;
var ajax = new XMLHttpRequest();
ajax.responseType = 'json';
ajax.onreadystatechange = () => {
if (ajax.readyState === 4) {
callback(ajax.response);
}
};
ajax.onerror = (evt) => {
console.log(evt)
scanButton.disabled = false;
alert("Failed to start see console")
}
ajax.open("POST", "/wifiscan");
ajax.send();
}
function test(){
var testButton = (document.getElementById("test") as HTMLButtonElement);
testButton.disabled = true;
var ajax = new XMLHttpRequest();
ajax.responseType = 'json';
ajax.onerror = (evt) => {
console.log(evt)
testButton.disabled = false;
alert("Failed to start see console")
}
ajax.open("POST", "/boardtest");
ajax.send();
}
function callback(data:SSIDList){
var ssidlist = document.getElementById("ssidlist")
ssidlist.innerHTML = ''
for (var ssid of data.ssids) {
var wi = document.createElement("option");
wi.value = ssid;
ssidlist.appendChild(wi);
}
}
let testBtn = document.getElementById("test") as HTMLButtonElement;
if(testBtn){
testBtn.onclick = test;
}
let scanWifiBtn = document.getElementById("scan") as HTMLButtonElement;
if(scanWifiBtn){
scanWifiBtn.onclick = scanWifi;
}
let saveWifiBtn = document.getElementById("save") as HTMLButtonElement;
if(saveWifiBtn){
saveWifiBtn.onclick = saveWifi;
}

2
rust/src_webpack/webpack.config.js
View File

@ -3,7 +3,7 @@ const path = require('path');
module.exports = {
mode: "development",
entry: ['./src/form.ts','./src/ota.ts','./src/wifi.ts', "./src/battery.ts"],
entry: ['./src/form.ts','./src/ota.ts', "./src/battery.ts"],
devtool: 'inline-source-map',
module: {
rules: [