wincwifi 0.2.1

WINC1500 Wifi chip embedded driver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use super::AsyncClient;
use super::StackError;
use crate::stack::socket_callbacks::WifiModuleState;
use crate::transfer::Xfer;

// todo: deduplicate this
// 1 minute max, if no other delays are added
const AP_CONNECT_TIMEOUT_MILLISECONDS: u32 = 60_000;

impl<X: Xfer> AsyncClient<'_, X> {
    pub async fn start_wifi_module(&mut self) -> Result<(), StackError> {
        if self.callbacks.borrow().state != WifiModuleState::Reset {
            return Err(StackError::InvalidState);
        }
        self.callbacks.borrow_mut().state = WifiModuleState::Starting;
        self.manager.borrow_mut().set_crc_state(true);

        let mut state = Default::default();
        loop {
            let result = self
                .manager
                .borrow_mut()
                .boot_the_chip(&mut state)
                .map_err(StackError::WincWifiFail)?;
            if result {
                self.callbacks.borrow_mut().state = WifiModuleState::Unconnected;
                return Ok(());
            }
            self.dispatch_events()?;
            self.yield_once().await; // todo: busy loop, maybe should delay here
        }
    }
    pub async fn connect_to_saved_ap(&mut self) -> Result<(), StackError> {
        if matches!(
            self.callbacks.borrow().state,
            WifiModuleState::Reset | WifiModuleState::Starting
        ) {
            return Err(StackError::InvalidState);
        }
        let mut countdown = AP_CONNECT_TIMEOUT_MILLISECONDS;
        self.callbacks.borrow_mut().state = WifiModuleState::ConnectingToAp;
        self.manager.borrow_mut().send_default_connect()?;
        loop {
            countdown -= 1;
            if countdown == 0 {
                return Err(StackError::GeneralTimeout);
            }
            let read_state = self.callbacks.borrow().state.clone();
            match read_state {
                WifiModuleState::ConnectionFailed => {
                    let mut callbacks = self.callbacks.borrow_mut();
                    let res = callbacks.connection_state.conn_error.take().unwrap();
                    return Err(StackError::ApJoinFailed(res));
                }
                WifiModuleState::ConnectedToAp => {
                    return Ok(());
                }
                _ => {}
            }
            self.dispatch_events()?;
            self.yield_once().await;
        }
    }
}