bedside-clock/components/time/time_manager.c

/*
 * SPDX-License-Identifier: AGPL-3.0-only
 * Copyright (c) Camden Dixie O'Brien
 */

#include "time_manager.h"

#include "console.h"
#include "settings.h"
#include "time_sntp.h"

#include "esp_log.h"
#include "esp_timer.h"
#include "fatal.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "nvs_flash.h"
#include <string.h>
#include <sys/time.h>

#define TAG "Time"

#define NVS_NAMESPACE "time"
#define TIMESTAMP_KEY "timestamp"

#define TM_YEAR_OFFSET 1900
#define TM_MONTH_OFFSET 1

#define UPDATE_PERIOD_US 1000000UL
#define MAX_CALLBACKS 8

static TimeCallback callbacks[MAX_CALLBACKS];
static unsigned callback_count;

static void handle_timezone_update(const char *timezone)
{
	setenv("TZ", timezone, 1);
	tzset();
	time_sntp_restart();
}

static int store_time(void)
{
	esp_err_t error;

	nvs_handle_t nvs;
	error = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs);
	if (error != ESP_OK) {
		ESP_LOGE(TAG, "Error opening NVS: %04x", error);
		return 1;
	}

	struct timeval tv;
	gettimeofday(&tv, NULL);
	error = nvs_set_u64(nvs, TIMESTAMP_KEY, tv.tv_sec);
	if (error == ESP_OK)
		ESP_LOGI(TAG, "Time stored");
	else
		ESP_LOGE(TAG, "Error storing time: %04x", error);

	nvs_close(nvs);
	return error == ESP_OK ? 0 : 1;
}

static void run_callbacks(void *arg)
{
	const Time time = get_time();
	for (unsigned i = 0; i < callback_count; ++i)
		callbacks[i](&time);
}

static int time_command_func(int argc, char **argv)
{
	if (argc == 1) {
		const Time time = get_time();
		printf("%02u:%02u\n", time.hour, time.minute);
		return 0;
	} else if (argc == 2) {
		if (strcmp(argv[1], "store") == 0) {
			return store_time();
		} else {
			Time time;
			const int result
			    = sscanf(argv[1], "%02u:%02u", &time.hour, &time.minute);
			if (result < 2 || time.hour > 23 || time.minute > 59) {
				printf("Invalid time\n");
				return 1;
			}
			set_time(time);
			return 0;
		}
	} else {
		printf("Invalid number of arguments\n");
		return 1;
	}
}

static int date_command_func(int argc, char **argv)
{
	if (argc == 1) {
		const Date date = get_date();
		printf("%04u-%02u-%02u\n", date.year, date.month, date.day);
		return 0;
	} else if (argc == 2) {
		if (strcmp(argv[1], "week-day") == 0) {
			const WeekDay day = get_week_day();
			printf("%s\n", week_day_name(day));
			return 0;
		}
		Date date;
		const int result = sscanf(
		    argv[1], "%04u-%02u-%02u", &date.year, &date.month, &date.day);
		if (result != 3 || date.month == 0 || date.month > 12
		    || date.day == 0 || date.day > 31) {
			printf("Invalid date\n");
			return 1;
		}
		set_date(date);
		return 0;
	} else {
		printf("Invalid number of arguments\n");
		return 1;
	}
}

static void time_saver_func(void *arg)
{
	(void)arg;
	const TickType_t delay = CONFIG_TIME_SAVE_PERIOD_MS / portTICK_PERIOD_MS;
	while (1) {
		(void)store_time();
		vTaskDelay(delay);
	}
}

