smart_alarm/smart_alarm.cpp

#include "hardware/clocks.h"
#include "hardware/rtc.h"
#include "hardware/spi.h"
#include "hardware/timer.h"
#include "lwip/apps/sntp.h"
#include "lwip/err.h"
#include "lwip/ip_addr.h"
#include "nlohmann/json.hpp"
#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "pico/util/datetime.h"
#include "wifi_conf.h"
#include <lwip/arch.h>
#include <pico/stdio.h>

#include "net_utils.h"
#include "lwip/dns.h"
#include "lwip/tcp.h"

using nlohmann::json;

// SPI Defines
// We are going to use SPI 0, and allocate it to the following GPIO pins
// Pins can be changed, see the GPIO function select table in the datasheet for
// information on GPIO assignments
#define SPI_PORT spi0
#define PIN_MISO 16
#define PIN_CS 17
#define PIN_SCK 18
#define PIN_MOSI 19

//constexpr char* timezone_api_host = "worldtimeapi.org";
//constexpr char* timezone_request = "GET /api/ip HTTP/1.1\r\nHost: worldtimeapi.org\r\nUser-Agent: smart_clock/0.1.0\r\nAccept: */*\r\n\r\n";
constexpr char* timezone_api_host = "example.org";
constexpr char* timezone_request = "GET / HTTP/1.1\r\nHost: example.org\r\nUser-Agent: curl/8.15.0\r\nAccept: */*\r\n\r\n";
static volatile bool request_complete = false;
static volatile bool request_error = false;

static char buffer[1024];

static err_t connected_callback(void *arg, struct tcp_pcb *tpcb, err_t err) {
  if (err == ERR_OK) {
    printf("Connected to server successfully!\n");
  } else {
    printf("Connection failed with error: %d\n", err);
  }
  return ERR_OK;
}


err_t set_timezone_offset(void *arg, struct altcp_pcb *conn, struct pbuf *p, err_t err) {
  printf("\ncontent err %d\n", err);

  if (err != ERR_OK || p == NULL) {
    return err;
  }

  u16_t offset = 0;
  while (offset < p->tot_len) {
    char c = (char)pbuf_get_at(p, offset++);
    putchar(c);
  }

  pbuf_free(p); // Important: Free the pbuf
  return ERR_OK;
}

err_t timezone_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
  extern volatile bool request_complete, request_error;
  u16_t *offset = static_cast<u16_t*>(arg);

  if (p == NULL) {
    printf("Connection closed by remote host\n");
    request_complete = true;
    return ERR_OK;
  }

  if (err == ERR_OK) {
    printf("Received %u bytes: ", p->tot_len);
    pbuf_copy_partial(p, buffer, p->tot_len, 0);
    buffer[p->tot_len] = '\0';

    try {
      json response = json::parse(buffer);
      *offset = response["raw_offset"].get<int>() + response["dst_offset"].get<int>();
      request_complete = true;
    } catch (const std::exception& e) {
      printf("JSON parse error: %s\n", e.what());
      request_error = true;
    }

    tcp_recved(tpcb, p->tot_len);
  } else {
    request_error = true;
  }

  pbuf_free(p);
  return ERR_OK;
}

void timezone_err(void *arg, const err_t err) {
  extern volatile bool request_error;
  printf("timezone_err: %d:%s\n", err, lwip_strerr(err));
  request_error = true;
}



std::tuple<u16_t, err_t> get_timezone_offset() {
  printf("getting timezone offset\n");
  tcp_pcb *pcb = tcp_new();
  tcp_recv(pcb, timezone_recv);
  tcp_err(pcb, timezone_err);
  static u16_t offset = 0;

  // Reset flags for new request
  request_complete = false;
  request_error = false;
  offset = 0;

  tcp_arg(pcb, &offset);
  ip_addr_t server_ip;
  dns_resolve_sync(timezone_api_host, &server_ip, 5000);

  if (tcp_connect(pcb, &server_ip, 80, connected_callback) == ERR_OK) {
    tcp_write(pcb, timezone_request, strlen(timezone_request), TCP_WRITE_FLAG_COPY);
    tcp_output(pcb);

    // Wait until request completes or errors out
    uint32_t timeout_ms = 10000; // 10 second timeout
    uint32_t elapsed_ms = 0;
    const uint32_t poll_interval = 100; // Check every 100ms

    while (!request_complete && !request_error && elapsed_ms < timeout_ms) {
      sleep_ms(poll_interval);
      elapsed_ms += poll_interval;
    }

    tcp_close(pcb);

    if (request_error) {
      printf("Request failed due to error\n");
      return {0,ERR_ABRT};
    } else if (elapsed_ms >= timeout_ms) {
      printf("Request timed out\n");
      return {0,ERR_TIMEOUT};
    }
  } else {
    printf("Failed to connect\n");
    tcp_close(pcb);
    return {0,ERR_ABRT};
  }

  return {offset,ERR_OK};
}



