1282 lines
46 KiB
Rust
1282 lines
46 KiB
Rust
use bq34z100::{Bq34Z100Error, Bq34z100g1, Bq34z100g1Driver};
|
|
|
|
use chrono_tz::Europe::Berlin;
|
|
use embedded_svc::wifi::{
|
|
AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration,
|
|
};
|
|
use esp_idf_hal::adc::attenuation;
|
|
use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
|
|
use esp_idf_hal::adc::oneshot::{AdcChannelDriver, AdcDriver};
|
|
use esp_idf_hal::i2c::{APBTickType, I2cConfig, I2cDriver, I2cError};
|
|
use esp_idf_hal::units::FromValueType;
|
|
use esp_idf_svc::eventloop::EspSystemEventLoop;
|
|
use esp_idf_svc::ipv4::IpInfo;
|
|
use esp_idf_svc::mqtt::client::QoS::AtLeastOnce;
|
|
use esp_idf_svc::mqtt::client::QoS::ExactlyOnce;
|
|
use esp_idf_svc::mqtt::client::{EspMqttClient, LwtConfiguration, MqttClientConfiguration};
|
|
use esp_idf_svc::nvs::EspDefaultNvsPartition;
|
|
use esp_idf_svc::wifi::config::{ScanConfig, ScanType};
|
|
use esp_idf_svc::wifi::EspWifi;
|
|
use measurements::Temperature;
|
|
use plant_ctrl2::sipo::ShiftRegister40;
|
|
|
|
use anyhow::anyhow;
|
|
use anyhow::{bail, Ok, Result};
|
|
use std::ffi::CString;
|
|
use std::fs::File;
|
|
use std::path::Path;
|
|
|
|
use chrono::{DateTime, Utc};
|
|
use ds18b20::Ds18b20;
|
|
use std::result::Result::Ok as OkStd;
|
|
use std::str::FromStr;
|
|
use std::sync::atomic::AtomicBool;
|
|
use std::sync::{Arc, Mutex};
|
|
use std::time::Duration;
|
|
|
|
use embedded_hal::digital::OutputPin;
|
|
use esp_idf_hal::delay::Delay;
|
|
use esp_idf_hal::gpio::{AnyInputPin, Gpio18, Gpio5, IOPin, InputOutput, Level, PinDriver, Pull};
|
|
use esp_idf_hal::pcnt::{
|
|
PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex,
|
|
};
|
|
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 one_wire_bus::OneWire;
|
|
|
|
use crate::config::{self, Config, WifiConfig};
|
|
use crate::{plant_hal, STAY_ALIVE};
|
|
|
|
//Only support for 8 right now!
|
|
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;
|
|
|
|
const PUMP8_BIT: usize = 0;
|
|
const PUMP1_BIT: usize = 1;
|
|
const PUMP2_BIT: usize = 2;
|
|
const PUMP3_BIT: usize = 3;
|
|
const PUMP4_BIT: usize = 4;
|
|
const PUMP5_BIT: usize = 5;
|
|
const PUMP6_BIT: usize = 6;
|
|
const PUMP7_BIT: usize = 7;
|
|
|
|
const MS_0: usize = 8;
|
|
const MS_4: usize = 9;
|
|
const MS_2: usize = 10;
|
|
const MS_3: usize = 11;
|
|
const SENSOR_ON: usize = 12;
|
|
const MS_1: usize = 13;
|
|
//unused 14
|
|
//unused 15
|
|
|
|
const FAULT_3: usize = 16;
|
|
const FAULT_8: usize = 17;
|
|
const FAULT_7: usize = 18;
|
|
const FAULT_6: usize = 19;
|
|
const FAULT_5: usize = 20;
|
|
const FAULT_4: usize = 21;
|
|
const FAULT_1: usize = 22;
|
|
const FAULT_2: usize = 23;
|
|
|
|
const SENSOR_A_1: u8 = 7;
|
|
const SENSOR_A_2: u8 = 6;
|
|
const SENSOR_A_3: u8 = 5;
|
|
const SENSOR_A_4: u8 = 4;
|
|
const SENSOR_A_5: u8 = 3;
|
|
const SENSOR_A_6: u8 = 2;
|
|
const SENSOR_A_7: u8 = 1;
|
|
const SENSOR_A_8: u8 = 0;
|
|
|
|
const SENSOR_B_1: u8 = 8;
|
|
const SENSOR_B_2: u8 = 9;
|
|
const SENSOR_B_3: u8 = 10;
|
|
const SENSOR_B_4: u8 = 11;
|
|
const SENSOR_B_5: u8 = 12;
|
|
const SENSOR_B_6: u8 = 13;
|
|
const SENSOR_B_7: u8 = 14;
|
|
const SENSOR_B_8: u8 = 15;
|
|
|
|
#[link_section = ".rtc.data"]
|
|
static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
|
|
#[link_section = ".rtc.data"]
|
|
static mut CONSECUTIVE_WATERING_PLANT: [u32; PLANT_COUNT] = [0; PLANT_COUNT];
|
|
#[link_section = ".rtc.data"]
|
|
static mut LOW_VOLTAGE_DETECTED: bool = false;
|
|
|
|
pub struct FileSystemSizeInfo {
|
|
pub total_size: usize,
|
|
pub used_size: usize,
|
|
pub free_size: usize,
|
|
}
|
|
|
|
#[derive(strum::Display)]
|
|
pub enum ClearConfigType {
|
|
WifiConfig,
|
|
Config,
|
|
None,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
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 {}
|
|
|
|
pub struct PlantCtrlBoard<'a> {
|
|
shift_register: ShiftRegister40<
|
|
PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
>,
|
|
shift_register_enable_invert:
|
|
PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Output>,
|
|
tank_channel: AdcChannelDriver<'a, Gpio5, AdcDriver<'a, esp_idf_hal::adc::ADC1>>,
|
|
solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
|
|
boot_button: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
|
|
signal_counter: PcntDriver<'a>,
|
|
light: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
main_pump: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
tank_power: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
|
|
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<I2cDriver<'a>, Delay>>,
|
|
}
|
|
|
|
impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
|
|
fn is_day(&self) -> bool {
|
|
self.solar_is_day.get_level().into()
|
|
}
|
|
|
|
fn water_temperature_c(&mut self) -> Result<f32> {
|
|
let mut delay = Delay::new_default();
|
|
|
|
self.one_wire_bus
|
|
.reset(&mut delay)
|
|
.map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
|
|
let first = self.one_wire_bus.devices(false, &mut delay).next();
|
|
if first.is_none() {
|
|
bail!("Not found any one wire Ds18b20");
|
|
}
|
|
let device_address = first
|
|
.unwrap()
|
|
.map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
|
|
|
|
let water_temp_sensor = Ds18b20::new::<EspError>(device_address)
|
|
.map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
|
|
|
|
water_temp_sensor
|
|
.start_temp_measurement(&mut self.one_wire_bus, &mut delay)
|
|
.map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
|
|
ds18b20::Resolution::Bits12.delay_for_measurement_time(&mut delay);
|
|
let sensor_data = water_temp_sensor
|
|
.read_data(&mut self.one_wire_bus, &mut delay)
|
|
.map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
|
|
if sensor_data.temperature == 85_f32 {
|
|
bail!("Ds18b20 dummy temperature returned");
|
|
}
|
|
Ok(sensor_data.temperature / 10_f32)
|
|
}
|
|
|
|
fn tank_sensor_percent(&mut self) -> Result<u16> {
|
|
let delay = Delay::new_default();
|
|
self.tank_power.set_high()?;
|
|
//let stabilize
|
|
delay.delay_ms(100);
|
|
unsafe {
|
|
vTaskDelay(100);
|
|
}
|
|
|
|
let mut store = [0_u16; TANK_MULTI_SAMPLE];
|
|
for multisample in 0..TANK_MULTI_SAMPLE {
|
|
let value = self.tank_channel.read()?;
|
|
store[multisample] = value;
|
|
}
|
|
store.sort();
|
|
let median = store[6] as f32 / 1000_f32;
|
|
let config_open_voltage_mv = 3.0;
|
|
if config_open_voltage_mv < median {
|
|
self.tank_power.set_low()?;
|
|
bail!(
|
|
"Tank sensor missing, open loop voltage {} on tank sensor input {}",
|
|
config_open_voltage_mv,
|
|
median
|
|
);
|
|
}
|
|
|
|
let r2 = median * 50.0 / (3.3 - median);
|
|
let mut percent = r2 / 190_f32 * 100_f32;
|
|
percent = percent.clamp(0.0, 100.0);
|
|
|
|
println!("Tank sensor raw {} percent {}", median, percent);
|
|
return Ok(percent as u16);
|
|
}
|
|
|
|
fn set_low_voltage_in_cycle(&mut self) {
|
|
unsafe {
|
|
LOW_VOLTAGE_DETECTED = true;
|
|
}
|
|
}
|
|
|
|
fn clear_low_voltage_in_cycle(&mut self) {
|
|
unsafe {
|
|
LOW_VOLTAGE_DETECTED = false;
|
|
}
|
|
}
|
|
|
|
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<()> {
|
|
let index = match plant {
|
|
0 => PUMP1_BIT,
|
|
1 => PUMP2_BIT,
|
|
2 => PUMP3_BIT,
|
|
3 => PUMP4_BIT,
|
|
4 => PUMP5_BIT,
|
|
5 => PUMP6_BIT,
|
|
6 => PUMP7_BIT,
|
|
7 => PUMP8_BIT,
|
|
_ => bail!("Invalid pump {plant}",),
|
|
};
|
|
//currently infailable error, keep for future as result anyway
|
|
self.shift_register.decompose()[index].set_state(enable.into())?;
|
|
Ok(())
|
|
}
|
|
|
|
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>) {
|
|
unsafe {
|
|
LAST_WATERING_TIMESTAMP[plant] = time.timestamp_millis();
|
|
}
|
|
}
|
|
|
|
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 {
|
|
unsafe {
|
|
return CONSECUTIVE_WATERING_PLANT[plant];
|
|
}
|
|
}
|
|
|
|
fn fault(&self, plant: usize, enable: bool) {
|
|
let index = match plant {
|
|
0 => FAULT_1,
|
|
1 => FAULT_2,
|
|
2 => FAULT_3,
|
|
3 => FAULT_4,
|
|
4 => FAULT_5,
|
|
5 => FAULT_6,
|
|
6 => FAULT_7,
|
|
7 => FAULT_8,
|
|
_ => panic!("Invalid plant id {}", plant),
|
|
};
|
|
self.shift_register.decompose()[index]
|
|
.set_state(enable.into())
|
|
.unwrap()
|
|
}
|
|
|
|
fn low_voltage_in_cycle(&mut self) -> bool {
|
|
unsafe {
|
|
return LOW_VOLTAGE_DETECTED;
|
|
}
|
|
}
|
|
|
|
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>> {
|
|
let time = EspSystemTime {}.now().as_millis();
|
|
let smaller_time = time as i64;
|
|
let local_time = DateTime::from_timestamp_millis(smaller_time)
|
|
.ok_or(anyhow!("could not convert timestamp"))?;
|
|
Ok(local_time)
|
|
}
|
|
|
|
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 {
|
|
let delay = Delay::new_default();
|
|
delay.delay_ms(100);
|
|
counter += 100;
|
|
if counter > max_wait_ms {
|
|
bail!("Reached sntp timeout, aborting")
|
|
}
|
|
}
|
|
|
|
self.time()
|
|
}
|
|
|
|
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,
|
|
1 => SENSOR_A_2,
|
|
2 => SENSOR_A_3,
|
|
3 => SENSOR_A_4,
|
|
4 => SENSOR_A_5,
|
|
5 => SENSOR_A_6,
|
|
6 => SENSOR_A_7,
|
|
7 => SENSOR_A_8,
|
|
_ => bail!("Invalid plant id {}", plant),
|
|
},
|
|
Sensor::B => match plant {
|
|
0 => SENSOR_B_1,
|
|
1 => SENSOR_B_2,
|
|
2 => SENSOR_B_3,
|
|
3 => SENSOR_B_4,
|
|
4 => SENSOR_B_5,
|
|
5 => SENSOR_B_6,
|
|
6 => SENSOR_B_7,
|
|
7 => SENSOR_B_8,
|
|
_ => bail!("Invalid plant id {}", plant),
|
|
},
|
|
};
|
|
|
|
let mut results = [0; REPEAT_MOIST_MEASURE];
|
|
for repeat in 0..REPEAT_MOIST_MEASURE {
|
|
self.signal_counter.counter_pause()?;
|
|
self.signal_counter.counter_clear()?;
|
|
//Disable all
|
|
self.shift_register.decompose()[MS_4].set_high().unwrap();
|
|
|
|
self.sensor_multiplexer(sensor_channel)?;
|
|
|
|
self.shift_register.decompose()[MS_4].set_low().unwrap();
|
|
self.shift_register.decompose()[SENSOR_ON]
|
|
.set_high()
|
|
.unwrap();
|
|
|
|
let delay = Delay::new_default();
|
|
let measurement = 10;
|
|
let factor = 1000 as f32 / measurement as f32;
|
|
|
|
//give some time to stabilize
|
|
delay.delay_ms(10);
|
|
self.signal_counter.counter_resume()?;
|
|
delay.delay_ms(measurement);
|
|
self.signal_counter.counter_pause()?;
|
|
self.shift_register.decompose()[MS_4].set_high().unwrap();
|
|
self.shift_register.decompose()[SENSOR_ON]
|
|
.set_low()
|
|
.unwrap();
|
|
delay.delay_ms(10);
|
|
let unscaled = self.signal_counter.get_counter_value()? as i32;
|
|
let hz = (unscaled as f32 * factor) as i32;
|
|
results[repeat] = hz;
|
|
//println!("Measuring {:?} @ {} with {}", sensor, plant, hz);
|
|
}
|
|
results.sort();
|
|
|
|
let mid = results.len() / 2;
|
|
|
|
Ok(results[mid])
|
|
}
|
|
|
|
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<()> {
|
|
let apconfig = AccessPointConfiguration {
|
|
ssid: heapless::String::from_str("PlantCtrl").unwrap(),
|
|
auth_method: AuthMethod::None,
|
|
ssid_hidden: false,
|
|
..Default::default()
|
|
};
|
|
let clientconfig = ClientConfiguration::default();
|
|
self.wifi_driver
|
|
.set_configuration(&Configuration::Mixed(clientconfig, apconfig))?;
|
|
self.wifi_driver.start()?;
|
|
Ok(())
|
|
}
|
|
|
|
fn wifi(
|
|
&mut self,
|
|
ssid: heapless::String<32>,
|
|
password: Option<heapless::String<64>>,
|
|
max_wait: u32,
|
|
) -> Result<IpInfo> {
|
|
match password {
|
|
Some(pw) => {
|
|
//TODO expect error due to invalid pw or similar! //call this during configuration and check if works, revert to config mode if not
|
|
self.wifi_driver.set_configuration(&Configuration::Client(
|
|
ClientConfiguration {
|
|
ssid: ssid,
|
|
password: pw,
|
|
..Default::default()
|
|
},
|
|
))?;
|
|
}
|
|
None => {
|
|
self.wifi_driver.set_configuration(&Configuration::Client(
|
|
ClientConfiguration {
|
|
ssid: ssid,
|
|
auth_method: AuthMethod::None,
|
|
..Default::default()
|
|
},
|
|
))?;
|
|
}
|
|
}
|
|
|
|
self.wifi_driver.start()?;
|
|
self.wifi_driver.connect()?;
|
|
|
|
let delay = Delay::new_default();
|
|
let mut counter = 0_u32;
|
|
while !self.wifi_driver.is_connected()? {
|
|
println!("Waiting for station connection");
|
|
delay.delay_ms(250);
|
|
counter += 250;
|
|
if counter > max_wait {
|
|
//ignore these errors, wifi will not be used this
|
|
self.wifi_driver.disconnect().unwrap_or(());
|
|
self.wifi_driver.stop().unwrap_or(());
|
|
bail!("Did not manage wifi connection within timeout");
|
|
}
|
|
}
|
|
println!("Should be connected now");
|
|
|
|
while !self.wifi_driver.is_up()? {
|
|
println!("Waiting for network being up");
|
|
delay.delay_ms(250);
|
|
counter += 250;
|
|
if counter > max_wait {
|
|
//ignore these errors, wifi will not be used this
|
|
self.wifi_driver.disconnect().unwrap_or(());
|
|
self.wifi_driver.stop().unwrap_or(());
|
|
bail!("Did not manage wifi connection within timeout");
|
|
}
|
|
}
|
|
//update freertos registers ;)
|
|
let address = self.wifi_driver.sta_netif().get_ip_info()?;
|
|
println!("IP info: {:?}", address);
|
|
Ok(address)
|
|
}
|
|
|
|
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 {
|
|
base_path: base_path.as_ptr(),
|
|
partition_label: storage.as_ptr(),
|
|
max_files: 2,
|
|
format_if_mount_failed: true,
|
|
};
|
|
|
|
unsafe {
|
|
esp_idf_sys::esp!(esp_idf_sys::esp_vfs_spiffs_register(&conf))?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
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;
|
|
unsafe {
|
|
esp_idf_sys::esp!(esp_idf_sys::esp_spiffs_info(
|
|
storage.as_ptr(),
|
|
&mut total_size,
|
|
&mut used_size
|
|
))?;
|
|
}
|
|
Ok(FileSystemSizeInfo {
|
|
total_size,
|
|
used_size,
|
|
free_size: total_size - used_size,
|
|
})
|
|
}
|
|
|
|
fn is_config_reset(&mut self) -> bool {
|
|
self.boot_button.get_level() == Level::Low
|
|
}
|
|
|
|
fn remove_configs(&mut self) -> Result<ClearConfigType> {
|
|
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);
|
|
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();
|
|
}
|
|
Ok(config)
|
|
}
|
|
|
|
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>> {
|
|
self.wifi_driver.start_scan(
|
|
&ScanConfig {
|
|
scan_type: ScanType::Passive(Duration::from_secs(5)),
|
|
show_hidden: false,
|
|
..Default::default()
|
|
},
|
|
true,
|
|
)?;
|
|
Ok(self.wifi_driver.get_scan_result()?)
|
|
}
|
|
|
|
fn test_pump(&mut self, plant: usize) -> Result<()> {
|
|
self.any_pump(true)?;
|
|
self.pump(plant, true)?;
|
|
unsafe { vTaskDelay(30000) };
|
|
self.pump(plant, false)?;
|
|
self.any_pump(false)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn test(&mut self) -> Result<()> {
|
|
self.general_fault(true);
|
|
unsafe { vTaskDelay(100) };
|
|
self.general_fault(false);
|
|
unsafe { vTaskDelay(100) };
|
|
self.any_pump(true)?;
|
|
unsafe { vTaskDelay(500) };
|
|
self.any_pump(false)?;
|
|
unsafe { vTaskDelay(500) };
|
|
self.light(true)?;
|
|
unsafe { vTaskDelay(500) };
|
|
self.light(false)?;
|
|
unsafe { vTaskDelay(500) };
|
|
for i in 0..PLANT_COUNT {
|
|
self.fault(i, true);
|
|
unsafe { vTaskDelay(500) };
|
|
self.fault(i, false);
|
|
unsafe { vTaskDelay(500) };
|
|
}
|
|
for i in 0..PLANT_COUNT {
|
|
self.pump(i, true)?;
|
|
unsafe { vTaskDelay(100) };
|
|
self.pump(i, false)?;
|
|
unsafe { vTaskDelay(100) };
|
|
}
|
|
for plant in 0..PLANT_COUNT {
|
|
let a = self.measure_moisture_hz(plant, plant_hal::Sensor::A);
|
|
let b = self.measure_moisture_hz(plant, plant_hal::Sensor::B);
|
|
print!("P:{} a:{:?} b:{:?}", plant, a, b)
|
|
}
|
|
println!();
|
|
Delay::new_default().delay_ms(10);
|
|
Ok(())
|
|
}
|
|
|
|
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);
|
|
let mqtt_client_config = MqttClientConfiguration {
|
|
lwt: Some(LwtConfiguration {
|
|
topic: &last_will_topic,
|
|
payload: "lost".as_bytes(),
|
|
qos: AtLeastOnce,
|
|
retain: true,
|
|
}),
|
|
client_id: Some("plantctrl"),
|
|
keep_alive_interval: Some(Duration::from_secs(60 * 60 * 2)),
|
|
//room for improvement
|
|
..Default::default()
|
|
};
|
|
|
|
let mqtt_connected_event_received = Arc::new(AtomicBool::new(false));
|
|
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);
|
|
println!("Stay alive topic is {}", stay_alive_topic);
|
|
|
|
let mqtt_connected_event_received_copy = mqtt_connected_event_received.clone();
|
|
let mqtt_connected_event_ok_copy = mqtt_connected_event_ok.clone();
|
|
let stay_alive_topic_copy = stay_alive_topic.clone();
|
|
let round_trip_topic_copy = round_trip_topic.clone();
|
|
let round_trip_ok_copy = round_trip_ok.clone();
|
|
println!(
|
|
"Connecting mqtt {} with id {}",
|
|
config.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);
|
|
}
|
|
}
|
|
}
|
|
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 {
|
|
match mqtt_connected_event_received.load(std::sync::atomic::Ordering::Relaxed) {
|
|
true => {
|
|
println!("Mqtt connection callback received, progressing");
|
|
match mqtt_connected_event_ok.load(std::sync::atomic::Ordering::Relaxed) {
|
|
true => {
|
|
println!("Mqtt did callback as connected, testing with roundtrip now");
|
|
//subscribe to roundtrip
|
|
client.subscribe(round_trip_topic.as_str(), ExactlyOnce)?;
|
|
client.subscribe(stay_alive_topic.as_str(), ExactlyOnce)?;
|
|
//publish to roundtrip
|
|
client.publish(
|
|
round_trip_topic.as_str(),
|
|
ExactlyOnce,
|
|
false,
|
|
"online_test".as_bytes(),
|
|
)?;
|
|
|
|
let wait_for_roundtrip = 0;
|
|
while wait_for_roundtrip < 100 {
|
|
match round_trip_ok.load(std::sync::atomic::Ordering::Relaxed) {
|
|
true => {
|
|
println!("Round trip registered, proceeding");
|
|
self.mqtt_client = Some(client);
|
|
return Ok(());
|
|
}
|
|
false => {
|
|
unsafe { vTaskDelay(10) };
|
|
}
|
|
}
|
|
}
|
|
bail!("Mqtt did not complete roundtrip in time");
|
|
}
|
|
false => {
|
|
bail!("Mqtt did respond but with failure")
|
|
}
|
|
}
|
|
}
|
|
false => {
|
|
unsafe { vTaskDelay(10) };
|
|
}
|
|
}
|
|
}
|
|
bail!("Mqtt did not fire connection callback in time");
|
|
}
|
|
|
|
fn mqtt_publish(&mut self, config: &Config, subtopic: &str, message: &[u8]) -> Result<()> {
|
|
if !subtopic.starts_with("/") {
|
|
println!("Subtopic without / at start {}", subtopic);
|
|
bail!("Subtopic without / at start {}", subtopic);
|
|
}
|
|
if subtopic.len() > 192 {
|
|
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,
|
|
);
|
|
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)?;
|
|
}
|
|
};
|
|
}
|
|
None => {
|
|
bail!("No mqtt client");
|
|
}
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
|
|
fn sensor_multiplexer(&mut self, n: u8) -> Result<()> {
|
|
assert!(n < 16);
|
|
let is_bit_set = |b: u8| -> bool { n & (1 << b) != 0 };
|
|
|
|
let pin_0 = &mut self.shift_register.decompose()[MS_0];
|
|
let pin_1 = &mut self.shift_register.decompose()[MS_1];
|
|
let pin_2 = &mut self.shift_register.decompose()[MS_2];
|
|
let pin_3 = &mut self.shift_register.decompose()[MS_3];
|
|
if is_bit_set(0) {
|
|
pin_0.set_high()?;
|
|
} else {
|
|
pin_0.set_low()?;
|
|
}
|
|
if is_bit_set(1) {
|
|
pin_1.set_high()?;
|
|
} else {
|
|
pin_1.set_low()?;
|
|
}
|
|
if is_bit_set(2) {
|
|
pin_2.set_high()?;
|
|
} else {
|
|
pin_2.set_low()?;
|
|
}
|
|
if is_bit_set(3) {
|
|
pin_3.set_high()?;
|
|
} else {
|
|
pin_3.set_low()?;
|
|
}
|
|
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<I2cDriver, Delay>,
|
|
) -> Result<(), Bq34Z100Error<I2cError>> {
|
|
println!("Try communicating with battery");
|
|
let fwversion = battery_driver.fw_version().unwrap_or_else(|e| {
|
|
println!("Firmeware {:?}", e);
|
|
0
|
|
});
|
|
println!("fw version is {}", fwversion);
|
|
|
|
let design_capacity = battery_driver.design_capacity().unwrap_or_else(|e| {
|
|
println!("Design capacity {:?}", e);
|
|
0
|
|
});
|
|
println!("Design Capacity {}", design_capacity);
|
|
if design_capacity == 1000 {
|
|
println!("Still stock configuring battery, readouts are likely to be wrong!");
|
|
}
|
|
|
|
let flags = battery_driver.get_flags_decoded()?;
|
|
println!("Flags {:?}", flags);
|
|
|
|
let chem_id = battery_driver.chem_id().unwrap_or_else(|e| {
|
|
println!("Chemid {:?}", e);
|
|
0
|
|
});
|
|
|
|
let bat_temp = battery_driver.internal_temperature().unwrap_or_else(|e| {
|
|
println!("Bat Temp {:?}", e);
|
|
0
|
|
});
|
|
let temp_c = Temperature::from_kelvin(bat_temp as f64 / 10_f64).as_celsius();
|
|
let voltage = battery_driver.voltage().unwrap_or_else(|e| {
|
|
println!("Bat volt {:?}", e);
|
|
0
|
|
});
|
|
let current = battery_driver.current().unwrap_or_else(|e| {
|
|
println!("Bat current {:?}", e);
|
|
0
|
|
});
|
|
let state = battery_driver.state_of_charge().unwrap_or_else(|e| {
|
|
println!("Bat Soc {:?}", e);
|
|
0
|
|
});
|
|
let charge_voltage = battery_driver.charge_voltage().unwrap_or_else(|e| {
|
|
println!("Bat Charge Volt {:?}", e);
|
|
0
|
|
});
|
|
let charge_current = battery_driver.charge_current().unwrap_or_else(|e| {
|
|
println!("Bat Charge Current {:?}", e);
|
|
0
|
|
});
|
|
println!("ChemId: {} Current voltage {} and current {} with charge {}% and temp {} CVolt: {} CCur {}", chem_id, voltage, current, state, temp_c, charge_voltage, charge_current);
|
|
let _ = battery_driver.unsealed();
|
|
let _ = battery_driver.it_enable();
|
|
return Result::Ok(());
|
|
}
|
|
|
|
impl CreatePlantHal<'_> for PlantHal {
|
|
fn create() -> Result<Mutex<PlantCtrlBoard<'static>>> {
|
|
let peripherals = Peripherals::take()?;
|
|
|
|
let i2c = peripherals.i2c0;
|
|
let config = I2cConfig::new()
|
|
.scl_enable_pullup(true)
|
|
.sda_enable_pullup(true)
|
|
.baudrate(400_u32.kHz().into())
|
|
.timeout(APBTickType::from(Duration::from_millis(100)));
|
|
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);
|
|
|
|
//esp!(unsafe { esp_idf_sys::i2c_set_timeout(i2c_port, 22)}).unwrap();
|
|
|
|
let mut battery_driver: Bq34z100g1Driver<I2cDriver, Delay> = Bq34z100g1Driver {
|
|
i2c: driver,
|
|
delay: Delay::new(0),
|
|
flash_block_data: [0; 32],
|
|
};
|
|
|
|
let mut clock = PinDriver::input_output(peripherals.pins.gpio15.downgrade())?;
|
|
clock.set_pull(Pull::Floating).unwrap();
|
|
let mut latch = PinDriver::input_output(peripherals.pins.gpio3.downgrade())?;
|
|
latch.set_pull(Pull::Floating).unwrap();
|
|
let mut data = PinDriver::input_output(peripherals.pins.gpio23.downgrade())?;
|
|
data.set_pull(Pull::Floating).unwrap();
|
|
let shift_register = ShiftRegister40::new(clock.into(), latch.into(), data.into());
|
|
for mut pin in shift_register.decompose() {
|
|
pin.set_low().unwrap();
|
|
}
|
|
|
|
let mut one_wire_pin = PinDriver::input_output_od(peripherals.pins.gpio18)?;
|
|
one_wire_pin.set_pull(Pull::Floating).unwrap();
|
|
|
|
//disable all
|
|
let ms0 = &mut shift_register.decompose()[MS_0];
|
|
ms0.set_low()?;
|
|
let ms1 = &mut shift_register.decompose()[MS_1];
|
|
ms1.set_low()?;
|
|
let ms2 = &mut shift_register.decompose()[MS_2];
|
|
ms2.set_low()?;
|
|
let ms3 = &mut shift_register.decompose()[MS_3];
|
|
ms3.set_low()?;
|
|
|
|
let ms4 = &mut shift_register.decompose()[MS_4];
|
|
ms4.set_high()?;
|
|
|
|
//init,reset rtc memory depending on cause
|
|
let reasons = ResetReason::get();
|
|
let reset_store = match reasons {
|
|
ResetReason::Software => false,
|
|
ResetReason::ExternalPin => false,
|
|
ResetReason::Watchdog => true,
|
|
ResetReason::Sdio => true,
|
|
ResetReason::Panic => true,
|
|
ResetReason::InterruptWatchdog => true,
|
|
ResetReason::PowerOn => true,
|
|
ResetReason::Unknown => true,
|
|
ResetReason::Brownout => true,
|
|
ResetReason::TaskWatchdog => true,
|
|
ResetReason::DeepSleep => false,
|
|
};
|
|
if reset_store {
|
|
println!("Clear and reinit RTC store");
|
|
unsafe {
|
|
LAST_WATERING_TIMESTAMP = [0; PLANT_COUNT];
|
|
CONSECUTIVE_WATERING_PLANT = [0; PLANT_COUNT];
|
|
LOW_VOLTAGE_DETECTED = false;
|
|
};
|
|
} else {
|
|
println!("Keeping RTC store");
|
|
unsafe {
|
|
println!(
|
|
"Current low voltage detection is {:?}",
|
|
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
|
|
);
|
|
}
|
|
for i in 0..PLANT_COUNT {
|
|
println!(
|
|
"CONSECUTIVE_WATERING_PLANT[{}] = {}",
|
|
i, CONSECUTIVE_WATERING_PLANT[i]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut counter_unit1 = PcntDriver::new(
|
|
peripherals.pcnt0,
|
|
Some(peripherals.pins.gpio22),
|
|
Option::<AnyInputPin>::None,
|
|
Option::<AnyInputPin>::None,
|
|
Option::<AnyInputPin>::None,
|
|
)?;
|
|
|
|
println!("Channel config start");
|
|
|
|
counter_unit1.channel_config(
|
|
PcntChannel::Channel0,
|
|
PinIndex::Pin0,
|
|
PinIndex::Pin1,
|
|
&PcntChannelConfig {
|
|
lctrl_mode: PcntControlMode::Keep,
|
|
hctrl_mode: PcntControlMode::Keep,
|
|
pos_mode: PcntCountMode::Increment,
|
|
neg_mode: PcntCountMode::Hold,
|
|
counter_h_lim: i16::MAX,
|
|
counter_l_lim: 0,
|
|
},
|
|
)?;
|
|
|
|
println!("Setup filter");
|
|
|
|
//TODO validate filter value! currently max allowed value
|
|
counter_unit1.set_filter_value(1023)?;
|
|
counter_unit1.filter_enable()?;
|
|
|
|
println!("Wifi start");
|
|
|
|
let sys_loop = EspSystemEventLoop::take()?;
|
|
let nvs = EspDefaultNvsPartition::take()?;
|
|
let wifi_driver = EspWifi::new(peripherals.modem, sys_loop, Some(nvs))?;
|
|
|
|
let adc_config = AdcChannelConfig {
|
|
attenuation: attenuation::DB_11,
|
|
resolution: esp_idf_hal::adc::config::Resolution::Resolution12Bit,
|
|
calibration: true,
|
|
};
|
|
let tank_driver = AdcDriver::new(peripherals.adc1)?;
|
|
let tank_channel: AdcChannelDriver<Gpio5, AdcDriver<esp_idf_hal::adc::ADC1>> =
|
|
AdcChannelDriver::new(tank_driver, peripherals.pins.gpio5, &adc_config)?;
|
|
|
|
let mut solar_is_day = PinDriver::input(peripherals.pins.gpio8.downgrade())?;
|
|
solar_is_day.set_pull(Pull::Floating)?;
|
|
|
|
let mut boot_button = PinDriver::input(peripherals.pins.gpio9.downgrade())?;
|
|
boot_button.set_pull(Pull::Floating)?;
|
|
|
|
let mut light = PinDriver::input_output(peripherals.pins.gpio10.downgrade())?;
|
|
light.set_pull(Pull::Floating).unwrap();
|
|
|
|
let mut main_pump = PinDriver::input_output(peripherals.pins.gpio2.downgrade())?;
|
|
main_pump.set_pull(Pull::Floating)?;
|
|
main_pump.set_low()?;
|
|
let mut tank_power = PinDriver::input_output(peripherals.pins.gpio11.downgrade())?;
|
|
tank_power.set_pull(Pull::Floating)?;
|
|
let mut general_fault = PinDriver::input_output(peripherals.pins.gpio6.downgrade())?;
|
|
general_fault.set_pull(Pull::Floating)?;
|
|
general_fault.set_low()?;
|
|
|
|
let one_wire_bus = OneWire::new(one_wire_pin)
|
|
.map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
|
|
|
|
println!("After stuff");
|
|
|
|
let status = print_battery(&mut battery_driver);
|
|
if status.is_err() {
|
|
println!("Error communicating with battery!! {:?}", status.err());
|
|
} else {
|
|
println!("Managed to comunnicate with battery");
|
|
}
|
|
|
|
let shift_register_enable_invert = PinDriver::output(peripherals.pins.gpio21.downgrade())?;
|
|
|
|
let rv = Mutex::new(PlantCtrlBoard {
|
|
shift_register,
|
|
shift_register_enable_invert,
|
|
tank_channel,
|
|
solar_is_day,
|
|
boot_button,
|
|
light,
|
|
main_pump,
|
|
tank_power,
|
|
general_fault,
|
|
one_wire_bus,
|
|
signal_counter: counter_unit1,
|
|
wifi_driver,
|
|
mqtt_client: None,
|
|
//battery_driver: None,
|
|
battery_driver: Some(battery_driver),
|
|
});
|
|
|
|
let _ = rv.lock().is_ok_and(|mut board| {
|
|
unsafe { gpio_hold_dis(board.shift_register_enable_invert.pin()) };
|
|
board.shift_register_enable_invert.set_low().unwrap();
|
|
unsafe { gpio_hold_en(board.shift_register_enable_invert.pin()) };
|
|
return true;
|
|
});
|
|
|
|
Ok(rv)
|
|
}
|
|
}
|