void time_manager_init(void)
{
	callback_count = 0;

	time_sntp_init();

	char timezone[SETTINGS_MAX_VALUE_SIZE];
	(void)settings_get_timezone(timezone, SETTINGS_MAX_VALUE_SIZE);
	handle_timezone_update(timezone);
	settings_add_timezone_callback(&handle_timezone_update);

	console_register(
	    "time", "Get, set or store the time", "time [HH:MM] OR time store",
	    time_command_func);
	console_register(
	    "date", "Get or set the date, or get the day of the week",
	    "date [yyyy-mm-dd] OR date week-day", date_command_func);

	// Attempt to load time from storage
	esp_err_t error;
	nvs_handle_t nvs;
	error = nvs_open(NVS_NAMESPACE, NVS_READONLY, &nvs);
	if (error == ESP_OK) {
		uint64_t timestamp;
		error = nvs_get_u64(nvs, TIMESTAMP_KEY, &timestamp);
		if (error == ESP_OK) {
			struct timeval tv = { .tv_sec = (time_t)timestamp };
			settimeofday(&tv, NULL);
		} else {
			if (error != ESP_ERR_NVS_NOT_FOUND)
				ESP_LOGE(TAG, "Error getting stored time: %04x", error);
		}
		nvs_close(nvs);
	} else {
		if (error != ESP_ERR_NVS_NOT_FOUND)
			ESP_LOGE(TAG, "Error opening NVS: %04x", error);
	}

	// Start task to save time to storage
	(void)xTaskCreate(
	    &time_saver_func, "time saver", CONFIG_DEFAULT_TASK_STACK, NULL, 1,
	    NULL);

	// Create and start timer
	esp_timer_handle_t update_timer;
	const esp_timer_create_args_t update_timer_config = {
		.callback = &run_callbacks,
		.arg = NULL,
		.name = "time updates",
	};
	error = esp_timer_create(&update_timer_config, &update_timer);
	if (error != ESP_OK) {
		ESP_LOGE(TAG, "Error creating update timer: %04x", error);
		FATAL();
	}
	error = esp_timer_start_periodic(update_timer, UPDATE_PERIOD_US);
	if (error != ESP_OK) {
		ESP_LOGE(TAG, "Error starting update timer: %04x", error);
		FATAL();
	}
}

void add_time_callback(TimeCallback callback)
{
	if (callback_count >= MAX_CALLBACKS) {
		ESP_LOGE(TAG, "Max number of time callbacks exceeded");
		return;
	}
	callbacks[callback_count] = callback;
	++callback_count;
}

Time get_time(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	return (Time) { .hour = timeinfo.tm_hour, .minute = timeinfo.tm_min };
}

void set_time(Time time)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	timeinfo.tm_hour = time.hour;
	timeinfo.tm_min = time.minute;

	tv.tv_sec = mktime(&timeinfo);
	settimeofday(&tv, NULL);
}

Date get_date(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	return (Date) {
		.year = timeinfo.tm_year + TM_YEAR_OFFSET,
		.month = timeinfo.tm_mon + TM_MONTH_OFFSET,
		.day = timeinfo.tm_mday,
	};
}

void set_date(Date date)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	timeinfo.tm_year = date.year - TM_YEAR_OFFSET;
	timeinfo.tm_mon = date.month - TM_MONTH_OFFSET;
	timeinfo.tm_mday = date.day;

	tv.tv_sec = mktime(&timeinfo);
	settimeofday(&tv, NULL);
}

WeekDay get_week_day(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);
	if (timeinfo.tm_wday == 0)
		return WEEK_DAY_SUNDAY;
	else
		return (WeekDay)(timeinfo.tm_wday - 1);
}

const char *week_day_name(WeekDay day)
{
	switch (day) {
	case WEEK_DAY_MONDAY:
		return "Monday";
	case WEEK_DAY_TUESDAY:
		return "Tuesday";
	case WEEK_DAY_WEDNESDAY:
		return "Wednesday";
	case WEEK_DAY_THURSDAY:
		return "Thursday";
	case WEEK_DAY_FRIDAY:
		return "Friday";
	case WEEK_DAY_SATURDAY:
		return "Saturday";
	case WEEK_DAY_SUNDAY:
		return "Sunday";

	default:
		ESP_LOGE(
		    TAG, "Invalid day of the week passed to %s(): %u", __func__,
		    (unsigned)day);
		return "INVALID";
	}
}