Second sdcard implementation

Author: yoshiaki-yamada

sdcard/Cargo.toml

@@ -34,6 +34,11 @@ esp-idf-hal = { version = "0.41", optional = true, default-features = false }
 esp-idf-svc = { version = "0.46", optional = true, default-features = false }
 embedded-svc = { version = "0.25", optional = true, default-features = false }
 embedded-sdmmc = "0.5.0"
+anyhow = "1.0.75"
+chrono = { version = "0.4.23", default-features = false, features = ["clock", "std", "wasmbind"] }
+time = "0.3.29"
+simple-ntp = "0.1.1"
+
 
 [build-dependencies]
 embuild = "0.31.2"

sdcard/src/main.rs

@@ -1,17 +1,55 @@
+use chrono::{DateTime, Datelike, Local, LocalResult, TimeZone, Timelike};
 use embedded_sdmmc::{TimeSource, Timestamp};
 use esp_idf_hal::{
     gpio::PinDriver,
     peripherals,
     prelude::*,
     spi::{config, SpiDeviceDriver, SpiDriver, SpiDriverConfig, SPI2},
 };
-use esp_idf_sys as _; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
+use esp_idf_svc::eventloop::EspSystemEventLoop;
+use simple_ntp::sntp;
+mod wifi;
+use wifi::wifi;
 
-struct Clock;
-impl TimeSource for Clock {
-    fn get_timestamp(&self) -> Timestamp {}
+struct NtpClient<'a> {
+    url: &'a str,
+    port: i8,
 }
 
