]> git.scottworley.com Git - tattlekey/blob - client/tattlekey.c
c38de126d50245cd3a9ba08d128e170b6c23d75c
[tattlekey] / client / tattlekey.c
1 #include "pico/cyw43_arch.h"
2 #include "pico/stdlib.h"
3 #include "pico/util/pheap.h"
4 #include "pico/util/queue.h"
5
6 #include "blink.h"
7 #include "button.h"
8 #include "config.h"
9 #include "net.h"
10
11 typedef struct {
12 uint32_t timestamp;
13 u16_t seq;
14 u8_t send_count;
15 } send_t;
16
17 uint32_t next_send(send_t *s) {
18 return s->timestamp + (1 << s->send_count) - 1;
19 }
20
21 bool next_send_less_than(void *user_data, pheap_node_id_t a,
22 pheap_node_id_t b) {
23 send_t *sends = (send_t *)user_data;
24 return next_send(&sends[a]) < next_send(&sends[b]);
25 }
26
27 enum event_type { BUTTONPRESS, SEND };
28 typedef struct {
29 enum event_type type;
30 union {
31 struct {
32 uint32_t timestamp;
33 } buttonpress;
34 };
35 } event_t;
36
37 queue_t queue;
38
39 uint32_t time_s() { return time_us_64() / 1000000ul; }
40
41 /* Often we don't bother checking for failure (full queue) because
42 * 1. The best thing to do in this unfortunate situation is to blithely
43 * continue, dropping some events; continuing is better than stopping.
44 * 2. Neither interrupt context nor queue-processing context can block
45 * until space is available, or even sit around & blink the LED to
46 * signal a problem.
47 * (We also get a bit of type safety by taking event_t* rather than void*.) */
48 static void queue_try_add_ignoring_errors(queue_t *q, event_t *e) {
49 queue_try_add(q, e);
50 }
51
52 static void button_pressed() {
53 /* This runs in interrupt context; don't linger. */
54 static uint64_t last_button_press_time = 0;
55 uint32_t now = time_s();
56 uint32_t time_since_last_press = now - last_button_press_time;
57 if (time_since_last_press >= config_minimum_seconds_between_button_presses) {
58 last_button_press_time = now;
59 event_t e;
60 e.type = BUTTONPRESS;
61 e.buttonpress.timestamp = now;
62 queue_try_add_ignoring_errors(&queue, &e);
63 }
64 }
65
66 static void time_to_send(uint _) {
67 /* This runs in interrupt context; don't linger. */
68 event_t e;
69 e.type = SEND;
70 queue_try_add_ignoring_errors(&queue, &e);
71 }
72
73 void service_sleeps(int alarm, send_t *sleeping_sends, pheap_t *sleeps_heap) {
74 hardware_alarm_cancel(alarm);
75
76 while (1) {
77 uint32_t now = time_s();
78 pheap_node_id_t i = ph_peek_head(sleeps_heap);
79 if (i == 0)
80 return;
81 send_t *send = &sleeping_sends[i];
82 if (next_send(send) > now) {
83 uint32_t sleep_duration = next_send(send) - now;
84 if (hardware_alarm_set_target(
85 alarm, make_timeout_time_ms(sleep_duration * 1000)))
86 signal_error_by_blinking();
87 return;
88 }
89 if (ph_remove_head(sleeps_heap, false) != i)
90 signal_error_by_blinking();
91 uint32_t ago = now - send->timestamp;
92 send_report(send->seq, ago);
93 send->send_count++;
94 if (send->send_count < config_resend_count)
95 ph_insert_node(sleeps_heap, i);
96 else
97 ph_free_node(sleeps_heap, i);
98 }
99 }
100
101 void service_queue() {
102 int alarm = hardware_alarm_claim_unused(true);
103 if (alarm == -1)
104 signal_error_by_blinking();
105 hardware_alarm_set_callback(alarm, time_to_send);
106
107 send_t sleeping_sends[PICO_PHEAP_MAX_ENTRIES];
108 pheap_t *sleeps_heap =
109 ph_create(PICO_PHEAP_MAX_ENTRIES, next_send_less_than, sleeping_sends);
110 u16_t seq = 0;
111 while (1) {
112 service_sleeps(alarm, sleeping_sends, sleeps_heap);
113
114 event_t e;
115 queue_remove_blocking(&queue, &e);
116 switch (e.type) {
117 case BUTTONPRESS: {
118 pheap_node_id_t i = ph_new_node(sleeps_heap);
119 if (i == 0) {
120 /* TODO: Don't drop new presses just because sleeps_heap is full of old
121 * presses. */
122 break;
123 }
124 sleeping_sends[i].timestamp = e.buttonpress.timestamp;
125 sleeping_sends[i].seq = seq++;
126 sleeping_sends[i].send_count = 0;
127 ph_insert_node(sleeps_heap, i);
128 } break;
129 case SEND: {
130 /* OK, we're awake. Cool. Thanks! (We actually do the sends in the
131 * service_sleeps() call at the top of the loop.) */
132 } break;
133 default:
134 signal_error_by_blinking();
135 }
136 }
137 }
138
139 int main() {
140 stdio_init_all();
141 if (cyw43_arch_init_with_country(CYW43_COUNTRY_USA))
142 signal_error_by_blinking();
143 cyw43_arch_enable_sta_mode();
144 signal(3, 100);
145 if (cyw43_arch_wifi_connect_timeout_ms(config_wifi_ssid, config_wifi_pass,
146 CYW43_AUTH_WPA2_AES_PSK, 90000))
147 signal_error_by_blinking();
148 signal(2, 300);
149
150 queue_init(&queue, sizeof(event_t), 99);
151
152 begin_listening_for_button_press(button_pressed);
153
154 service_queue();
155 }