WIP

esp/rust/03_aht20/Cargo.toml

@@ -25,6 +25,11 @@ experimental = ["esp-idf-svc/experimental"]
 [dependencies]
 log = "0.4"
 esp-idf-svc = "0.51"
+embedded-hal = "1.0.0"
+esp-backtrace = "0.17.0"
+esp-hal = { version = "1.0.0-rc.0", features = ["unstable"] }
+fugit = "0.3.7"
+esp-println = { version = "0.15.0", features = ["log-04"] }
 
 # --- Optional Embassy Integration ---
 # esp-idf-svc = { version = "0.51", features = ["critical-section", "embassy-time-driver", "embassy-sync"] }

esp/rust/03_aht20/src/main.rs

@@ -1,10 +1,152 @@
-fn main() {
+#![no_std]
-    // It is necessary to call this function once. Otherwise some patches to the runtime
+#![no_main]
-    // 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
+/// Represents a reading from the sensor.
-    esp_idf_svc::log::EspLogger::initialize_default();
+pub struct SensorReading<T> {
-
+    pub humidity: T,
-    log::info!("Hello, world!");
+    pub temperature: T,
+}
+
+/// Possible errors when interacting with the sensor.
+#[derive(Debug)]
+pub enum SensorError {
+    ChecksumMismatch,
+    Timeout,
+    PinError,
+}
+
+// pub struct Dht20<I: I2cEmbedded, D: DelayNs> {
+//     pub i2c: I,
+//     pub delay: D,
+// }
+//
+// impl<I: I2cEmbedded, D: DelayNs> Dht20<I, D> {
+//     const SENSOR_ADDRESS: u8 = 0x38;
+//
+//     pub fn new(i2c: I, delay: D) -> Self {
+//         Self { i2c, delay }
+//     }
+//
+//     pub fn read(&mut self) -> Result<SensorReading<f32>, SensorError> {
+//         // Check status
+//         let mut status_response: [u8; 1] = [0; 1];
+//         let _ = self
+//             .i2c
+//             .write_read(Self::SENSOR_ADDRESS, &[0x71], &mut status_response);
+//
+//         // Calibration if needed
+//         if status_response[0] & 0x18 != 0x18 {
+//             let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0x1B, 0, 0]);
+//             let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0x1C, 0, 0]);
+//             let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0x1E, 0, 0]);
+//         }
+//
+//         // Trigger the measurement
+//         self.delay.delay_ms(10);
+//         let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0xAC, 0x33, 0x00]);
+//
+//         // Read the measurement status
+//         self.delay.delay_ms(80);
+//         loop {
+//             let mut measurement_status_response: [u8; 1] = [0; 1];
+//             let _ = self
+//                 .i2c
+//                 .read(Self::SENSOR_ADDRESS, &mut measurement_status_response);
+//             let status_word = measurement_status_response[0];
+//             if status_word & 0b1000_0000 == 0 {
+//                 break;
+//             }
+//             self.delay.delay_ms(1);
+//         }
+//
+//         // Read the measurement (1 status + 5 data + 1 crc)
+//         let mut measurement_response: [u8; 7] = [0; 7];
+//         let _ = self
+//             .i2c
+//             .read(Self::SENSOR_ADDRESS, &mut measurement_response);
+//
+//         // Humidity 20 bits (8 + 8 + 4)
+//         let mut raw_humidity = measurement_response[1] as u32;
+//         raw_humidity = (raw_humidity << 8) + measurement_response[2] as u32;
+//         raw_humidity = (raw_humidity << 4) + (measurement_response[3] >> 4) as u32;
+//         let humidity_percentage = (raw_humidity as f32 / ((1 << 20) as f32)) * 100.0;
+//
+//         // Temperature 20 bits
+//         let mut raw_temperature = (measurement_response[3] & 0b1111) as u32;
+//         raw_temperature = (raw_temperature << 8) + measurement_response[4] as u32;
+//         raw_temperature = (raw_temperature << 8) + measurement_response[5] as u32;
+//         let temperature_percentage = (raw_temperature as f32 / ((1 << 20) as f32)) * 200.0 - 50.0;
+//
+//         // Compare the calculated CRC with the received CRC
+//         let data = &measurement_response[..6];
+//         let received_crc = measurement_response[6];
+//         let calculated_crc = Self::calculate_crc(data);
+//         if received_crc != calculated_crc {
+//             return Err(SensorError::ChecksumMismatch);
+//         }
+//
+//         Ok(SensorReading {
+//             humidity: humidity_percentage,
+//             temperature: temperature_percentage,
+//         })
+//     }
+//
+//     fn calculate_crc(data: &[u8]) -> u8 {
+//         let polynomial = 0x31u8; // x^8 + x^5 + x^4 + 1
+//         let mut crc = 0xFFu8;
+//
+//         for &byte in data {
+//             crc ^= byte;
+//             // CRC8 - process every bit
+//             for _ in 0..8 {
+//                 if crc & 0x80 != 0 {
+//                     crc = (crc << 1) ^ polynomial;
+//                 } else {
+//                     crc <<= 1;
+//                 }
+//             }
+//         }
+//
+//         crc
+//     }
+// }
+//
+use embedded_hal::{delay::DelayNs, i2c::I2c as I2cEmbedded};
+use esp_backtrace as _;
+use esp_hal::{
+    clock::CpuClock,
+    delay::Delay,
+    gpio::{Level, Pull},
+    i2c::master::I2c,
+    xtensa_lx_rt::entry,
+};
+use fugit::{ExtU64, HertzU32};
+
+#[entry]
+fn main() -> ! {
+    // let peripherals = esp_hal::init(esp_hal::Config::default());
+    // esp_println::logger::init_logger_from_env();
+    // let mut delay = Delay::new();
+    //
+    // // TODO: Remove unwrap
+    // let i2c_for_dht20 =
+    //     esp_hal::i2c::master::I2c::new(peripherals.I2C0, esp_hal::i2c::master::Config::default())
+    //         .unwrap()
+    //         .with_sda(peripherals.pins.gpio21)
+    //         .with_scl(peripherals.pins.gpio22);
+    // let mut dht20 = Dht20::new(i2c_for_dht20, delay);
+    //
+    // loop {
+    //     delay.delay_ms(5000);
+    //     match dht20.read() {
+    //         Ok(sensor_reading) => log::info!(
+    //             "DHT 20 Sensor - Temperature: {} °C, humidity: {} %",
+    //             sensor_reading.temperature,
+    //             sensor_reading.humidity
+    //         ),
+    //         Err(error) => log::error!("An error occurred while trying to read sensor: {:?}", error),
+    //     }
+    //
+    //     log::info!("-----");
+    // }
 }