PlantCtrl/rust/src/main.rs

use std::{
    ffi::CString,
    fs::File,
    io::{Read, Write},
    str::from_utf8,
};

use chrono::{Datelike, NaiveDateTime, Timelike};

use anyhow::{Context, Result};
use chrono_tz::Europe::Berlin;
use esp_idf_hal::delay::Delay;
use esp_idf_svc::http::server::EspHttpServer;
use plant_hal::{CreatePlantHal, PlantCtrlBoardInteraction, PlantHal, PLANT_COUNT};
use webserver::webserver::httpd;
mod config;
pub mod plant_hal;
mod webserver {
    pub mod webserver;
}

fn main() -> Result<()> {
    // It is necessary to call this function once. Otherwise some patches to the runtime
    // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
    esp_idf_svc::sys::link_patches();

    // Bind the log crate to the ESP Logging facilities
    esp_idf_svc::log::EspLogger::initialize_default();

    log::info!("Startup Rust");

    let git_hash = env!("VERGEN_GIT_DESCRIBE");
    println!("Version useing git has {}", git_hash);

    
        let mut board = PlantHal::create()?;

        println!("Board hal init");

        let time = board.time();
        let mut cur = match time {
            Ok(cur) => cur,
            Err(err) => {
                log::error!("time error {}", err);
                NaiveDateTime::from_timestamp_millis(0).unwrap().and_utc()
            }
        };
        //check if we know the time current > 2020
        if cur.year() < 2020 {
            if board.is_day() {
                //assume TZ safe times ;)
                cur = *cur.with_hour(15).get_or_insert(cur);
            } else {
                cur = *cur.with_hour(3).get_or_insert(cur);
            }
        }

        println!("cur is {}", cur);




        //continous/interrupt?
            //check if boot button is pressed, if longer than 5s delete config and reboot into config mode


        let config = board.get_config();
        match config {
            Ok(conf) => {

            },
            Err(err) => {

            },
        }

    //    let proceed = config.unwrap();

        //check if we have a config file
            // if not found or parsing error -> error very fast blink general fault
                //if this happens after a firmeware upgrade (check image state), mark as invalid
                    //blink general fault error_reading_config_after_upgrade, reboot after
                // open accesspoint with webserver for wlan mqtt setup
                    //blink general fault error_no_config_after_upgrade
                        //once config is set store it and reboot

        //if proceed.tank_sensor_enabled() {

        //}
        //is tank sensor enabled in config?
            //measure tank level (without wifi due to interference)
            //TODO this should be a result// detect invalid measurement value
            let tank_value = board.tank_sensor_mv();
            match tank_value {
                Ok(tank_raw) => {
                    println!("Tank sensor returned {}", tank_raw);
                },
                Err(_) => {
                    //if not possible value, blink general fault error_tank_sensor_fault
                    board.general_fault(true);
                    //set general fault persistent
                    //set tank sensor state to fault
                },
            }


        //measure each plant moisture
        let mut initial_measurements_a: [i32;PLANT_COUNT] = [0;PLANT_COUNT];
        let mut initial_measurements_b: [i32;PLANT_COUNT] = [0;PLANT_COUNT];
        let mut initial_measurements_p: [i32;PLANT_COUNT] = [0;PLANT_COUNT];
        for plant in 0..PLANT_COUNT {
            initial_measurements_a[plant] = board.measure_moisture_hz(plant, plant_hal::Sensor::A)?;
            initial_measurements_b[plant] = board.measure_moisture_hz(plant, plant_hal::Sensor::B)?;
            initial_measurements_p[plant] = board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)?;
        }

        //match board.wifi("C3MA", Some("chaosimquadrat"), 10000) {
        //    Ok(_) => println!("online mode"),
        //    Err(_) => {

    //            println!("Offline mode");
            //},
        //}
        //try connect wifi and do mqtt roundtrip
            // if no wifi, set general fault persistent
                //if no mqtt, set general fault persistent

    let mut total_size = 0;
    let mut used_size = 0;         
    unsafe {
        let base_path = CString::new("/spiffs")?;
        let storage = CString::new("storage")?;

        let conf = esp_idf_sys::esp_vfs_spiffs_conf_t {
            base_path: base_path.as_ptr(),
            partition_label: storage.as_ptr(),
            max_files: 5,
            format_if_mount_failed: true,
        };
        esp_idf_sys::esp!(esp_idf_sys::esp_vfs_spiffs_register(&conf))?;

        esp_idf_sys::esp!(esp_idf_sys::esp_spiffs_info(storage.as_ptr(),&mut total_size,&mut used_size))?;
    }
    println!("Total spiffs size is {}, used size is {}", total_size, used_size);
    println!("writing");
    let mut config_file = File::create("/spiffs/config.cfg")?;
    config_file.write_all("test stuff".as_bytes())?;
    config_file.flush()?;
    println!("Reading");
    let mut cfg = File::open("/spiffs/config.cfg")?;
    let mut data: [u8; 512] = [0; 512];
    let read = cfg.read(&mut data)?;
    println!("Read file {}", from_utf8(&data[0..read])?);

    /* 
    match board.sntp(1000 * 120) {
        Ok(new_time) => cur = new_time,
        Err(err) => {
            println!("sntp error: {}", err);
        }
    }
    println!("Running logic at utc {}", cur);
    let europe_time = cur.with_timezone(&Berlin);
    println!("Running logic at europe/berlin {}", europe_time);

    //if config battery mode
    //read battery level
    //if not possible set general fault persistent, but do continue
    //else
    //assume 12v and max capacity

    //if tank sensor is enabled
    //if tank sensor fault abort if config require is set
    //check if water is > minimum allowed || fault
    //if not, set all plants requiring water to persistent fault

    //for each plant
    //check if moisture is < target
    //state  += dry
    //check if in cooldown
    //state += cooldown
    //check if consecutive pumps > limit
    //state += notworking
    //set plant fault persistent

    //pump one cycle
    // set last pump time to now
    //during pump state += active
    //after pump check if Pump moisture value is increased by config delta x
    // state -= active
    // state += cooldown
    // if not set plant error persistent fault
    // state += notworking
    //set consecutive pumps+=1

    //check if during light time
    //lightstate += out of worktime
    //check battery level
    //lightstate += battery empty
    //check solar level if config requires
    //lightstate += stillday
    //if no preventing lightstate, enable light
    //lightstate = active

    //keep webserver in scope
    let webserver = httpd(true);
    let delay = Delay::new_default();
    loop {
        //let freertos do shit
        delay.delay_ms(1001);
    }
*/
    return Ok(());
}

//error codes
//error_reading_config_after_upgrade
//error_no_config_after_upgrade
//error_tank_sensor_fault