extern "C" void sync_system_time(unsigned int sec, unsigned int usec) {
  printf("SNTP callback received: %lu\n", (unsigned long)sec);
  time_t unix_time = (time_t)sec;

  u16_t timezone_offset_sec = []()->u16_t
  {
    while (true)
    {
      auto [offset,err] = get_timezone_offset();
      if (err == ERR_OK)
      {
        return offset;
      }
      printf("failed to get timezone offset, retrying\n");
    }

  }();

  // Apply timezone offset for local time
  unix_time += timezone_offset_sec;

  struct tm *time_info = gmtime(&unix_time);
  if (time_info == NULL) {
    printf("SNTP: Invalid timestamp %lu\n", (unsigned long)sec);
    return;
  }

  datetime_t dt = {.year = static_cast<int16_t>(time_info->tm_year + 1900),
                   .month = static_cast<int8_t>(time_info->tm_mon + 1),
                   .day = static_cast<int8_t>(time_info->tm_mday),
                   .dotw = static_cast<int8_t>(time_info->tm_wday),
                   .hour = static_cast<int8_t>(time_info->tm_hour),
                   .min = static_cast<int8_t>(time_info->tm_min),
                   .sec = static_cast<int8_t>(time_info->tm_sec)};

  // Sanity checks
  if (dt.year < 2020 || dt.year > 2100 || dt.month < 1 || dt.month > 12 ||
      dt.day < 1 || dt.day > 31 || dt.hour > 23 || dt.min > 59 || dt.sec > 59) {
    printf("SNTP: Invalid date/time components\n");
    return;
  }

  // Set RTC
  if (rtc_set_datetime(&dt)) {
    printf("SNTP: Time set to %04d-%02d-%02d %02d:%02d:%02d %s\n", dt.year,
           dt.month, dt.day, dt.hour, dt.min, dt.sec,
           (timezone_offset_sec == 0) ? "UTC" : "Local");
  } else {
    printf("SNTP: Failed to set RTC\n");
  }
}

int main() {
  stdio_init_all();
  if (cyw43_arch_init()) {
    return 1;
  }
  rtc_init();

  // SPI initialisation. This example will use SPI at 1MHz.
  spi_init(SPI_PORT, 1000 * 1000);
  gpio_set_function(PIN_MISO, GPIO_FUNC_SPI);
  gpio_set_function(PIN_CS, GPIO_FUNC_SIO);
  gpio_set_function(PIN_SCK, GPIO_FUNC_SPI);
  gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI);

  // Chip select is active-low, so we'll initialise it to a driven-high state
  gpio_set_dir(PIN_CS, GPIO_OUT);
  gpio_put(PIN_CS, 1);

  // Timer example code - This example fires off the callback after 2000ms
  // add_alarm_in_ms(2000, alarm_callback, NULL, false);

  printf("connecting to wifi\n");
  // connect to wifi
  cyw43_arch_enable_sta_mode();
  if (cyw43_arch_wifi_connect_timeout_ms(wifi_ssid, wifi_pass,
                                         CYW43_AUTH_WPA2_AES_PSK, 30000)) {
    return 1;
  }

  printf("IP: %s\n", ip4addr_ntoa(netif_ip_addr4(netif_default)));
  printf("Mask: %s\n", ip4addr_ntoa(netif_ip_netmask4(netif_default)));
  printf("Gateway: %s\n", ip4addr_ntoa(netif_ip_gw4(netif_default)));

  ip_addr_t dns_server;
  IP_ADDR4(&dns_server, 1, 1, 1, 1);
  dns_setserver(0, &dns_server);

  IP_ADDR4(&dns_server, 8, 8, 8, 8);
  dns_setserver(1, &dns_server);

  printf("Initializing SNTP\n");
  sntp_setoperatingmode(SNTP_OPMODE_POLL);
  sntp_init();
  ip_addr_t ntp_server;
  if (ipaddr_aton("162.159.200.123", &ntp_server)) { // Cloudflare NTP
    sntp_setserver(0, &ntp_server);
  }
  if (ipaddr_aton("129.6.15.28", &ntp_server)) { // NIST NTP
    sntp_setserver(1, &ntp_server);
  }

  printf("SNTP initialized, waiting for time sync...\n");

get_timezone_offset();



  while (true) {

    // Keep the program running to allow SNTP to work
    sleep_ms(1000);

    // Optional: Print current time periodically to verify sync
    datetime_t t;
    if (rtc_get_datetime(&t)) {
      printf("Current time: %04d-%02d-%02d %02d:%02d:%02d\n", t.year, t.month,
             t.day, t.hour, t.min, t.sec);
    } else {
      printf("failed to get rtc\n");
    }
  }
  cyw43_arch_lwip_end();
  return 0;
}