137 lines
4.0 KiB
Rust
137 lines
4.0 KiB
Rust
use alloc::string::String;
|
|
use crate::network::wifi::WifiCredentials;
|
|
use crate::Mutex;
|
|
use crate::peripherals::storage::Nvs;
|
|
use alloc::sync::Arc;
|
|
use core::error::Error;
|
|
use core::fmt::Display;
|
|
use esp_nvs::Key;
|
|
|
|
const NVS_NAMESPACE_WIFI: Key = Key::from_str("WIFI");
|
|
const NVS_WIFI_SSID_KEY: Key = Key::from_str("WIFI_SSID");
|
|
const NVS_WIFI_PASS_KEY: Key = Key::from_str("WIFI_PASS");
|
|
const NVS_WIFI_INITIALIZED_KEY: Key = Key::from_str("INITIALIZED");
|
|
|
|
#[derive(Debug)]
|
|
pub enum WifiStoreError {
|
|
Store(esp_nvs::error::Error),
|
|
}
|
|
|
|
impl Error for WifiStoreError {}
|
|
|
|
impl Display for WifiStoreError {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
match self {
|
|
WifiStoreError::Store(e) => e.fmt(f),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<esp_nvs::error::Error> for WifiStoreError {
|
|
fn from(error: esp_nvs::error::Error) -> WifiStoreError {
|
|
WifiStoreError::Store(error)
|
|
}
|
|
}
|
|
|
|
pub struct WifiStore {
|
|
nvs: Arc<Mutex<Nvs>>,
|
|
}
|
|
|
|
impl WifiStore {
|
|
pub async fn new(nvs: Arc<Mutex<Nvs>>) -> Result<Self, WifiStoreError> {
|
|
if !Self::is_initialized(&nvs).await? {
|
|
log::info!("WifiStore has not been initialized");
|
|
Self::initialize(&nvs).await?;
|
|
}
|
|
|
|
log::info!("WifiStore has been initialized");
|
|
|
|
Ok(Self { nvs })
|
|
}
|
|
|
|
async fn is_initialized(nvs: &Mutex<Nvs>) -> Result<bool, WifiStoreError> {
|
|
log::info!("check initialization");
|
|
let mut nvs_lock = nvs.lock().await;
|
|
match nvs_lock.get::<bool>(&NVS_NAMESPACE_WIFI, &NVS_WIFI_INITIALIZED_KEY) {
|
|
Ok(initialized) => {
|
|
log::debug!("initialization_check: initialized {initialized:?}");
|
|
return Ok(true);
|
|
}
|
|
Err(esp_nvs::error::Error::NamespaceNotFound) => {
|
|
log::debug!("initialization_check: error: namespace not found");
|
|
return Ok(false);
|
|
}
|
|
Err(esp_nvs::error::Error::KeyNotFound) => {
|
|
log::debug!("initialization_check: error: key not found");
|
|
return Ok(false);
|
|
}
|
|
Err(error) => return Err(error.into()),
|
|
};
|
|
}
|
|
|
|
async fn initialize(nvs: &Mutex<Nvs>) -> Result<(), WifiStoreError> {
|
|
log::info!("initializing wifi store");
|
|
|
|
let mut nvs_lock = nvs.lock().await;
|
|
|
|
log::debug!("initialization: write dummy ssid");
|
|
nvs_lock.set::<&str>(
|
|
&NVS_NAMESPACE_WIFI,
|
|
&NVS_WIFI_SSID_KEY,
|
|
""
|
|
)?;
|
|
|
|
log::debug!("initialization: write dummy pass");
|
|
nvs_lock.set::<&str>(
|
|
&NVS_NAMESPACE_WIFI,
|
|
&NVS_WIFI_PASS_KEY,
|
|
""
|
|
)?;
|
|
|
|
// set initialized
|
|
log::debug!("initialization: write initialized");
|
|
nvs_lock.set::<bool>(
|
|
&NVS_NAMESPACE_WIFI,
|
|
&NVS_WIFI_INITIALIZED_KEY,
|
|
true,
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn load_credentials(&self) -> Result<WifiCredentials, WifiStoreError> {
|
|
log::debug!("loading wifi credentials");
|
|
log::debug!("loading ssid");
|
|
let mut nvs_lock = self.nvs.lock().await;
|
|
let ssid = nvs_lock.get::<String>(&NVS_NAMESPACE_WIFI, &NVS_WIFI_SSID_KEY)?;
|
|
log::debug!("ssid: {ssid}");
|
|
|
|
log::debug!("loading pass");
|
|
let pass = nvs_lock.get::<String>(&NVS_NAMESPACE_WIFI, &NVS_WIFI_PASS_KEY)?;
|
|
log::debug!("pass: {pass}");
|
|
|
|
Ok(WifiCredentials{ssid, pass})
|
|
}
|
|
|
|
pub async fn save_credentials(&self, credentials: &WifiCredentials) -> Result<(), WifiStoreError> {
|
|
log::debug!("writing wifi credentials");
|
|
log::debug!("writing ssid...\nssid: {}", credentials.ssid);
|
|
|
|
self.nvs.lock().await.set::<&str>(
|
|
&NVS_NAMESPACE_WIFI,
|
|
&NVS_WIFI_SSID_KEY,
|
|
&credentials.ssid,
|
|
)?;
|
|
|
|
log::debug!("writing pass...\npass: {}", credentials.pass);
|
|
|
|
self.nvs.lock().await.set::<&str>(
|
|
&NVS_NAMESPACE_WIFI,
|
|
&NVS_WIFI_PASS_KEY,
|
|
&credentials.pass,
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|