DNS server configuration + AP

src/asynch/control.rs

@@ -182,7 +182,7 @@
         Ok(mac.to_be_bytes()[2..].try_into().unwrap())
     }
 
-    async fn get_wifi_status(&self) -> Result<WifiStatusVal, Error> {
+    pub async fn get_wifi_status(&self) -> Result<WifiStatusVal, Error> {
         match (&self.at_client)
             .send_retry(&GetWifiStatus {
                 status_id: StatusId::Status,
@@ -333,32 +333,56 @@
                     ap_config_param: AccessPointConfig::IPv4Mode(IPv4Mode::Static),
                 })
                 .await?;
-        }
 
-        // Network IP address
-        if let Some(ip) = options.ip {
             (&self.at_client)
                 .send_retry(&SetWifiAPConfig {
                     ap_config_id: AccessPointId::Id0,
-                    ap_config_param: AccessPointConfig::IPv4Address(ip),
+                    ap_config_param: AccessPointConfig::IPv4Address(
+                        options.ip.unwrap_or(Ipv4Addr::new(192, 168, 2, 1)),
+                    ),
                 })
                 .await?;
-        }
-        // Network Subnet mask
-        if let Some(subnet) = options.subnet {
+
             (&self.at_client)
                 .send_retry(&SetWifiAPConfig {
                     ap_config_id: AccessPointId::Id0,
-                    ap_config_param: AccessPointConfig::SubnetMask(subnet),
+                    ap_config_param: AccessPointConfig::SubnetMask(
+                        options.subnet.unwrap_or(Ipv4Addr::new(255, 255, 255, 0)),
+                    ),
+                })
+                .await?;
+
+            (&self.at_client)
+                .send_retry(&SetWifiAPConfig {
+                    ap_config_id: AccessPointId::Id0,
+                    ap_config_param: AccessPointConfig::DefaultGateway(
+                        options.gateway.unwrap_or(Ipv4Addr::new(192, 168, 2, 1)),
+                    ),
                 })
                 .await?;
         }
-        // Network Default gateway
-        if let Some(gateway) = options.gateway {
+
+        // Network Primary + Secondary DNS
+        let primary = match options.dns.as_slice() {
+            &[primary] => Some(primary),
+            &[primary, secondary] => {
+                (&self.at_client)
+                    .send_retry(&SetWifiAPConfig {
+                        ap_config_id: AccessPointId::Id0,
+                        ap_config_param: AccessPointConfig::SecondaryDNS(secondary),
+                    })
+                    .await?;
+
+                Some(primary)
+            }
+            _ => None,
+        };
+
+        if let Some(primary) = primary {
             (&self.at_client)
                 .send_retry(&SetWifiAPConfig {
                     ap_config_id: AccessPointId::Id0,
-                    ap_config_param: AccessPointConfig::DefaultGateway(gateway),
+                    ap_config_param: AccessPointConfig::PrimaryDNS(primary),
                 })
                 .await?;
         }
@@ -445,11 +469,16 @@
             })
             .await?;
 
