smart_alarm/smart_alarm.cpp

#include "hardware/clocks.h"
#include "hardware/rtc.h"
#include "hardware/spi.h"
#include "hardware/timer.h"
#include "lwip/apps/http_client.h"
#include "lwip/apps/sntp.h"
#include "lwip/err.h"
#include "lwip/ip_addr.h"
#include "nlohmann/json.hpp"
#include "pico/async_context.h"
#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 <stdio.h>
#include <time.h>

// 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

static void result_fn(void *arg, httpc_result_t httpc_result,
                      u32_t rx_content_len, u32_t srv_res, err_t err) {
  if (httpc_result == HTTPC_RESULT_OK && err == ERR_OK) {
    printf("Request completed successfully. Received %lu bytes\n", rx_content_len);
  } else {
    printf("Request failed - HTTP result: %d, lwIP error: %d, HTTP status: %lu\n",
           httpc_result, err, srv_res);
  }
}

static err_t get_timezone_callback(void *arg, struct altcp_pcb *pcb,
                                   struct pbuf *p, err_t err) {
  if (p == NULL) {
    // Connection closed
    return ERR_OK;
  }

  // Print the JSON response body
  char *json_data = (char *)p->payload;
  printf("%.*s\n", p->len, json_data);

  // Required: Free memory and acknowledge receipt
  uint16_t len = p->tot_len;
  pbuf_free(p);
  altcp_recved(pcb, len);

  return ERR_OK;
}

err_t get_timezone_offset() {
  httpc_connection_t settings = {.use_proxy = 0,
                               .result_fn = result_fn,
                               .headers_done_fn = NULL};
  memset(&settings, 0, sizeof(settings));
  settings.use_proxy = 0;
  settings.result_fn = result_fn;
  settings.headers_done_fn = NULL;

  httpc_state_t *connection = NULL;

  err_t err = httpc_get_file_dns("worldtimeapi.org", 80, "/api/ip", &settings,
                                 get_timezone_callback, NULL, &connection);

  if (err != ERR_OK) {
    printf("Failed to start request: %d\n", err);
  }
  return err;
}

#define TIMEZONE_OFFSET_SEC 7200
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;

  // 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)));

  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");
    }
  }
  return 0;
}