#![no_std]
#![no_main]

use esp_backtrace as _;
use esp_hal::{delay::Delay, main};

use log::info;
use tft::TftDisplay;


#[main]
fn main() -> ! {
    let mut _display = TftDisplay::new();

    let delay = Delay::new();
    loop {
        info!("Hello world!");
        delay.delay_millis(500);
    }
    //
    // // for inspiration have a look at the examples at https://github.com/esp-rs/esp-hal/tree/v0.23.1/examples/src/bin
}


main.rs

diagram.json

[package]
edition = "2021"
name = "smart_watering"
version = "0.1.0"

[[bin]]
name = "rust"
path = "./src/bin/main.rs"

[dependencies]
critical-section = "1.2.0"
esp-backtrace = { version = "0.15.0", features = [
  "esp32",
  "exception-handler",
  "panic-handler",
  "println",
] }
esp-hal = { version = "0.23.1", features = ["esp32", "unstable"] }
esp-println = { version = "0.13.0", features = ["esp32", "log"] }
log = { version = "0.4.21" }
embedded-graphics-core = "0.4.0"
embedded-graphics = "0.8.1" # Graphics library
embedded-hal = "1.0.0" #"0.2" # Common HAL traits
mipidsi = "0.9.0" # Driver for MIPI displays (ILI9341)
display-interface-spi = "0.5.0" # SPI interface for displays
profont = "0.7.0" # Profont font support
embedded-hal-bus = "0.2.0"


[lib]
name = "smart_watering"
path = "src/lib.rs"

[profile.dev]
# Rust debug is too slow.
# For debug builds always builds with some optimization
opt-level = "s"

[profile.release]
codegen-units = 1        # LLVM can perform better optimizations using a single thread
debug = 2
debug-assertions = false
incremental = false
lto = 'fat'
opt-level = 's'
overflow-checks = false


Cargo.toml

ChannelValues

ads7830

ads7830.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 

use std::ffi::{CString};

use wokwi_chip_ll::{
    debugPrint, pinInit, pinWatch, pinWrite, INPUT, OUTPUT, HIGH, LOW,
};

struct Chip {
    // Store your chip state here
}

// chipInit() will be called once per chip instance. We use CHIP_VEC to keep track of all the instance.
static mut CHIP_VEC: Vec<Chip> = Vec::new();

#[no_mangle]
pub unsafe extern "C" fn chipInit() {
    let chip = Chip {
        // Set initial values as needed
    };
    CHIP_VEC.push(chip);
    let chip = CHIP_VEC.last().unwrap();

    // TODO: Initialize the chip, set up IO pins, create timers, etc.

    debugPrint(CString::new("Hello Rust Chip!").unwrap().into_raw());
}


ads7830.chip.rs

// TODO: Re-export submodules
pub mod tft;
pub mod graphics;


display_mod.rs

// TODO: Re-exports submodules
pub mod motor;

actuators_mod.rs

// TODO: Re-exports submodules
pub mod rotary_encoder;
pub mod adc;
pub mod water_level_sens;

input_mod.rs

// TODO: Re-exports submodules
pub mod neopixels;

lighting_mod.rs

use embedded_graphics::{
    draw_target::DrawTarget,
    geometry::{Dimensions, /*Point,*/ Size},
    mono_font::MonoTextStyle,
    pixelcolor::Rgb565,
    prelude::RgbColor,
    text::Text,
    Drawable,
};
use embedded_hal_bus::spi::{ExclusiveDevice, NoDelay};
use esp_hal::gpio::{Input, Level, Output, Pull};
use esp_hal::spi::master::{Config, Spi};
use esp_hal::time::RateExtU32;
use esp_hal::{clock::CpuClock, delay::Delay, spi, Blocking};
use esp_println::println;
use mipidsi::models::ILI9341Rgb565;
use mipidsi::options::{ColorOrder /*, Orientation*/};
use mipidsi::{interface::SpiInterface, Builder};
use profont::PROFONT_24_POINT;

pub mod tft;

static mut BUFFER: [u8; 512] = [0_u8; 512];

/// TFT Display abstraction
pub struct TftDisplay {
    display: mipidsi::Display<
        SpiInterface<
            'static,
            ExclusiveDevice<Spi<'static, Blocking>, Output<'static>, NoDelay>,
            Output<'static>,
        >,
        ILI9341Rgb565,
        Output<'static>,
    >,
}

impl TftDisplay {
    /// Initializes the TFT display and returns a `TftDisplay` instance.
    pub fn new() -> Self {
        let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
        let peripherals = esp_hal::init(config);

        let sck = Output::new(peripherals.GPIO6, Level::Low);
        let mosi = Output::new(peripherals.GPIO7, Level::Low);
        let miso = Input::new(peripherals.GPIO8, Pull::Up);
        let cs = Output::new(peripherals.GPIO2, Level::Low);
        let dc = Output::new(peripherals.GPIO3, Level::Low);
        let reset = Output::new(peripherals.GPIO10, Level::Low);
        let mut backlight = Output::new(peripherals.GPIO4, Level::Low);

        // Configure backlight
        backlight.set_high();

        // Configure SPI
        let spi = Spi::new(
            peripherals.SPI2,
            Config::default()
                .with_frequency(100u32.MHz())
                .with_mode(spi::Mode::_0),
        )
        .unwrap()
        .with_sck(sck)
        .with_mosi(mosi)
        .with_miso(miso);
        //.with_cs(cs);

        let buffer = unsafe { &mut BUFFER };
        let spi_device = ExclusiveDevice::new_no_delay(spi, cs).unwrap();
        let di = SpiInterface::new(spi_device, dc, buffer);

        let mut delay = Delay::new();

        let mut display = Builder::new(ILI9341Rgb565, di)
            .reset_pin(reset)
            .color_order(ColorOrder::Bgr)
            .display_size(320, 240)
            .init(&mut delay)
            .unwrap();

        // Draw on the display
        display.clear(Rgb565::WHITE).unwrap();

        let mut tft_display = Self { display };
        tft_display.draw_message("Display initialized!");

        println!("TFT Display initialized!");

        tft_display
    }

    /// Clears the display with the specified color.
    pub fn clear(&mut self, color: Rgb565) {
        self.display.clear(color).unwrap();
    }

    /// Draws a message at the center of the screen.
    pub fn draw_message(&mut self, message: &str) {
        let bounding_box = self.display.bounding_box();
        let text_style = MonoTextStyle::new(&PROFONT_24_POINT, Rgb565::BLACK);

        Text::new(
            message,
            bounding_box.center() - Size::new(bounding_box.size.width / 2 - 10, 0),
            text_style,
        )
        .draw(&mut self.display)
        .unwrap();
    }
}