+        self.state_ch.set_should_connect(true);
+
         Ok(())
     }
 
     /// Closes access point.
     pub async fn close_ap(&self) -> Result<(), Error> {
+        self.state_ch.wait_for_initialized().await;
+        self.state_ch.set_should_connect(false);
+
         (&self.at_client)
             .send_retry(&WifiAPAction {
                 ap_config_id: AccessPointId::Id0,

src/asynch/network.rs

@@ -1,21 +1,20 @@
-use core::str::FromStr as _;
-
 use atat::{asynch::AtatClient, UrcChannel, UrcSubscription};
+use core::str::FromStr as _;
 use embassy_time::{with_timeout, Duration, Timer};
 use embedded_hal::digital::OutputPin as _;
 use no_std_net::{Ipv4Addr, Ipv6Addr};
 
 use crate::{
     command::{
         network::{
-            responses::NetworkStatusResponse,
-            types::{InterfaceType, NetworkStatus, NetworkStatusParameter},
+            responses::{APStatusResponse, NetworkStatusResponse},
+            types::{APStatusParameter, InterfaceType, NetworkStatus, NetworkStatusParameter},
             urc::{NetworkDown, NetworkUp},
-            GetNetworkStatus,
+            GetAPStatus, GetNetworkStatus,
         },
         system::{RebootDCE, StoreCurrentConfig},
         wifi::{
-            types::DisconnectReason,
+            types::{AccessPointStatus, DisconnectReason},
             urc::{WifiLinkConnected, WifiLinkDisconnected},
         },
         Urc,
@@ -56,22 +55,22 @@
 
     pub async fn run(&mut self) -> Result<(), Error> {
         loop {
             match embassy_futures::select::select(
                 self.urc_subscription.next_message_pure(),
                 self.ch.wait_for_wifi_state_change(),
             )
             .await
             {
                 embassy_futures::select::Either::First(event) => {
                     #[cfg(feature = "edm")]
                     let Some(event) = event.extract_urc() else {
                         continue;
                     };
 
                     self.handle_urc(event).await?;
                 }
                 _ => {}
             }
 
             if self.ch.wifi_state(None) == WiFiState::Inactive && self.ch.connection_down(None) {
                 return Ok(());
@@ -88,12 +87,16 @@
                 connection_id: _,
                 bssid,
                 channel,
-            }) => self.ch.update_connection_with(|con| {
-                con.wifi_state = WiFiState::Connected;
-                con.network
-                    .replace(WifiNetwork::new_station(bssid, channel));
-            }),
+            }) => {
+                info!("wifi link connected");
+                self.ch.update_connection_with(|con| {
+                    con.wifi_state = WiFiState::Connected;
+                    con.network
+                        .replace(WifiNetwork::new_station(bssid, channel));
+                })
+            }
             Urc::WifiLinkDisconnected(WifiLinkDisconnected { reason, .. }) => {
+                info!("Wifi link disconnected");
                 self.ch.update_connection_with(|con| {
                     con.wifi_state = match reason {
                         DisconnectReason::NetworkDisabled => {
@@ -109,19 +112,33 @@
                     }
                 })
             }
-            Urc::WifiAPUp(_) => warn!("Not yet implemented [WifiAPUp]"),
-            Urc::WifiAPDown(_) => warn!("Not yet implemented [WifiAPDown]"),
+            Urc::WifiAPUp(_) => self.ch.update_connection_with(|con| {
+                con.wifi_state = WiFiState::Connected;
+                con.network.replace(WifiNetwork::new_ap());
+            }),
+            Urc::WifiAPDown(_) => self.ch.update_connection_with(|con| {
+                con.network.take();
+                con.wifi_state = WiFiState::Inactive;
+            }),
             Urc::WifiAPStationConnected(_) => warn!("Not yet implemented [WifiAPStationConnected]"),
             Urc::WifiAPStationDisconnected(_) => {
                 warn!("Not yet implemented [WifiAPStationDisconnected]")
             }
             Urc::EthernetLinkUp(_) => warn!("Not yet implemented [EthernetLinkUp]"),
             Urc::EthernetLinkDown(_) => warn!("Not yet implemented [EthernetLinkDown]"),
             Urc::NetworkUp(NetworkUp { interface_id }) => {
-                self.network_status_callback(interface_id).await?;
+                if interface_id > 10 {
+                    self.ap_status_callback().await?;
+                } else {
+                    self.network_status_callback(interface_id).await?;
+                }
             }
             Urc::NetworkDown(NetworkDown { interface_id }) => {
-                self.network_status_callback(interface_id).await?;
+                if interface_id > 10 {
+                    self.ap_status_callback().await?;
+                } else {
+                    self.network_status_callback(interface_id).await?;
+                }
             }
             Urc::NetworkError(_) => warn!("Not yet implemented [NetworkError]"),
             _ => {}
@@ -137,6 +154,7 @@
         // credentials have been restored from persistent memory. This although
         // the wifi station has been started. So we assume that this type is
         // also ok.
+        info!("Entered network_status_callback");
         let NetworkStatusResponse {
             status:
                 NetworkStatus::InterfaceType(InterfaceType::WifiStation | InterfaceType::Unknown),
@@ -165,12 +183,17 @@
         else {
             return Err(Error::Network);
         };
+        info!(
+            "Network status callback ipv4: {:?}",
+            core::str::from_utf8(&ipv4).ok()
+        );
 
         let ipv4_up = core::str::from_utf8(ipv4.as_slice())
             .ok()
             .and_then(|s| Ipv4Addr::from_str(s).ok())
             .map(|ip| !ip.is_unspecified())
             .unwrap_or_default();
+        info!("Network status callback ipv4: {:?}", ipv4_up);
 
         #[cfg(feature = "ipv6")]
         let ipv6_up = {
@@ -208,13 +231,19 @@
         else {
             return Err(Error::Network);
         };
+        info!(
+            "Network status callback ipv6: {:?}",
+            core::str::from_utf8(&ipv6_link_local).ok()
+        );
 
         let ipv6_link_local_up = core::str::from_utf8(ipv6_link_local.as_slice())
             .ok()
             .and_then(|s| Ipv6Addr::from_str(s).ok())
             .map(|ip| !ip.is_unspecified())
             .unwrap_or_default();
 
+        info!("Network status callback ipv6: {:?}", ipv6_link_local_up);
+
         // Use `ipv4_addr` & `ipv6_addr` to determine link state
         self.ch.update_connection_with(|con| {
             con.ipv6_link_local_up = ipv6_link_local_up;
@@ -229,6 +258,36 @@
         Ok(())
     }
 
+    async fn ap_status_callback(&mut self) -> Result<(), Error> {
+        let APStatusResponse {
+            status_val: AccessPointStatus::Status(ap_status),
+            ..
+        } = self
+            .at_client
+            .send_retry(&GetAPStatus {
+                status_id: APStatusParameter::Status,
+            })
+            .await?
+        else {
+            return Err(Error::Network);
+        };
+        info!("AP status callback Status: {:?}", ap_status);
+
+        let ap_status = ap_status.into();
+
+        self.ch.update_connection_with(|con| {
+            con.ipv6_link_local_up = ap_status;
+            con.ipv4_up = ap_status;
+
+            #[cfg(feature = "ipv6")]
+            {
+                con.ipv6_up = ap_status;
+            }
+        });
+
+        Ok(())
+    }
+
     async fn wait_startup(&mut self, timeout: Duration) -> Result<(), Error> {
         let fut = async {
             loop {

src/command/network/mod.rs

@@ -9,6 +9,16 @@ use types::*;
 
 use super::NoResponse;
 
+/// 7.10 Wi-Fi Acess point status +UWAPSTAT
+///
+/// Read status of Wi-Fi interface id.
+#[derive(Clone, AtatCmd)]
+#[at_cmd("+UWAPSTAT", APStatusResponse, attempts = 3, timeout_ms = 1000)]
+pub struct GetAPStatus {
+    #[at_arg(position = 0)]
+    pub status_id: APStatusParameter,
+}
+
 /// 10.1 Network host name +UNHN
 ///
 /// Sets a new host name.

src/command/network/responses.rs

@@ -1,7 +1,15 @@
 //! Responses for Network Commands
+use crate::command::wifi::types::AccessPointStatus;
+
 use super::types::*;
 use atat::atat_derive::AtatResp;
 
+/// 7.10 WiFi AP status +UWAPSTAT
+#[derive(Clone, AtatResp)]
+pub struct APStatusResponse {
+    pub status_val: AccessPointStatus,
+}
+
 /// 10.2 Network status +UNSTAT
 #[derive(Clone, AtatResp)]
 pub struct NetworkStatusResponse {

src/command/network/types.rs

@@ -7,6 +7,39 @@
 
 use crate::command::OnOff;
 
+#[derive(Clone, PartialEq, AtatEnum)]
+pub enum APStatus {
+    // 0: The <status_val> is the currently used SSID.
+    #[at_arg(value = 0)]
+    SSID(String<64>),
+    // 1: The <status_val> is the currently used BSSID.
+    #[at_arg(value = 1)]
+    BSSID(#[at_arg(len = 20)] Bytes<20>),
+    // 2: The <status_val> is the currently used channel.
+    #[at_arg(value = 2)]
+    Channel(u8),
+    // 3: The <status_val> is the current status of the access point.
+    // - 0: disabled
+    // - 1: enabled
+    #[at_arg(value = 3)]
+    Status(OnOff),
+}
+
+#[derive(Clone, PartialEq, AtatEnum)]
+#[repr(u8)]
+pub enum APStatusParameter {
+    // 0: The <status_val> is the currently used SSID.
+    SSID = 0,
+    // 1: The <status_val> is the currently used BSSID.
+    BSSID = 1,
+    // 2: The <status_val> is the currently used channel.
+    Channel = 2,
+    // 3: The <status_val> is the current status of the access point.
+    // • 0: disabled
+    // • 1: enabled
+    Status = 3,
+}
+
 #[derive(Clone, PartialEq, AtatEnum)]
 pub enum NetworkStatus {
     /// 0: The <status_val> is the interface hardware address (displayed only if applicable).
@@ -25,7 +58,7 @@
     /// - 4: PPP
     /// - 5: Bridge
     /// - 6: Bluetooth PAN - This interface type is supported by ODIN-W2 from software
     /// version 5.0.0 onwards only.
     #[at_arg(value = 2)]
     InterfaceType(InterfaceType),
     /// 101: The <status_val> is the currently used IPv4_Addr (omitted if no IP address has
@@ -80,7 +113,7 @@
     /// - 4: PPP
     /// - 5: Bridge
     /// - 6: Bluetooth PAN - This interface type is supported by ODIN-W2 from software
     /// version 5.0.0 onwards only.
     InterfaceType = 2,
     /// 101: The <status_val> is the currently used IPv4_Addr (omitted if no IP address has
     /// been acquired).
@@ -159,9 +192,9 @@
     /// - 2: Wi-Fi Access Point
     /// - 3: Ethernet
     /// - 6: Bluetooth PAN - This interface is supported by ODIN-W2 from software version
     /// 6.0.0 onwards only.
     /// For example, AT+UBRGC = 0,1,1,3. This adds the Wi-Fi station and Ethernet
     /// interfaces to the bridge.
     #[at_arg(value = 1)]
     LinkLayerList(Option<u8>, Option<u8>, Option<u8>, Option<u8>),
     /// IP interface list. This list defines the interfaces that accept IP
@@ -171,9 +204,9 @@
     /// - 2: Wi-Fi Access Point
     /// - 3: Ethernet
     /// - 6: Bluetooth PAN - This interface is supported by ODIN-W2 from software version
     /// 6.0.0 onwards only.
     /// For example, AT+UBRGC = 0,2,1,3. This allows the Wi-Fi station and Ethernet
     /// interfaces to accept IP traffic.
     #[at_arg(value = 2)]
     IPInterfaceList(Option<u8>, Option<u8>, Option<u8>, Option<u8>),
     /// IPv4 Mode - <param_val1> to set the way to retrieve an IP address
@@ -201,8 +234,8 @@
     /// <param_val> is the DHCP server configuration.
     /// - 0 (default): Disable DHCP server
     /// - 1: Enable DHCP server. The DHCP Server will provide addresses according to the
     /// following formula - "(Static address and subnet mask) + 100". If DHCP Server is
     /// enabled, the IPv4 Mode should be set to static.
     #[at_arg(value = 106)]
     DHCPServer(OnOff),
     /// Address conflict detection. The factory default value is 0 (disabled). This tag is
@@ -230,11 +263,11 @@
     Load = 2,
     /// Validates and activates the configuration.
     /// - When a bridge is activated, the data on all network interfaces connected to
     /// the bridge is handled by the bridge. The IP configuration set in the individual
     /// network interface configurations is not used while the IP configuration of the
     /// bridge is used.
     /// - The MAC address of the bridge will be set to the Ethernet MAC address but
     /// with the U/L bit set to 1 for a locally administered address.
     Activate = 3,
     /// Deactivates the configuration. After deactivating a bridge
     /// configuration, the network interfaces connected to the bridge must be deactivated

src/connection.rs

@@ -50,15 +50,13 @@
         }
     }
 
-    #[allow(dead_code)]
     pub fn is_station(&self) -> bool {
         self.network
             .as_ref()
             .map(|n| n.mode == WifiMode::Station)
             .unwrap_or_default()
     }
 
-    #[allow(dead_code)]
     pub fn is_access_point(&self) -> bool {
         !self.is_station()
     }

src/network.rs

@@ -44,6 +44,20 @@ impl WifiNetwork {
             mode: WifiMode::Station,
         }
     }
+
+    pub fn new_ap() -> Self {
+        Self {
+            bssid: Bytes::new(),
+            op_mode: OperationMode::Infrastructure,
+            ssid: String::new(),
+            channel: 0,
+            rssi: 1,
+            authentication_suites: 0,
+            unicast_ciphers: 0,
+            group_ciphers: 0,
+            mode: WifiMode::AccessPoint,
+        }
+    }
 }
 
 impl TryFrom<ScannedWifiNetwork> for WifiNetwork {