354 lines
10 KiB
C
354 lines
10 KiB
C
#include "simulator.h"
|
|
|
|
#include "color.h"
|
|
#include "led_strip_ws2812.h"
|
|
#include "storage.h"
|
|
#include <esp_heap_caps.h>
|
|
#include <esp_log.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#include <math.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
static const char *TAG = "simulator";
|
|
static char *time;
|
|
|
|
static char *time_to_string(int hhmm)
|
|
{
|
|
static char buffer[20];
|
|
snprintf(buffer, sizeof(buffer), "%02d:%02d Uhr", hhmm / 100, hhmm % 100);
|
|
return buffer;
|
|
}
|
|
|
|
static TaskHandle_t simulation_task_handle = NULL;
|
|
|
|
// The struct is extended with a 'next' pointer to form a linked list.
|
|
typedef struct light_item_node_t
|
|
{
|
|
char time[5];
|
|
uint8_t red;
|
|
uint8_t green;
|
|
uint8_t blue;
|
|
struct light_item_node_t *next;
|
|
} light_item_node_t;
|
|
|
|
// Global pointers for the head and tail of the list.
|
|
static light_item_node_t *head = NULL;
|
|
static light_item_node_t *tail = NULL;
|
|
|
|
// Interpolation mode selection
|
|
typedef enum
|
|
{
|
|
INTERPOLATION_RGB,
|
|
INTERPOLATION_HSV
|
|
} interpolation_mode_t;
|
|
|
|
// You can change this to test different interpolation methods
|
|
static const interpolation_mode_t interpolation_mode = INTERPOLATION_RGB;
|
|
|
|
char *get_time(void)
|
|
{
|
|
return time;
|
|
}
|
|
|
|
// Main interpolation function that selects the appropriate method
|
|
static rgb_t interpolate_color(rgb_t start, rgb_t end, float factor)
|
|
{
|
|
switch (interpolation_mode)
|
|
{
|
|
case INTERPOLATION_RGB:
|
|
return interpolate_color_rgb(start, end, factor);
|
|
case INTERPOLATION_HSV:
|
|
default:
|
|
return interpolate_color_hsv(start, end, factor);
|
|
}
|
|
}
|
|
|
|
esp_err_t add_light_item(const char time[5], uint8_t red, uint8_t green, uint8_t blue, uint8_t white,
|
|
uint8_t brightness, uint8_t saturation)
|
|
{
|
|
// Allocate memory for a new node in PSRAM.
|
|
light_item_node_t *new_node = (light_item_node_t *)heap_caps_malloc(sizeof(light_item_node_t), MALLOC_CAP_SPIRAM);
|
|
if (new_node == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to allocate memory in PSRAM for new light_item_node_t.");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
rgb_t color = {.red = red, .green = green, .blue = blue};
|
|
hsv_t hsv = rgb_to_hsv(color);
|
|
hsv.v = brightness;
|
|
hsv.s = saturation;
|
|
rgb_t adjusted_color = hsv_to_rgb(hsv);
|
|
|
|
// Initialize the data of the new node.
|
|
memcpy(new_node->time, time, sizeof(new_node->time));
|
|
new_node->red = adjusted_color.red;
|
|
new_node->green = adjusted_color.green;
|
|
new_node->blue = adjusted_color.blue;
|
|
new_node->next = NULL;
|
|
|
|
// Append the new node to the end of the list.
|
|
if (head == NULL)
|
|
{
|
|
// If the list is empty, the new node becomes both head and tail.
|
|
head = new_node;
|
|
tail = new_node;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, append the new node to the end and update tail.
|
|
tail->next = new_node;
|
|
tail = new_node;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
void cleanup_light_items(void)
|
|
{
|
|
light_item_node_t *current = head;
|
|
light_item_node_t *next_node;
|
|
|
|
while (current != NULL)
|
|
{
|
|
next_node = current->next;
|
|
heap_caps_free(current);
|
|
current = next_node;
|
|
}
|
|
|
|
head = NULL;
|
|
tail = NULL;
|
|
ESP_LOGI(TAG, "Cleaned up all light items.");
|
|
}
|
|
|
|
static void initialize_light_items(void)
|
|
{
|
|
if (head != NULL)
|
|
{
|
|
ESP_LOGI(TAG, "Light schedule already initialized.");
|
|
return;
|
|
}
|
|
|
|
initialize_storage();
|
|
load_file("/spiffs/schema_02.csv");
|
|
|
|
if (head == NULL)
|
|
{
|
|
ESP_LOGW(TAG, "Light schedule is empty. Simulation will not run.");
|
|
vTaskDelete(NULL);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static light_item_node_t *find_best_light_item_for_time(int hhmm)
|
|
{
|
|
light_item_node_t *best_item = NULL;
|
|
light_item_node_t *current = head;
|
|
int best_time = -1;
|
|
|
|
while (current != NULL)
|
|
{
|
|
int current_time = atoi(current->time);
|
|
if (current_time <= hhmm && current_time > best_time)
|
|
{
|
|
best_time = current_time;
|
|
best_item = current;
|
|
}
|
|
current = current->next;
|
|
}
|
|
|
|
if (best_item == NULL)
|
|
{
|
|
// If no item is found for the given time (e.g., before the first item of the day),
|
|
// find the last item of the previous day.
|
|
best_time = -1;
|
|
current = head;
|
|
while (current != NULL)
|
|
{
|
|
int current_time = atoi(current->time);
|
|
if (current_time > best_time)
|
|
{
|
|
best_time = current_time;
|
|
best_item = current;
|
|
}
|
|
current = current->next;
|
|
}
|
|
}
|
|
|
|
return best_item;
|
|
}
|
|
|
|
static light_item_node_t *find_next_light_item_for_time(int hhmm)
|
|
{
|
|
light_item_node_t *current = head;
|
|
light_item_node_t *next_item = NULL;
|
|
int next_time = 9999; // Initialize with a value larger than any possible time
|
|
|
|
// First pass: find the soonest time after hhmm
|
|
while (current != NULL)
|
|
{
|
|
int current_time = atoi(current->time);
|
|
if (current_time > hhmm && current_time < next_time)
|
|
{
|
|
next_time = current_time;
|
|
next_item = current;
|
|
}
|
|
current = current->next;
|
|
}
|
|
|
|
// If no item is found for the rest of the day, wrap around to the beginning of the next day
|
|
if (next_item == NULL)
|
|
{
|
|
current = head;
|
|
next_time = 9999;
|
|
while (current != NULL)
|
|
{
|
|
int current_time = atoi(current->time);
|
|
if (current_time < next_time)
|
|
{
|
|
next_time = current_time;
|
|
next_item = current;
|
|
}
|
|
current = current->next;
|
|
}
|
|
}
|
|
return next_item;
|
|
}
|
|
|
|
void start_simulate_day(void)
|
|
{
|
|
initialize_light_items();
|
|
|
|
light_item_node_t *current_item = find_best_light_item_for_time(1200);
|
|
if (current_item != NULL)
|
|
{
|
|
led_strip_update(LED_STATE_DAY,
|
|
(rgb_t){.red = current_item->red, .green = current_item->green, .blue = current_item->blue});
|
|
}
|
|
}
|
|
|
|
void start_simulate_night(void)
|
|
{
|
|
initialize_light_items();
|
|
|
|
light_item_node_t *current_item = find_best_light_item_for_time(0);
|
|
if (current_item != NULL)
|
|
{
|
|
led_strip_update(LED_STATE_NIGHT,
|
|
(rgb_t){.red = current_item->red, .green = current_item->green, .blue = current_item->blue});
|
|
}
|
|
}
|
|
|
|
void simulate_cycle(void *args)
|
|
{
|
|
simulation_config_t *config = (simulation_config_t *)args;
|
|
int cycle_duration_minutes = config->cycle_duration_minutes;
|
|
heap_caps_free(config);
|
|
|
|
if (cycle_duration_minutes <= 0)
|
|
{
|
|
ESP_LOGE(TAG, "Invalid cycle duration: %d minutes. Must be positive.", cycle_duration_minutes);
|
|
vTaskDelete(NULL);
|
|
return;
|
|
}
|
|
|
|
initialize_light_items();
|
|
|
|
const int total_minutes_in_day = 24 * 60;
|
|
long delay_ms = (long)cycle_duration_minutes * 60 * 1000 / total_minutes_in_day;
|
|
ESP_LOGI(TAG, "Starting simulation of a 24h cycle over %d minutes. Each simulated minute will take %ld ms.",
|
|
cycle_duration_minutes, delay_ms);
|
|
|
|
int current_minute_of_day = 0;
|
|
|
|
while (1)
|
|
{
|
|
int hours = current_minute_of_day / 60;
|
|
int minutes = current_minute_of_day % 60;
|
|
int hhmm = hours * 100 + minutes;
|
|
time = time_to_string(hhmm);
|
|
|
|
light_item_node_t *current_item = find_best_light_item_for_time(hhmm);
|
|
light_item_node_t *next_item = find_next_light_item_for_time(hhmm);
|
|
|
|
if (current_item != NULL && next_item != NULL)
|
|
{
|
|
int current_item_time_min = (atoi(current_item->time) / 100) * 60 + (atoi(current_item->time) % 100);
|
|
int next_item_time_min = (atoi(next_item->time) / 100) * 60 + (atoi(next_item->time) % 100);
|
|
|
|
if (next_item_time_min < current_item_time_min)
|
|
{
|
|
next_item_time_min += total_minutes_in_day;
|
|
}
|
|
|
|
int minutes_since_current_item_start = current_minute_of_day - current_item_time_min;
|
|
if (minutes_since_current_item_start < 0)
|
|
{
|
|
minutes_since_current_item_start += total_minutes_in_day;
|
|
}
|
|
|
|
int interval_duration = next_item_time_min - current_item_time_min;
|
|
if (interval_duration == 0)
|
|
{
|
|
interval_duration = 1;
|
|
}
|
|
|
|
float interpolation_factor = (float)minutes_since_current_item_start / (float)interval_duration;
|
|
|
|
// Prepare colors for interpolation
|
|
rgb_t start_rgb = {.red = current_item->red, .green = current_item->green, .blue = current_item->blue};
|
|
rgb_t end_rgb = {.red = next_item->red, .green = next_item->green, .blue = next_item->blue};
|
|
|
|
// Use the interpolation function
|
|
rgb_t final_rgb = interpolate_color(start_rgb, end_rgb, interpolation_factor);
|
|
|
|
led_strip_update(LED_STATE_SIMULATION, final_rgb);
|
|
}
|
|
else if (current_item != NULL)
|
|
{
|
|
// No next item, just use current
|
|
led_strip_update(
|
|
LED_STATE_SIMULATION,
|
|
(rgb_t){.red = current_item->red, .green = current_item->green, .blue = current_item->blue});
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(delay_ms));
|
|
|
|
current_minute_of_day++;
|
|
if (current_minute_of_day >= total_minutes_in_day)
|
|
{
|
|
current_minute_of_day = 0;
|
|
ESP_LOGI(TAG, "Simulation cycle restarting.");
|
|
}
|
|
}
|
|
}
|
|
|
|
void start_simulation_task(void)
|
|
{
|
|
if (simulation_task_handle != NULL)
|
|
{
|
|
vTaskDelete(simulation_task_handle);
|
|
simulation_task_handle = NULL;
|
|
}
|
|
|
|
simulation_config_t *config =
|
|
(simulation_config_t *)heap_caps_malloc(sizeof(simulation_config_t), MALLOC_CAP_SPIRAM);
|
|
if (config == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to allocate memory for simulation config.");
|
|
return;
|
|
}
|
|
|
|
config->cycle_duration_minutes = 15;
|
|
|
|
if (xTaskCreate(simulate_cycle, "simulate_cycle", 4096, (void *)config, tskIDLE_PRIORITY + 1,
|
|
&simulation_task_handle) != pdPASS)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to create simulation task.");
|
|
heap_caps_free(config);
|
|
}
|
|
}
|