simx00x 0.1.0

A no-std and no-alloc driver for SIM800L GSM modules (and probably similar modules)
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

/// SIM module configuration.
pub struct Config<'a, const QUEUE_LEN: usize> {
    pub sim_card_pin: Option<&'a str>,
    pub auto_reset_when_stalled: bool,

    // CALLBACKS
    /// Function called when the watchdog detects that the module is stalled
    pub module_stalled_callback: Option<&'a mut dyn FnMut() -> bool>,
    /// Function called when the module has been fully powered down
    pub module_powered_down_callback: Option<&'a mut dyn FnMut()>,
    /// Function called when a new SMS is received
    pub received_sms_callback: Option<&'a mut dyn FnMut(&str, &str)>,
    /// Function called when a call is received
    pub received_call_callback: Option<&'a mut dyn FnMut(&str) -> bool>,
    /// Function called when a call is connected
    pub call_connected_callback: Option<&'a mut dyn FnMut()>,
    /// Function called when a call is disconnected
    pub call_disconnected_callback: Option<&'a mut dyn FnMut()>,
    /// Function called when a USSD is received
    pub received_ussd_callback: Option<&'a mut dyn FnMut(&str)>,
}

impl<'a> Default for Config<'a, 10> {
    fn default() -> Self {
        Self {
            sim_card_pin: None,
            auto_reset_when_stalled: true,
            module_stalled_callback: None,
            module_powered_down_callback: None,
            received_sms_callback: None,
            received_call_callback: None,
            call_connected_callback: None,
            call_disconnected_callback: None,
            received_ussd_callback: None,
        }
    }
}

impl<'a, const QUEUE_LEN: usize> Config<'a, QUEUE_LEN> {
    pub fn new() -> Self {
        Self {
            sim_card_pin: None,
            auto_reset_when_stalled: true,
            module_stalled_callback: None,
            module_powered_down_callback: None,
            received_sms_callback: None,
            received_call_callback: None,
            call_connected_callback: None,
            call_disconnected_callback: None,
            received_ussd_callback: None,
        }
    }

    pub fn with_sim_card_pin(mut self, pin: &'a str) -> Self {
        self.sim_card_pin = Some(pin);
        self
    }

    pub fn with_auto_reset_when_stalled(mut self, auto_reset: bool) -> Self {
        self.auto_reset_when_stalled = auto_reset;
        self
    }

    pub fn with_module_stalled_callback(mut self, callback: &'a mut impl FnMut() -> bool) -> Self {
        self.module_stalled_callback = Some(callback);
        self
    }

    pub fn with_module_powered_down_callback(mut self, callback: &'a mut impl FnMut()) -> Self {
        self.module_powered_down_callback = Some(callback);
        self
    }

    pub fn with_received_sms_callback(mut self, callback: &'a mut impl FnMut(&str, &str)) -> Self {
        self.received_sms_callback = Some(callback);
        self
    }

    pub fn with_received_call_callback(
        mut self,
        callback: &'a mut impl FnMut(&str) -> bool,
    ) -> Self {
        self.received_call_callback = Some(callback);
        self
    }

    pub fn with_call_connected_callback(mut self, callback: &'a mut impl FnMut()) -> Self {
        self.call_connected_callback = Some(callback);
        self
    }

    pub fn with_call_disconnected_callback(mut self, callback: &'a mut impl FnMut()) -> Self {
        self.call_disconnected_callback = Some(callback);
        self
    }

    pub fn with_received_ussd_callback(mut self, callback: &'a mut impl FnMut(&str)) -> Self {
        self.received_ussd_callback = Some(callback);
        self
    }
}