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