+impl<'a> NtpClient<'a> {
+    fn get_timestamp(&self) -> LocalResult<DateTime<Local>> {
+        // Fetch current time using ntp.
+        let duration =
+            sntp::unix_timestamp(format!("{}:{}", &self.url, &self.port).as_str()).unwrap();
+        println!("Timestamps in local time:");
+        println!("{:?}", duration.as_secs());
+        let seconds = duration.as_secs();
+        chrono::Local.timestamp_opt(seconds as i64, 0)
+    }
+}
+
+struct Clock<'a> {
+    ntp_client: NtpClient<'a>,
+}
+
+impl TimeSource for Clock<'_> {
+    fn get_timestamp(&self) -> Timestamp {
+        let now = &self.ntp_client.get_timestamp().unwrap();
+        Timestamp {
+            year_since_1970: (now.year() - 1970) as u8,
+            zero_indexed_month: now.month0() as u8,
+            zero_indexed_day: now.day0() as u8,
+            hours: now.hour() as u8,
+            minutes: now.minute() as u8,
+            seconds: now.second() as u8,
+        }
+    }
+}
+
+// Please SSID and WIFI_PASSWORD to use wifi.
+const SSID: &str = "";
+const WIFI_PASSWORD: &str = "";
+
 fn main() {
     // 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
@@ -23,6 +61,14 @@ fn main() {
     let gpios = peripherals.pins;
     let pin_cs = PinDriver::output(gpios.gpio4).unwrap();
 
+    // Initialize wifi.
+    let _wifi = wifi(
+        SSID,
+        WIFI_PASSWORD,
+        peripherals.modem,
+        EspSystemEventLoop::take().unwrap(),
+    );
+
     // Initialize SPI interface
     let spi = peripherals.spi2;
     let driver = SpiDriver::new::<SPI2>(
@@ -37,34 +83,56 @@ fn main() {
     let spi_device_config = config::Config::new().baudrate(10.MHz().into());
     let spi_device = SpiDeviceDriver::new(driver, Some(gpios.gpio14), &spi_device_config).unwrap();
 
+    // Following is based on https://github.com/rust-embedded-community/embedded-sdmmc-rs/tree/v0.5.0#using-the-crate
+
     // Build an SD Card interface out of an SPI device, a chip-select pin and a delay object
     let sdcard = embedded_sdmmc::SdCard::new(spi_device, pin_cs, esp_idf_hal::delay::FreeRtos);
     // Get the card size (this also triggers card initialisation because it's not been done yet)
     println!("Card size is {} bytes", sdcard.num_bytes().unwrap());
     // Now let's look for volumes (also known as partitions) on our block device.
     // To do this we need a Volume Manager. It will take ownership of the block device.
-    let mut volume_mgr = embedded_sdmmc::VolumeManager::new(sdcard, time_source);
+    let mut volume_mgr = embedded_sdmmc::VolumeManager::new(
+        sdcard,
+        Clock {
+            ntp_client: NtpClient {
+                url: "time.google.com",
+                port: 123,
+            },
+        },
+    );
+
     // Try and access Volume 0 (i.e. the first partition).
     // The volume object holds information about the filesystem on that volume.
     // It doesn't hold a reference to the Volume Manager and so must be passed back
     // to every Volume Manager API call. This makes it easier to handle multiple
     // volumes in parallel.
-    let volume0 = volume_mgr.get_volume(embedded_sdmmc::VolumeIdx(0))?;
+    let mut volume0 = volume_mgr.get_volume(embedded_sdmmc::VolumeIdx(0)).unwrap();
     println!("Volume 0: {:?}", volume0);
     // Open the root directory (passing in the volume we're using).
-    let root_dir = volume_mgr.open_root_dir(&volume0)?;
+    let root_dir = volume_mgr.open_root_dir(&volume0).unwrap();
     // Open a file called "MY_FILE.TXT" in the root directory
-    let my_file = volume_mgr
-        .open_file_in_dir(root_dir, "MY_FILE.TXT", embedded_sdmmc::Mode::ReadOnly)
-        .unwrap();
-    // Print the contents of the file
-    while !volume_mgr.file_eof(my_file).unwrap() {
-        let mut buffer = [0u8; 32];
-        let num_read = volume_mgr.read(&volume0, &mut my_file, &mut buffer)?;
-        for b in &buffer[0..num_read] {
-            print!("{}", *b as char);
+    let my_file = volume_mgr.open_file_in_dir(
+        &mut volume0,
+        &root_dir,
+        "MY_FILE.TXT",
+        embedded_sdmmc::Mode::ReadOnly,
+    );
+
+    match my_file {
+        Ok(mut f) => {
+            // Print the contents of the file
+            while !f.eof() {
+                let mut buffer = [0u8; 32];
+                let num_read = volume_mgr.read(&volume0, &mut f, &mut buffer).unwrap();
+                for b in &buffer[0..num_read] {
+                    print!("{}", *b as char);
+                }
+            }
+            let _ = volume_mgr.close_file(&volume0, f);
+            volume_mgr.close_dir(&volume0, root_dir);
+        }
+        Err(error) => {
+            println!("Error happen while opening file {:?}", error);
         }
     }
-    volume_mgr.close_file(&volume0, my_file);
-    volume_mgr.close_dir(&volume0, root_dir);
 }

sdcard/src/wifi.rs

@@ -0,0 +1,84 @@
+// Following is based on https://github.com/esp-rs/std-training/blob/main/common/lib/wifi/src/lib.rs
+
+use anyhow::{bail, Result};
+use embedded_svc::wifi::{
+    AccessPointConfiguration, AuthMethod, ClientConfiguration, Configuration,
+};
+use esp_idf_hal::peripheral;
+use esp_idf_svc::eventloop::EspSystemEventLoop;
+use esp_idf_svc::{wifi::BlockingWifi, wifi::EspWifi};
+use log::info;
+
+pub fn wifi(
+    ssid: &str,
+    pass: &str,
+    modem: impl peripheral::Peripheral<P = esp_idf_hal::modem::Modem> + 'static,
+    sysloop: EspSystemEventLoop,
+) -> Result<Box<EspWifi<'static>>> {
+    let mut auth_method = AuthMethod::WPA2Personal;
+    if ssid.is_empty() {
+        bail!("Missing WiFi name")
+    }
+    if pass.is_empty() {
+        auth_method = AuthMethod::None;
+        info!("Wifi password is empty");
+    }
+    let mut esp_wifi = EspWifi::new(modem, sysloop.clone(), None)?;
+
+    let mut wifi = BlockingWifi::wrap(&mut esp_wifi, sysloop)?;
+
+    wifi.set_configuration(&Configuration::Client(ClientConfiguration::default()))?;
+
+    info!("Starting wifi...");
+
+    wifi.start()?;
+
+    info!("Scanning...");
+
+    let ap_infos = wifi.scan()?;
+
+    let ours = ap_infos.into_iter().find(|a| a.ssid == ssid);
+
+    let channel = if let Some(ours) = ours {
+        info!(
+            "Found configured access point {} on channel {}",
+            ssid, ours.channel
+        );
+        Some(ours.channel)
+    } else {
+        info!(
+            "Configured access point {} not found during scanning, will go with unknown channel",
+            ssid
+        );
+        None
+    };
+
+    wifi.set_configuration(&Configuration::Mixed(
+        ClientConfiguration {
+            ssid: ssid.into(),
+            password: pass.into(),
+            channel,
+            auth_method,
+            ..Default::default()
+        },
+        AccessPointConfiguration {
+            ssid: "aptest".into(),
+            channel: channel.unwrap_or(1),
+            ..Default::default()
+        },
+    ))?;
+
+    info!("Connecting wifi...");
+
+    wifi.connect()?;
+
+    info!("Waiting for DHCP lease...");
+
+    wifi.wait_netif_up()?;
+
+    let ip_info = wifi.wifi().sta_netif().get_ip_info()?;
+
+    info!("Wifi DHCP info: {:?}", ip_info);
+
+    Ok(Box::new(esp_wifi))
+}