st67w611 0.1.0

Async no_std driver for ST67W611 WiFi modules using Embassy framework
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Error types for the ST67W611 driver

use core::fmt;

/// Driver error types
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Error {
    /// SPI communication error
    Spi,

    /// AT command timeout
    Timeout,

    /// AT command failed (received ERROR response)
    AtCommandFailed,

    /// Invalid AT response format
    InvalidResponse,

    /// Buffer too small for operation
    BufferTooSmall,

    /// Invalid parameter provided
    InvalidParameter,

    /// Operation not supported
    NotSupported,

    /// WiFi not connected
    NotConnected,

    /// WiFi connection failed
    ConnectionFailed,

    /// Network operation failed
    NetworkError,

    /// Socket operation failed
    SocketError,

    /// Socket not available (pool exhausted)
    NoSocketAvailable,

    /// Invalid socket ID
    InvalidSocket,

    /// Socket already in use
    SocketInUse,

    /// TLS/SSL error
    TlsError,

    /// Certificate error
    CertificateError,

    /// MQTT operation failed
    MqttError,

    /// HTTP operation failed
    HttpError,

    /// Response slot pool exhausted
    NoResponseSlot,

    /// Parse error
    ParseError,

    /// Invalid state for operation
    InvalidState,

    /// Resource busy
    Busy,

    /// Operation would block
    WouldBlock,

    /// Unknown error
    Unknown,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::Spi => write!(f, "SPI communication error"),
            Error::Timeout => write!(f, "Operation timeout"),
            Error::AtCommandFailed => write!(f, "AT command failed"),
            Error::InvalidResponse => write!(f, "Invalid AT response"),
            Error::BufferTooSmall => write!(f, "Buffer too small"),
            Error::InvalidParameter => write!(f, "Invalid parameter"),
            Error::NotSupported => write!(f, "Operation not supported"),
            Error::NotConnected => write!(f, "WiFi not connected"),
            Error::ConnectionFailed => write!(f, "Connection failed"),
            Error::NetworkError => write!(f, "Network error"),
            Error::SocketError => write!(f, "Socket error"),
            Error::NoSocketAvailable => write!(f, "No socket available"),
            Error::InvalidSocket => write!(f, "Invalid socket ID"),
            Error::SocketInUse => write!(f, "Socket already in use"),
            Error::TlsError => write!(f, "TLS/SSL error"),
            Error::CertificateError => write!(f, "Certificate error"),
            Error::MqttError => write!(f, "MQTT error"),
            Error::HttpError => write!(f, "HTTP error"),
            Error::NoResponseSlot => write!(f, "No response slot available"),
            Error::ParseError => write!(f, "Parse error"),
            Error::InvalidState => write!(f, "Invalid state"),
            Error::Busy => write!(f, "Resource busy"),
            Error::WouldBlock => write!(f, "Operation would block"),
            Error::Unknown => write!(f, "Unknown error"),
        }
    }
}


/// Result type alias using driver Error
pub type Result<T> = core::result::Result<T, Error>;

/// Convert from embedded-hal SPI errors
impl<E> From<E> for Error
where
    E: embedded_hal::spi::Error,
{
    fn from(_: E) -> Self {
        Error::Spi
    }
}

// Note: We don't implement From<embassy_time::TimeoutError> directly
// to avoid potential conflicts with the generic From<E> impl above.